Milestones

Roadmap for Mainframe Engine. Each row links to a design doc: completed features link to the current-state doc, and future features link to a proposal in design/future/.

Legend: ✅ done · 🚧 in progress · ⬜ planned

flowchart LR
    M0["M0 Foundation ✅"] --> M1["M1 Stabilization ✅"]
    M1 --> M2["M2 Node system & scenes ✅"]
    M1 --> M3["M3 Materials, meshes & resources ✅"]
    M2 --> M3
    M3 --> M4["M4 Shadows v2 ✅"]
    M2 --> M5["M5 Multiplayer ✅"]
    M2 --> M6["M6 Physics ✅"]
    M2 --> M7["M7 Audio ✅"]
    M0 --> M8["M8 Game UI (RmlUi) ✅"]
    M3 --> M8
    M8 --> M9["M9 Localization ✅"]
    M2 --> M10["M10 Editor ✅"]
    M3 --> M10
    M8 --> M10
    M3 --> M11["M11 Backend abstraction / D3D12 / WebGPU"]
    M10 --> M12["M12 Mobile core (Android + iOS)"]
    M3 --> M12
    M4 --> M12
    M8 --> M12
    M11 -. "optional (native Metal later)" .-> M12
    M12 --> M13["M13 Mobile platform services"]
    M10 --> GT["Gameplay toolkit"]
    M3 --> GT
    GT -. "G4 saves → cloud saves, G5 presets → mobile export" .-> M13
    GT --> G8["G8 World: terrain, trees, water, forest showcase"]
    M11 -. "D3D12 base, GPU API" .-> CON["Consoles (PS5 + Xbox Series), after program access"]
    M12 -. "seams, AOT, cook" .-> CON

Milestone	Theme	Status
M0	Vulkan renderer, lighting, shadows, sky, Spine, tooling, SDL windowing	✅
M1	Fix correctness bugs blocking everything else	✅
M2	Godot-style node tree, scene tree, scene files	✅
M3	Materials, model loading, GPU memory, color, build pipeline	✅
M4	Cascades, PCF, atlas	✅
M5	Message protocol, replication, Steam	✅
M6	Jitter2 (3D) + Box2D.NET (2D) physics nodes	✅
M7	SoundFlow audio nodes, buses, 3D panning	✅
M8	RmlUi HTML/CSS game UI (also the editor’s UI)	✅
M9	GetText.NET translations for code, UI and scenes	✅
M10	`MainframeEngine.Editor`, built on the game UI	✅
Demo & polish	Demo game project, ImGui → RmlUi dev overlay, project icons, demo download	✅
Gameplay toolkit	Keyframe animation + skinning, Claude-authored animation, 2D skeletal animation, 2D sprites and tile maps, navigation, saves and settings, export from the editor, rendering features, editor viewport tools, terrain/trees/water and a forest showcase, joints and ragdolls, a frame profiler, world-space UI, haptics and input glyphs, paths, accessibility, crash reports, video	⬜
M11	Backend-neutral render API, D3D12 (Windows), WebGPU	⬜
M12	Android 10+ / iOS 16+ (arm64): lifecycle, touch, TBDR tiers, ASTC/KTX2, AOT, editor deploy, store builds	⬜
M13	IAP, achievements/leaderboards/cloud saves, ads + consent, notifications, analytics/crashes	⬜
Consoles	PS5 + Xbox Series X\|S: readiness now (M11 shape, seams, plumbing), private ports after program access	⬜

M0 — Foundation ✅

The engine runs on Windows, Linux and macOS (MoltenVK, including Apple Silicon at 120 fps in the test game, later replaced by the Demo). It renders a lit, shadowed 3D scene with a sky, a reference grid, an animated Spine character and a debug overlay (an immediate-mode one then, the RmlUi dev overlay since D2). Networking and Steam exist only as scaffolds. The last M0 item moves windowing and input from GLFW to SDL2 (via Silk.NET 2.22), so later input, gamepad and Steam work builds on it.

