Pinned Tweet
In 2022, nopsta stored minimal64, a compact Commodore 64 emulator, on Ethereum. Four data contracts, about 55 KB, immutable, GPL-licensed. The C64 was a machine of 64 kilobytes and hard limits; he put a working version of it on a public ledger.
We became fascinated by a simple question: what else could this 1980s machine do if someone treated it as open, immutable infrastructure?
For our first experiment we deliberately didn't build a game ourselves. We chose the demo of Tony: Born for Adventure, an MIT-licensed C64 platformer by Maciej Małecki and collaborators, built from his published source.
What we wanted to test was whether nopsta's original on-chain deployment could function as reusable infrastructure for software it was never deployed with.
Gm ☕️
Over 5 years after Strange Attractors debuted I was finally able to complete my set
To be honest I didn't think it was going to happen
Thank you @cxkoda for creating something very very special 💚
Read what @CypherDAO has to say here
teapawt.net/CypherDAO/status/20880…
"Parental Advisory: Explicit Yul Content. You and people around you may be exposed to content that you find objectionable and/or offensive. All stunts were performed by trained professionals, don't try this at home."
That's an actual comment in the Strange Attractors source code. It sits right above the part where @cxkoda solves differential equations in raw EVM assembly.
We spent this week reviewing the full contract system for this project again, all three layers of it. Here's what's actually happening when you look at one of these, because we don't think most people know. Even holders.
TL;DR: Strange Attractors, @cxkoda, October 2021
• Every render means the EVM numerically solving chaotic differential equations. Runge-Kutta 4, real computational physics, hand-written in assembly
• The EVM has no sin, cos, or sqrt. So he built trigonometry from scratch, in the contract. π is stored on-chain as a 96-bit fixed-point integer
• The smooth curves aren't smoothing. The renderer uses the equations' own derivatives as Bézier handles. The physics draws itself
• Holders can move the camera, recolor, and re-render.
• Interactivity at contract level.
• No server, no stored image, no script in your browser.
• Ask the chain, it computes the artwork again. Every time. Forever
• Minted in 2021, a very special historical window that produced Brotchain @divergencearran and @divergenceharri, Cypher @TsukamotoHideki, Loot @dhof, solSeedlings @dievardump, Terraforms @mathcastles, @_deafbeef's generative audiovisual series and others. We believe that window was not an accident!
• Written entirely by hand in 2021, before AI coding assistants existed. Every opcode of this was one person and a problem. That kind of authorship is now datable, like brushwork
When a Strange Attractor renders, the EVM numerically integrates a system of chaotic differential equations. Not "references a stored image." Not "runs a script in your browser." The chain runs a Runge-Kutta 4 integration, the workhorse scheme of computational physics. For the Huang Multi-Wing system that's 6,656 timesteps per render, and each of the five systems carries its own parameters, inscribed permanently in its setup transaction. The solver is hand-written assembly because Solidity alone would be too expensive.
The EVM has no math library. No sine. No cosine. No square root. So he built them. MathHelpers.sol implements trigonometry from scratch as Taylor series, with hand-derived fixed-point coefficients and documented error bounds ("absolute error <1e-3"), plus square root via the Babylonian method with fixed iterations so gas stays predictable. π is stored in the contract as 248902613312231085230521944622.
Why does every edition of the same system look different? Fibonacci sphere lattices. The contract computes quasi-evenly distributed points on a sphere and each edition gets its own camera angle onto the attractor. The viewing direction is math too.
And the curves: the solver outputs not just points but tangents, the actual derivatives of the dynamical system, and the renderer uses them as Bézier control handles. The smooth lines aren't smoothing. They're the equations' own slopes shaping the path.
It's interactive at the contract level too. Holders can set their own projection axes, colors, and render size, directly on-chain. You don't own a picture of a simulation. You own a view into one, and you can move the camera.
One precision worth stating: the contract recomputes all of this every time it's asked. Marketplaces cache the result and rarely ask again, but that's a fact about marketplaces, not the artwork. Call tokenURI yourself, free, and the chain solves the equations again. The cached thumbnail is a convenience. The mathematics is the artwork.
And because we believe in reading the whole contract: there's an owner-only function called rerollTokenRandomSeed, and its comment explains itself with total honesty. It exists as "a last resort" in case a seed produces values that don't converge to the attractor. "Although this never happened while testing, you never know for sure with random numbers." An escape hatch against mathematics itself, documented in deployed source. That's artist integrity at the bytecode level.
Class III in our working taxonomy (v0.1), On-Chain Simulated System, is exactly this: the chain doesn't store the art or point at the art. It computes the art, live, from its own physics, every time you ask.
Maybe a handful of projects in existence operate at this technical depth. This is one of them.
Disclosure: CypherDAO holds Strange Attractors.
A Commodore 64 game, read from Ethereum, running in your browser, inside this post. Tap for sound. Arrows move, space fires.
chamber64.com/play/tony/?v=2
#C64
Previous post on this work:
In 2022, nopsta stored minimal64, a compact Commodore 64 emulator, on Ethereum. Four data contracts, about 55 KB, immutable, GPL-licensed. The C64 was a machine of 64 kilobytes and hard limits; he put a working version of it on a public ledger.
We became fascinated by a simple question: what else could this 1980s machine do if someone treated it as open, immutable infrastructure?
For our first experiment we deliberately didn't build a game ourselves. We chose the demo of Tony: Born for Adventure, an MIT-licensed C64 platformer by Maciej Małecki and collaborators, built from his published source.
What we wanted to test was whether nopsta's original on-chain deployment could function as reusable infrastructure for software it was never deployed with.
Come play Oasis, I won't even make you leave the page.
oasis.diid.art/play
CypherDAO retweeted
Private Ledger invited its collector to express & zk-prove a meaning without revealing it. Part of @SuperRare's Intimate Systems event last year. 🙏 @CypherDAO. Visual & numeric encoding:
CypherDAO retweeted
.@zaphodok @ClarkPeters2020 @CypherDAO @miragenesi are the oligarchs, but we voted to diminish their impact; instead, all can summon gm() with COLLECTIVE effect. & CHAOS won the vote, any market activity perturbs, CORPUS into variations.
Yesterday we showed the Wanderer, whose path through the room is shaped by dice seeded from Ethereum.
The Echo works differently. He doesn’t read the chain. He watches you.
The program records your position, height, pose and direction as you play, then replays those states through the clone four seconds later. The result feels responsive, almost attentive.
But nothing is being learned.
That distinction became important to us while building the series.
A system can react to you, carry a short history of what happened, and still be following a completely authored rule.
We wanted to understand that side of the boundary clearly before crossing into behaviour that changes because of experience.
This is happening inside the 1982 architecture of the #Commodore64 environment @nopsta_ left open on Ethereum in 2022 — the machine underneath the whole series.
Fully self-contained on-chain
No off-chain assets
No servers
Previous post:
teapawt.net/CypherDAO/status/21025…
A few weeks ago we shared some of what we’d been building on top of @nopsta_’s on-chain Commodore 64.
The first experiment was simple: could his original 2022 deployment be reused for software it had never been built to run?
It worked.
So our next question was what it would mean for Ethereum to become part of the program’s environment, rather than only the place the machine was stored and booted from.
Another was about behavior itself: if we eventually wanted something inside this little world to learn, what would the authored side of that boundary actually look like? The Chamber was where we started trying to answer those questions.
This is The Wanderer.
He doesn’t respond to me. His behaviour is written: walk for a while, stop, sit, jump, keep moving.
What changes from one run to another are the dice underneath it. Before the #C64 starts, the contract writes a seed derived from Ethereum into the program, and the Wanderer uses four bytes of it to decide how that fixed behaviour unfolds.
Same program.
Same rules.
Different walk through them.
CypherDAO retweeted
This is amazing: Commodore 64 etched on chain then "could his original 2022 deployment be reused for software it had never been built to run?"
A few weeks ago we shared some of what we’d been building on top of @nopsta_’s on-chain Commodore 64.
The first experiment was simple: could his original 2022 deployment be reused for software it had never been built to run?
It worked.
So our next question was what it would mean for Ethereum to become part of the program’s environment, rather than only the place the machine was stored and booted from.
Another was about behavior itself: if we eventually wanted something inside this little world to learn, what would the authored side of that boundary actually look like? The Chamber was where we started trying to answer those questions.
This is The Wanderer.
He doesn’t respond to me. His behaviour is written: walk for a while, stop, sit, jump, keep moving.
What changes from one run to another are the dice underneath it. Before the #C64 starts, the contract writes a seed derived from Ethereum into the program, and the Wanderer uses four bytes of it to decide how that fixed behaviour unfolds.
Same program.
Same rules.
Different walk through them.
CypherDAO retweeted
This is brilliant! Well played 👏
A few weeks ago we shared some of what we’d been building on top of @nopsta_’s on-chain Commodore 64.
The first experiment was simple: could his original 2022 deployment be reused for software it had never been built to run?
It worked.
So our next question was what it would mean for Ethereum to become part of the program’s environment, rather than only the place the machine was stored and booted from.
Another was about behavior itself: if we eventually wanted something inside this little world to learn, what would the authored side of that boundary actually look like? The Chamber was where we started trying to answer those questions.
This is The Wanderer.
He doesn’t respond to me. His behaviour is written: walk for a while, stop, sit, jump, keep moving.
What changes from one run to another are the dice underneath it. Before the #C64 starts, the contract writes a seed derived from Ethereum into the program, and the Wanderer uses four bytes of it to decide how that fixed behaviour unfolds.
Same program.
Same rules.
Different walk through them.
This is the beginning of a much larger research/art project.
We’ve been working through these questions quietly for a while, and I’m excited to finally start sharing some of it.
If any of this interests you, hit me up.
A few weeks ago we shared some of what we’d been building on top of @nopsta_’s on-chain Commodore 64.
The first experiment was simple: could his original 2022 deployment be reused for software it had never been built to run?
It worked.
So our next question was what it would mean for Ethereum to become part of the program’s environment, rather than only the place the machine was stored and booted from.
Another was about behavior itself: if we eventually wanted something inside this little world to learn, what would the authored side of that boundary actually look like? The Chamber was where we started trying to answer those questions.
This is The Wanderer.
He doesn’t respond to me. His behaviour is written: walk for a while, stop, sit, jump, keep moving.
What changes from one run to another are the dice underneath it. Before the #C64 starts, the contract writes a seed derived from Ethereum into the program, and the Wanderer uses four bytes of it to decide how that fixed behaviour unfolds.
Same program.
Same rules.
Different walk through them.
A few weeks ago we shared some of what we’d been building on top of @nopsta_’s on-chain Commodore 64.
The first experiment was simple: could his original 2022 deployment be reused for software it had never been built to run?
It worked.
So our next question was what it would mean for Ethereum to become part of the program’s environment, rather than only the place the machine was stored and booted from.
Another was about behavior itself: if we eventually wanted something inside this little world to learn, what would the authored side of that boundary actually look like? The Chamber was where we started trying to answer those questions.
This is The Wanderer.
He doesn’t respond to me. His behaviour is written: walk for a while, stop, sit, jump, keep moving.
What changes from one run to another are the dice underneath it. Before the #C64 starts, the contract writes a seed derived from Ethereum into the program, and the Wanderer uses four bytes of it to decide how that fixed behaviour unfolds.
Same program.
Same rules.
Different walk through them.
For context, this is the earlier post where we first shared what we were building on top of nopsta’s 2022 deployment:
teapawt.net/CypherDAO/status/20960…
In 2022, nopsta stored minimal64, a compact Commodore 64 emulator, on Ethereum. Four data contracts, about 55 KB, immutable, GPL-licensed. The C64 was a machine of 64 kilobytes and hard limits; he put a working version of it on a public ledger.
We became fascinated by a simple question: what else could this 1980s machine do if someone treated it as open, immutable infrastructure?
For our first experiment we deliberately didn't build a game ourselves. We chose the demo of Tony: Born for Adventure, an MIT-licensed C64 platformer by Maciej Małecki and collaborators, built from his published source.
What we wanted to test was whether nopsta's original on-chain deployment could function as reusable infrastructure for software it was never deployed with.









