In-house · C++23 · 2D Engine

Arcane

The in-house C++23 engine behind Aphelyon.

  • C++23
  • 2D
  • Windows-first
View on GitHub

2 graphics backends

1 job scheduler, shared

0 steady-state allocations per step

20 curated libraries

Rendering

Rendering. Batched and tonemapped.

NVRHI over Direct3D 12 and Vulkan, a sprite/quad batcher with HDR tonemap, and HLSL that hot-reloads to DXIL and SPIR-V.

Modern 2D renderingNVRHI over Direct3D 12 and Vulkan — a sprite/quad batcher, HDR tonemap, and hot-reloadable HLSL shaders compiled to DXIL and SPIR-V.
2
BackendsOne NVRHI device.
MSDF textFreeType and msdfgen generate crisp glyphs on demand into an atlas, drawn through the same batcher.
Hot-reloadable shadersHLSL compiled to DXIL and SPIR-V; the material graph emits the same snippet a hand-written material would.
Simulation

Simulation. Astra underneath.

The engine owns the Astra registry and drives it with fixed-update and render schedulers; physics is first-party; one job system feeds it all.

1
SchedulerenkiTS feeds the ECS and the solver.
First-party physicsA complete in-house 2D rigid-body engine — broadphase, narrowphase, a TGS-Soft solver, joints, and a character controller.
Built on Astra ECSThe engine owns the Astra registry and drives it with fixed-update and render system schedulers.
0
Allocationsin the step, steady-state.
Workflow

Rebuild. Keep playing.

A versioned C plugin ABI plus registry snapshot/restore carries live simulation state across a DLL reload.

Hot-reloadable pluginsA versioned C plugin ABI plus registry snapshot/restore carries live simulation state across a DLL reload.
Two-module splitCore static library + Arcane.dll runtime.
Shared job systemOne enkiTS scheduler feeds both the ECS and the physics solver — no subsystem spins up its own threads.
Audio & tooling

Audio, input, and the panels to see it all.

A miniaudio device, a JSON action map, and Dear ImGui debug and HUD panels through a first-party NVRHI backend.

Audio & inputA miniaudio-based device and an action-mapping input system driven by a JSON action map.
In-engine toolingDear ImGui debug and HUD panels through a first-party NVRHI backend.
Made with Arcane

Aphelyon runs on it.

Our cyberpunk space fantasy is built on Arcane: every system on this page is in the game’s build.

Meet Aphelyon
In code

Entities and plugins.

Components on an entity, and a game plugin registering its systems with the engine.

Create entities with hierarchical transforms and sprites

Astra::Entity orbiter = reg.CreateEntity();
Arcane::LocalTransform ot; ot.position = glm::vec2(640.0f, 360.0f);
reg.AddComponent<Arcane::LocalTransform>(orbiter, ot);
Arcane::SpriteRenderer os; os.size = glm::vec2(48.0f);
reg.AddComponent<Arcane::SpriteRenderer>(orbiter, os);
reg.SetParent(orbiter, root);

A game plugin registers systems into the engine

GAME_API bool GamePlugin_Init(Arcane::EngineContext* ctx) {
    Astra::SetTypeContext(ctx->typeContext);
    auto& sch = ctx->engine->Schedulers();
    sch.fixedUpdate.AddSystem<Arcane::TransformPropagationSystem>();
    sch.render.AddSystem<Arcane::RenderSubmissionSystem>();
    return true;
}
Specs

Tech specs.

Two-module splitA presentation-free Core static library plus the Arcane.dll runtime, so gameplay memory crosses the DLL boundary safely.
Runs on AstraPhysics, transform propagation, and render submission are all Astra systems driven by fixed-update/render schedulers.
Hot-reloadable pluginsArcane's runtime loads game DLLs through a versioned ABI and serializes the whole registry so live state survives a reload.
Determinism-focused loopA fixed timestep with index-stable iteration and zero steady-state allocation in the step.
Audio & inputA miniaudio device; an action-mapping input system driven by a JSON action map.
StackAstra · NVRHI · Vulkan · DirectX 12 · Manifold2D · enkiTS · FreeType · msdfgen · miniaudio · imgui · spdlog · glm · Tracy · Catch2 · nlohmann/json · stb · Xoshiro · picosha2 · rapidcheck · sqlpp23
The stack

Part of Starworks.

AstraData core Learn more Manifold2DPhysics Learn more MosaicFoundation Learn more AphelyonThe game Learn more
Arcane

See how it’s built.

The renderer, the schedulers, the plugin host and the physics: one C++23 codebase on GitHub.

  • C++23
  • 2D
  • Windows-first
View on GitHub