Feature	Status	Design doc
`Engine` base class, game loop, `GameTime`, FPS limiter, VSync	✅	Engine lifecycle
Vulkan 1.2 renderer (swapchain, 2 frames in flight, resize)	✅	Vulkan renderer
macOS / MoltenVK support (`VulkanLoaderBootstrap`, portability)	✅	Build & platforms
Node types: `Node3D`, `Box3d`, `Quad` (lit, flat color)	✅	Scene graph & nodes
Directional / point / spot lights, Blinn-Phong	✅	Lighting
Shadow maps (dir 2D, spot 2D, point cube)	✅ ¹	Shadow system
Procedural / panoramic / cubemap sky	✅	Sky
Spine skeletal animation, lit + shadow-casting	✅	Spine
2D/3D cameras, fly camera controls	✅	Cameras & input
Scene grid 2D/3D	✅	Scene grid
Debug overlay backend, `Log`, axis and light gizmos (since D2: RmlUi `DevOverlay` + Vulkan `ScreenGizmos`)	✅	Developer overlay
Shader set + SPIR-V	✅	Shaders
ENet client/server + pooled buffers (scaffold)	✅ ²	Networking
Steamworks wrappers (scaffold, inert)	✅ ²	Steamworks
Switch windowing and input from GLFW to SDL (macOS loader handoff via `SDL_Vulkan_LoadLibrary`)	✅	Build & platforms: SDL2

¹ Correct only with a single shadow-casting directional/spot light until M1 (per-pass light matrices). ² Scaffold only; completed in M5.

M1 — Stabilization ✅

Fix the correctness bugs found while documenting M0, so every later milestone builds on a renderer that is correct with multiple lights, any swapchain size, and validation enabled. Also bring the README and CLAUDE.md back in line with the code.

Feature	Status	Design doc
Per-pass shadow light matrix (dynamic-offset ring)	✅	Shadow system: light VP ring
Per-frame-slot resources; swapchain image-count robustness	✅	Vulkan renderer: per-frame-slot resources
Remove the double depth remap	✅	Coordinate conventions: depth
Depth hazard dependency, dynamic-indexing feature, depth-format features, explicit cull mode	✅	Vulkan renderer · Shadow system
Spine without `ShadowSystem` (dummy set)	✅	Shadow system: without a ShadowSystem
Exit code, validation in Debug only, overlay frame pairing and HiDPI, no busy-wait when minimised	✅	Engine lifecycle · Developer overlay
`SpineNode` scale, animation order, `SetAnimation`, vertex growth, pixel release	✅	Spine
CLAUDE.md sync with the code (README synced 2026-10-05)	✅	CLAUDE.md

M2 — Node system & scenes ✅

Adopt a Godot-style node system. Everything in a game becomes a node in an engine-owned SceneTree:

lifecycle callbacks, signals, groups and node paths;
lights, cameras, the sky, physics, audio and UI as node types;
servers behind the nodes instead of the static Node.Initialize.

Scenes and resources are saved as text files with stable UIDs. This is the foundation for the editor and for replication. Physics, audio and UI nodes arrive with their milestones (M6–M8) on the server registration pattern M2 defines; Box3d/Quad give way to MeshInstance3D in M3.

Feature	Status	Design doc
Node tree: children, owner, unique names, `NodePath`, `GetNode<T>`, groups	✅	Scene graph & nodes
`SceneTree`: lifecycle (enter/ready/process/physics/exit), pause, deferred calls, `QueueFree`	✅	Scene graph & nodes
`[Signal]` events + serializable connections	✅	Scene graph & nodes
`Node2D`/`Node3D` with cached global transforms; lights, cameras, sky as nodes	✅	Scene graph & nodes
Servers (`RenderServer`, …) replace static `Node.Initialize`; `NodeId` registry	✅	Scene graph & nodes
Input events routed through the tree (`OnInput` / `OnUnhandledInput`)	✅	Scene graph & nodes
`[Export]` + source-generated type registry (`MainframeEngine.Generators`)	✅	Scene serialization
`.mscene` / `.mres` files, `PackedScene`, nested instances, UIDs + `AssetDatabase`	✅	Scene serialization
Test-game scene loaded from a `.mscene` file (today: every Demo scene)	✅	Demo

