Custom Bezier tweens slow down after prolonged runtime

I’m writing a system that creates spherical particles running on a Bézier curve. A script called SmokeParticles creates clones of the script ParticleTween.

When the test starts, everything seems normal, until the size of the tween gets exponentially smaller. I’ve included the game and the ParticleTween script.

-- ParticleTween
-- This script creates, tweens, and automatically destroys a spherical particle.
local TweenService = game:GetService("TweenService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Create the particle in question.
local newSphere = Instance.new("Part")
newSphere.Shape = Enum.PartType.Ball
newSphere.Name = "Particle"
newSphere.CastShadow = false
newSphere.CanCollide = false
newSphere.Anchored = true
newSphere.Transparency = .25
newSphere.Color = Color3.fromHSV(0, 0, math.random(300, 700)/1000)
newSphere.Size = Vector3.new(0, 0, 0)
newSphere.Position = Vector3.new(0, 12, -15.5)
newSphere.Parent = workspace.ParticleSystem

-- Transparency and scale tweens
local endSize = math.random(2, 7) -- Randomly set the size of the particle
local ScaleTween = TweenService:Create(newSphere, TweenInfo.new(15, Enum.EasingStyle.Exponential), {Size = Vector3.new(endSize, endSize, endSize)}) -- Increase the size of the particle throughout its existance.
local TransparentTween = TweenService:Create(newSphere, TweenInfo.new(8.5, Enum.EasingStyle.Linear), {Transparency = 1}) -- Increase the transparency of the particle to create a better looking trail and a transition into destruction.
TransparentTween:Play()
ScaleTween:Play()

-- Linear Interpolation Defenition
function lerp(a, b, c)
	return a + (b - a) * c
end

-- Bezier Defenition
function cubicBezier(t, p0, p1, p2, p3)
	local l1 = lerp(p0, p1, t)
	local l2 = lerp(p1, p2, t)
	local l3 = lerp(p2, p3, t)
	local a = lerp(l1, l2, t)
	local b = lerp(l2, l3, t)
	local cubic = lerp(a, b, t)
	return cubic
end

-- Set location for each checkpoint
local p0 = Vector3.new(math.random(-1, 1), 12.4, math.random(-16, -15))
local p1 = Vector3.new(math.random(-2, 2), math.random(19, 26), math.random(13.5, 15.5))
local p2 = Vector3.new(math.random(-7, 7), math.random(26, 32), math.random(80, 84))
local p3 = Vector3.new(math.random(-10, 10), 32, math.random(300, 330))

-- Tween the particle using a Bezier curve
for x = 0, .85, .001 do
	newSphere.Position = cubicBezier((x*2^2+x), p0, p1, p2, p3)
	wait()
end

-- Destroy the evidence!
newSphere:Destroy()
script:Destroy()

I’m currently making a module to do all of the Bézier tweeting with so that all of this can be contained in one script. I’m thinking it’s a memory issue.