Skip to content

Roadmap: replace classic Atrinik with a fresh MIT Go and Rust stack #168

Open
7 of 22 issues completed
Open

Description

@zoeyrose

Reconciliation amendment — Tilewright ownership and continued Classic development (2026-10-30)

This amendment supersedes older critical-maintenance-only restrictions and conflicting shared-tooling ownership or sequencing statements below. The existing one-authored-content-source amendments remain in force: atrinik/content@main is the sole mutable authored source, including inputs for supported Classic artifacts.

  • Classic remains an active development and release target. Continue ordinary bug fixes, performance work, supported packaging, and owner-approved gameplay/content development through the appropriate Classic issues. Replacement foundations stay in their own repositories; existing licensing, provenance, isolated-state, compatibility, and rollback requirements remain.
  • Prioritize shared Tilewright renderer, world, editor, and content tooling. Atrinik server/client migration follows later. Existing milestone acceptance and dependency gates remain; this priority does not establish runtime, protocol, save, or content compatibility.
  • The canonical shared owners are Tilewright Renderer, Tilewright World, and Tilewright Editor. The former Atrinik renderer/editor URLs redirect to those same repositories; preserve the redirects and history.
  • Retain atrinik/content-toolkit as Atrinik's importer/exporter and Classic compatibility layer. Atrinik-specific rules, formats, catalogs, and game-profile adapters remain with Atrinik; shared game-neutral functionality belongs in Tilewright, with consumer compatibility verified during migration.
  • The successor renderer 0.5.1 and World 0.1.0 crates are published, and editor #42 has merged with a verified registry lock and transactional editing/undo/redo. This is a shared-library migration checkpoint; representative Atrinik content parity, import/export compatibility, production editor integrations, and runtime cutover retain their own acceptance.

No repository is established as unused by these changes. Toolkit retention is deliberate; any other retirement still requires an exact candidate and dependency/acceptance audit. Original roadmap text and historical evidence are retained below.


Architecture amendment — one authored content source (2026-08-13)

Initiative #357 supersedes every future live-branch instruction below. atrinik/content@main is the sole mutable authored content source. Future authored changes belong only on main; supported Classic artifacts must be derived from the same immutable main revision. Do not create, restore, author, backport, validate, publish, select, profile, or channel content through a live 1.x branch or content-1x checkout.

Exact historical commits, release tags, artifacts, checksums, and archived comparisons remain valid evidence. This amendment does not alter the issue's other feature, implementation, validation, licensing, or acceptance requirements.

Architecture amendment — one authored content source (2026-08-12)

Initiative #357 supersedes every split-line preservation instruction below. atrinik/content@main is the sole future mutable authored source; supported Classic content is a deterministic target built from the same main revision, not a maintained successor branch.

The certified migration inputs are main@v2.13.1 (3beec723be15d9f58d6321f728f5d73d33a00013) and final rollback release 1.x@v1.8.18 (0032e319dde316c2076832066fb5381177b34f42). The latter remains temporarily active only for migration/rollback until content #166, wrapper #358, Classic #170, playtester #2, and governance #64 complete. Historical tags/releases/assets/checksums/licenses/attribution remain permanent even after exact branch deletion.

Do not implement any older direction in this issue that requires ongoing content-1x authoring, separate releases, permanent branch protection, or a Classic consumer bound to 1.x. The Classic engine/support window itself is unchanged.

Purpose

Replace Atrinik's classic GPL implementation with a fresh, maintainable, independently releasable stack while preserving the game's existing gameplay, content, world, accessibility, and presentation design decisions.

This is a technical replacement program, not a gameplay redesign. It may use exact historical source material admitted under the evidence-gated policy below; otherwise independent implementation remains the default.

  • The authoritative server is new Go code.
  • The connected client and native editor are new Rust applications using SDL3.
  • One neutral Rust/wgpu renderer is shared by client, editor, and deterministic offscreen tooling.
  • Game Protocol 1 is a new Protobuf/Buf contract carried over QUIC with generated Go/Rust bindings.
  • Authored content is handled by a new Rust content toolkit and consumed as bounded compiled artifacts.
  • Runtime Python is removed. Generic gameplay is native Go plus compiled data; bounded typed CEL handles pure conditions/formulas. Starlark is a late, evidence-based escape hatch only if residual behavior genuinely requires it.
  • atrinik/atrinik remains a thin wrapper for repository composition, builds, profiles, scenarios, and supervised launch.

