THE CHAMBER · ARCHITECTURE
A Commodore 64 program, a Commodore 64 recreated in software to run it, and the page you look at both through are all held in Ethereum contracts. Ask for one of these tokens and those pieces are assembled at the moment you ask. Nothing we control is needed off the chain to put them back together.
That arrangement puts several systems inside one another, and each has rules the others have never heard of. A Commodore 64 — the home computer of 1982 — has no concept of a transaction. Ethereum has no concept of a raster line. Almost everything on this page was found at a border between two of them. We call those borders seams, and the page is arranged around them.
Four systems, one inside the next. Ethereum on the outside; then the browser; then the Commodore 64 the browser starts. At the centre, inside the program running on that machine, sits whatever the collection put in the gap left open for it.
A seam is a border in that picture: the place where one system hands something to another, and the rules change.
Compare with the Chamber
The outer arrangement is almost unchanged. What differs is the centre, and what the centre does to the ways in and out. The Chamber's gap holds a stamp, and there is one path to it: a read. Perception's holds a learner, and there are three.
One machine rations address space. The other rations computation.
A Commodore 64 has sixty-four kilobytes of address space and a memory map that was settled in 1982. Whatever you want the machine to do has to fit inside that, and the machine's own operating system is already living there.
Ethereum's ceiling is not space but work. Every operation a contract performs costs gas, and only so much of it fits in a transaction or a call. Ask for too much at once and nothing happens at all.
Put one piece of work across both and the question "does it fit?" stops having a single answer.
Neither machine is simply "the small one." Which limit binds depends on what you are shipping, and it swaps: a program shipped as a PRG is bound by the C64's 64 KB; the learning rate (32 lessons a batch) is bound by Ethereum's gas; a program shipped as a cartridge would be bound by Ethereum again.
The C64's 64 KB is not "64 KB minus the ROMs" — the ROMs and I/O are overlays the PLA switches out, and the RAM underneath is real. Perception's PRG uses it in anger: 8,192 bytes land in the BASIC ROM window, 4,096 at $C000–$CFFF, and 903 bytes land underneath the VIC and SID registers at $D000–$D386, 433 of them non-zero and patterned like bitmap data.
Before PerceptionCodec, the render was the limit. After it, the C64 is. The base64 encoder was ~73 gas a byte and two thirds of the whole render; rewriting it to fill a word per MSTORE instead of a byte per MSTORE8 took the placeholder tokenURI from 60.86 M gas to 18.97 M, and the real image from 102.4 M to 33.39 M — with the artwork untouched.
Genesis writes 42 bytes into its program's hole; Perception writes 834. The interesting difference is not 20×. Genesis's 42 are facts the chain already had — 32 bytes of seed, 8 digits of block number, plus a behaviour and a colour read from a table. Perception's 834 are a result the chain had to compute, and could have been wrong about. The hole went from a mailbox to a verdict.
One was finished in 2022 and cannot be edited. The other is rebuilt with every work.
The Commodore 64 here is nopsta's emulator, written in 2022 and stored in Ethereum contracts. That is the whole of it — there is no later version and no patch. Whatever it does and does not do, it will do and not do for as long as the contracts exist.
The page that starts it is ours, and a new one goes out with every work. The two sides of this border age differently, and most of what we learned here came from finding out what the 2022 machine can actually be asked to do.
The 2022 emulator's cartridge reader indexes fixed pointer arrays (roml[64], romh[16]) with a bank byte taken straight from the file and never range-checks it. It cannot be fixed — it is on chain for ever. So the safety moved to the caller: the page validates every .crt before a byte reaches the runtime. The general pattern: when the callee is immutable, the caller carries the safety.
The machine is not capped at 64 KB. nopsta's 2022 build includes a first-class cartridge port with bank switching: m64_loadCartridge is exported, and the arrays hold 64 ROML banks (512 KB) plus 16 ROMH (128 KB). Four formats are implemented — Normal (0), Ocean Type 1 (5), C64GS (15), Magic Desk (19). EasyFlash, which most large modern conversions use, is not supported. Per-format ceilings as the readers actually index them: Ocean 128/256/512 KB, C64GS 512 KB, Magic Desk 256 KB (bank masked value & 0x1f), Normal 4 K or 16 K.
cartridge_readNormal()'s 8 K branch allocates ROMH, frees ROML, then writes into the never-allocated ROML — out of bounds, a hard WASM trap. The adjacent 4 K and 16 K branches are internally consistent; only 8 K Normal is broken. Because the build is on chain, this is a permanent fact about the machine, not a bug to fix.
.d64 and every multi-load game are out. The serial bus is scaffolded — iecBus.c is 80 lines adapted from VICE, with iecBus_serialDeviceCount = 0 — but no drive CPU and no DOS was ever written behind it. This is the single largest category of software the machine cannot run, and it is structural.
The LGPL replacement ROMs we pressed on chain (KERNAL, BASIC, CHARGEN) roughly double the software the machine can run, by supplying the stock firmware environment that packed loaders and BASIC stubs assume. They add no memory. They subtract it: mapping BASIC takes back the 8 KB at $A000–$BFFF that Perception is currently using. And a full KERNAL still has nothing on the other end of the bus, so it does not get you a disk (F-007).
The page is frozen the day it ships. The browser it opens in is not.
A page stored in a contract is finished the day it goes out. The browser it will be opened in is not: browsers change, conventions move, and something safe today may not be in ten years. A browser has no reason to preserve the behaviour of a machine from 1982, or of a page written in 2026.
So the question at this border is which of those dependencies are actually dangerous — and it is easy to worry about the wrong ones.
animation_url is the fragile link, not the web standardsThe browser dependencies people worry about are the safe ones. The JS engine, Canvas 2D and requestAnimationFrame carry essentially zero removal risk; Web Audio's risk is policy drift, not removal. The genuinely fragile link is `animation_url` itself — a marketplace convention, not a standard, with no standards body and no deprecation process. The page is frozen on chain and cannot be patched if a convention moves, which is why the .prg exit (prg() / prgWithBrain() as contract views) is what actually makes the work durable.
The Genesis paper's live embed is gone for good. Its render is ~61 M gas against a 50 M provider cap on `eth_call` — a cap explicit gas cannot raise, because it is the provider's, not the transaction's. Replaced by a gallery of the eight characters served as files, proven against the on-chain bytes. Perception's render still loads at ~31 M.
Two ways to ask a contract a question. The same contract answers both.
Asking a contract for a token's artwork costs nothing and happens at once. Saving something to that contract costs gas and has to be mined. The same contract answers both, which is why most descriptions of on-chain art treat them as one thing.
tokenURI() and prg() are view calls. They run on one node, cost nothing, and are not consensus-verified — you trust them because they are deterministic and anyone can reproduce them, not because the network checked. saveMind() runs on every node and is adjudicated. Most descriptions of "on-chain art" conflate these. The Chamber has both in one contract, so the difference is concrete rather than theoretical.
Teaching is something that happens. A revision is something that is recorded.
Someone sits at a keyboard and teaches a small learner inside the running program. That is an event: it takes time, it happens in one browser, and nobody else is present for it. What ends up on Ethereum is not that event. It is a record — a starting state, a list of lessons, and a claim about what they produced.
The chain was not there. It could not have been. Everything at this border is about what can be established afterwards, from the record alone, by someone who was not in the room.
The chain never watches the teaching; it cannot. It re-derives it. What saveMind validates is exactly one proposition: the claimed brain is the necessary consequence of the claimed lessons under the stated rule. It validates nothing about whether the learning was good, useful, or interesting.
When a lesson's recorded prediction disagrees with the recomputed one, the Python oracle records the mismatch and carries on; the Solidity reverts. The EVM is the harshest reader of our own work, by choice.
savedBy is the address that submitted the transaction — the holder who committed the revision, never proof of who sat at the keyboard. We wrote that limitation into the data structure's own comment rather than letting a reader assume otherwise. The gap is structural, not a gap in our implementation: no chain can witness a human.
The obvious constraint is capacity (834 bytes, 800 weights). It is not the binding one. To live here an architecture must be exactly replayable: no floats (IEEE754 cannot be relied on byte-for-byte across three architectures), no hidden state, no clock, no unseeded randomness, no ordering ambiguity, and cost linear in lessons. That filter cuts across the usual taxonomy: a tiny float network is impossible here; a much larger integer one might be fine. Hebbian and other local rules are likely easier than what we shipped; decision trees and k-NN are trivially admissible; integer backprop is hard but not obviously impossible; attention is not honestly in reach.
A one-layer perceptron cannot learn a non-linearly-separable mapping — Minsky and Papert, 1969. BRAIN025 is one layer. It works anyway because toRelative() converts absolute taught actions into Tony-relative ones before the learner sees them, which makes the policy first-order and learnable. The representation was changed so the network did not have to be. This is shipped on mainnet and nothing public mentions it.
BRAIN025 agrees byte-for-byte on a 6510, in Python, and in the EVM — not because anyone ported anything, but because the specification admits no floats, no clocks and no external calls. That is the identical property that makes Ethereum work at all. Consensus is determinism at network scale; our learner is determinism at 834 bytes. Three independent implementations is also the minimum for a vote: with two, disagreement tells you there is a bug but not which side has it.
Not every discovery sat on a border. Some came from the way the work was built and checked — decisions about tooling, about what to refuse, and about how a fact gets from one place to another without changing on the way.
They are gathered here rather than forced into a seam. The seam idea is more useful for being allowed not to explain everything.
The oracle exists to check the Solidity. The fixtures exist to make the oracle checkable. The gates exist to make the fixtures checkable. The audit bundle exists to make the gates checkable by a stranger. Of the seven layers in ARCHITECTURE.md, three are the work and roughly four are the proof of the work. This is invisible from outside and is probably the most unusual thing about how it was built.
A C64 cartridge is the closest thing that machine has to an upgradeable contract: a fixed address ($8000) whose contents are swapped by writing a bank number to $DE00. The on-chain equivalent is delegatecall, or extcodecopy from a mutable pointer. We built the port, proved it boots, and then chose the unbanked machine for the artwork — every pointer is immutable and checked against a commitment. The asymmetry is the finding: on the C64 banking does not threaten the work's identity, because the cartridge is physically in someone's hand and the socket is outside the system. On chain there is no hand. A swappable pointer changes what tokenURI returns, and the work stops being one thing.
papers.py held a transcribed copy of a black paper's thesis line and was printing the stale version within the hour of the source changing. The fix was not vigilance — it was reading the line from paper.md at build time and failing loudly if absent. Any fact that appears in two places will disagree; the only reliable remedy is one source and a generator.
Five things have gone to mainnet, each carrying something the ones before it did not have. That sequence is not a seam either. It is chronology, and inheritance: what was built new, what was carried forward unchanged, and what was built a second time because the first version was not worth reusing.
The series reads as a ladder — a machine, then firmware, then a hole, then a learner — but the firmware step is not on the ladder. Neither artwork loads it. The Chamber's page does not even bind the ROM hooks; the Perception page binds them and never calls them. Both boot bare on minimal64's own minimal KERNAL, which is what makes nearly the whole 64 KB available (F-002). The pressing publishes firmware as its own finished object and doubles what the workbench can run; it is not a dependency of anything shipped. Two things the same look reveals: the Chamber imports READY 64's `Launcher` verbatim and pins its creation bytecode, so that is real reuse rather than a rewrite; and base64 has now been written three times — Codec, then inline in Chamber.sol, then PerceptionCodec — each faster than the last (F-003).
Three of the layers above make the work. Most of the rest exist so that claims about those three can be checked by someone who was not here when they were built.
That ratio is what F-019 is about, and it is invisible from outside. It is most of the reason this page exists.
These findings are generated from a private working notebook, as of 2f64684 on 2026-09-21. 22 of 25 are published; the rest are held back or still being checked. Nothing here is transcribed by hand — if a claim and its source ever disagree, the source wins.