Project roadmap
Each repository owns a distinct capability and release boundary. The lanes below keep that ownership visible while showing what is active, what follows it and which work remains deliberately later.
Current checkpoint: October 2026
Perimortem
Provides the compact runtime, memory, diagnostics and system capabilities shared by native projects.
Explicit runtime boundaries
Shipped the reorganized Core, allocation policies, shaped Matrix types, native Thread primitive, canonical filesystem paths, bounded JSON and synchronized diagnostics for native and Web consumers.
Stable C runtime replacement
Replace Tetrodotoxin’s remaining embedded runtime assumptions through Perimortem’s C boundary. Tetrodotoxin should consume the runtime without sharing its C++ types, allocators or private ownership model.
Toolchain
Owns compiler acquisition, Bazel rules, SDK packaging and the validation frontend used across repositories.
Composed SDK runtimes and system links
Added runtime-only Windows DLLs, host-provided link interfaces and component dependency reconciliation so static and shared consumers can compose SDKs without duplicate library definitions.
Private header export controls for SDKs
Let libraries mark headers as implementation-only so SDK archives expose the public interface without publishing internal platform and provider declarations.
TTX
Owns canonical data, contract negotiation and the shared semantic graph.
Data, Semantic and Graph foundation
Names the Graph layer, separates provider binding from reentry and defines Abstract navigation, policy composition and retained lifetime through C and C++ contracts.
Full in-process service mesh
Complete the local provider model so modules can publish live state, negotiate typed APIs, return retained graph locations and perform side effects through stable C contracts.
Network transport
Investigate carrying TTX negotiation and graph navigation across process and network boundaries while preserving provider authority, lifetime and failure semantics. Networking remains outside the 1.0 contract.
Tetrodotoxin
Owns Source, Puffer, dialects and the language-tooling applications built above TTX.
Dialects and Puffer
Publish the Dialect system and Puffer application on top of the released TTX contracts, with Source observations retained across language-tooling requests.
Puffer command-line integration
Bring Puffer capabilities into command-line workflows so the same source and dialect boundaries can serve editor and terminal consumers.
Execution dialect
Add the Execution dialect as the next published layer above Source, using the same provider and capability boundaries as the earlier tooling releases.
Godot
Adapts negotiated providers into Godot classes, resources and application behavior.
Composable providers and standalone demos
Adopted the TTX 0.2 contracts and packaged independently loaded C++, CUDA and GDScript providers as native and browser demonstrations.
Separate provider SDK and engine bridge
Publish provider-facing contracts without Godot C++ symbols, keep registration and conversion in the bridge, then rebuild the native and Web demos against released TTX and Perimortem SDKs.
Compute
Owns shared compute contracts and independent CPU and CUDA execution providers.
Command buffers across CPU and CUDA
Published a shared command-buffer SDK with independent CPU and CUDA engines. Submissions retain their inputs, results wait for the work that produces them and compatible CUDA results remain on the device through ordered stream dependencies.
Photophore
Owns windowing, input and Vulkan rendering for native applications.
Native windowing and Vulkan foundation
Shipped Vulkan rendering, windowing, input snapshots and image resources for Linux, Windows and Web SDKs, with independent SDK-consumer validation and an exercised Linux application.
Provider-owned cross-platform windows
Split the monolithic window backend into typed Wayland, Win32 and Web providers. Window creation reports host failure explicitly, moves preserve stable callback state and Presentation keeps Vulkan surface creation under the provider that owns it.
Evidence standard
- A native runtime test establishes behavior only on the host where it ran.
- A cross-build establishes compilation and packaging, not execution on that target.
- Benchmarks name the workload and environment instead of claiming a general ranking.
- Development records retain regressions and failed approaches alongside successful results.