Stepper

An 8-bit processor that lives in a contract.

[Stepper @steppercpu]

Stepper $STEP is now live on robinhood chain!

CA: 0xffc3776650cd2c9641ce72838f85c0a535cc440b

Steper is a real 8-bit processor that lives inside a smart contract on Robinhood Chain.

There is a token, and it pays for the clock. The machine under it runs before anyone owns any of it. That is the whole difference, and it is a difference of order and substance rather than category: 2,161 NAND gates, 167 flip-flops, 16 registers of eight bits, 256 bytes of RAM, and a 32-instruction set where all thirty-two are used, because the opcode field is five bits wide and thirty-two is what five bits addresses.

$STEP by $STEP

https://t.co/Mi7vrrr0uW

[Stepper @steppercpu]

Rotate first, then fold. That single ordering is the whole design. Addition doesn't care who arrived first two different sequences of sponsors produce the same total, so a machine built that way records who paid and never when. Rotating the accumulator before folding the new byte in fixes it permanently. What comes out is a signature of the exact order, and nobody can produce it without having lived through the same history.

[Stepper @steppercpu]

A processor is not a function call. Your byte is read on one edge, rotated on the next, folded on the one after, shown on the one after that, and only then written into memory. Four cycles between a byte going in and a trace of it existing. This is what every synchronous machine has looked like on paper since long before any of this, and it's the only drawing that shows the thing that matters not what a value is, but when it changed and what changed it.

[Stepper @steppercpu]

The whole machine fits in four lines of output. 2,161 NAND gates, 167 flip-flops, 256 bytes of memory, 1,024 words of program and they're gates, not a description of gates. The program running on it is nine words long with no halt instruction and no conditional branch anywhere in it, which means no byte anybody sends can steer this thing toward stopping. That's not trivia. It's why the reserve behind it can never be frozen by a stuck chip.

[Stepper @steppercpu]

This is the one I'd want checked hardest. preview() runs the same gates on the same three inputs the chip is about to receive, and it said the next edge would drive 42 before anybody had paid for it. One transaction later, a stranger's gas moved the machine, and the output port read 42. Not a forecast that happened to land. A consequence, computed early. That property is the entire reason to build out of gates rather than describe them.

[Stepper @steppercpu]

Three calls, and you can make all three. The first says how many clock edges the reserve can still pay for. The second says what it pays, a figure fixed at construction. The third is what it cannot do and that isn't a function we disabled, it's a function that was never written. Four hundred and ninety-nine edges sitting there, and no key anywhere that reaches them.

[Stepper @steppercpu]

Both sources went silent for over ten hours and both ports refused to convert. The clock line goes flat and stays there. Nobody staged this the feeds went quiet on their own and the machine did exactly what it was built to do, which was nothing, visibly. The easy version hands the processor the last number it had and keeps running. Between a machine that has obviously stopped and a machine that is confidently wrong, only one of them can be noticed.

[Stepper @steppercpu]

Every 256 edges, it forgets everything and starts again.

256 bytes of memory, one trace per clock edge, advancing and wrapping. Nobody chose that interval it is 256 because the address register is eight bits, and it is eight bits because that is the machine. The forgetting is a consequence of the size of the thing, not a decision anybody made.

But the output port never forgets. It holds a digest of every byte anybody ever sent, rotated before folding so the order is part of the answer.

The memory lets go. The signature keeps all of it.

[Stepper @steppercpu]

Four hundred thousand gas, one call, no approval and no allowlist. Read edgesRemaining() first so you know whether the reserve can pay. Call fuel(n) with any byte from nought to two five five and it goes straight to the processor's input port. Two hundred $STEP arrives in the same transaction, paid to the address that did the work. Then check snapshot() the cycle went up by one, and your byte is folded into the machine's digest in the order you arrived, permanently.

[Stepper @steppercpu]

Eleven months to build the machine. What's in front of us is every machine it can become.

There are 2,161 NAND gates on this chain and they are gates, not a description of gates. 167 flip-flops, 256 bytes of memory, 1,024 words of program. Every cycle is that table evaluated in order, which is why the contract, the simulator and the SDK all give the same answer and always will.

That part is finished. It is the foundation, and foundations are supposed to stop being interesting.

What's interesting is what it turned out to be a foundation for.

The chip has a port now, one byte in, one byte out, the same contact with the world every processor has ever had. Two are wired: one converts ETH across a band, one converts NVIDIA. This chain publishes sixteen sources today that a port could read, and the number isn't capped at sixteen, because any contract that answers two functions can be one. Every source is a different instrument built from the same silicon. We have wired two.

