Get all of my knowledge in one package:
linktr.ee/ByteBlox

you didn't use task.wait()... you better sleep with all holes closed tonight.

4:12. The reason why you dont use the brackets here is because you are not calling the function but are passing it as a parameter. If you use the brackets then you are not giving the task.spawn a function. Functions typically work as any other data type in lua. You could write a function like this: local add = function(num1,num2) return num1 + num2 end If you use typeof() on a function it will return function. That is what task.spawn does to check if you're sending it a function. If you put the brackets then you will be running the function instead of passing it meaning that the typeof will not recognise the parameter as a function therefore giving you that error

dude you are literally exactly what i've been looking for thank you for existing

That's CRAZY. Are you saying I never had the issue of needing to do something for all elements at the same time, but I always thought to myself it would happen someday and I wouldn't be able to fix it. This is just perfect!

i used to watch you since one of your first video , keep it up , your videos are very interesting

task.synchronize and task.desynchronize are only to be used with multi threading under actors. If this is not done, then the function will still work, but will warn something along the lines of this: "task.synchronize/task.desynchronize should only be called from a script that is a descendant of an Actor" both task and coroutines are nearly the same thing, except with a few minor differences. *Note that task.spawn() is slightly slower than coroutine.create()* task.spawn() can resume "dead" threads, unlike coroutine.resume() task.spawn() has a debug trace back, unlike coroutines. This basically means that if the script gets an error, it will show where the error occurred inside of the actual function, rather than coroutines which say something about where the coroutine was actually ran. task.cancel() doesn't return the thread's state, until coroutine.close() task is better for everyday things, because it is very easy to use. coroutines are more complicated, and are better for multi tasking programs overall however, unless you need to get very technical, using either task.spawn() or coroutine.wrap() is fine.

Dude you're too good man, love your explanations. Will you ever make like a scripting series or are you more focused on tips and tricks?

i just got into scripting and this is so helpful. thanks!

You're doing the world such a great service. Keep it up.

ceo of not knowing what hes talking about 🔥🔥🔥🔥

Thats pretty sick, you should cover the other task. functions!

You’re literally the roblox version of khan academy thanks so much bro

I learned about this recently and it is a new version of coroutines and is extremely useful

Me watching your videos as if I don't already know this information but your videos are always fun, engaging, and informative that I still watch through the whole thing ❤

i am not joking, this actually saved me from making multiple scripts. thank you so much

This is actually so useful, thanks for the video. I was literally having a problem a few days ago where a thing wasn't running fast enough and the game was breaking, but I could see how task.spawn can be really useful in some situations. Will definitely be saving this for later!

its very useful for things like if idk you want to have multiple things going on for multiple players so like idk a sword system and you can do damage to objects but you want a cooldown if you add a cooldown on the server it will be for everyone instead of you can use this and have it only have a cooldown for the 1 player on the server

I think you can make a variable and then run a task.spawn(), like local newThread = task.spawn(SomeFunction: function) which will return a thread, and then you can make it cancel (stop the thread) task.cancel(newThread)

GOOD VIDEO KEEP IT UP and you'll be a very successful , I CAN SEE IT.

It's funny how I started watching your tutorials occasionally for fun because of that one tutorial where you taught me how to love

I have been making an earthbending game but because I didn't know this, you had to wait for every ability to completely finish before using another one. This has been a lifesaver.

It greatly reduces the writing of code, Thanks!

for running, you could do a "Run" instead of a "Play" if you only want to run the server only, not the client

another banger tutorial bbg

oh my god. i've been scripting for a while and i was unaware that you could cancel spawned tasks. i knew you could cancel delayed tasks before they begin, but i though that was all cancel was used for

Task.delay is actually the only way to get a delay in JavaScript without a separate library (obviously it’s not called task.delay though)

this guy is just existing and give us life lessons

You should make a video about DataStores

The part where he has to check if the function, that spawns, has to use () is the equivalent of using a calculator to double check 10 + 10. Like you know but you never know if you don't know.

i was strugglin with this yesterday lol

me an my cousin trying to be roblox developer do you have/know any video series that can help me and my cousin ?

I think there are 2 options for task.cancel() Inside of a task, you should be able to run task.cancel() by itself or task.cancel(self) Outside of a task you probably need to write the task to an object, so local task1 = task.spawn()

so this is basically like coroutines but much easier to understand

lol already knew this exist really useful though I use it almost everytime I code something

Thanks

