Concurrent Event Simulation Engine
ConcurrEngine is built on a fundamentally different premise: that concurrency is not a problem to be solved, but a natural state to be harnessed. Where traditional systems treat parallel execution as an exception requiring careful management, ConcurrEngine treats it as the default mode of operation.
At its heart lies an event loop that processes thousands of simultaneous state transitions without blocking. Each event carries a causal fingerprint -- a vector clock that establishes happens-before relationships across distributed threads.
engine.spawn(async |ctx| {
let event = ctx.receive().await;
let resolved = ctx.arbiter
.resolve(event, Strategy::Optimistic)
.await?;
ctx.timeline.merge(resolved);
Ok(Signal::Converged)
});When two threads compete for the same resource, the Conflict Arbiter does not simply lock and block. It evaluates the causal graph, determines which thread holds the stronger temporal claim, and orchestrates a merge that preserves both timelines' integrity. The result is not a winner and a loser -- it is a unified state that both threads can accept.
The scheduler observes contention patterns in real time and redistributes workload to minimize hot spots. Using a sliding-window analysis of event throughput, it predicts bottlenecks before they occur and preemptively migrates tasks to underutilized threads.
scheduler.configure(|cfg| {
cfg.strategy(LoadBalance::Adaptive)
.window(Duration::from_millis(50))
.threshold(Contention::Medium)
.rebalance(true);
});Every execution path terminates in convergence. The engine maintains a formal proof that given any finite set of concurrent events, the system will reach a globally consistent state within bounded time. This is not optimism -- it is mathematics. The resolution rate metric in the HUD reflects this guarantee in real time.
Every thread converges.
signal@concurrengine.com