A manifesto you can walk through, edit, and break — plus a suite of five generative "probe" pieces that read the same text and bring it to life in different ways.
Everything in the project is driven by a single document, levelManifeto.txt — a hand-written, stream-of-consciousness manifesto. Two things share that document:
- A Java desktop game. You pilot an @ over the words of the manifesto; words highlight and become editable; glyph "objects" can be picked up and used on words; and the whole manifesto is paginated across a dynamic number of levels. There's also a companion instrument that visualizes the manifesto and a stream of numeric data live.
- Five HTML / Three.js "probe" pieces. Each renders the manifesto as a manifold — a cylinder, a torus, an unrolled grid, a runner field — and seeds autonomous object systems from the text, each with its own distinct behavior.
Where the rest of the artistic work asks what computation feels like, this one asks what a piece of writing becomes when you can operate it — push its words around, grow geometry out of it, and let the whole thing breathe on its own.
placeholders — real captures to come.
Requires a JDK (17+, built on OpenJDK 24), python3 for the local server, and a modern browser with WebGL. No build tool, no dependencies — it runs from the project folder as-is.
The Java game
The launcher compiles when needed and runs from the project folder so the relative-path assets load:
./run_manifoldgame.sh # the manifesto game
./run_manifoldgame.sh probe # the data-probe instrumentIt opens three windows: the game, a Field Manual, and an editable levelManifeto.txt window that auto-saves and live-updates the game as you type.
The HTML probes
The probes fetch() the manifesto, which is blocked under file:// — so serve the folder over HTTP, then open the pages on localhost:
cd ManifoldGame
python3 -m http.server 8777
# then open, e.g.:
# http://localhost:8777/PROBE_VIEWER:%20RELATIONAL_PARADIGM_V1.html
# http://localhost:8777/dualobserverprobe.html
# http://localhost:8777/theView.htmlEach probe opens with a splash screen explaining what it is and how to drive it.
The charmap atlas
Everything draws text from one bitmap font, and its exact layout matters (it was the source of several bugs). The image is 128 × 64 px, holding 18 columns × 6 rows of glyphs:
- Columns are 7 px apart with a 1 px left margin; rows are 9 px apart with a 1 px top margin; each glyph is a 7 × 8 px cell.
- The glyphs are white-on-opaque-black, so to render them in color the code keys the alpha from luminance (white → color, black → transparent) in 2D, or uses additive blending in 3D so black contributes nothing and white glows.
- The uppercase A–Z slots are decorative rune-like glyphs; lowercase, digits, and punctuation are normal — which is why the (almost entirely lowercase) manifesto reads cleanly.
ManifoldGame.java — the manifesto game
A single-file Swing application; no frameworks. A background thread runs update() then repaint() at ~60 fps; input and rendering run on the Swing event thread; cross-thread state is kept safe with volatile fields and by swapping lists by reference rather than mutating them.
Pagination → levels
The manifesto is laid out into pages, and each page is a level. The number of levels is dynamic — it grows and shrinks with the text. The text is tokenized into words (each remembering its source line and character span), greedily wrapped into rows up to the panel width, then sliced into pages of what fits on screen at a full, readable size. The text never shrinks; overflow simply becomes more pages. Type enough into the editor and new levels spawn live.
Word provenance
Each rendered word knows exactly where it came from in the source text. This provenance map is the backbone of every word interaction: because a word knows its source span, any edit / move / delete can be spliced straight back into the manifesto and round-tripped to disk.
The interaction model
The @ is the cursor. Walking over a word highlights it. Bumping an object picks it up (it then rides with you, even across pages). Then ENTER on the highlighted word resolves in priority order — drop a carried word, else use a held object's verb, else edit the word inline:
| object | glyph | verb |
|---|---|---|
| block | # | move — pick the word up to carry; ENTER on a second word relocates it |
| spark | * | scramble — anagram the word's letters |
| coin | $ | duplicate — insert a copy after it |
| node | o | delete — remove the word |
| bar | = | join — glue it to the next word |
Every change — from a verb, an in-game edit, or typing in the manifesto window — flows the same way: the new text updates the editor, re-paginates and repaints the game live, and is auto-saved (debounced) to levelManifeto.txt. The game, the window, and the file stay in sync both directions.
The render pipeline
Drawn back-to-front: a gradient/grid/vignette backdrop, the manifesto page on a dark panel (each word's screen rect recorded, the word under the player highlighted), the page's generated objects breathing on top, the player and whatever is in hand, an amber readout, and a CRT scanline + sweep overlay over everything.
ProbeNavigator.java — the data-probe runner
A separate, simpler instrument. Every frame it re-reads two files live: the manifesto and a stream of numeric tuples (output.txt). It renders the manifesto as dim background noise, the data as a glowing column field, a DATA_PRESSURE bar, and a pulsing probe. It gates its file re-read for ~1.5 s after an edit so the editor stays the source of truth until its save lands.
Two level systems, layered
The platformer heritage. The game began as a fixed 13-level platformer (a spin-off of an older engine), and the original level0.xml … level12.xml files survive — though only levels 1, 2, 11, 12 hold real geometry; the rest are stubs, and there is no level0.xml. They're preserved as the project's archaeology.
The dynamic, manifesto-driven model. Today the game derives levels from the manifesto itself: each page is a level, the level count is dynamic, and each level's geometry is generated deterministically from that page's text — so the same page always yields the same field, and different pages yield different ones. These generated levels are persisted to manifest_levels/page_N.xml (the original level files are never touched). A page's objects only regenerate when you enter it, so editing never makes the field jump around.
The manifold, five ways
All five share one idea: the manifesto becomes a manifold, and manifesto-seeded objects (# = * $ o) live on it. The difference from the game: there you drive the objects; here the objects are autonomous — they move on their own. And each piece's dynamic is distinct.
| piece | manifold | autonomous dynamic |
|---|---|---|
| Relational Paradigm | 3D torus, words scattered around it | Bonded network — objects breathe; cyan bonds form and break between neighbors as they drift, opacity pulsing with distance. |
| Dual Observer | 3D cylinder of glyph-planes, lit by a probe | Gravity wells — drifting objects pull the surrounding text toward them, denting the manifold. |
| Probe 01 | 3D cylinder, self-lit, warps & spins | Orbiters — objects circle the axis trailing ribbons of light; orbit speed is tied to the warp dimension. |
| Flat Text Atlas | 2D unrolled grid — the manifold laid flat | Roamers — Langton's-ant objects crawl the chart, flipping and lighting cells, building drifting highways from simple turn-rules. |
| The View | 2D runner — the manifesto as a landscape | Flocking swarm — a boids school flows across the field and scatters from your probe, then re-forms. |
What it's about
The document everything reads is a transmission written live — half stand-up routine, half prayer. Its through-line: "the level that is the conversation i have with the ones and the zeros." Not a game about computation but a conversation with it. It circles friendship as the only thing worth standing for, insists that magic is real "no matter how you spell it," lays out a thirteen-year plan, and keeps a whiteboard that says Focus on the Level — then admits you can't focus on the level without focusing on the player.
CLAUDE_NOTE.md — an outside reading of the manifesto written from the perspective of a deep dive into the net and the "digital martial way."- Uppercase shows as runes — the font's A–Z slots are decorative; the manifesto is lowercase, so it rarely matters.
- The HTML probes need a server —
fetch()is blocked onfile://; the 3D pieces also need a connection for the Three.js CDN. - The gravity-well probe is the heaviest — it perturbs a sampled set of text planes each frame.
- Unfinished threads — the original stub levels 3–10 are empty, the numeric stream looks built for an eventual sonification pass, and the manifesto references a Web3 layer that was never wired up.