Oh my god if I would've found this sooner

What i used to do was make a function that coroutines a function... It kinda speed up everything. Imo coroutines are way better

i think task.cancel is used like that : local thread1 = task.spawn(function) task.cancel(thread1)

you really triggered me when you wrote wait(2) over task.wait(2) everything else is good though, nice tutorial I could teach you some of the task functions, I specialise in multi threaded luau i believe, not too sure but sure since I haven't used roblox studio in a while, task.spawn and task.delay returns a thread which you can use task.cancel on

I got coroutine wrap and task spawn confused apparently :/ also thanks for help

Can you make a tutorial on how to make a moving train like in jailbreak?

if im not wrong, in this case, does it start all 5 functions as soon as it can rather than doing each wait 1 by 1 and it having to wait each time

I really wanted to take your course, but unfortunately I don't know English, I can only read words in English and understand at best, but I can't understand spoken words

I've been repeatedly using coroutines until this very video.

thanks

Roblox devs discover multithreadding

is this the same as coroutines?

So it's basically a simplified coroutine? You have no idea how many times I could've used this instead of manually setting up a coroutine lol. I've been scripting for a couple years and never heard of this, Thank you.

sounds like coroutines but this is good thanks

Easy summary: play in background

Didn't know roblox was capable of multi threading!

You can also use coroutines for this

it's like a less laggy coroutine.wrap

I’m watching this as if I actually write code

i have read task.spawn had throttling, so i used corutines

Hey, is it different from coroutines?

how would you use task.defer in a practical sense since i see that its not as used as the others

yes

So, it's literally just asynchronous code in a single script instance. Nice IG, but this is why Luau is somewhat underwhelming when compared to other languages. I've always made the argument that if Roblox utilized its engine's chief language, C++, for its OOP task, it would be much more efficient and effective. But, then again, with Luau being designed for novice programmers, I guess it finds a good balance between implementing new libraries and introducing new people to coding. Nonetheless, this is a seriously effective method! Thanks.

bruh u dont use task.wait but u use task.spawn choose will u use task or not

What is the difference between this and a Coroutine?

Bro I replaced all my script with something else, so what do I do! Ctrl Z doesn’t work!!!!😭🙏

i always use coroutines but I'm not sure what the best solution is

Oh so this is Roblox threading?

local wait = task.wait :troll:

alr

Man should've watched sleitnick's video before making this one 💀

oh so basically it ignores the task.wait()?

hey bro, you can make a tutorial of How to animate objects? Exemple: Doors, closets...

where is my next love tutorial byteblox

wont this cause memory leaks

Why am I watching this? I don't know how to script

Hey, I have a question, what's the difference between "spawn()" and "task.spawn()"?

hamburger

why not call this video `tutorial on multithreading`?

you could also do: 0 = time delay(0 ,function() print("idk") end)

no u

Bro stop spamming the word “right”

literally ntts roblox tutorials

bro took 4 minutes to get to the point

or just spawn, please at least explain to them what task does first bro ngl

r u sure this will sav me time

E

coroutine is better bro

lmao everthing in this video is wrong and I just hope you know that

FIRST W

SECOND

save me hours

To save a thread do Variable = task.delay(stuff here) Task.cancel(Variable)

task.spawn() runs functions asyncronously.

So, maybe I'm lil dumb for my level, but what is the difference between coroutine.wrap and task.spawn() ? Please reply the ones who *understands* it.

WHY ARE YOU NOT USING TASK.WAIT INSTEAD OF WAIT!?

bite blozx

why tf do you make these tutorials when you don't know the full topic anyways task.spawn returns a thread task.spawn: (function: () -> nil, ...: variant) -> thread task.cancel: (thread: thread) -> nil coroutines also return threads as well as task.delay and task.defer and for those who want a tl;dr on the task library here you go: * task.spawn: (function: () -> nil, ...: variant) -> thread calls/resumes the given function immediately * task.defer: (function: () -> nil, ...: variant) -> thread calls/resumes the given function on the end of the current invocation cycle (think of it like the function being put off until the end of the frame/heartbeat) * task.cancel: (thread: thread) -> nil cancels the given thread * task.wait: (seconds: number): number yields the given script for [seconds] seconds. note that it will return the real amount of time it yielded for * task.desynchronize: () -> nil this is for parallel luau which is its on can of worms * task.synchronize: () -> nil see task.desynchronize

coroutine.resume(coroutine.create(function() end))

Coroutines Better 🥱

no u