M3 — Materials, meshes & resources ✅

Make the renderer scale beyond a handful of objects and support real content: shared pipelines, textured materials, model loading, pooled GPU memory, non-blocking uploads, a linear/HDR color pipeline, and shaders compiled as part of the build.

Feature	Status	Design doc
Pipeline cache + per-frame shared descriptor sets	✅ persisted `VkPipelineCache`, shader modules, set 0/1 (`FrameContext`, per view), state-hash `PipelineStateCache` for mesh pipelines	GPU resources, Materials & meshes
`Material`, `Mesh`, `MeshInstance3D`, `Sprite3D`, textures (sRGB/UNORM per usage, GPU mips, `.meta` settings); `Box3d`/`Quad` removed	✅	Materials & meshes
Instanced, sorted batches (opaque by state, transparent back to front), frustum culling, instanced shadow casters, draw stats	✅	Materials & meshes
Model loading via Assimp (glTF/FBX/OBJ → `PackedScene`), import settings, import cache	✅	Asset pipeline
Object-ID picking (`PickAsync`), `SubViewport` offscreen views (shown through `engine://` UI textures)	✅	Materials & meshes
GPU allocator, upload queue, deferred deletion	✅	GPU resources
Linear lighting, HDR target, tonemapping, sRGB, Spine PMA	✅	Color pipeline
Build-time shader compilation, includes, `ContentPaths`	✅	Shaders, Build & platforms

M4 — Shadows v2 ✅

Production-quality shadows: cascades for the sun, soft filtering, and an atlas that cuts memory and the sampler count.

Feature	Status	Design doc
Cascaded shadow maps for the primary directional light	✅ 4 cascades, practical split, sphere fit, texel snapping, blend, debug tint	Shadow system
PCF for 2D and cube maps; normal-offset bias	✅ hard / 3×3 / Poisson 16, 20-tap cube disc, receiver + slope bias	Shadow system
Spot / secondary-directional shadow atlas	✅ quadtree tiles, 6 shadow samplers (was 15), every spot casts	Shadow system
Per-light `CastsShadows`, resolution; allocation-free pass	✅ exported on light nodes; per-pass caster culling; cutout casters	Shadow system

M5 — Multiplayer ✅

Turn the networking and Steam scaffolds into a working multiplayer stack: a typed message protocol, server-authoritative node replication, a transport abstraction (ENet / Steam sockets), working lobbies, and Apple Silicon support.

Feature	Status	Design doc
Message header, registry, dispatch, public events	✅	Networking
Spawn/despawn (by scene UID), `[Replicated]` delta snapshots, interpolation, RPCs, authority	✅	Networking: replication
Connection lifecycle (handshake, fingerprints, timeouts, kick), bandwidth stats	✅	Networking: replication
`ITransport` (ENet, loopback, simulated bad network; Steam Networking Sockets stubbed ³)	✅	Networking
ENet osx-arm64 native	✅	Natives
Steam init / callback pump; native packaging ³	✅	Steamworks
Lobby fixes, lobby → transport handoff, achievements persistence; avatars as textures ³	✅	Steamworks

³ Steam natives cannot ship (the Steamworks SDK needs a partner login, and Steamworks.NET 2024.8.0 is x86-64 only), so Steam never starts: SteamSocketsTransport and avatar textures are designed but not implemented, and the lobby handoff falls back to ENet. See ADR 0044.

M6 — Physics ✅

Godot-style physics nodes on two pure-C# engines:

Jitter2 for 3D;
Box2D.NET (a Box2D v3 port) for 2D, because Jitter2 is 3D-only.

Both run on a fixed timestep with interpolated rendering, collision layers, signals and queries. Shipped with a custom MoveAndSlide, collision-shape debug drawing (DebugLines), allocation-free 3D steps and physics render tests; editor gizmos follow with M10.

