Concurrency

FutureBlitz has a tool for each kind of concurrency. Spawn and Parallel For run heavy work on every core. Async and Await wait for files, networks, and time without blocking, on the main thread, where coroutines are written as the steps they take. Channels, Atomics, Mutexes, and Shared Classes share data between threads, and the compiler checks every value that crosses one, so a data race is a compile error rather than a bug to hunt for.

Tutorials

1. Spawn and Task Run work on other cores with Spawn, wait for its result with a Task, and give long-running work a Thread of its own.
2. Parallel For Split a loop's passes over every core with Parallel For, and keep each pass to its own element.
3. Channels Pass values between threads in order with a Channel, close it when the sender is done, and check it without waiting.
4. Mutex and Atomic Share counters between threads with Atomic, and larger data with a Mutex and Lock.
5. Sendable and Shared Class Know which values can cross threads, and make a Class whose objects every thread can share.
6. Async and Await Write code that waits for files and other work without blocking, with Async Functions, Await, and the errors their Tasks carry.
7. Coroutines and Schedulers Write sequences that take time as Async Functions that Await Wait, and run them on a Scheduler you tick yourself.
8. The main thread Keep main-thread code on the main thread with @MainThread, and run coroutines from a loop of your own with Scheduler.Main.Step.

The rules behind this area are in the language reference.