How can I optimize my VFX code?

[Magus_ArtStudios]

Utilize parallel luau by placing your VFX scripts that refer to your module within actor instances. This will multi-thread your VFX system utilizing individual threads spread across all cores instead of utilizing one core and one thread by default.
Also if you are using a touch connection make sure to make the object CanTouch=false once it has been triggered this will save possibly thousands of touch connections.
Also disabling any modular scripts and destroying them once they are done being used is a good way to make sure all your threads are disconnected.

--your previous loop would disconnect when player stops moving
while humanoid.Health>0 do
if humanoid.MoveDirection.Magnitude > 0 and humanoid.FloorMaterial ~= Enum.Material.Air   then
  print(humanoid.FloorMaterial)
    print("Person is running")
    VFXController.Action("Run", true)
end
    task.wait(0.2)
end

[althruist]

…So, I have no idea how luau works, or threads for that matter. I haven’t really gotten to that point…

[Magus_ArtStudios]

it’s very easy parallel luau works just like regular luau except it has some more features.
To utilize parallel luau just put the script inside a instance called Actor. A actor has the properties of a model but it is of a different class.
When a script is inside a actor it will utilize parallel luau.
The way to understand how parallel luau works is that by default scripts run all on the same thread. Or think of it as a line. When you utilize this feature it turns that line into a bunch of different lines that spread across all of the cores of the device the game is running on.

The main hurtle is being able to efficiently spread the load across as many actor instances as you need. Although in many instances this is not necessary or an issue. It depends on your coding style and what you are working on.
If it’s an interconnected system that has many internal variables then that is more challenging to utilize many actors. Meanwhile if you are executing code within objects by enabling a script then actors would be the easy way to go.
Also by default you should just use actors. You can read more about them if you would like. But by default all the scripts are running on the same core and same thread. You will notice while testing your game if you do not utilize parralel luau it will only use one core. So if you have an 8 core computer you would be using about 12% CPU at max.
You can keep scripts running on the same thread together by placing them within the same actor.
Most modern phones have a 8 core processor. Utilizing only 1 core locally in a mobile game is a recipe for performance bottlenecks, crashing and the like.

[Magus_ArtStudios]

I’m sure once you utilize this form of Luau and my other advice concerning disconnecting threads it would solve al lot of your performance issues.
You can utilize the Find/ReplaceAll feature in studio if you need to change commonly used paths in a multitude of scripts.
You can disconnect a connection like this example
You disabled the Touch because if you do not the touch connection will fire as many times as possible and potentially causing lots of lag.
Another thing to keep in mind is if an object is physically interacting with another object while it has a touch connection then it will trigger as well. So having those scripts run while the player is not there to interact with them can also cause performance issues. Especially as you scale your project.

local exampleconnect--initialize local event before it is mentioned
local function TouchEvent(hit)
if game.Players:GetPlayerFromCharacter(hit.Parent)~=nil then
VFXObject.CanTouch=false--assuming event has been triggered and does not trigger again
--insert event here
exampleconnect:Disconnect()
end
end

exampleconnect=VFXObject.Touched:Connect(TouchEvent)

[faze_paspro (Sus)]

Hello i know you already found a solution but i hope this helps

Here’s the result :

(Sorry couldn’t make a longer video i doesn’t show anything )

Here’s the script i explain everything in there even if it’s poorly explained:

local player = game.Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local humanoid = character:WaitForChild("Humanoid")
local humanoidRootPart = character:WaitForChild("HumanoidRootPart")

local ReplicatedStorage = game:GetService("ReplicatedStorage")

local isRunning = false

--I use :GetPropertyChangedSignal("MoveDirection") that triggers whenever the moveDirection changed too avoid using constand checking wich can make the game more laggy

local dustFx , weld -- I created two variables dustFx that have no values yet to bypass local scope (because if i created it in a function i wouldn't be able to use it in a another one) 
humanoid:GetPropertyChangedSignal("MoveDirection"):Connect(function() 
	if humanoid.MoveDirection.Magnitude > 0 and humanoid:GetState() == Enum.HumanoidStateType.Running  and not isRunning then -- checks if the length of the moveDirection (wich is a vector) is greater that zero meaning is currently moving and the humanoidStateType is equal to running
		print("You are running !")
		
		dustFx = ReplicatedStorage.Fx.DustFx:Clone()
		dustFx.Parent = game.Workspace
		dustFx.Position = humanoidRootPart.Position + Vector3.new(0,-3,0) 
		
		weld = Instance.new("WeldConstraint",game.Workspace) -- We attach the DustFx with another part note that the order doesn't matter only if you care about C0 and C1 but this another Topic
		weld.Part0 = dustFx
		weld.Part1 = humanoidRootPart
		
		isRunning = true -- I use this boolean to avoid creating more than one dust particle when the moveDirection just changes a litte bit
	elseif humanoid.MoveDirection.Magnitude == 0 then -- If the player stops
		print("You stopped running !")
		
		-- This is where the two variables i created on top come in handy because if i were to create it the variables in the first condition i wouldn't be able to use 
		-- and i will have to instead search it in the workspace like so : game.Workspace:WaitForChaild("DustFx"):Destroy() same thing for the weld 
		
		dustFx:Destroy() -- We destroy the particle alternatively what we can do is simply disable it to make it smoother and not dissapear instantly and we wouldn't destroy weld
		weld:Destroy()
		
		isRunning = false 
	end
end)

humanoid.StateChanged:Connect(function(oldState,newState) -- I use StateChanged because moveDirection doesn't change when we jump so we have to use this event to detect jumping
	if newState == Enum.HumanoidStateType.Jumping then -- If the player jumps we destroy the effects
		if dustFx then
			dustFx:Destroy()
		end
		
		if weld then
			weld:Destroy()
		end
	elseif newState == Enum.HumanoidStateType.Landed then -- If he lands we add back the effect
		dustFx = ReplicatedStorage.Fx.DustFx:Clone()
		dustFx.Parent = game.Workspace
		dustFx.Position = humanoidRootPart.Position + Vector3.new(0,-3,0) 

		weld = Instance.new("WeldConstraint",game.Workspace)
		weld.Part0 = dustFx
		weld.Part1 = humanoidRootPart
		
		isRunning = true -- We set it to true to avoid creating two effects because if the moveDirection changes it will create another dustFx 
		
		-- You can also play your landed animation and do other effects too 
	end
end)

EDIT : wrong video