Development Roadmap
CNA is a long-term project developed incrementally. This page describes the honest current state and the path forward - no overpromising, no fake ETAs.
Honest timeline note: CNA is a long-term open-source project maintained in spare time. There are no fixed release dates. Milestones are goals, not commitments, and items marked "Open" below are gaps that have been identified, not work that has been scheduled. Progress is incremental and driven by API coverage, renderer stability, and real-world testing against ported games.
Where CNA actually is
0.1.0-alpha.1 is CNA's first tagged pre-release. It resolves to commit 1bb2145d99ed572dd4eb15009c34e2e5f410fcf0 (20 August 2026) and follows Semantic Versioning. This page tracks the development snapshot c1c316b9 (9 October 2026, branch apple/m4-stabilization), which is 3,687 commits later; its product version string is still 0.1.0-alpha.1 and no newer tag exists (see Releases & Versioning). At this snapshot CNA represents every one of the 331 documented XNA 4.0 runtime types and 3,627 documented members — representation, not behaviour — exposes 14 renderer identities across 12 implementation families (alpha.1: 50 across 46), and has 813 C++ test sources with 11,380 statically discoverable GoogleTest-family definitions. These are source facts, not a universal pass count; APIs may still change before 1.0.
Read that as: breadth is largely done, depth is not. The sections below separate what has shipped since alpha.1 from what is genuinely partial and what remains open.
ShippedWhat is done and verified
Everything in this list exists in the source tree of snapshot c1c316b9 and was confirmed by audit rather than by changelog. Items labelled "New" arrived after the alpha.1 tag.
14 renderer identities, single or multi-renderer builds Shipped
A normal build selects one identity with CNA_GRAPHICS_RENDERER. An opt-in CNA_GRAPHICS_RENDERERS list links several compatible families and selects one before the first device through GraphicsRendererSelection; fallback is explicit and the choice latches once the first renderer has been created successfully. Platform gates and dependency costs still apply. Since alpha.1 the set has been deliberately curated from 50 identities over 46 implementation families to 14 over 12: a name outside the 14 is a configure-time error, never a silent fallback, and no surviving identity was renumbered in the C ABI. See Graphics Renderers.
EasyGL renderer — the most mature path Shipped
EasyGL implements CNA's three GL-profile identities — OPENGLES3, OPENGL33 and the browser's WEBGL2 — and is the Linux default through OPENGLES3. It covers the stock effect families, lighting and GL context-loss recovery, instancing, occlusion queries, anisotropy, multiple render targets and 3D textures. Use the renderer capability report for the exact profile and feature boundary.
Direct3D 9 renderer — functional, and the pixel-exact XNA oracle target Shipped
This page previously described DIRECTX9 as a possible future renderer. That is out of date: it is a Windows-only implementation with SM2/SM3 shaders, device-lost recovery and MRT bounded by the graphics profile. It is also the renderer used for CNA's 39-scene pixel-exact XNA oracle comparison at --tolerance 0: the references come from the genuine XNA 4.0 runtime under Wine and DXVK on Linux, the result is recorded as 39 of 39 (the last consolidated dated report covers 31 scenes; later per-scene notes record the rest), and the check is manual and not run in CI. Compiled XNA effects are an opt-in build feature.
Vulkan renderer Shipped
A functional SPIR-V renderer with MRT handling, device-queried depth formats, stencil state, MSAA resolve and mip blit cascades. Its modern-graphics campaign added compute and storage buffers, indirect and base-instance draws, GPU timers, float and half-float render targets, and shadow-map and image-based-lighting sampling. Compiled XNA effects are an independent opt-in build feature.
SDL_GPU renderer Shipped
A deferred/retained renderer with SPIR-V shaders, the stock effect families, stencil and MSAA resolve. It is no longer Vulkan-only: with CNA_SDL_GPU_SHADERCROSS (on by default on Windows and Apple) SDL's Direct3D 12 and Metal devices are reached by translating the SPIR-V through SDL_shadercross. The modern-graphics campaign added compute, indirect draw, float targets and shadow and IBL sampling; the renderer reports no occlusion queries. Compiled XNA effects are an independent opt-in feature.
ASCII effect Shipped
A CNAEXT post-process effect, CNA::Graphics::AsciiPostProcessEffect, renders any finished frame as ASCII art. Because it works through the public Texture2D::GetData() and SpriteBatch API, it applies on any renderer and to 3D-rendered sources. Requires -DCNA_CNAEXT=ON.
The .xnb content pipeline Shipped
A real XNB loader is wired into ContentManager: 61 built-in readers (60 without native 128-bit integers), covering primitives, math, textures, fonts, audio, video, stock and compiled effects, and models on top of LZX decompression and shared-resource resolution. Typed external references and explicit custom-reader registration are present, ReflectiveTypeReaderBuilder registers custom types from a declared field list, and a Game registers the built-in readers itself. Since alpha.1 CNA also writes content: the build-time cna-content tool turns source assets into .cnb (the default) or .xnb, including LZX compression, and ContentManager resolves .xnb, then .cnb, then loose files. CNA reports that its XNB output loads in a genuine XNA 4.0 runtime under Wine; that has not been re-run for this page. See XNB Content Pipeline.
Build-time Content Pipeline and the CNB format Shipped
The XNA-shaped Microsoft::Xna::Framework::Content::Pipeline API is represented (128 of 128 types, 705 of 705 members, 10 importers, 12 processors) and driven by cna-content, which imports images, audio, video, fonts, glTF, .fbx, .x and existing .xnb and compiles .fx sources through an external legacy fxc (that route's verification against a genuine Microsoft fxc is not established). CNB is CNA's own deterministic container: a 64-byte header, CRC-32C per structure and chunk, and schemas for textures, models, animation clips, sounds and more. The pipeline has no C ABI export. See Content Pipeline, CNB Format and Command-Line Tools.
PBR effects and skeletal animation Shipped
Beyond the five XNA stock effects and SpriteEffect (all implemented natively in C++, not translated from bytecode), CNA ships non-XNA PbrEffect and SkinnedPbrEffect, with shadow-map and image-based-lighting inputs. Skeletal animation is real: SkinningData on Model::Tag with AnimationPlayer, AnimationClipEXT, BoneTrackEXT and KeyframeEXT (the Avatar path has its own SkinnedModelEXT), plus MorphTargetEXT blend shapes. All of it sits behind the CNAEXT boundary, so it is visible at compile time as non-XNA surface. PBR draws are implemented on the GL family, Vulkan, SDL_GPU, WebGPU, Direct3D 9/11 and Metal (Software as a reduced CPU cross-check); FNA3D refuses them.
Pixel-exact verification against the real XNA runtime Shipped
39 scenes under tools/xna-oracle/, rendered by the genuine Microsoft XNA 4.0 runtime under Wine and DXVK on Linux and diffed byte-for-byte against CNA's DIRECTX9 output at --tolerance 0 — recorded in the repository as matching all 39, run manually rather than in CI, and not yet repeated on native Windows. Alongside it: differential testing against a real running FNA build (tools/fna-reference/, also manual), and a compile-time CNAEXT purity check: defining CNA_STRICT_XNA_API turns CNAEXT declarations into [[deprecated]] warnings that -Werror promotes to errors, though the repository's own harness for it covers only Microsoft::Devices and its sensors.
A real Input, Audio, Net and Storage core Shipped
Input has zero stubs and a SDL3 GamePad bridge. XACT is a real parser and player, not a facade — a real binary parser for the XGS/XWB/XSB formats with FACT's actual volume formula. Net is real ENet over genuine UDP with real LAN discovery and best-effort host migration; PlayerMatch, Ranked and JoinInvited are refused with GamerServicesNotAvailableException rather than pretending. Storage is real std::filesystem IO with correct player namespacing and path-containment checks. See XNA Compatibility for the per-namespace breakdown.
XNA API representation closed: 331 of 331 types, 3,627 of 3,627 members Shipped
Every documented type and member of the ten XNA 4.0 runtime assemblies now has a matching C++ declaration (the first census found 3,463), measured by tools/audit_xna_runtime_surface.py against Microsoft's own XML documentation and DLL metadata. That includes the previously missing Microsoft.Xna.Framework.Design namespace: thirteen type converters in the opt-in CNA::Design module (see Framework.Design). This is representation, not behaviour: behaviour is verified only for the subsets on the Verification page, and the census is a manual script, not a CI gate.
Windows, X11 and Wayland through one SDL3 platform Shipped
CNA_PLATFORM selects one of three implementations: SDL3 (the default and the one windowing platform), HEADLESS and TERMINAL. SDL3 reaches Windows, X11 and Wayland through SDL’s own video drivers, and a game can still read the native handles (HWND, the X11 display and window, the Wayland display and surface) through GameWindow::GetNativeWindowHandleEXT(). CNA_ENABLE_SDL=OFF builds a windowless tree without SDL. CI runs the SDL3 window suite on SDL’s x11 driver under Xvfb and on its wayland driver under a headless Weston, and builds and runs it natively on Windows by manual dispatch. See Windows, X11 and Wayland.
ALSA audio and optional FFmpeg Shipped
CNA_AUDIO_PLATFORM=ALSA plays and records through ALSA (libasound is loaded at run time) with CNA's own mixer and vendored WAV, Ogg Vorbis, MP3 and FLAC decoders, so SDL-free Linux builds have XNA audio. FFmpeg video is now optional (CNA_ENABLE_VIDEO=AUTO|ON|OFF): the Video types link everywhere and throw NotSupportedException when no backend was built.
Compiled XNA effects on 11 renderer identities Shipped
Effect(GraphicsDevice&, bytes) and the XNB EffectReader load XNA Effect Framework bytecode on FNA3D (always) and, behind default-OFF build options, on the EasyGL family, Vulkan, WebGPU, Software, Direct3D 9 and 11, SDL_GPU and Metal. A default configure reports the capability on FNA3D only. Runtime HLSL .fx compilation, DXBC and MGFX remain unsupported.
Modern-graphics campaigns: SDL_GPU, WebGPU, Vulkan and Direct3D 11 Shipped
Base-instance draws, float and half-float render targets, shadow-map and image-based-lighting sampling, and renderer-internal compute and indirect-draw support landed on the renderers whose code and tests support them; WebGPU and Vulkan draw paths were made several times faster on a real street scene. GraphicsCapability grew from 14 to 19 members and the new RendererCapabilityProfile API reports 32 features, 22 limits and per-format usage. 32 cross-renderer parity fixtures are registered for EasyGL, WebGPU, SDL_GPU and Direct3D 11, against the fixtures' own assertions — not against real XNA.
CNAEXT extensions Opt-in, not in CI
The opt-in CNA::Graphics module holds three retro post-processing effects (CRT, colour-depth reduction, ASCII), a debug-drawing helper and portable shader packages. It needs -DCNA_CNAEXT=ON (default OFF); no workflow builds it. See CNAEXT Extensions.
Diagnostics and Inspector Opt-in, not in CI
CNA_DIAGNOSTICS=OFF|STATS|FULL (default OFF) adds counters, gauges, per-frame counters, CPU profiler zones, bounded recording and Chrome-trace export, with built-in instrumentation for frames, draw calls and audio voices. CNA_BUILD_INSPECTOR adds an in-process agent (authenticated TCP) and the cna-inspector bridge that serves an offline browser UI; it is view-only and desktop-only, and no renderer supplies a resource-preview provider yet. No workflow configures either. See Diagnostics and Inspector.
C# through CNA.NET Beta, source-first
The C# binding builds on the C ABI: CNA.XnaCompat exposes the Microsoft.Xna.Framework API over the native C++ runtime, so XNA 4.0 C# game source compiles and runs without being rewritten. Its public metadata matches the selected XNA 4.0 runtime profile, it pairs with exactly C ABI 0.46.0, and a dotnet new template creates games with desktop, browser and Android heads. Qualified on Linux x86_64, in headless Chromium and on the x86_64 Android emulator; on a physical Mac mini M4 (osx-arm64) it builds, passes its managed suites and package acceptance, and smoke-runs its 84 samples on SOFTWARE and METAL, as local evidence without a CI leg, signing or notarization. See C# with CNA.NET.
XNA 4.0 samples in C++, in the browser and in original C# Practically complete
91 of Microsoft’s XNA 4.0 samples and games have complete C++ ports (cna-samples 5db32e6); 8 relevant C# programs remain, and the rest of the 153-entry audit list are not port targets. 90 C++ builds are playable at samples.libcna.com; the Racing Game Kit is ported but not hosted. 84 original C# sample programs run unchanged through CNA.NET (cna-dotnet-samples 1e6d763). See the Showcase.
Gamer Services, Guide, avatars and online sessions Linux; macOS recorded
Players are local profiles by default; configured outside game code, the same XNA APIs connect to the self-hosted CNA Gamer Services server for accounts, friends, presence, pictures, leaderboards and relayed PlayerMatch and Ranked sessions with invites and host migration. Avatars draw with CNA’s own art. Qualification is on Linux, with a CNA-recorded run on one physical Mac mini M4; there is no public server instance, and achievements and scores are client claims without anti-cheat. See Gamer Services & Avatars.
Save persistence on the web Shipped
WebAssembly builds mount the browser’s IndexedDB for StorageDevice and isolated storage and restore it before main(), so saves survive a page reload; threaded builds need CNA_EMSCRIPTEN_USE_WASMFS=OFF for this. The GamerServices local profile store is not yet inside these mounts.
Partial, and known to be partial
These exist and work in part. The gaps below are specific and audited, not vague.
WebGPU — formerly no render targets at all Partial
In alpha.1 this was a backbuffer-only forward renderer: no render targets, MSAA, cube or 3D textures, queries or instancing, with a non-functional stencil path. It now reports real MRT (two to four targets), occlusion queries, wireframe, multi-stream input, instancing, probed MSAA, probed float render targets and compute, and it gained a browser route through the Emscripten emdawnwebgpu port and opt-in compiled effects. CNA still declares it Experimental, half-float linear filtering is false, and the only workflow that builds it is the Emscripten one, which builds and inspects a browser bundle without running it.
Metal — supported on a physical Mac, not yet primary-production Partial
Since CNA's Mac mini M4 campaign Metal implements MSAA, multiple render targets, occlusion queries, instancing and multi-stream input, float, packed and DXT formats, cube and volume textures, full PBR and SpriteBatch-scoped MSL custom effects, with compiled XNA effects behind CNA_METAL_COMPILED_EFFECTS (off by default); it runs on macOS and, with Simulator evidence only, on iOS. On a physical Mac mini M4 its full test suite and its 261 Metal tests under the validation layers pass. CNA declares it Supported but not primary-production: compiled effects are off by default, on-screen presentation was never observed, no physical iOS device has run it and no soak run has bounded its caches; the hosted macOS lane runs only the Metal tests, on a paravirtual GPU.
Continuous integration Partial
The snapshot contains 18 workflow files (24 jobs; 16 of the files trigger automatically on pushes and pull requests, and 21 of the jobs run that way) covering Linux, Apple (macOS and iOS, on macos-26 runners), Emscripten, the SDL3, HEADLESS and TERMINAL platform implementations (SDL3 on SDL’s x11 and wayland drivers), multi-renderer selection and five build-free C API gates. The alpha.1 defect in which the general job and two Input rows selected a removed renderer value and failed at configure time is fixed. Still absent: any workflow for Android, building the C API library or running the oracle corpus; the Windows lanes remain manual; and nothing builds the CNAEXT extensions, Diagnostics or the Inspector. Every lane now checks out the sharp-runtime branch that CNA’s sibling script chooses; no green hosted run of the Apple or Metal workflow is recorded after the Mac mini M4 campaign, whose own full-suite runs are local evidence rather than CI. The working lanes provide useful scoped evidence, but not exhaustive coverage across 14 identities, graphics drivers, physical iOS devices or the complete GPU pixel/oracle matrix.
Truthful capability reporting Partial
Six GraphicsCapability answers — compiled effects, float and half-float render targets, half-float linear filtering, compute and indirect draw — are now derived from dedicated renderer hooks that default to false, and multiple render targets are capped by the GraphicsProfile. The remaining entries still fall through to the renderer's own switch, whose shared default is permissive. DIRECTX11 and SDL_GPU now override SupportsCapability(), but DIRECTX9 still never does — so it advertises MSAA, occlusion queries, custom effects and instancing without necessarily querying the device. The new RendererCapabilityProfile adds device-probed answers, but a true from the older capability API still means "not contradicted", not "verified".
Experimental C API — release gate "Not ready" Partial
The C ABI is at 0.46.0 (alpha.1: 0.7.0) with 60 headers, 3,210 routes and 197 recorded struct layouts. Its committed release report records one unmet criterion: 631 in-scope public C++ declarations still lack C mappings (8,142 inventoried: 7,053 implemented, 15 partial, 631 planned, 443 not applicable). No CNA CI job builds the library; it has been built and tested on a physical Mac mini M4 (a Mach-O libcna_c_api.dylib exporting exactly the 3,210 routes, a static archive and an installed-package test), and CNA.NET builds and uses it on Linux and, as local evidence, on macOS. ABI 0.x is experimental and several minor steps since alpha.1 were incompatible. The C# binding CNA.NET pairs with exactly 0.46.0; the Common Lisp, Go, Java, Python, Ruby, Rust, Swift and TypeScript bindings are archived and will not follow new ABI versions. See Experimental Native C API.
Work that remains before 1.0
Compiled effects beyond qualified builds Partial
XNA/FNA D3D9 Effect Framework binaries now load through Effect and XNB EffectReader on 11 of the 14 identities: FNA3D always, and ten more behind default-OFF build options, METAL's among them since the Mac mini M4 campaign. What remains open is the 2D-only and no-pixel renderers, and the default configure, which reports the capability on FNA3D only. HLSL .fx source, DXBC and MGFX remain unsupported at run time; .fx sources compile only at build time through an external legacy fxc, which was not exercised on macOS.
Consistent surface-format coverage Renderer-dependent
Public Texture2D format admission is renderer-qualified: eight renderer families (SDL_GPU, Vulkan, WebGPU, Direct3D 11, Metal, FNA3D, EasyGL and Software) classify formats themselves, while the others defer to the framework's Color-only public rule even when an internal renderer layer knows additional native formats. The default Reach profile additionally refuses the eleven HiDef-only formats. The remaining task is a truthful, tested per-renderer contract for every format a game intends to use.
ReflectiveReader for custom XNB types Partial
The XNB loader has 61 built-in readers. Video, typed external references and compiled effects are represented, and custom readers can be registered explicitly, either as a ContentTypeReader<T> or, since alpha.1, through ReflectiveTypeReaderBuilder and EnumTypeReader from a declared field list. What remains absent is runtime reflection-based discovery, which C++ does not offer: user and closed-generic types still require deliberate registration.
Gamer Services beyond Linux Open
The service client, relay and server are qualified on Linux; on macOS, CNA’s Apple campaign records them on one physical Mac mini M4, with online play needing a WebSocket-capable libcurl rather than Apple’s system one. Open: Windows (credential storage is sealed with DPAPI but has run only under Wine; the server has not run natively), a real wide-area network, browser builds (where the service, relay and voice are absent), iOS (built without networking) and avatar pixels on Direct3D and Metal, and no public server instance is operated. Offline leaderboards drop stream columns, and online sessions refuse guests.
Media portability and codec coverage Platform-dependent
The Media catalogue layer, playback, and FFmpeg-backed video paths are implemented. Remaining boundaries are platform and codec specific: the Video types exist in every build, but file-backed decoding needs the optional FFmpeg backend, which is built only on Linux and macOS, so elsewhere it throws NotSupportedException; on macOS a binary linked against Homebrew’s FFmpeg starts only on the macOS that FFmpeg was built for. SDL_mixer does not provide AAC decoding for .m4a/.aac; CNA's own ALSA mixer decodes WAV, Ogg Vorbis, MP3 and FLAC, and Opus, WMA and XMA are not decoded. Expand only with explicit build and runtime evidence.
Deeper tests for Media and Storage Open
Coverage is uneven rather than absent: Storage has 14 GoogleTest-family definitions (path safety, not read/write round trips) and Media 304. Those source counts still leave many runtime paths and platform combinations without execution evidence.
Android and oracle checks in CI Open
Android has code, an SDL entry point and a demo Gradle project, but no workflow builds for Android. The 39-scene XNA oracle diff is a CTest only in a DIRECTX9 plus Wine cross-build tree and is in no workflow; the last consolidated dated DIRECTX9 report covers 31 scenes (later per-scene notes record the rest) and a native-Windows re-run is open; EasyGL and Software have a CTest on two line scenes only (the EasyGL test fails on any pixel difference; the Software test only if a scene does not render). Software has been measured at 18 of 39 scenes byte-exact.
CNA.NET on Windows and iOS, and on macOS beyond local evidence Future qualification
CNA.NET’s runtime qualification covers Linux x86_64, headless Chromium and the x86_64 Android emulator and, as local evidence on a physical Mac mini M4, macOS on Apple silicon (osx-arm64): its managed suites, package acceptance, the template and a smoke run of all 84 samples on SOFTWARE and METAL, without a CI leg, signing or notarization (its SDL_RENDERER integration suite is still open there). Windows has documented build steps but nothing has been run on it; iOS is planned through static linking. Interactive browsers, hardware GPUs in the browser, physical Android devices and a macOS CI leg are the next evidence to collect.
Public stable release (v1.0) Long term
The project is versioned, but this snapshot is deliberately pre-1.0: its version string is still 0.1.0-alpha.1 and nothing newer has been tagged. Reaching 1.0 requires an explicit compatibility policy, stable public APIs (the C ABI is 0.x and has taken incompatible steps recently), clearer renderer capability contracts, reproducible configuration-scoped verification and production evidence on the platforms CNA intends to support.
Contributing: high-value work includes closing named renderer gaps, improving capability accuracy, expanding configuration-specific runtime evidence, and testing this snapshot's new platform, content-pipeline, compiled-effect and C API boundaries. See the GitHub repository (the documented snapshot is on its next branch) and the detailed roadmap.