license: public domain CC0
Design Document: The Git Multiverse Roguelike
(with forward‑compatibility for 3D, TV, and cinematic adaptations)
1. High‑Level Concept
A procedurally generated roguelike set inside a surreal, shifting multiverse built from the semantic, emotional, and structural history of real software. Every room, NPC, item, puzzle, and hazard is generated from:
- commit metadata
- blame lineage
- cyclomatic complexity
- code smells
- subsystem boundaries
- cross‑repo universes (Linux, BSDs, Illumos, etc.)
- PR drama
- contributor counts
- deleted history
- secret‑commits
- reverts, cherry‑picks, backports
- multiverse divergence
The game blends fast ASCII action with a deep textual lore layer, powered by an in‑world LLM “Archivist” that can answer questions, describe rooms, and maintain a persistent story.
This design is fully compatible with future expansions into:
- a 3D immersive version
- a cinematic TV adaptation
- a narrative podcast
- a graphic novel
- a Netflix series titled something like
Linux: An Adventure Written in Blood
(your title is metal as hell, by the way)
2. Core Gameplay Loop
Player explores a procedurally generated dungeon of commits.
Each commit is a room with:
- geometry shaped by code metrics
- emotional tone shaped by PR history
- NPCs shaped by contributor behavior
- hazards shaped by code instability
- items shaped by semantic relationships
Two layers of interaction:
- Fast roguelike movement/combat
- Deep textual exploration via the Archivist window
Players can ignore the lore and just play the game,
or dive into the story and metadata at any time.
3. Screen Layout (ASCII Roguelike)
Recommended Layout
+----------------------+------------------------+
| MAP WINDOW | LORE / STORY |
| (ASCII gameplay) | (Archivist output) |
| | |
+----------------------+------------------------+
| METADATA SIDEBAR | MESSAGE LOG |
+----------------------+------------------------+
Why this works
- Keeps action readable
- Gives space for rich text
- Lets the LLM act as an in‑world character
- Supports players who want depth and players who want speed
4. Rendering Styles (Semantic Visual Layers)
Available Styles
- High‑color tile mode (modern, stable code)
- 16‑bit Gauntlet‑style (mid‑history)
- Unicode/emoji roguelike (expressive chaos)
- Classic ASCII (old, brittle code)
- TRS‑80 monochrome (ancient, cursed code)
- ZX Spectrum isometric (divergent universes)
- Matrix‑glyph rain (secret‑commits, instability)
Recommendation
Use rendering style as a diegetic indicator of code stability:
- HEAD commits → crisp tiles
- Mid‑history → 16‑bit
- Old commits → ASCII
- Fossilized commits → monochrome
- Collided blame‑rooms → flickering mixed styles
- Secret‑commit vaults → Matrix green
- Ephemeral rooms → degrading styles over time
This creates a visual “signal quality” metaphor for the code.
5. Room Generation
Inputs
- cyclomatic complexity
- LOC
- nesting depth
- coupling
- cohesion
- churn
- commit type (fix, revert, cherry‑pick…)
- blame lineage
- universe origin
- code smells
- deleted history
- secret‑commit flags
Outputs
- geometry
- lighting (ASCII palette)
- NPC population
- hazards
- items
- music cues (textual)
- rendering style
Recommendations
- High CC → labyrinthine rooms
- High nesting → vertical shafts
- High coupling → many exits
- Low cohesion → mismatched props
- High churn → unstable geometry
- Reverts → backwards rooms
- Cherry‑picks → mirrored rooms
- Fix‑ups → patched rooms
- Deleted code → collapsing rooms
- Secret commits → vaults
6. Blame‑Rooms (Collided Realities)
Concept
Each version of a file/function becomes a room.
They must overlap by 20% minimum to ensure navigability.
Additional versions branch off but still overlap something.
Effects
- intersecting geometry
- flickering exits
- NPCs from multiple universes
- props clipping through each other
- contradictory lighting
- multi‑layered procedural music
- rendering styles blending or glitching
Recommendation
Use blame‑rooms as major set‑pieces and puzzle hubs.
7. Hazards & Dynamic Rooms
Ephemeral Rooms
Rooms that collapse, evaporate, or phase out unless stabilized.
Trap Compression Rooms
Walls close in unless the player resolves the underlying code issue.
Merge‑Conflict Rooms
Geometry shifts unpredictably.
Dangling Commit Rooms
Rooms that collapse instantly unless the player has a temporal key.
Recommendation
Tie hazards to real code events so they feel meaningful.
8. NPC System
Types
- Sentinels (guards requiring items)
- Fragmented NPCs (unstable versions)
- Builder NPCs (fix‑commit workers)
- Ghost NPCs (deleted code)
- Divergent NPCs (parallel universes)
- Agitated NPCs (high churn)
Recommendation
NPCs should reflect the emotional history of the code.
9. Items & Gating
Procedural Artifacts
- Patch fragments
- Revert shards
- Echo tokens
- Stability glyphs
- Vault sigils
- Temporal keys
- Multiverse sigils
Recommendation
Items should be semantic keys tied to commit relationships.
10. Story Engine
Two Layers
- Global story generated once at world creation
- Local embellishments generated per room
Archivist LLM
- answers questions
- describes rooms
- explains commit history
- gives cryptic hints
- maintains narrative consistency
Recommendation
Treat the Archivist as an in‑world character, not a narrator.
11. Future Adaptations
3D Game
- Rooms become full 3D spaces
- Rendering styles become shaders
- Blame‑rooms become impossible architecture
- NPCs become animated
- City‑scale codebase visualization becomes possible
TV Show / Netflix Pitch
Linux: An Adventure Written in Blood
A surreal, character‑driven exploration of the emotional and architectural history of the world’s most important software.
Think:
- Dark
- Severance
- Arcane
- Mr. Robot
- Everything Everywhere All At Once
…but set inside the multiverse of code.
Recommendation
Build the roguelike first — it becomes the story bible for all future media.
12. Summary of Key Recommendations
- Use rendering style as a semantic indicator of code stability
- Make blame‑rooms major puzzle hubs
- Use cyclomatic complexity and metrics to shape geometry
- Use the Archivist LLM as an in‑world lore engine
- Keep the roguelike fast but give space for deep text
- Build a global story once, with local variations
- Save the city‑scale visualization for the 3D version
- Treat hazards as metaphors for real code events
No comments:
Post a Comment