And the chip is one of many. Anyone can launch one through the factory a program, a machine and a token in a single transaction and ours holds no privilege over theirs, because there is no privilege in the contract to hold. Every program somebody writes is a machine that did not exist that morning.

The reserve is funded and audited with real money in it: 99,800 STEP, 499 clock edges, one non-view function, no owner, no way out for anyone including us. It pays whoever advances the processor. That is a market for a machine's time, and it has just opened.

Then there's the part that still makes me sit back. preview() runs the same gates on the same inputs and tells you what the next edge will do before anybody pays for it. This week it said an edge would drive 42. An hour later a stranger's transaction drove 42. Not a prediction that came true a consequence, computed early. That property is what a court is built on, and the court is written and measured: one contested clock edge, recomputed on chain, 392,471 gas. Every off-chain run becomes a claim somebody can settle.

ST-16 builds from the same netlist at sixteen bits: 65,536 steps across the same window instead of 256. Same design, finer instrument. Replay in the browser is next, where you re-derive every edge since genesis and watch the chain agree.

None of this required permission. None of it has an owner. All of it compounds a new port is a new sense, a new chip is a new machine, a wider datapath is a finer reading of both.

We spent this year proving a processor can live here. The next one is about what it reads, what it decides, and who it does that for.

[Stepper @steppercpu]

One per cent of supply is committed to the reserve. It is being released five hundred edges at a time, and here is why.

The rebate contract has been live and working since the day it was deployed five edges have already gone through it. What it did not have was a balance. Ten million $STEP, one per cent of total supply, is now committed to it, and it will arrive in tranches of one hundred thousand. At the rate of two hundred per clock edge fixed at construction, each tranche is five hundred cycles of a real processor, and there are a hundred tranches to come.

We could have sent all of it at once. We are not going to, and the reason is the only kind of reason worth giving: a permissionless contract cannot tell a person from a script, and any check that tried would need an owner to maintain it which would be a far worse hole than the one it closed. So nothing here stops a bot. The design never pretended otherwise. What a tranche does is put a known, small ceiling on what any single actor can take before we have seen it happen.

The arithmetic is public. Five hundred edges at about four hundred and fifteen thousand gas each is somewhere between thirty-seven and three hundred and sixty-two dollars of gas, depending where the chain's base fee is sitting that hour. That is what it costs somebody to empty a tranche. Against it they receive one hundred thousand STEP. Whether that trade is worth making is a question the market answers, not us but the point is that the answer is bounded, visible, and repeats a hundred times with us watching each one.

That is also what makes this a test rather than a gesture. Every tranche is the mechanism running in the open, under real conditions, with real gas prices and real callers, before more is committed to it. If something about the economics behaves differently than the arithmetic predicted, we find out at one hundred thousand tokens rather than at ten million. Shipping the whole per cent in one transaction would have been louder and would have taught us nothing.

Here is the part that does not change between tranches. Read the deployed bytecode of 0x94b00a18…: one thousand nine hundred and four bytes, exactly one non-view function, zero payable functions, and no withdraw, no sweep, no transferOwnership, no setRate. Not disabled, not timelocked, not behind a multisig absent. Every token that goes in leaves our control permanently. There is no key that reaches it, no emergency function, no upgrade path, no vote.

In every sense that should matter to you, funding this reserve is a burn. It is simply a burn that does something, because the only way a token ever leaves is as payment to whoever made a processor take a cycle. An ordinary burn removes supply and buys nothing. This removes it from us and buys the machine time.

You will never have to take our word for any of it. A tranche is a transfer to a public address, and edgesRemaining() tells you exactly how many edges the contract can still pay for. That figure is not something we report to you, it is a subtraction you can watch. Five hundred after each tranche lands, counting down as people take them.

And to be exact about what this pays, because precision is the whole argument here: it pays for work, not for holding. It pays the address that advanced the processor. There is no function anywhere in our contracts that pays a holder, and that absence is deliberate, it is the same absence that means nobody can drain this reserve, including us.

Five hundred edges at a time. A hundred times. Nobody can take one back.

[Stepper @steppercpu]

No API. No backend. No key.

The netlist ships as a file and every runner walks it the same way: the browser at 10 Hz, node in a terminal, the EVM under a contract.

Pull the network cable out and run it anyway.

[Stepper @steppercpu]

Every bit has a name.

167 flip-flops · 16 registers · a program counter · an output port · three flags · a RAM port

And one left over. Bit 166 exists because a load does not finish in one clock edge, it is the machine remembering it is halfway through reading memory.

[Stepper @steppercpu]

Introducing the port.

