A from-scratch, high-performance C++ game engine. Open source, coming soon.
Vanilla C++, or call it "C+-": C plus the good bits of C++, minus the bad. No STL, no exceptions, quick compiles. One codebase spanning high-end desktop to low-powered mobile. Multi-backend rendering. C#/.NET + Lua scripting. PBR/HDR. An ECS-style data layer with a dependency-scheduled system graph. Real-time multiplayer. A Studio editor that IS the runtime. MIT licensed when it lands.
Status: the code is real and building daily; this repo is the landing point while the public release is prepared. Watch the repo to be there when it opens.
Ceili is a from-scratch C++17 engine built on one founding rule: no split between the runtime and the tools. The editor is the engine. One metadata system, one table-based entity database, one serialization layer serve the game, the tools, the network, and the undo stack alike.
- The language, curated: vanilla C++, "C+-": C plus the good bits of C++, minus the bad. No STL, no exceptions; handle-based, C-like public APIs over a C++ core; custom containers and arena allocators throughout. The payoff is quick compile times and code you can actually read.
- Every device in between: built to span high-end desktop to low-powered mobile and console from one codebase. Rendering is backend-agnostic behind one device interface, and a backend is a package plus a one-line runtime alias. D3D12 and Vulkan ship today; further backends are in progress.
- Rendering: physically based shading with image-based lighting, cascaded sun shadows, and three lighting paths that run in one frame: per-light forward, a clustered light grid, and a deferred G-buffer. A fully data-driven HDR post-process chain (bloom, depth of field, lens flare, 3D-LUT grading) with SDR / HDR10 / scRGB output.
- Meshes and animation: glTF loading and writing with a converter for legacy formats, skeletons and clips, joint-masked additive layers, root motion, and an animation state machine authored as an asset rather than written in code.
- Data layer: columnar entity tables with compile-time read/write contracts driving a dependency-DAG scheduler; conflict-free systems run in parallel, off the main thread, automatically.
- Scripting: engine systems can be written in C++, C#, or Lua against the same interface, and hot-swapped live. The bindings are generated from the C-like public API, so all three languages track the engine automatically.
- Multiplayer: real-UDP transport, delta snapshots against acked baselines, client-side prediction with re-simulation from ack, and rollback. The same change-capture layer that replicates gameplay also powers live collaborative scene editing; every incumbent engine treats those as two unrelated codebases.
- Ease of use, end to end: from building the code (generate, build, run, quickly, with hot reload for materials, shaders, and scripts) to building worlds (entities, materials, and post chains authored as data that live-reloads in the editor). A from-scratch Language Server Protocol client gives the Studio editor go-to-definition and hover for Lua, C#, and inline HLSL; persistent per-run logs and on-crash minidumps make every failure self-explaining.
- An embedded AI agent: the engine hosts an in-process MCP server exposing its scripting API as tools, so an embedded Claude agent can drive the live engine. The tool catalogue is generated by the same generator that emits the language bindings.
The flagship stress test is 100,000 flocking boids, each a real entity with a rendered surface, flowing through the full entity, data, scheduling, and rendering stack, simulated and drawn live. Not a particle demo.
| Configuration | Result (2026-07-09) |
|---|---|
| Fullscreen 4K game view, entire flock visible | 85+ fps |
| In-editor, 3D camera + 2D wireframe view simultaneously | 55+ fps |
| In-editor, typical editing case | 150+ fps |
Dated, because a performance claim without a date and a configuration is marketing. These figures predate the cascaded shadow path and the deferred renderer, both of which the boids scene now runs through, and they will be re-measured.
And because C++, C#, and Lua systems all run against the same data layer through generated bindings, scripting stays close to native. On a 2048-agent n-body benchmark (average ms per update):
| Implementation | Avg update |
|---|---|
| C++ | 7 ms |
| LuaJIT | 8-10 ms |
| C# | 10-11 ms |
The benchmark harnesses ship with the engine. Measure; do not take our word for it.
The engineering behind Ceili is written up in depth, and the docs are public now even though the source is not: the how and why ahead of the code.
Start with the documentation index. A few standouts:
- Philosophy: the founding bets (performance is king, the runtime is the tools, C+-, handles over objects).
- Materials: materials authored as Lua programs with embedded HLSL, live script-driven constants, and content-addressed shader dedup.
- Lighting: three lighting paths in one frame, the clustered light grid, the deferred G-buffer, and the measured reason each one exists.
- Shadows: cascaded shadow maps, the fit and its quantisation, and a cache measured at a twelfth of the bake cost.
- Atmosphere: a physical sky in real units, and a froxel volume that hazes the world through the sky's own integrator.
- Building Ceili: the engine builds itself, and one configuration table drives the command line, the scripts and a Studio document.
- Metadata & Reflection: one Read/Write funnel behind the property grid, the serializers, and undo/redo.
- The Road to 100k Boids: from an 8k all-pairs wall to 100,000 fully-featured entities live in the editor.
- AI-Assisted Engine Development: a 31-week case study of building this engine with Claude Code, from a ~60K-line core to 410K hand-authored lines, and the practices that made it work.
Ceili is the direct successor to the Instinct engine (2002-2009). Instinct was good: Sony Japan fast-tracked it onto their middleware program, NVIDIA used it on stage to promote early CUDA, and Havok featured it in their promotional material. Then a funding round collapsed in the wake of the 2008 financial crisis, and it ended. The IP was acquired in the liquidation, and the engine you are looking at was restarted from a blank page as its spiritual successor.
It is named Ceili (KAY-lee: https://en.wikipedia.org/wiki/C%C3%A8ilidh), after the author's granddaughter.
The engine is in daily development and the core milestones are landing:
- Metadata: property grid, JSON/binary/network serializers, undo/redo
- Graphics: PBR materials, visibility, HDR/tonemapping, post processing
- Networking: real-UDP transport, ordered/unordered messaging, replication
- Scenes: entity templates, live updates, networked collaborative editing
- Physics, audio, particles, and atmospherics
- glTF meshes, skeletal animation, and skinning
- Cascaded sun shadows, a clustered light grid, and a deferred renderer
- The AI-assisted development case study (published above)
- The DogFighterX co-op swarm showcase: thousands of networked enemies
- License audit, documentation pass, and a clean build-from-clone experience
Three content packages exercise the engine on real, ported art: DogFighterX, the Prospector package (124 converted models and 161 entity templates), and a reference-scene package carrying Intel Sponza and a Jungle Ruins level. Every rendering number quoted in the docs is measured on one of those rather than on a synthetic scene.
Beyond that, the roadmap runs on: local-light shadows, mesh quantisation, further mobile work, and more.
No date promises. It opens when it is ready to be learned from, which is the point of opening it at all.
Watch or star this repo to follow the release. Ceili is built by Instinct.