Non-goals

  • Do not replace or reopen existing gameplay/content design decisions merely because implementation moves.
  • Do not mechanically translate unadmitted GPL C/Python code or tests. Exact qualifying material follows the historical-grant audit and destination record below.
  • Do not put server, client, editor, renderer, compiler, protocol, or website implementation in this wrapper repository.
  • Do not recreate classic packet IDs, 49 display slots, Flex loaders, CPython plugin ABI, C globals, or source-tree runtime coupling in the fresh stack.
  • Do not blanket-relicense maps, archetypes, scripts, sound, graphics, or other mixed-license data.

Adopted repository map

Repository Canonical ownership License
atrinik/server Go simulation, authority, persistence, native gameplay/quest/dialogue/services, CEL, optional reviewed Starlark host, operations MIT
atrinik/client Rust connected session/actions, QUIC adapter, game UI, SDL3 input/audio/platform application MIT
atrinik/editor Rust authoring application, project/history/tools/inspectors, document-to-scene adapter MIT
atrinik/renderer Neutral scene/resource APIs, wgpu/WGSL GPU rendering, SDL3 surface bridge, UI/text render integration, offscreen atrinik-render, visual testkit MIT
atrinik/content-toolkit Rust lossless authored model, schema/catalog/diagnostics, transactions, ABIN/AMAP compiler, validator/CLI/automation MIT
atrinik/protocol Game Protocol 1 Protobuf schemas/specs, Buf policy, generated Go/Rust packages, golden/negative/fuzz fixtures MIT
atrinik/website Astro site and Cloudflare Pages deployment MIT
atrinik/atrinik Thin multi-repository orchestration only MIT
atrinik/content@main Forward authored content, replacement-format migration, and replacement release inputs Per-file/mixed
atrinik/content@1.x Maintained classic authored formats and v1.x content releases for the classic support window Per-file/mixed
atrinik/resources Separately released visual/media resources and exact provenance manifests Per-file/mixed
atrinik/sound Music/effects releases Per-file/mixed
atrinik/metaserver-worker Server registration/discovery Worker MIT
atrinik/devcontainer Reusable toolchain images, not workspace composition MIT
atrinik/classic (server/, client/, editor/, libatrinik/, protocol/) Preserved classic history, critical maintenance, unified Classic 5.x releases, rollback, retirement GPL-2.0-or-later