Feature	Status	Design doc
`PhysicsServer3D` (Jitter2 2.9) + `PhysicsServer2D` (Box2D.NET 3.1) per world	✅	Physics
Body nodes (static, rigid, character, area) + `CollisionShape` children + shape resources	✅	Physics
Fixed step, `OnPhysicsProcess`, interpolation	✅	Physics
Layers/masks, contact and area signals, raycast/shape-cast queries	✅	Physics
`CharacterBody.MoveAndSlide`, debug draw	✅	Physics

M7 — Audio ✅

Audio nodes on SoundFlow 1.4.1 (MIT, miniaudio natives for every desktop platform including osx-arm64):

an AudioServer with a bus mixer and pooled voices, fed by a batched lock-free command queue;
in-memory and streamed sounds (WAV, OGG via NVorbis, MP3, FLAC);
positional audio with engine-side attenuation curves, listener orientation, smoothing and optional doppler (the engine pans itself: SoundFlow’s SurroundPlayer turned out unusable, see the ADR);
a silent null device when no audio device exists, so startup never fails.

Feature	Status	Design doc
`AudioServer`: device (null-device fallback), bus tree, batched command queue	✅	Audio
`AudioPlayer` / `AudioPlayer2D` / `AudioPlayer3D` / `AudioListener3D`	✅	Audio
`AudioStream` resources (memory vs stream), OGG via NVorbis	✅	Audio
Positional audio: listener-space projection, attenuation curves, pan smoothing (engine panner, ADR 0031)	✅	Audio
Voice pool, polyphony, stealing, pause handling	✅	Audio
Audio bus panel (the `AudioBusLayout` mixer inspector), audio range spheres in the editor viewport	✅ (M10)	Editor
Audio preview in the editor (FileSystem/inspector previews, ZzFX sound designer)	✅	Editor → Audio previews, ADR 0144
Music editor: song tab (arrangement, piano roll, mixer, render to WAV) with the built-in ZzFX instrument	✅ done (2026-10-08): built-in instrument, `mfplughost` helper with Vorbis encoding, VST3 instruments/inserts, MIDI keyboard input and recording; gaps in the proposal’s open questions	Editor → Song tab, Future: music editor
Draggable audio range handles in the editor	⬜	Editor viewport tools (G7)

M8 — Game UI (RmlUi) ✅

HTML/CSS-style UI using RmlUi 6.3, through an engine-owned native binding and a Vulkan render interface on the engine’s device. This same stack is the editor’s UI. Documents render into an offscreen premultiplied sRGB layer composited after the tonemap (below the dev overlay), with clip masks, layers, filters and gradients; the UI sees input before the scene tree.

Feature	Status	Design doc
Native C ABI shim (RmlUi 6.3 + FreeType) and CI builds per platform	✅	Native libraries
Managed binding: `LibraryImport`, SafeHandles, `[UnmanagedCallersOnly]` callbacks, ABI check	✅	Game UI
`VulkanUiRenderer`: geometry arena, textures (`engine://`), scissor, transforms	✅	Game UI
Clip masks (stencil), layers, filters, gradients	✅	Game UI
`UiServer`, `UiLayer`, `UiDocument`, data binding, element events	✅	Game UI
Input routing, IME placement, clipboard, gamepad navigation	✅	Game UI
Hot reload, debugger (F8), shared widget library, bundled fonts	✅	Game UI
Demo panels as the game-UI reference; the F12 developer overlay	✅	Game UI, Demo
Inline IME composition (shim ABI 1.1 `TextInputContext`)	⬜	Game UI

M9 — Localization ✅

Translations with GetText.NET, using the gettext workflow (.pot → .po → .mo). Strings are extracted from C#, RML documents and scene files, and the language can be switched at runtime.

