The BindToRenderStep function binds a custom function to be called at a specific time during the render step. There are three main arguments for BindToRenderStep: name, priority, and what function to call.

As it is linked to the client's rendering process, BindToRenderStep can only be called on the client.

Name

The name parameter is a label for the binding, and can be used with RunService:UnbindFromRenderStep() if the binding is no longer needed.

1
2
3
4
5
6
7
8

local RunService = game:GetService("RunService")

local function functionToBind() end

-- Bind the function above to the binding named "tempBinding"
RunService:BindToRenderStep("tempBinding", 1, functionToBind)
-- Unbind the function bound to "tempBinding"
RunService:UnbindFromRenderStep("tempBinding")

Priority

The priority of the binding is an integer, and determines when during the render step to call the custom function. The lower this number, the sooner the custom function will be called. If two bindings have the same priority the Roblox engine will randomly pick one to run first. The default Roblox control scripts run with these specific priorities:

• Player Input: 100
• Camera Controls: 200 For convenience, the RenderPriority enum can be used to determine the integer value to set a binding. For example, to make a binding right before the default camera update, simply subtract 1 from the camera priority level.

When using RenderPriority, remember to use .Value at the end of the desired enum. RunService:BindToRenderStep() will not work if just the enum is used on its own.

1
2
3
4
5
6
7

local RunService = game:GetService("RunService")

local function beforeCamera(delta)
	-- Code in here will run before the default Roblox camera script
end

RunService:BindToRenderStep("Before camera", Enum.RenderPriority.Camera.Value - 1, beforeCamera)

Custom Function and Delta Time

The last argument of BindToRenderStep is the custom function to call. This function will be passed one parameter called deltaTime. DeltaTime shows how much time passed between the beginning of the previous render step and the beginning of the current render step.

All rendering updates will wait until the code in the render step finishes. Make sure that any code called by BindToRenderStep runs quickly and efficiently. If code in BindToRenderStep takes too long, then the game visuals will be choppy.

The Heartbeat event fires every frame, after the physics simulation has completed. The step argument indicates the time that has elapsed since the previous frame.

As Heartbeat fires every frame, it runs on a variable frequency. This means the rate will vary depending on the performance of the machine. If the game is running at 40 FPS, then Heartbeat will fire 40 times per second and the step argument will be roughly 1/40th of a second.

The step argument can be used to account for the variable frequency of this event, for example:

1
2
3
4
5
6
7

local RunService = game:GetService("RunService")

local RATE_PER_SECOND = 2

RunService.Heartbeat:Connect(function(step)
	local increment = RATE_PER_SECOND * step
end)

There is no guarantee that functions connected to this event will fire at the exact same time, or in any specific order. For an alternative where the priority can be specified, see RunService:BindToRenderStep().

This function returns whether the current environment is running on the client.

If the code that invoked this method is running in a client context (in a LocalScript or a ModuleScript required by a LocalScript) then this method will return true. In all other cases, this function will return false.

If this function returns true, then the current environment can access client-only features like RunService.PreRender or Players.LocalPlayer.

RunService test function results

See also:

• RunService:IsServer()
• RunService:IsStudio()
• RunService:IsEdit()
• RunService:IsRunning()
• RunService:IsRunMode()

This function returns whether the 'Run' button has been pressed to run the simulation in Roblox Studio.

If the user has pressed 'Run', then this function will return true. This function will continue to return true if the simulation has been paused using the 'Pause' button. However, once it has been stopped using the 'Stop' button it will revert to returning false.

Roblox Studio only enters run mode when the 'Run' button is pressed, not the 'Play' button. This function will also return false if the simulation was started using RunService:Run() rather than the 'Run' button.

RunService test function results

See also:

• RunService:IsClient()
• RunService:IsServer()
• RunService:IsStudio()
• RunService:IsRunning()
• RunService:IsEdit()

Returns whether the game is currently running

The game is considered running when it is not in edit mode in Roblox Studio. This means, if the simulation has been run using the 'Run' or 'Play' buttons the game is running.

IsRunning will always return the inverse of RunService:IsEdit() with one exception, if the simulation has been 'paused' then both RunService:IsEdit() and IsRunning will return false.

RunService test function results

See also:

• RunService:IsClient()
• RunService:IsServer()
• RunService:IsStudio()
• RunService:IsEdit()
• RunService:IsRunMode()

This function returns whether the current environment is running on the server.

If the code that invoked this method is running in a server context (in a Script or a ModuleScript required by a Script) then this method will return true. In all other cases, this function will return false.

If this function returns true, then the current environment can access server-only features like ServerStorage or ServerScriptService.

See also:

• RunService:IsClient()
• RunService:IsStudio()
• RunService:IsEdit()
• RunService:IsRunning()
• RunService:IsRunMode()

This function returns whether the current environment is running in Roblox Studio.

This function will only return true when using Roblox Studio and can be used to add code to test your game within Studio.

See also:

• RunService:IsClient()
• RunService:IsServer()
• RunService:IsStudio()
• RunService:IsEdit()
• RunService:IsRunMode()

The RenderStepped event fires every frame, prior to the frame being rendered. The step argument indicates the time that has elapsed since the previous frame.

RenderStepped does not run in parallel to Roblox's rendering tasks and code connected to RenderStepped must be executed prior to the frame being rendered. This can lead to significant performance issues if RenderStepped is used inappropriately. To avoid this, only use RenderStepped for code that works with the camera or character. Otherwise, RunService.Heartbeat should be used.

As RenderStepped fires every frame, it runs on a variable frequency. This means the rate will vary depending on the performance of the machine. If the game is running at 40 FPS, then RenderStepped will fire 40 times per second and the step argument will be roughly 1/40th of a second.

The step argument can be used to account for the variable frequency of this event, for example:

1
2
3
4
5
6
7

local RunService = game:GetService("RunService")

local RATE_PER_SECOND = 2

RunService.RenderStepped:Connect(function(step)
	local increment = RATE_PER_SECOND * step
end)

There is no guarantee that functions connected to this event will fire at the exact same time, or in any specific order. For an alternative where the priority can be specified, see RunService:BindToRenderStep().

As RenderStepped is client-side only, it can be used in a LocalScript or a ModuleScript required by a LocalScript.

The Stepped event fires every frame prior to the physics simulation. The step argument indicates the time that has elapsed since the previous frame.

As Stepped fires every frame, it runs on a variable frequency. This means the rate will vary depending on the performance of the machine. If the game is running at 40 FPS, then Stepped will fire 40 times per second and the step argument will be roughly 1/40th of a second.

The step argument can be used to account for the variable frequency of this event, for example:

1
2
3
4
5
6
7

local RunService = game:GetService("RunService")

local RATE_PER_SECOND = 2

RunService.Stepped:Connect(function(time, step)
	local increment = RATE_PER_SECOND * step
end)

There is no guarantee that functions connected to this event will fire at the exact same time, or in any specific order. For an alternative where the priority can be specified, see RunService:BindToRenderStep().

Given a name of a function sent to BindToRenderStep, this method will unbind the function from being called during PreRender. This is used to unbind bound functions once they are no longer needed, or when they no longer need to fire every step.

If there is no bound function by the given name, this method takes no action and continues without raising an error.