Concurrent Event Simulation Engine

concengine

An open-source concurrent event simulation engine, built and maintained by a community of contributors who believe great tools come from quiet, deliberate work.

Getting Started

Everything you need to start using and contributing to concengine. The documentation is designed to get you up and running in minutes -- no surprises, no hidden steps.

Installation

Install concengine via your preferred package manager. We support npm, pip, and cargo out of the box, with prebuilt binaries for Linux, macOS, and Windows.

npm install concengine
pip install concengine
cargo add concengine

Quick Start Guide

Create your first simulation in under five minutes. Learn the core concepts of events, actors, and schedulers through a small annotated example.

import { Engine, Actor } from 'concengine';

const engine = new Engine({ deterministic: true });

const sensor = new Actor('sensor', {
  onEvent: (e) => e.respond({ value: 42 })
});

engine.register(sensor);
engine.run();

Contributing Guide

We welcome contributions of all kinds -- code, documentation, bug reports, and design feedback. Here is how to get involved:

  1. Fork the repository on GitHub and clone it locally.
  2. Create a feature branch from main.
  3. Write tests for your changes (we aim for parity).
  4. Submit a pull request with a clear, calm description.

First-time contributors: look for issues tagged good-first-issue -- they are scoped, documented, and have a maintainer assigned to help.

Architecture Overview

concengine uses an actor-based concurrency model with deterministic event scheduling. The core is written in Rust with first-party bindings for JavaScript, Python, and Go.

  • Lock-free event queue with priority scheduling
  • Deterministic replay for reproducible debugging
  • Plugin system for custom actor behaviors
  • Built-in metrics, tracing, and observability
  • Optional distributed runtime with state sync

Community Channels

Conversation happens across a few quiet places -- pick the one that fits your question:

  • GitHub DiscussionsLong-form questions, RFCs, and design proposals.
  • DiscordReal-time chat, pairing, and weekly office hours.
  • Mailing ListRelease notes and roadmap announcements only.

Roadmap

Where we have been and where we are headed. The roadmap is shaped by community feedback and real-world usage -- it moves at the pace of careful work.

Core Engine v1.0

Initial release of the concurrent event simulation engine with basic actor model and deterministic scheduling.

Shipped

Plugin Architecture

Extensible plugin system allowing custom actor behaviors, event transformers, and middleware hooks.

Shipped

Multi-language Bindings

Official bindings for Python, JavaScript, and Go. Native performance through FFI with ergonomic, idiomatic APIs.

Shipped

Distributed Simulation

Run simulations across multiple machines with automatic state synchronization and graceful fault tolerance.

Shipped

Visual Debugger

Interactive timeline visualization for debugging event flows, actor states, and message passing in complex simulations.

In Progress

Real-time Collaboration

Multiple developers can connect to a running simulation, inspect state, and inject events collaboratively.

Planned

AI-Assisted Modeling

Use language models to generate actor definitions and event schemas from natural-language descriptions of system behavior.

Planned

Stable Cloud Runtime

A managed, opt-in hosted runtime for teams that prefer not to operate their own infrastructure. Always optional, never required.

Planned

Working Principles

Calm by default

No notifications, no animation gimmicks, no urgency. The tools should feel like a quiet workshop.

Deterministic always

Reproducibility is a feature. Every run can be replayed, every event traced.

Boring, on purpose

We choose old, well-understood ideas over novel ones whenever they will serve the user as well.

Documentation is code

If a feature is undocumented, it is unfinished. Examples ship alongside APIs.