Threads are the fundamental units of concurrent execution. Each thread represents an independent sequence of instructions that can run simultaneously with others, sharing the same memory space while maintaining its own execution context. The Process Grid above visualizes each thread as a cell -- watch how they independently cycle through states, occasionally synchronizing at barriers.

A mutex (mutual exclusion) is the gatekeeper of shared resources. When a thread acquires a mutex, all others must wait -- their execution suspended until the lock is released. The Mutex Gold cells in the grid represent threads in this waiting state, queued patiently for access to a contested resource. Mutexes prevent data races but introduce the possibility of contention.

Barriers are synchronization points where threads converge. No thread may proceed past the barrier until all participating threads have arrived. Watch the Process Grid when multiple cells simultaneously shift from Waiting gold to Running cyan -- that is a barrier release. Barriers ensure that phases of computation complete in lockstep, enabling deterministic coordination in a non-deterministic environment.

A deadlock occurs when two or more threads are each waiting for a resource held by another, creating a circular dependency from which none can escape. The Deadlock Red flashes in the Process Grid signal this fatal condition. The engine detects deadlocks through cycle detection in the resource dependency graph and resolves them by forcibly releasing the youngest lock. Watch for the red cascade followed by green resolution.

The event loop is the heartbeat of the concurrengine. It is a perpetual cycle that polls for pending events, dispatches handlers, and yields control back to the scheduler. Unlike threads which run in parallel, the event loop processes tasks sequentially but rapidly -- switching context in microseconds, creating the illusion of concurrency on a single core. The Timeline panel shows events flowing through this loop as colored bars.