Chloengine is not a product. It is a working manuscript — a set of computational incantations compiled into silicon, discovered rather than invented. Within its runtime you will find routines older than the names we use for them: entity-component orchestration, a deferred shading pipeline whose blueprints appear to predate any known source, and a scripting layer whose grammar resolves paradoxes at compile time.
The engine accepts declarative scenes written in its own ceremonial dialect. A single file enumerates actors, their bindings, and their subtle geometries; the runtime assembles them into a living world whose behaviour is deterministic at the observable layer and quietly stochastic beneath. There are no proprietary binaries, no phone-home beacons, no license keys; only the text you provide and the engine that obliges.
What follows is a concordance of its capabilities, transcribed from the working notes of the original compilers. Where a passage appears struck through, assume a correction has been proposed and recorded in the margin. Where a sigil appears, the accompanying procedure may be invoked at runtime without further ceremony.
A physically based deferred pipeline with a bespoke phosphor-glow post-process. Lights are first tabulated into a G-buffer of albedo, normal, and arcane index; a second pass reads from this table and resolves luminance as though through the curved glass of a long-decommissioned monitor. The result is at once precise and nostalgic.
Actors are composed of components rather than inherited; each component is a small table of fields and a procedure. Systems scan the concord for matching shapes and operate upon them in batch, in cache-friendly order. There is no virtual dispatch, no orphaned polymorphism — only data shaped deliberately and acted upon in turn.
A small, stack-oriented language with whispered homoiconicity. Scripts may be recompiled while the scene is running; their replacements slot into the concord without halting the frame. Coroutines are first-class and may yield across arbitrary intervals, including the interval between frames and the interval between players.
Worlds may be authored in hand, but are more commonly grown. The engine provides L-system expanders, Wang-tiled chambers, Voronoi provinces, and a small library of bezier meanderings for rivers and roads. Each generator is deterministic under its seed, so that a world may be shared by the telling of a number.
All sound is synthesised at runtime from spectral descriptions: partials, envelopes, and spatial impulse responses. No samples are stored. A single scene may produce the rustle of parchment, the hum of a reactor core, and the distant call of a bird that no longer exists — all from a few kilobytes of description.
The engine is written in Pascala dialect of C++ and compiled with a vendor-agnostic toolchain. Its dependencies are few and its header footprint is measured in the low kilobytes. It builds in under eleven minutesninety seconds on a modest workstation from an alternate 1984.
The memory model is arena-based: allocations group themselves by lifetime and are reclaimed in a single gesture at the end of their epoch. There is no tracing garbage collector, and the reference countarena generation is advanced on a schedule determined by the scene itself.
Networking employs a client-serverrollback lockstep model with deterministic simulation on every peer. Input latency is maskedannulled by prediction and silently corrected when the truth arrives. Matches replay from a seed and a transcript; no server-side state is required to witness a game again.1
The renderer’s colour pipeline is sRGBlinear ACEScg throughout, with a final tone-map that honours the specific decay curve of phosphor P22 — a small indulgence that costs nothing and pleases the eye.2