Wrap a coroutine to :BindToRenderstep()?

[omgcchheeessee (West)]

You can write your topic however you want, but you need to answer these questions:

1. What do you want to achieve? I want to put my function which is binded to renderstep on a different thread

2. What is the issue? I dont know how

3. What solutions have you tried so far?

local CFunction = coroutine.wrap(RunService:BindToRenderStep("BrickAnimate", Enum.RenderPriority.First.Value, AnimateText))
CFunction()

Tried doing something like this but it returns an error

[Spooce]

Unless I’m misinterpreting your use case, I’d reason that the extra thread is unnecessary. BindToRenderStep() doesn’t yield, so it won’t block the calling thread.

---

For future reference, however, here’s the correct syntax for wrapping an object method:

-- Option 1: Wrap the call in a function
local CFunction = coroutine.wrap(function()
	RunService:BindToRenderStep("BrickAnimate", Enum.RenderPriority.First.Value, AnimateText)
end)
CFunction()

-- Option 2: Use dot notation and pass in the object and your arguments
local CFunction = coroutine.wrap(RunService.BindToRenderStep)
CFunction(RunService, "BrickAnimate", Enum.RenderPriority.First.Value, AnimateText)

You might also find that the task library is more user-friendly for scheduling simple threads.

[omgcchheeessee (West)]

My use case is I have an effect that I render every frame that I want to put on a seperate thread for performance reasons. I don’t care about yielding the coroutine or anything I just want to squeeze out some extra performance

[Spooce]

I don’t think you’ll see any performance benefits in this case. Coroutines are a form of collaborative multithreading, which broadly means that they yield to give other coroutines a chance to run. Execution is still occurring serially from a single thread, but not necessarily in program order.

Consider a web request that blocks a script until some external server sends a response. If you wrap the request in a coroutine, then the script can continue to do useful work while waiting. If the response came back immediately, then the coroutine would provide no advantage.

You may be able to achieve true simultaneous execution with parallel Luau, but I would advise against premature optimization.