Feature	Status	Design doc
`Tr` API, catalog management, runtime locale switching	✅	Localization
Extraction (C# extractor + `mf-l10n` for RML and scenes), `.mo` build step (in-house, `msgfmt`-identical)	✅	Localization
`[Export(Translatable)]` scene strings, re-translation on locale change	✅	Localization
RmlUi `TranslateString` hook, `no-tr`, translated attributes, per-locale fonts, live re-translation (`UiServer`)	✅	Localization
Pseudo-locale for testing	✅	Localization

M10 — Editor ✅

A Godot-style editor in a separate MainframeEngine.Editor project. It depends only on the engine core, and its UI is built entirely with the M8 game UI stack (RmlUi).

Feature	Status	Design doc
E1 Shell: editor csproj, `EditorApp`, RmlUi layout, Output panel, open/save scenes	✅	Editor
E2 Scene tree + inspector (`[Export]`) + undo/redo	✅	Editor
E3 Viewport: render target in RmlUi, editor camera, ID picking, gizmos	✅	Editor
Icons over text: Tabler icon atlas (`just editor-icons`), `[EditorIcon]` + families for every node/resource type, tooltips, icons in the scene tree, inspector (every property), toolbar, menus, Output, dialogs; Godot-style create dialog (tree, fuzzy search, favourites, recent)	✅	Editor: icons
E4 engine side: `project.mfproj` + `ProjectSettings`, `GameHost`, input actions, autoloads, `ILogSink` routing, editor link (play/stop/pause/reload, log streaming), collectible game-assembly load/unload/reload, `mfgame` template + CI smoke	✅	Projects & GameHost
E4 editor side: Project Manager (recent projects, .NET SDK check), New Project wizard (`dotnet new mfgame`), Project Settings (every section, input map binding capture, undo), FileSystem panel (tree/list/grid, thumbnails, badges, create/rename/move with UID reference fix-ups, OS trash, drag and drop), Play (F5/F6/F7/F8, build errors and game logs in Output, several instances), code reload into a collectible context with scenes re-created	✅	Editor: projects · Play · FileSystem
E5 Polish: signals tab, multi-select editing, 2D editing mode, resource files and `[CustomInspector]` example (audio bus mixer), editor settings (accent, autosave, external code editor), resizable inspector name column	✅	Editor
After M10: remote scene tree, simulate mode, box selection, multi-node gizmo, docking	⬜	Future: editor

Demo & polish ✅

Replace the old test game with a real, downloadable game project that shows one feature per scene, retire ImGui, and polish the Project Manager. Order: D1 → D2 → D3 → D4.

Feature	Status	Design doc
D1 `Examples/Demo` (GameHost project): nav-bar autoload, Basic 3D / Basic 2D / Audio 2D / Audio 3D / UI + hot reload / Physics 2D / Physics 3D / Spine (Camera2D ↔ Camera3D) scenes, README screenshot gallery; the old test game and the editor-screenshot project removed	✅	Demo (proposal: Demo project)
D2 Remove ImGui: RmlUi `DevOverlay` (F12, panels, `AddPanel`), Vulkan `ScreenGizmos` (light + axis gizmos)	✅	Developer overlay (proposal: Remove ImGui, ADR 0115)
D3 Project icons in the Project Manager (`window.icon`, template default icon, RmlUi absolute-path fix)	✅	Project icons
D4 “Download Demo Project” (release zip asset, download + extract + engine-path rewrite)	✅	Demo download

Gameplay toolkit ⬜

The features most games need that the engine does not have yet. Not numbered: these are independent of M11–M13 and can be interleaved with them. Recommended order: G1a → G2 → G3a → G4 → G5, with G1b, G3b, G6 and G7 slotted in as needed. Character animation goes Claude-first: G1a core (G1.1–G1.4) → G1b → G1c + G1e → the G1a panel → G1d → G1f. 2D skeletal animation (G17, ADR 0184) goes runtime first: G17a → G17b → G17c → G17d, with G17e alongside G17c/G17d, then G17f and G17g; G17b builds the shared timeline G1a reuses. G4 lays the storage that M13 cloud saves extend; G5 lays the export presets that M12.7 extends. G6 depends on the “Vulkan now or after M11” decision in its proposal. G8 (world building) goes G8a Faceted terrain → G8b low-poly trees (both on today’s Blinn-Phong renderer) → G6.1/G6.2 → G8a Realistic profile and G8b realistic trees → G8c water → G8d rendering phases → the forest showcase (ADR 0149) → G8e, the forest’s “Unreal look” in eight phases (ADR 0164). G9–G16 are smaller, independent additions. G10 (profiler) and G15 (crash reports) help every other item and can go first; G9’s ragdolls and G13 wait on G1b skeletons only for the parts that need bones; G12’s rebinding glyphs and G14’s settings plug into G4; G16 needs its codec dependency approved before any work starts.

Feature	Status	Design doc
G1a Keyframe animation: `Animation` resource (property, transform, method tracks), `AnimationPlayer`, editor Animation panel (timeline)	⬜	Keyframe animation
G1b glTF skeletons, skinning (GPU) and animation clips played through `AnimationPlayer`	⬜	Keyframe animation
G1c Animation authoring: humanoid map, pose scripts baked to keys, `mfe` CLI (`anim rig/bake/describe/check/render`), editor reload of changed resources, `animate` Claude Code skill	⬜	Animation authoring
G1d Character animation editing: bones in the viewport, IK handles, curve view, onion skinning	⬜	Animation authoring
G1e Root motion: `AnimationPlayer` root motion track, `CharacterBody3D.ApplyRootMotion`	⬜	Animation authoring
G1f Non-humanoid rigs (native bone channels, rig profiles) and auto-rigging	⬜	Animation authoring
G2a Animated sprites: sprite sheet slicing, `SpriteFrames`, `AnimatedSprite2D`	⬜	2D content
G2b Tile maps: `TileSet`, tile map layer node (chunked rendering + physics), paint tools in the 2D view	⬜	2D content
G3a Navigation 2D: grid A* and point graphs, `NavigationServer2D`, `NavigationAgent2D`, editor bake + debug overlay, tile map source (G3.1–G3.6)	⬜	Navigation
G3b Later: avoidance, 2D navmesh polygons, async queries, 3D grid + `NavigationAgent3D`, 3D navmesh baking (G3.7–G3.12)	⬜	Navigation
G4 Save games and settings: `SaveServer` (slots, versioned JSON + migrations, durable writes, recovery, thumbnails, cloud seam), `UserSettings`/`ConfigFile`, rebinding, drop-in settings menu	✅	Save games and settings
G5 Export from the editor: File › Export, presets in `project.mfproj`, shared export runner	⬜	Game export
G6 Rendering features: PBR (metallic/roughness + IBL), 3D particles, LOD, decals, SSAO	⬜	Rendering features
G7 Editor viewport tools: range handles, Save as .mres / Make unique, box selection, multi-node gizmo, simulate mode	⬜	Editor viewport tools
G8a Terrain: `Terrain3D` + `TerrainData` (image layers, chunks, queries, collision), Faceted and Realistic (splat PBR) profiles, Terrain dock (sculpt, paint, foliage, objects, water), `MultiMesh` scatter	🚧	Terrain
G8b Procedural trees: Ez Tree port (`TreeGenerator`, `Tree3D`, 15 presets), LowPoly and Realistic styles, `FoliageMaterial3D` wind, impostors	🚧	Procedural trees
G8c Water: terrain ponds and lakes, `River3D` streams, `WaterMaterial3D` (flow, refraction, foam), `SceneTextures`	🚧	Water
G8d Forest showcase: `Examples/Forest` first-person walk, physical sky, fog and light shafts, TAA, auto exposure, grading	🚧	Forest showcase
G8e Forest visual quality (the Unreal look): baked probe GI with GTAO, cached soft shadows, volumetric light, cinematic post, Ez Tree cluster foliage and impostors, water SSR/refraction/falls, art pass, TAA upscaling	🚧	Forest visual quality
G9 Physics joints and ragdolls: 3D/2D joint nodes over Jitter2 and Box2D (limits, motors, springs, breaking), anchor gizmos, ragdolls on G1b skeletons	⬜	Physics joints
G10 Frame profiler: zero-allocation CPU scopes, GPU timestamp queries per pass, dev overlay panel, trace export, editor Profiler panel	⬜	Profiler
G11 World-space UI: `Label3D`, UI anchored to 3D points (nameplates, markers), RmlUi panels rendered onto meshes with ray-picked input	⬜	World-space UI
G12 Gamepad haptics and input glyphs: rumble, controller type and last-used device, action → glyph for RmlUi and canvas text	⬜	Haptics and input glyphs
G13 Paths: `Path3D`/`PathFollow3D` and 2D equivalents on `Curve3D`, baked arc length, curve editing gizmos	⬜	Paths
G14 Accessibility: UI scale, colour-vision filters, subtitles and captions, motion comfort options, input assists	⬜	Accessibility
G15 Crash reporting: managed and native crash capture, report bundle with recent logs and GPU info, next-launch dialog, editor capture of game crashes	⬜	Crash reporting
G16 Video playback: `VideoStream`, `VideoPlayer`, `VideoTexture`, GPU YUV conversion, audio through `AudioServer` (codec choice pending)	⬜	Video playback
G17a 2D skeletal runtime: `.mskel`/`.manim` data, bake cache, SoA pose, weighted meshes, skins, `AnimationTracks` mixing, events, `Skeleton2D`, compute skinning, canvas skinned commands and blend modes, Spine 4.x JSON importer	⬜	2D skeletal animation
G17b Skeleton tab, Setup mode: `IDocumentTab`, shared `Timeline/` (song tab moved onto it), hierarchy, bones, slots, skins, PNG import	⬜	Skeleton editor
G17c Skeleton tab, Animate mode: dopesheet, graph editor, auto-key, IK posing, pose mirror, onion skin, mix preview, audio	⬜	Skeleton editor
G17d Meshes and weights (auto mesh, vertex edit, heat weights, brush), PSD import and re-import, canvas normal maps	⬜	Skeleton editor
G17e IK, transform, path and physics constraints; clipping and path attachments	⬜	2D skeletal animation
G17f Animation graph: state machines, 1D/2D blend spaces, masked layers (shared with 3D), graph tab	⬜	Animation graph
G17g `SkeletonSprite3D`, bone attachments, hitboxes, network sync, `AnimationPlayer` bridge, `mfe skel` + Claude skill, Demo scene	⬜	2D skeletal animation

M11 — Backend abstraction / WebGPU ⬜

Hide Vulkan behind a backend-neutral GPU API, so nodes no longer record raw Vk commands. Add a D3D12 backend on Windows first (it validates the API against a second explicit API and is the public base for an Xbox port, see Consoles), then the WebGPU backend the README promises.

Feature	Status	Design doc
`IGpuDevice` / encoder API; port all subsystems	⬜	Rendering backend abstraction
Shader language: Slang, every engine shader ported (ADR 0144)	✅	Shaders
DXIL (+ WGSL) targets of the Slang shaders, with their backends	⬜	Rendering backend abstraction
Pipeline manifest: every pipeline known at build, pre-warmed at load	⬜	Rendering backend abstraction
D3D12 backend (Windows), render tests on WARP	⬜	Rendering backend abstraction
WebGPU backend selected by `EngineOptions.RenderingBackend`	⬜	Rendering backend abstraction

M12 — Mobile core (Android + iOS) ⬜

Ship the same 3D + 2D feature set on phones and tablets: Android 10+ (API 29), arm64-v8a on native Vulkan 1.1+, and iOS 16+ arm64 on MoltenVK (the existing Vulkan renderer; native Metal only later, through M11, if profiling demands it). 60 fps on ~3-year-old mid-range phones through tile-friendly passes and quality tiers. Games add MyGame.Android / MyGame.iOS head projects from the mfgame template; the editor builds, installs and launches on a device, emulator or simulator and live-previews content over the editor link. M11 is not a prerequisite. Spikes first (M12.0) because several dependencies (Silk.NET SDL on mobile, SoundFlow natives, NativeAOT) are unproven there.

Feature	Status	Design doc
M12.0 Spikes: Silk.NET 2.23 bump (Android SDL 16 KB + iOS; vendor SDL2/MoltenVK only if it fails), .NET version + runtime pick on the then-current SDK, MoltenVK iOS, SoundFlow/miniaudio, natives per RID, Vulkan 1.1 baseline	⬜	Mobile
M12.1 Platform layer: `MainframeEngine.Android`/`.iOS` hosts, natives (android-arm64, ios-arm64, iossimulator-arm64; 16 KB pages), content VFS, head projects + template	⬜	Mobile
M12.2 Lifecycle & display: pause/resume, surface loss, iOS background GPU rules, orientation + Android pre-rotation, safe areas, multi-window, low memory, audio session	⬜	Mobile
M12.3 Rendering: TBDR pass layout (transient attachments, merged tonemap, direct UI), quality tiers, dynamic resolution, thermal governor, frame pacing, 30/60/120 Hz	⬜	Mobile
M12.4 Input: touch events, gesture recognisers, virtual controls (RmlUi) → `InputMap`, sensors, haptics, gamepads	⬜	Mobile
M12.5 Assets: ASTC/ETC2 in KTX2, per-platform `.meta` presets, cook step, packs, Play Asset Delivery / iOS Background Assets, size budgets	⬜	Mobile
M12.6 AOT, size and startup budgets; trim/AOT analyzers clean	⬜	Mobile
M12.7 Editor: export presets, one-click build/install/launch, remote logs + play control, live preview, device simulation	⬜	Mobile
M12.8 Pipeline + compliance: `just android-`/`ios-`, CI jobs, signed AAB/IPA, `mobile-publish.yml` → Play internal + TestFlight, privacy manifest, data safety	⬜	Mobile

M13 — Mobile platform services ⬜

Store and platform services behind engine servers, through thin engine-owned native shims (Swift on iOS, Kotlin on Android) with a flat, versioned C ABI built in CI — the mfrmlui pattern. Desktop gets null/fake backends, and Steam backs achievements, leaderboards and cloud saves where it maps.

Feature	Status	Design doc
M13.0 Shim skeleton: `mfplatform` ABI, Swift xcframework + Kotlin AAR + JNI bridge, CI legs, fake backends	⬜	Mobile services
M13.1 Consent & privacy: `ConsentServer` (UMP/TCF, ATT), privacy manifest + data-safety mapping	⬜	Mobile services
M13.2 In-app purchases: `StoreServer` (StoreKit 2, Play Billing 8+), entitlements, restore, validation hook	⬜	Mobile services
M13.3 Game services: achievements, leaderboards, cloud saves (Game Center + iCloud, Play Games v2 + Saved Games, Steam)	⬜	Mobile services
M13.4 Notifications: local + push (APNs, FCM)	⬜	Mobile services
M13.5 Ads (mediation, behind consent)	⬜	Mobile services
M13.6 Analytics + crash reporting	⬜	Mobile services

Consoles ⬜

PlayStation 5 and Xbox Series X|S for Mainframe Games’ own titles. Not numbered: nothing is scheduled until the developer programs grant access. Until then the work is public readiness through M11, M12 and the console-ready plumbing checklist; the ports themselves live in private repositories (ADR 0143).

Feature	Status	Design doc
C0 Readiness: plumbing checklist, `IsAotCompatible`, desktop NativeAOT smoke in CI	⬜	Consoles
C1 M11 shaped for explicit APIs: D3D12 on Windows, shader language, pipeline manifest	⬜	Consoles
C2 Platform layer: SDL3, `IUserPlatform`, `IAudioOutput`, `IGlyphProvider`, controller-first UI, system text input	⬜	Consoles
C3 Spikes after access (private): runtimes, GPU backends, natives, requirements	⬜	Consoles
C4 First port and certification (private)	⬜	Consoles

Updating this file: flip a row to 🚧 when work starts and to ✅ when it merges. When a proposal ships, move its content into the matching current-state doc in design/ and repoint the row’s link there.