# RUSTBA MATURATION ROADMAP

Filed 2026-11-06, on the founder's call (08:57 EST): *"Do it then… no
more limitations from this point forward just creative exploration
without caps."*

This is a ROADMAP ONLY (house law: roadmap before code). No
implementation is authorized by this document; each rung opens its
own lane when the founder or the funnel calls it.

## What this serves

The horizon filed in `~/workspace/n64-shell/CORE-MATRIX.md` ("Beyond
elimination — our own ROMs, one language"): **original ROMs authored
in Rustba, compiled per console target.** The game is written once;
every front gets a build. Rustba is the founder's designated
universal language (08:54): *"Rustba could be the universal language
going forward too, idc use all my languages to make our own shit from
now on."* The whole family (Rustba · Gemba · Lavemba · tRust) is
licensed into the house's authoring work.

Founder's principles, verbatim, governing every rung:

- **HD, not retro** (08:53): *"We're making an HD engine with HD
  cores for HD graphics, not retro anything."* This roadmap's output
  is an HD authoring stack; "retro" describes source games' eras,
  never the product.
- **No half measures** (08:41–08:45): coverage is everything;
  unreachable is a research state, never a verdict.
- **Plant flags** (07:16): *"We plant flags where people dream of
  going and show them it can be done if you try hard enough."*
- **Creative exploration without caps** (08:57).
- **The founder's maturation frame** (08:55): identity as a language
  primitive · differentiation by problem, not syntax · the ladder
  spec → playground → per-target standard libraries → dogfooding ·
  the tax dies where authoring begins.

---

## STATE — what actually exists today (verified 2026-11-06)

### Exists

- [x] **The design itself, on raijinsocial.com** — Rustba is
  "Mamba State Space 10D SSM Matrix", hardware-aware (A/B/C
  matrices, delta step). Concept-first. Both goal records agree:
  **no formal grammar exists.** (Sources: `rustba-for-mobile/GOAL.md`,
  `sovereign-mobile-languages/GOAL.md`, both 2026-10-09.)
- [x] **A runnable playground interpreter** — `~/workspace/droidemba/index.html`
  (223 lines, still Droidemba-branded internally): parses screen
  blocks, widgets (title/text/button/input/row/spacer), gestures
  (tap/swipe/pinch/longpress), and resource-capped effects; renders
  a working phone UI; buttons navigate; gestures bind via
  touch/mouse. A rebranded copy circulates as
  `files/rustba-playground.html` in both goal workspaces (identical
  md5 `71808a62…`; the droidemba original is `5dd5708c…` — two
  living copies, not one canonical file).
- [x] **A 3D viewer + icon set** — `files/rustba-3d-viewer.html`
  (30 KB) and `files/dock-icons.json`, untouched since 2026-10-09.
- [x] **One production Rustba program** — `veda-audit.rustba`
  (2026-10-17, Veda's guard chain): six typed effects
  (`auditSummary … auditTruth`) with `needs` guards, run in order
  by `runAudit`; first failing guard stops the line. This is real
  shipped semantics — effect + needs + runAudit, `: Document +
  Network` effect-type annotations (a single syntactic sighting,
  not yet confirmed grammar) — and it is one of the spec's four
  sources of truth. (Record: goal `agent_notes/2026-10-17`,
  `agent_notes/2026-11-05`; brief "Veda's Guard Chain", 2026-10-17.)
- [x] **Design principles, stated** — gesture syntax ·
  constraint-typed layouts (`stack(safe)`) · explicit resource
  effects (Network + Battery; `needs` guards as the gating form) ·
  offline-first (cache first, sync propose).
- [x] **Reference material** — `~/workspace/raven-docs/` (field
  archetypes, outside-looking-in, appshelf architecture); Drive:
  a `languages` folder (contents not enumerated in this pass), the
  `raijinsocial-com-cloudflare` archive zip (the site's own source
  class), the RESONANCE World Mandala language material, and the
  Harakiri Unified builds (the founder's authored HTML lineage).
  Drive name-queries for 'Rustba'/'Gemba'/'Lavemba' return no
  dedicated files — the languages' canonical home today is the
  site + this workspace, not Drive documents.
- [x] **A consumer already waiting** — GameM8c finalization's
  BACKEND-NOTES section (in `GAMEM8C-FINALIZATION.md`) is
  contracted to feed a Rustba → GBC backend: entry format fixed
  (topic · finding · evidence · generalizes? GBC-universal /
  Crystal-specific / Gen-2-specific), written in target terms.

### Named gaps (no vibes)

- **G-L1 — The spec is FRAGMENTS, not a document.** Rustba's
  semantics live in four unabsorbed sources: the playground's
  `needs`/`hw{}` constructs, the runtime gating rules, shipped
  Rustba code, and `veda-audit.rustba`. No single grammar file
  exists anywhere. This is the first gap the ladder closes.
- **G-L2 — One known parser bug, still open**: the effect-body line
  (`cache first, sync propose`) reports "outside screen" — the
  effect-body regex doesn't match the indented line (recorded
  2026-10-09, never fixed).
- **G-L3 — Branding/canonical-copy drift**: the interpreter is
  branded Droidemba; two non-identical copies of the playground
  circulate. No canonical source file is designated.
- **G-L4 — Nothing has moved since 2026-10-09.** Five consecutive
  study passes (through 2026-11-05) confirm the goal files are
  untouched; the founder's 08:54/08:57 calls are the first motion
  in a month. The hardware-premise question (an Edge-2025 `hw{}`
  profile) stands unanswered on the record — it is a founder
  decision below, not a blocker to Rung 1.
- **G-L5 — The BACKEND-NOTES stream is EMPTY.** The section exists
  and the format is contracted, but it holds zero entries; the
  first findings land with GameM8c's ROM recon lane. Every GBC
  backend claim in this roadmap is therefore a designed interface
  against a contracted-but-unfilled stream — stated plainly so
  nobody plans as if the knowledge were already banked.
- **G-L6 — No compiler exists at any level.** The playground
  interprets a UI DSL for mobile screens. Nothing targets a
  console, emits a ROM, or knows what a bank is. The distance from
  playground to GBC backend is the whole ladder; this roadmap
  does not pretend otherwise.

---

## THE LADDER

Checkbox = verified done. Everything below is unchecked until a
lane's receipt proves it.

### Rung 0 — Canonicalization (small, first, unglamorous)

- [ ] Designate ONE canonical playground file (rebrand Droidemba →
  Rustba; the goal-workspace copies become exports, not sources).
- [ ] Fix the effect-body parser bug (G-L2) with a regression case
  filed beside the interpreter.
- [ ] Inventory the four spec sources into one extraction dossier
  (construct · where it executes · evidence file/line).
- **Gate:** a stranger to the project can find the language's
  current truth in exactly two places: the dossier + the canonical
  playground.

### Rung 1 — Formal spec v1

- [ ] Grammar + semantics document absorbing all four sources
  (playground constructs · gating rules · shipped code ·
  veda-audit), with every absorbed construct cited to its source.
- [ ] The mobile core specified as designed: screens/widgets ·
  gesture syntax · constraint-typed layout · resource effects
  with `needs` guards · offline-first execution model.
- [ ] Open grammar questions settled BY THE FOUNDER where the
  sources disagree (the `: Document + Network` effect annotation
  is the standing example — grammar or accident is his call, D-3).
- **Gate:** the spec is complete enough that a second implementer
  could build a conforming interpreter without asking the author
  anything. Conformance suite sketched alongside (cases drawn
  from the shipped programs).

### Rung 2 — Runnable playground, spec-true

- [ ] Interpreter brought to spec v1 (every spec construct runs;
  every divergence between old playground behavior and spec is
  resolved in the spec's favor or the spec is amended on record).
- [ ] Conformance suite green on the canonical playground.
- [ ] The two shipped programs (playground demo corpus +
  veda-audit guard chain) run unmodified under the spec-true
  interpreter — the past must keep working.
- **Gate:** spec and interpreter are the same language, proven by
  the suite, not by assertion.

### Rung 3 — Identity as a language primitive (THE design rung)

The founder's 08:55 commitment: games in Rustba **declare**
state/assets/context natively. The compiler emits, as ONE artifact:

```text
the game  +  its M8trix profile  +  its coverage table  +  its state contract
```

- [ ] Declaration design: how source declares game state (the
  predicate vocabulary the State-Aware Identity Doctrine evaluates:
  RAM-class state, clock bands, frame phase), assets with context
  (day/night/lit/unlit variants as source-level facts, not
  renderer discoveries), and UI/portrait/slot surfaces.
- [ ] Contract format: the emitted state contract must be exactly
  what M8trix's profile layer consumes — the Conditional Claims
  grammar, authored-side. (Renderer Law holds: the renderer stays
  ignorant; the profile — now compiler-emitted — explains.)
- [ ] Coverage emission: the compiler's coverage table is computed
  over asset × state × predicate space (Coverage Law), so a Rustba
  game's coverage is a compile-time report, not a post-hoc census.
- [ ] Born-proven clause: for Rustba-authored games, the
  Verification Law's capture→diff→prove burden is discharged by
  construction (declared, not reverse-engineered). The law still
  governs library games in full — this rung changes nothing there.
- **Gate:** a worked design + one hand-compiled example (a small
  game fragment carried through declaration → contract → profile
  by hand, on paper) that the M8trix side accepts as consumable.
  No compiler yet; the artifact contract is the deliverable.
- **Design-now note:** this rung's DESIGN should run as a shadow
  track during Rungs 1–2 (see MY READ) — the declaration syntax
  must be in spec v1's grammar or it will be bolted on later.
- **CRITICAL-PATH OBSERVATION — the Expression Grammar Junction
  (filed 2026-11-06 10:21 EST; disposition: AWAIT FOUNDER DECISION):**
  three examinations converged on one dependency: the *expression
  grammar* is the critical junction of the entire language program.
  Identity evaluation, predicate evaluation, guard evaluation,
  shader derivation, and capability checks all require one common
  expression substrate; without a coherent answer, growth fractures
  into incompatible mini-languages (predicate logic ≠ guard logic ≠
  shader logic ≠ identity logic → duplicated tooling, divergent
  validation, drift). Convergence record: (1) the Dimentra3D
  improvement lane's read — the only one of the three that read
  CODE; it named expression-as-text placeholders as the cliff where
  every subsystem waits on the same grammar; (2) the
  DIMENTRA-M8TRIX-MAP review — M-1 (predicate grammar form) and
  M-3 (provable guards) both collapse into "what expression system
  governs truth?"; (3) Copilot's independent reading, drafted as a
  formal critical-path entry at the founder's hand-off. Provenance
  note (parent): the convergence is real but the independence is
  PARTIAL — reads (2) and (3) reasoned from documents (the map, the
  parent's summary) while (1) reasoned from the implementation; all
  three share the SPEC as root artifact. Confidence in the JUNCTION
  is high because the code-level and document-level reads agree.
  This observation resolves NOTHING: M-0 (succession), M-1
  (predicate grammar form), M-3 (guard proof strategy) remain
  founder decisions. The roadmap records the convergence, not a
  ruling.

### Rung 4 — Per-target standard libraries (GBC first)

- [ ] **Interface (design now):** the GBC library is designed
  against GAMEM8C-FINALIZATION.md's BACKEND-NOTES stream. The
  library's chapters map 1:1 to the notes' topics: bank discipline
  (MBC behavior, switchable windows, fixed-bank residents) ·
  tile/palette data formats (2bpp layout, palette RAM plumbing) ·
  graphics compression (algorithm, ratios, decode cost) · address
  spaces (ROM/RAM windows, mirroring, I/O) · hardware forbids
  (timing, DMA, mode constraints). A library section may only be
  written from notes entries marked GBC-universal (Crystal- or
  Gen-2-specific entries inform, never ground, a library rule).
- [ ] **Dependency (honest):** the notes stream is EMPTY today
  (G-L5). Rung 4's GBC chapter cannot be written until the ROM
  recon lane's findings land. The interface above is the contract;
  the stream's arrival is GameM8c's schedule, not this ladder's.
- [ ] GBC standard library v1: hardware truth as callable,
  typed surface (banks, tiles, palettes, input, RTC, audio) with
  the resource-effect discipline carried over (VRAM/DMA/bank
  operations declare their costs the way mobile effects declare
  battery/network).
- [ ] Later targets (in funnel order, each its own chapter when
  its core's notes exist): GBA → DS → N64-class. Switch/Wii
  U-class targets are accounting-only in this roadmap (see Tax
  Accounting); no library is designed for hardware we haven't
  built a core for.
- **Gate:** the GBC library + the Rung-3 contract together are
  sufficient to express the Rung-6 title's full design without
  reaching outside them.

### Rung 5 — First backend: Rustba → GBC (the compiler rung)

- [ ] A backend that compiles a declared Rustba game to a
  bootable GBC ROM: header/checksum discipline, bank assignment
  from the library's discipline, asset embedding per the Rung-3
  contract, and the profile/coverage/contract artifact emitted
  alongside the ROM (one build, two outputs, same truth).
- [ ] The emitted ROM boots on GameM8c (EdgeMu proof standard:
  loads + renders; the founder's glance is the look gate, per the
  glance-gated core law).
- **Gate:** a non-trivial demo game (not a hello-world: declared
  state, at least one state-variant asset, one slot surface)
  compiles, boots, and its emitted profile drives M8trix's
  predicate evaluation with zero hand-written profile data.

### Rung 6 — Dogfooding (the maturity proof)

- [ ] One house tool rewritten in Rustba and run in production:
  candidate named by evidence — a guard-chain/audit tool in the
  Veda lineage is the natural heir (its ancestor is already the
  language's one production program), but the choice is the
  founder's (D-5). A census or pack-manifest tool is the
  alternative class: a tool whose output the house already trusts,
  so the rewrite is verified against a known-good oracle.
- [ ] The rewrite's gaps feed back into spec/library issues filed
  as first-class work, not workarounds — dogfooding that doesn't
  hurt a little isn't testing anything.
- **Gate:** the tool runs in the house's real workflow for a full
  work cycle with its outputs accepted at the same gates the
  original passed.

### Rung 7 — First original title

- [ ] An original game authored in Rustba, compiled to GBC via
  Rung 5, shipped through the GameM8c line (finalized ROM in Drive
  + workspace, per the founder's own-ROMs doctrine).
- [ ] The creature game's reopening is the founder's flagged call
  (CORE-MATRIX, "Beyond elimination") — this rung exists whether
  or not that call is yes: a smaller original title proves the
  stack end-to-end either way, and the choice of title is D-6.
- **Gate:** the founder plays it. (His standing definition of
  done for the whole line: a build he can install and play.)

---

## FAMILY DIFFERENTIATION MAP

Settled by the founder: **Rustba = the universal language**
(games · state · systems · mobile). The rest of the family is
proposed below — every row is a **FOUNDER'S CALL**, with the
evidence the record actually supports. Nothing here invents design
detail the sources don't contain; the recorded characters are one
line each (sovereign goal, 2026-10-09), and the proposals are
labeled with how far that evidence reaches.

| Language | Recorded character (evidence) | Proposed chair | Evidence reach |
|---|---|---|---|
| **Rustba** | Hardware-aware Mamba — "Mamba State Space 10D SSM Matrix", A/B/C matrices, delta step (site + both goals) | **Universal: games/state/systems + mobile** — SETTLED (founder, 08:54) | Settled, not a proposal |
| **Lavemba** | "20D synthesis" (sovereign goal); also recorded as "the candidate for a later grand synthesis" (same source) | **Rendition / materials** — high-dimensional synthesis is the family's only recorded construct that speaks in the rendition layer's native terms (parameter spaces, materials, light). ALTERNATIVE the founder may prefer: no chair — Lavemba sits ABOVE the family as the eventual grand synthesis, per the goal's own wording | Thin — one phrase each way; the "grand synthesis" reading is at least as supported as the chair |
| **Gemba** | "Petri nets" (sovereign goal) | **Tooling / orchestration** — Petri nets are flow-and-transition machinery: build pipelines, crew workflows, audit chains are Petri-shaped work. Secondary fit: in-game event/flow logic, which would put it inside Rustba's games chair as a subsystem rather than a chair of its own | Moderate — the construct genuinely matches the chair's shape |
| **tRust** | "Types" (sovereign goal) | **The family's type & verification substrate** — not a chair beside the others but the discipline under them: shared type language for contracts (Rung 3's state contracts are typed artifacts), guard semantics (Veda's chains are typed effects), conformance checking | Moderate — "types" is a substrate by nature, and the family's one production program already leans on typed effects |

**Layout/UI** is deliberately NOT assigned above: the evidence
says it already lives inside Rustba (both goals define the mobile
line as gesture-first, constraint-typed layouts — Rustba's own
design brief). Assigning it elsewhere would contradict the record.
If the founder wants it separated, that's D-4.

Open chairs after this map: none forced. A chair invented to fill
a table would violate differentiation-by-problem — a language
earns its use case from its construct, or it waits (the Lavemba
alternative above is the standing example).

---

## TAX-ELIMINATION ACCOUNTING

**The tax, defined:** per platform per game, the reverse-
engineering route charges census + state proving + seam-hunting +
pack authoring against a finished binary that answers no
questions. This morning's record prices its class: a single seam
port (mGBA → SameBoy) is 11–20 engineer-days; the community's
reference N64 pack cost one artist five years; GameM8c's
finalization (full census join, every-class authoring, bake-in)
is a multi-lane program for ONE game on ONE platform. That is the
per-title, per-platform rate the authored route abolishes.

| Platform | Reverse-engineering route (library titles) | Rustba route (our titles) | What carries / what's new |
|---|---|---|---|
| **GBA** | Full per-game tax: census, proving, seam work in the GBA renderer (Emerald port proved the seam ports, games don't) | New backend + GBA library chapter; games then compile | Carries: doctrine, predicate grammar, instruments, crew skill. New: one backend + one library, ONCE |
| **DS** | Tax at its worst: two screens, 3D/2D boundary, per-game proving in the least-documented renderer of the set | New backend + DS library chapter (notes fed by the DS core work, same BACKEND-NOTES pattern) | Carries: everything from the GBC backend's design. New: one backend + one library, ONCE |
| **N64-class** | The historical famine: play-driven dumping, unprovable coverage, per-plugin format lock-in orphaning packs per generation | New backend + library chapter; our titles never enter the CRC/dump economy at all | Carries: the whole authoring stack. New: one backend + one library, ONCE. (Library titles here keep the .hts route — the doctrine's correction stands: no predicate seam on the plugin line) |
| **Switch / Wii U-class** | Not yet paid by anyone here — would be the largest tax ever: modern binaries, no seams, no pack culture to inherit | A shell/core integration + a backend; titles authored in Rustba arrive with profile + coverage + contract emitted | This is the founder's "never tax ourselves again" in its exact form: for OUR titles the marginal cost of a new platform is a backend, not a research war |

**Honest bounds (the founder's own, 08:55, restated as law here):**

- For **our titles**: the tax is zero, forever, per platform,
  after the one-time backend + library cost. Authored once, run
  everywhere — Switch and Wii U included.
- For **library titles**: the tax SHRINKS per platform and never
  reaches zero. The doctrine, instruments, predicate grammar, and
  crew learning carry; the per-game proof cost (census + proving
  against that game's reachable state space) remains, declining
  as the crew's per-platform knowledge compounds. Any version of
  this roadmap claiming library titles become free is lying, and
  the Coverage Law's warning (every state multiplies the census)
  applies to them permanently.
- The funnel narrows per platform — highway → freeway → single
  road — it does not teleport. The backend+library for platform
  two is cheaper than platform one because the contract, the
  compiler's shape, and the failure curriculum already exist;
  platform five is cheaper still. That compounding, not any
  single platform, is the asset.

---

## FOUNDER DECISIONS (open scope — his calls, never guessed)

- **D-1 · Creature game:** does the parked creature-capture title
  reopen under the own-ROMs doctrine as Rung 7's title, or does a
  smaller original prove the stack first? (Flagged in CORE-MATRIX;
  still his one-word call.)
- **D-2 · Lavemba's seat:** rendition/materials chair, or above
  the family as the grand synthesis (the goal's own candidate
  wording)? The map above argues both readings honestly.
- **D-3 · Grammar settlements:** where the four spec sources
  disagree (first instance: the `: Document + Network` effect
  annotation — grammar or accident?), the founder rules during
  Rung 1 extraction.
- **D-4 · Layout/UI:** stays inside Rustba (the record's reading)
  or is separated into its own chair?
- **D-5 · Dogfooding target:** the Rung-6 rewrite — a Veda-lineage
  guard/audit tool, or a census/manifest tool with a known-good
  oracle?
- **D-6 · Rung 7's title** (if not D-1's): what original game
  proves the stack?
- **D-7 · Hardware premise (standing, from 2026-10-30):** does the
  spec's `hw{}` model gain an Edge-2025 profile (his only phone),
  and do console targets join `hw{}` as first-class profiles in
  spec v1 or in a later revision?

---

## MY READ

The ladder's order is right in its spine — spec before playground-
truth, contract before backend, library before title — and I
wouldn't swap any two adjacent rungs. But the record forces two
amendments to how it's read, and I'd be filing a dishonest roadmap
if I presented the ladder as a clean staircase.

First: **the ladder is partly retroactive.** Rung 6's dogfooding
has, in embryo, already happened — `veda-audit.rustba` ran in
production in October, before any spec existed. The language has a
production user and zero grammar. That inverts the usual risk: the
danger isn't that the spec describes a language nobody can use,
it's that Rung 1 "extracts" a spec tidier than the one the shipped
code actually speaks, and Rung 2 then breaks the only real program
we have. That's why Rung 2's gate explicitly includes the shipped
programs running unmodified — the spec answers to the code that
already worked, not the other way round.

Second: **Rung 3 cannot wait for Rungs 1–2 to finish.** Identity-
as-primitive is a *syntax* commitment — declarations of state,
assets, and context have to be grammatical in spec v1, or the
"universal language" ships as a mobile UI DSL with a compiler
bolted on, and the declarations get retrofitted the way our
pipeline stages were retrofitted onto mGBA: successfully, at
triple cost, with a scar. The roadmap therefore runs Rung 3's
design as a shadow track from day one; only its gate (the
hand-compiled example) waits for the spec to exist. I have written
the rungs in founder order; read them with those two corrections
and the ladder is, in my judgment, the right shape.

And the honest critical path: it isn't the spec. It's an empty
section in somebody else's document — BACKEND-NOTES, zero entries,
waiting on a ROM recon lane inside a different program. Rungs 0–3
are entirely within our control; Rung 4 onward eats what GameM8c
learns. If the founder ever asks where this program can stall, the
answer is there, and it is already named in G-L5 rather than
discovered later — which is where a roadmap earns its keep.

— the maturation roadmap lane, 2026-11-06