The five former standalone component repositories are already archived after their histories were imported into atrinik/classic; the fresh replacement repositories use independent main histories. The 12 temporary history/* refs used to verify that import have also been retired after their exact targets were recorded on classic main. The active classic source and release owner is now the single monorepo.

Checkout, content-line, and coexistence contract

  • Plain ./atrinik init initializes only the replacement/default development set. It never implicitly clones atrinik/classic, content@1.x, or the GPL tools repository.
  • ./atrinik init --with classic explicitly adds the complete classic cohort, including content-1x resolving atrinik/content@1.x.
  • Built-in default resolves canonical server/client/protocol/renderer/toolkit plus content@main. Built-in classic resolves classic-server, classic-client, classic-protocol, and classic-libatrinik from one monorepo checkout plus content@1.x and only explicitly retained classic dependencies.
  • content@main may migrate to JSONL or another separately approved replacement format. content@1.x retains classic authored/collection formats and v1.x releases; neither branch changes the corpus’s exact per-file licenses.
  • No wrapper fallback substitutes a canonical component for a missing classic component or vice versa. Mixed server/client/protocol/content/state combinations fail before build or launch.
  • Canonical and classic topologies can run simultaneously with distinct topology names, concrete components, build/cache roots, ports, typed server states, client configurations, runtime content trees, logs, and process ownership.
  • Default checkout selection in M1 is separate from production/runtime cutover in M6. The explicit classic cohort remains available through the rollback/support window.

The replacement-default/classic-opt-in wrapper interface was implemented by #276 and PR #281. Its current inspection surface is:

./atrinik init
./atrinik init --with classic
./atrinik status --json
./atrinik profile show default --json
./atrinik profile show classic --json

Detailed ownership: #263, #276, #277, #278, content#45, and content#46.

One-owner dependency model

content source ──> content-toolkit ──> compiled content ──> Go server
                         │                                  │
                         └────────> Rust editor             │
                                                            ▼
Game Protocol 1 <────────────────────────────────────── server projection
       │
       ▼
Rust client session ──> client-to-scene adapter ──> shared renderer
Rust editor document ─> editor-to-scene adapter ──> shared renderer
                                                    ├─ client window
                                                    ├─ editor viewport
                                                    └─ atrinik-render

Rules:

  • protocol owns network schemas only; it is not a generic content-schema repository.
  • content-toolkit owns source parsing/model/catalog/compiler/transaction logic and cannot depend on renderer/client/editor/server.
  • Go consumes compiled artifacts; there is no Go↔Rust FFI.
  • renderer cannot depend on protocol, client session, or editor documents.
  • Client and editor cannot depend on one another.
  • The wrapper invokes component-owned commands and manages isolated composition/state; it cannot reconstruct component internals.

Licensing and provenance

Independent MIT implementation remains available and is the default when qualifying reuse cannot be proven. This is an evidence gate, not a blanket clean-room prohibition. Under the canonical historical-grant policy, exact independently separable Classic material may be inspected as implementation reference, copied, migrated or ported, translated or adapted, and relicensed for an MIT destination.

Each selected contribution must fit one applicable row's temporal and sole-original-authorship scope. Distinct contributions may cite different rows only when each independently satisfies one row; rows cannot be combined to cover a jointly authored contribution, generated output, or inseparable mixed work. Later human- or agent-assisted material needs its own contemporaneous compatible permission. Git identity, prompting, direction, selection, or receipt of agent output does not establish historical-grant coverage.

Every reuse record must identify immutable source repository, path, and history; verified identity and sole original authorship; separability and embedded-material review; destination and transformation; retained copyright, attribution, terms, and notices; applicable grant entry; canonical registry revision; and reviewer. Tests, fixtures, generated bindings, assets, and dependency code receive no presumption of coverage. Shallow, uncovered, uncertain, or conflicting evidence fails closed.

The checked-in Classic distribution and notices remain GPL-2.0-or-later. Only the exact proven selected material receives additional MIT permission in its recorded destination; no surrounding file, dependency, asset, subtree, binary, or repository is relicensed. Source reuse does not itself approve linking to, depending on, or bundling the GPL Classic repository, library, or binary.

MIT engine/tooling can read and distribute separately licensed content when each file/package retains its actual terms and notices. Current content provenance gaps remain blocked from replacement packaging until resolved.

Server decisions

  • Go with a deterministic single-owner simulation model: bounded region command queues, injected clocks/RNG, stable generational identities, explicit preflight/commit/cancel transactions, and no goroutine-per-entity design.
  • QUIC transport uses Game Protocol 1 generated contracts, authenticated server identity, bounded frames/queues/rates, and atomic message validation.
  • SQLite WAL is the initial operational persistence owner with one coordinated writer, transactional migrations/checkpoints/backups, content-digest association, and failure injection. The classic importer, if any, is separate.
  • Quests, dialogue/interfaces, commerce, community/property, commands, metrics, achievements, triggers, and gameplay systems are native Go services.
  • CEL is typed, versioned, deterministic, pure, resource-bounded, and limited to approved conditions/formulas.
  • Starlark is not a baseline dependency. server#60 is a late go/no-go gate after native services, typed action graphs, and CEL have been proven. If approved, it receives immutable snapshots and returns typed commands; no filesystem/network/imports/mutation/ambient time/randomness.
  • Production cutover requires zero CPython/runtime Python: server#61.

The audited estate begins at 130 runtime/map Python and test/mock files, about 15,435 lines, 83 interfaces, and 16 quest definitions. server#4 and content#41 own the per-file behavior/provenance manifest.

Detailed server work: server#1 through server#68. Original server feature numbers #6–#35 were preserved and their product specifications retained.

Client, renderer, and editor decisions

  • Client is Rust + SDL3 for platform/window/input/audio, with a renderer-independent session/action core and generated QUIC/Protobuf adapter.
  • Renderer is a separate Cargo repository using wgpu/WGSL, with SDL3 surface glue only at the target boundary. Bevy is not used: Atrinik needs a bounded existing-world renderer and editor reuse, not a second ECS/application framework.
  • Client window, editor viewport, and deterministic offscreen output use one device/pass/resource/material/scene implementation.
  • Editor is a standalone Rust application depending on released renderer and content-toolkit crates, never the client.
  • Client/editor packages cannot contain one another's capabilities; the connected client never includes write-capable content authoring.
  • Shared semantic identity/depth/coverage masks drive visual tests and editor picking.
  • UI/text integration is shared at the render/component level; product layouts/state remain client/editor owned.
  • Linux/Vulkan and Windows/D3D12 are first-class supported targets, with explicit diagnostics/recovery and no permanent alternate renderer.

Detailed work:

Shared milestones and exit gates

No calendar due dates. Later work may prototype earlier, but a phase is complete only when its exit gate passes.

M1 — Provenance-controlled MIT foundations

  • Replacement/classic ownership, provenance/grant policy, repository guidance, CI/security/release bootstrap.
  • Replacement-only default initialization, explicit classic opt-in, branch-qualified content@main/content@1.x, and safe existing-workspace migration.
  • Go/Rust/Protobuf/toolkit/renderer/editor/client/website buildable skeletons.
  • Complete server, client, editor, content, tool, and asset behavior/licensing inventories, including the authoring inventory in editor#15.
  • Safe wrapper checkout relocation and component registration plan.

Exit: every fresh owner builds/tests independently, has an auditable MIT boundary, and no required contract/state owner is duplicated or unowned. A clean plain ./atrinik init creates zero classic checkouts; explicit classic initialization and both content branches resolve exactly.

M2 — Contracts, content, and headless world

  • Game Protocol 1 transport/common/domain contracts and Go/Rust conformance.
  • Lossless content model/catalog/transactions and deterministic ABIN/AMAP.
  • Deterministic Go simulation, persistence, entities/maps/actions, accounts, native quest/dialogue, CEL.
  • Baseline shared renderer/resources/offscreen output and client session/transport.
  • Wrapper build/dependency/topology composition.
  • Independently resolvable canonical and classic dependency closures with concrete service roles and typed state ownership.
  • Versioned black-box equivalence observations, normalization, reporting, and bounded comparison fixtures in #279.

Exit: toolkit→Go/editor, server→protocol→client, and scene→renderer boundaries pass the same bounded golden/negative fixtures; a headless world can load, authenticate, move, persist, and export an authorized scene. Canonical/classic protocol, content, server, and state mismatches are rejected before execution, and #279 can compare a bounded behavior sample without coupling implementations.

M3 — First playable replacement

  • One explicitly licensed compiled map chain.
  • Account/character/login/reconnect.
  • Movement, GPU ordered scenes, inventory/equipment, basic combat/AI/loot, chat/social, merchant/dialogue, one quest, Sam's saw/activity, save/reconnect.
  • Native Go only: no Python or Starlark.
  • Rust client HUD plus the bounded editor open/edit/preview/save/playtest slice in editor#17.
  • Deterministic wrapper account/character scenario and vertical-slice gate.

Exit: server#55 and atrinik#271 pass from clean pinned repositories on supported targets; atrinik#278 proves a canonical pair and classic pair can run simultaneously without sharing state, ports, content, protocol, client configuration, builds, or logs.

M4 — Shared editor and scalable presentation

  • Complete native map-editor MVP, lossless transactions/recovery, automation, isolated playtest, catalog/inspector/diagnostics.
  • Shared 2.5D geometry, shaders/materials, retained GPU data, lighting, world imagery/projection, UI/accessibility/performance, offscreen CI.
  • No duplicate parser, renderer, scene, or pixel-selection implementation.

Exit: client/editor/atrinik-render produce the same semantic scene results and editor workflows are safe enough to supersede classic authoring for representative content.

M5 — Gameplay and world migration

  • Preserve and implement all open gameplay/content designs on the native Go/Rust foundations.
  • Migrate quest/interface/NPC/economy/community/map/item/monster/global behavior in parallel domain batches.
  • Complete client and editor behavior parity (client#37, editor#16) and whole content-corpus conversion on content@main; the maintained 1.x classic line is preserved and is not mechanically merged or deleted.
  • Ordered structural scenes and large-world streaming fully replace classic representation.
  • Starlark go/no-go is resolved; CPython/runtime Python reaches zero.

Exit: #280 proves whole-baseline-content-pack functional equivalence. Parity/behavior/content manifests contain zero unowned, skipped, ambiguous, or unexpectedly divergent required rows; all deliberate differences or exclusions have explicit product approval.

M6 — Production hardening and cutover

  • Security/fuzz/load/soak/fault/device/recovery gates.
  • Reproducible packages, SBOM/provenance/licenses, operations, backups, optional approved state import.
  • Website/download/metaserver/release set and wrapper-default cutover rehearsal with objective rollback gates.
  • Complete the unified Classic 5.x release pipeline in classic#16, beginning with v5.6.0 as the first monorepo release, and preserve final classic releases/history/state plus the content@1.x branch/tags throughout the support/rollback window. The five former standalone component repositories are already archived.
  • Switch production/runtime recommendations separately from the already replacement-only checkout default.

Exit: after #280, atrinik#272 succeeds; atrinik#273 may then retire the classic monorepo and wrapper support cohort explicitly.

Authoritative cross-repository execution plan

This issue is the single program plan above repository-local milestones. Every open implementation issue must belong to exactly one M1–M6 milestone; the only intentionally unmilestoned issue is this roadmap. A later-milestone prototype may start early, but no milestone is complete until all required issues in every repository and the join gate below are complete.

The phase dependency is:

M1 provenance-controlled owners/inventories
        │
        ▼
M2 contracts + headless world + equivalence harness
        │
        ▼
M3 playable/client/editor vertical slice ─────┐
        │                                     │
        └──────────► M4 full renderer/editor ─┤
                                              ▼
                              M5 whole-pack parity (#280)
                                              │
                                              ▼
                              M6 hardening/cutover/retirement

Phase-by-phase dispatch and joins

Gate Required work before the join Work that should run in parallel Join/exit evidence
M1 Namespace/provenance/governance; protected content@1.x; replacement-default/classic-opt-in component model; fresh repository bootstrap; architecture boundaries; server/client/editor/content behavior inventories Server shell/architecture, protocol/Buf seed, toolkit lossless-model design, renderer proof/API, client session/action core, editor shell, resource/license audit, wrapper safe-relocation design Each owner builds/tests alone; AGENTS.md and MIT/provenance gates exist; server#4, client#5, editor#15, and content#41 assign every required behavior; default/classic profile resolution is exact
M2 Stable identity/limits/error/version contracts; Game Protocol 1 schemas; toolkit document/catalog/transaction/artifact contracts; deterministic simulation/state/persistence model; renderer scene/resource contract; wrapper build/topology/state contract Protocol domain schema groups; toolkit parser/catalog/transaction/compiler; server simulation/transport/content/entities/maps/accounts/actions/quest/dialogue/CEL; client session/transport; renderer baseline/offscreen; editor document-to-scene adapter; wrapper isolation/reporting Cross-language golden/negative/fuzz fixtures pass; headless load/login/move/save/reconnect passes; #279 emits a reproducible bounded classic/replacement comparison
M3 M2 versions pinned; one licensed content chain; minimal server gameplay; connected client; bounded editor slice; deterministic scenarios Server #48–#55, client M3 UI/action domains, renderer ordered-scene work, protocol conformance, content slice, editor#17, wrapper scenario/topology work server#55, #271, and #278 pass from pinned clean state; then protocol#13 freezes GP1
M4 M2 toolkit/renderer interfaces and lessons from the M3 slice Renderer shaders/2.5D/lighting/UI/offscreen/performance; editor project/transactions/viewport/tools/inspectors/automation/playtest; toolkit workflow/corpus testing; client automation/accessibility/presentation One renderer/picking path serves client/editor/offscreen; native map-editor MVP is lossless, recoverable, automatable, and safe on representative content
M5 Stable M3 protocol and M4 authoring/presentation foundations Server behavior domains and Python removal #57–#61; client matrix #37; editor matrix #16; content conversion content#8; toolkit whole-corpus proof #9; renderer streaming/structural scenes Each lane publishes a pinned zero-unowned local report; #280 then runs the aggregate whole-baseline-pack equivalence gate with only explicitly approved differences
M6 M5 #280 passed and immutable release candidates available Server/client/editor/renderer/toolkit packaging and hardening; security/load/soak/fault/device tests; state migration/backup/restore; website/metaserver/download updates; unified Classic 5.x release and rollback rehearsal #272 cuts over only after objective rollback gates pass; #273 retires the classic monorepo/support cohort only after the support window

Ordered workstreams

Within each lane, contracts/fixtures precede consumers; implementations may then proceed concurrently.

Lane Order and ownership
Governance and workspace #260–#265 and #276 → #266–#269 plus #277 → #279 → #270–#271 and #278 → #280 → #272–#273. Root changes remain orchestration-only.
Protocol protocol#1–#3 foundations → domain schemas/bindings #4–#12 in parallel with Go/Rust consumers → GP1 freeze #13 after M3.
Content and toolkit Provenance/inventory content#41–#43, toolkit#1–#2 → model/catalog/transaction/compiler/release toolkit#3–#7, content#11, #44 → workflow/corpus migration toolkit#8–#9, content#8. main and 1.x remain separately released.
Go server server#1–#5 architecture/inventory → all M2 simulation/transport/content/state/service issues, especially #32–#47 → M3 gameplay #48–#55 → parallel domain/Python closure #57–#61 plus preserved feature issues → M6 importer/ops/security/cutover #62–#65.
Renderer Bootstrap/API/proof/resource ownership renderer#1–#4 → baseline scene/resource/UI/offscreen work #5–#12 and shared extraction #17 → advanced editor/presentation work #14–#16, #21–#22 → structural/streaming parity #18 → M6 packaging/hardening.
Rust client Bootstrap/architecture/platform/behavior inventory client#1–#5 and session core #15 → protocol/session/resources #12, #32 → M3 UI/action domains → automation/presentation → parity closure #37 → packaging/hardening #38–#39.
Rust editor Bootstrap/architecture/inventory editor#1, #2, #15 → M2 document/scene boundary #12 → M3 vertical slice #17 → M4 MVP #3–#6, #10–#11 → non-map demand #7 and parity closure #16 → M6 package/hardening/retirement #8–#9, #13, atrinik#259.
Public/operations dependencies Resource/sound provenance and packages, devcontainer toolchains, the discovery/publishing cluster (protocol#12, metaserver-worker#13, #21, #22, server#68, and client#41), website #1–#4, and GitHub governance progress alongside component work; public default changes remain M6 and cannot imply cutover before #280/#272.

Native dependency edges and integration ownership

The critical joins are recorded with GitHub's native “blocked by” relationships as well as in issue bodies:

  • #279 is blocked by wrapper cohort/topology/state work (#276, #269, #277), the server/client/editor/content inventories, and replacement content manifests.
  • #271 is blocked by #279, wrapper scenarios #270, server#55, client#34, renderer#17, and editor#17.
  • #278 is blocked by wrapper initialization/build/supervision/cohort/state work (#263, #266, #269, #276, #277), content#45, and the replacement slice #271.
  • editor#16 is blocked by the inventory, M3 slice, and all required M4/M5 editor workflow issues.
  • #280 is blocked by #279, #271, #278, whole-corpus content/toolkit evidence, server/client/editor/renderer parity closure, GP1 freeze, and replacement content manifests.
  • #272 is blocked by #280; #273 remains the post-cutover per-repository retirement gate.

Cross-repository integration issues verify released contracts; they do not absorb component implementation. A failed join creates or reopens a focused issue in the one owning repository.

Parallelization rules

  • Start immediately: M1 repositories, provenance audits, behavior inventories, wrapper cohort design, protocol primitives, toolkit grammar/model work, renderer proof, client session core, and server deterministic-value/architecture work.
  • Parallel after M2 interfaces exist: protocol domains, server simulation/persistence/content/services, renderer scene/resources, client transport/actions, editor adapters, wrapper topology/equivalence adapters, and content compilation.
  • Parallel after the M3 pin: server behavior-domain batches, client UI/parity domains, renderer presentation, editor MVP/non-map domains, and corpus conversion. None needs to wait for another domain's implementation if it uses released contracts and shared fixtures.
  • Serialized joins only: GP1 freeze follows the M3 slice; the aggregate #280 run follows all local parity reports; production cutover follows #280; classic support retirement follows cutover/support/rollback evidence.
  • Never use a source-level cross-repository dependency to bypass a contract. Temporary local overrides belong in wrapper profiles and must resolve back to independently releasable versions.
  • Every required capability has one stable ID, one implementation owner, one acceptance fixture/procedure, and one milestone. An unowned/skipped row is a failing gate, not deferred invisible work.

Classic maintenance policy

The active atrinik/classic monorepo accepts only critical security/data-loss/build/release/export work needed for fallback and retirement. Its unified Classic 5.x release pipeline, beginning with v5.6.0, is tracked by classic#16. No new gameplay features or replacement foundations land there. The five former standalone component repositories are archived and read-only; their source, releases, issues, licenses, and attribution remain available. atrinik/content itself stays active: main moves forward, while 1.x accepts only approved classic maintenance and is preserved after support ends. Approved-grantor evidence may move an exact original contribution into MIT ownership but never blanket-relicenses a repository or branch.

Classic maintenance and eventual retirement issues:

Program maintenance rules

  • Every implementation issue names exactly one owning repository, milestone, dependencies, bounds, failure behavior, acceptance fixtures, licensing/provenance method, and wrapper integration where applicable.
  • Product/design decisions remain in their owning issue; technical edits must not silently alter them.
  • Cross-repository contracts require producer/consumer/conformance issues and explicit compatibility/versioning.
  • When an issue moves, update final URLs, milestone, parent/sub-issues, and dependent bodies in the same change.
  • Add a new parser, renderer, scheduler, persistence model, scripting host, or schema owner only through an explicit architecture decision.
  • Update this index whenever repository ownership, phase gate, critical dependency, or cutover policy changes.

Activity

  1. zoeyrose commented on Aug 6, 2026

    @zoeyrose
    MemberAuthor

    Milestones have been repaired after the repository split.

    • client: M1 2, M2 4, M3 16, M4 3, M5 1
    • server: M1 3, M2 7, M3 11, M4 6, M5 3
    • content: M1 5, M2 1, M3 5, M4 9, M5 4
    • protocol: M2 1
    • tools: M2 1
    • integration: M1 3, M2 2, M5 11

    Every open executable issue has exactly one owning-repository milestone. This
    master roadmap remains intentionally unassigned because it spans all phases.
    The empty integration M3 milestone was closed while preserving its completed
    issue history, and the wholly unused integration M4 milestone was removed;
    those phases remain active in their component repositories.

  2. changed the title [-]Master roadmap: sequence the 2026 Atrinik revival backlog[/-] [+]Roadmap: sequence the 2026 Atrinik revival backlog[/+] on Aug 7, 2026
  3. changed the title [-]Roadmap: sequence the 2026 Atrinik revival backlog[/-] [+]Roadmap: replace classic Atrinik with a fresh MIT Go and Rust stack[/+] on Aug 7, 2026
  4. pinned this issue on Aug 7, 2026
  5. 11 remaining items

  6. moved this from Inbox to Backlog in Atrinik workon Aug 8, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Fields

    No fields configured for Initiative.

    Projects

    Milestone

    No milestone

    Relationships

    None yet

    Development

    No branches or pull requests

    Issue actions