Coroutines vs BindableEvents

[Drainhp]

I’m conflicted on whether I should use Coroutines or BindableEvents for starting new threads.

Coroutines:

local func = coroutine.create(function()
    print("Coroutine")
end)

coroutine.resume(func)

BindableEvents

local bindableEvent = Instance.new("BindableEvent")
bindableEvent.Event:Connect(function()
    print("BindableEvent")
end)

bindableEvent:Fire()

Are there any benefits in using one over the other, or is it just up to personal preference? Which one do you use, and why?

[sjr04 (uep)]

It depends. I personally use bindables. With coroutine.create, any exceptions need to be handled (it’s like pcall where it stops exception from propagating and returns the success and message), where as bindable events don’t have this. Also coroutines kill the stack trace so rip debugging.

btw coroutine.create returns a new thread so naming the variable func is misleading (though coroutine.wrap does return a function)

[RuizuKun_Dev (Kitsune)]

There are a few threads that I found related to your inquiry

Which Fast Spawn variant do you prefer?

Which Fast Spawn Variant do you use? What I mean by Fast Spawn is creating a new thread using various methods as mentioned below; poll Coroutine Fastest but destroys the stack trace and obscure errors. Heartbeat Fast but has a Delay and becomes slower depending on work load. BindableEvent Slowest and not Code based but reliable. Reference: https://devforum.roblox.com/t/coroutines-v-s-spawn-which-one-should-i-use/368966 Each variant is useful in their own way but I would lik…

Coroutines V.S. Spawn()... Which one should I use?

The title says it all… Basically I want to know in what scenarios I should use: spawn(function() -- Script end) And what scenarios I should use: local thing = coroutine.create(function() -- Script end) coroutine.resume(thing) So… When is it best to use spawn(function() and when it is best to use coroutines?

[Drainhp]

Thanks for the quick reply! I’m starting to lean towards BindableEvents, since I don’t want to make debugging harder for myself.
And yeah, I forgot coroutine.create() returns a new thread, not a function!

[RoBreadd (Agidyne)]

Personally I would use coroutines, as using bindable events just seem like a hacky workaround. I feel like coroutines would be faster, as you don’t have to ping every script and check if it has a listener. However, I’m not sure how either does garbage collection but I think events are automated and coroutines aren’t.

[sjr04 (uep)]

@RobotTerrarian

Personally I would use coroutines, as using bindable events just seem like a hacky workaround.

Bindable events are somewhat hacky, yes, but at least debugging is less of a pain with bindables.

[RoBreadd (Agidyne)]

True. Even though I’m all for team coroutines BindableEvents are much easier to debug.

[Wunder_Wulfe]

I usually only ever use bindable events if it is something that multiple scripts / threads / etc are connecting to. I also do not use coroutines that often because I try to keep things orderly in a sequential manner. Also, coroutine.wrap seems to have proper error logging unlike with resume(create)

[https_KingPie]

I’ve been in a big coroutine mood lately, so I would recommend those. I find them very useful for centralizing things and utilizing multi-threading without creating a separate script.

[Eternalove_fan32 (FrostDracony)]

@Drainhp

BindableEvents

local bindableEvent = Instance.new("BindableEvent")
bindableEvent.Event:Connect(function()
    print("BindableEvent")
end)

bindableEvent:Fire()

I would use BindableEvent, like @Wunder_Wulfe say, to connect multiple scripts, with RemoteEvents you only can have a client to server or server to client connection, but with BindableEvent you can make your own events and have a Server to server script connection. Coroutine.wrap is more if you have two loops that you want to play in the same moment, and i think that it should play your function faster.

[FastKnight401]

coroutine.wrap() does not act like a pcall(), if an error is raised, it will be an error in the output, so it would probably be better using coroutine.wrap()