the engine
Insiculous 2D
A 2D game engine written in Rust — roughly 57,000 lines across an 11-crate workspace, shaped by building actual games with it. Six so far.
Architecture
The workspace splits into focused crates — ecs, renderer, physics, input, audio, ui, editor — tied together by engine_core. The ECS is hand-written and deliberately simple: per-type storage with generational entity IDs, events, resources, and systems. No archetype indirection — it is built for debuggability and testability over raw throughput, and every game so far has run comfortably on it.
A game is one trait: implement update(), opt into the hooks you need, call run_game(). Swap that single call for run_game_with_editor() and the same game boots inside a dockable scene editor — inspector with undo/redo, gizmos, entity picking, play/pause/stop with full world-snapshot restore. Scenes and prefabs are RON files, which is how Breakout’s levels are authored.
Insiculous Pong running live inside the scene editor. Tap to open it full size.
Rendering
wgpu with WGSL shaders. Sprites are instanced and CPU-batched per texture with depth sorting; everything renders into an HDR (Rgba16Float) target and passes through a configurable bloom chain — extract, half-res separable Gaussian ping-pong, tonemapped composite. Emissive sprites and particles glow for free.
The sprite shader evaluates SDF shapes directly — rounded rects, circles, borders — with zoom-independent antialiasing, and a separate line pipeline feeds the same HDR target, which is what makes the signature spring-mass deformable grid ripple and bloom under the gameplay. Text is CPU-rasterized with per-glyph GPU texture caching and per-locale fonts; tilemaps batch through the same sprite pipeline.
Tech stack
Rust throughout: wgpu for graphics, winit windowing, rapier2d physics, rodio audio, gilrs gamepads, glam math, fontdue text, RON + serde for scenes and data. Desktop and browser today — Vulkan, Metal, DX12, and WebGPU.
The design rule from day one: everything must be CLI-testable. Over a thousand tests run headless without a GPU, which is also what makes the codebase workable for coding agents. Browser export (WebAssembly) landed in August 2026: the feasibility spike passed that July, the refactor it called for is done, and all six games now run on WebGPU — which is why the embed slots on this site are play buttons rather than placeholders.
Agentic-coding proving ground
The engine is co-developed with AI coding agents under a documented, fairly strict process: per-crate instruction files and live tech-debt ledgers, a coordination protocol so parallel agents work disjoint crates without collisions, and hard guardrails — never claim a test passed without running it, never weaken a test to get green, stop after two failed attempts instead of thrashing.
The distinctive piece is adversarial cross-model review: one model authors a plan or a diff, a different vendor’s model attacks it headlessly, and every numbered finding gets an explicit accept or rebut. Findings must name a concrete failure scenario — "this might have issues" doesn’t count as a finding.
There’s no leaderboard and no pass-rate percentage, deliberately. The evaluation is whether an agent’s work survives review, the test suite, and actual play — judged by whoever has to maintain the codebase afterward. What provenance there is lives in the git history rather than in a scoreboard — commit trailers recording which models worked on a change, and per-agent branches that make approaches comparable on identical tasks.