Until this week, STEPPER only knew what you typed at it. One byte, by hand, per clock edge. That was the entire conversation between a 2,161-gate processor and the world. A CPU is not supposed to work that way. Every processor that has ever controlled anything controlled it through a port: a disk, a servo, a converter. Something outside turns the world into a number. The silicon decides what to do with it.

So we built the outside.

A port converts a published quantity into one byte. A bus clocks the chip through it. One edge is: convert, present, run the gates, latch, drive. The chip itself did not change, not one gate. It still has no idea a bus exists.And here is what made it worth building on this chain in particular.

On most chains a share price is something you fetch and trust. Here it is a contract address. NVIDIA sits at "0x5798d6c6…" eight decimals, and it had published nine seconds before this board was read.

A processor cannot call an API. It has one port and it reads one byte. But an address can be read by anything that can make a call, including the device on the far side of that port.

Which means this chain puts NVIDIA's price somewhere 2,161 NAND gates can actually reach it.

Eight companies. Nine seconds old. All of them addressable.

https://t.co/a5nhZlDgrP

[Stepper @steppercpu]

Shown, not promised.

A chip of our own, done. A reserve that pays for edges, done. Replay in the browser, next. A court, written. ST-16, builds.

No dates. A date is the one thing on that list we cannot check before saying it, and everything else on it is something you can.

[Stepper @steppercpu]

There is nothing here to drain.

A permissionless contract cannot tell a person from a script. Any check that tried would need an owner to maintain it, and an owner is a worse hole than the one it closes.

So nothing in this contract stops a bot. It simply costs one more than it pays.

The arithmetic, this morning. One clock edge costs 401,254 gas, which at the current base fee is about $0.081. The reserve pays back 200 $STEP, about $0.030. So a loop covers 37% of its own cost and loses roughly $0.05 on every single call. Running it a thousand times costs fifty dollars and produces nothing a person wanted.

The rate is fixed at construction and can never be raised, so the only thing that could make farming worthwhile is the token appreciating 2.7×. And if that happens, the reserve simply stops being topped up. No function needs to change and nobody needs to decide anything.

The rest is structural rather than economic.

fuel() takes no address. It advances one chip, named when the contract was built, so there is no way to point it at a chip somebody deployed themselves. That was the attack worth closing: launch your own processor for the price of a launch fee, then drain the reserve into it. It is not priced around, it is absent.

A token that calls back during transfer is paid once, not twice. A transient lock holds the door for the length of one transaction and costs nothing after it.

The counters follow the money rather than the intention. A token that takes a fee on transfer cannot make paid drift away from the balance, because what is recorded is what actually left.

And there are zero functions that can withdraw. No owner, no pause, no setter, nothing payable. Once a token is in there the only way out is to somebody who made a processor take a clock edge.

35 checks against mocks written to attack it, and four more against a chip the real factory built.

[Stepper @steppercpu]

A partnership is a post and two logos. This is a call in our contract.

Our factory calls their venue. Every chip anybody launches is their launch, in one transaction. Nobody has to be trusted to keep it, because it is in the code path.

[Stepper @steppercpu]

The gates answer.

392,389 gas to recompute one clock edge on chain

Two people disagree about what a processor did. There is no arbiter, no committee and nobody to appeal to. The contested edge is recomputed from the gates and whoever was right is right.

[Stepper @steppercpu]

No server. Not somebody else's either.

A host · a database · a pinning service · somebody paying for all three

None of them. The processor is a contract, so is its memory, so is its picture. If every machine we run went dark tonight it would still answer tomorrow.

[Stepper @steppercpu]

256 cells of RAM, one trace per edge, advancing and wrapping. So every 256 edges the machine has overwritten everything it remembered, exactly once.

That is our halving. It is not a number anybody chose: it is the size of the machine. Nobody can move it, nobody can bring it forward, and anyone can count how many edges are left before the next sweep.

The difference from a halving is the better half. A halving arrives on its own. A sweep only happens because people kept deciding the next edge was worth buying.

[Stepper @steppercpu]

The rebate is live.

There is a processor on chain that remembers everybody who ever paid for it. From today it pays you to advance it.

Hand it a byte and it folds yours into the number it is holding, in the order you arrived, so the result is a signature of the exact sequence of people who paid for it.

200 $STEP for every clock edge you buy.

How:

1. Open https://t.co/TkeWB4AYmk
2.Connect a wallet on chain 4663
3. Pick your byte, 0 to 255
4. Press the button
You pay the gas and nothing else. No fee to us, nobody takes a cut, and the chip itself charges nothing.

256 cells of memory, one trace per edge. Nobody is in the number yet.

https://t.co/TkeWB4AYmk