For new software
Roop
For people writing new programs. You write each step once, and the reverse comes with it.
Explore RoopReversible computing at data centre scale
Ordinary chips turn erased information into heat. Never Singular keeps it: Roop, an open source language where every program can run backward, and a compiler for the AI models you already run.
bank.roopForward
Alice0
Bob0
Alice starts with nothing
fn transfer(src: &mut i64, dst: &mut i64, amount: &i64) { src -= amount; dst += amount; expect src >= 0;} fn main() { auto ancilla alice: i64 = 0; auto ancilla bob: i64 = 0; auto ancilla failed: bool = false; alice += 100; try { call transfer(alice, bob, 150); call println("sent"); } catch_rollback { call println("not enough money: rolled back"); } -> failed; call print_int(alice); call print(" "); call println_int(bob);}Output, waiting to be shown
Information erased0 bits
No information has been thrown away so far, so none has to be paid for as heat.
1 / 16
Why reversible
Every erased bit becomes heat
Ordinary chips throw information away all the time: two inputs go in, one comes out, and the lost bit leaves as heat. A data centre pays for that heat twice, once in electricity and again in cooling.
A reversible computer keeps every bit, so it does not have to make that heat in the first place. That is the saving Never Singular is built for: the same work, with less of its energy lost as heat.
At the back, two lanes squeeze into one and the spare marble drops into the bin: that is erasing. At the front, every marble gets through. Hover to slow the flow down.
Landauer's limit
The floor ordinary chips cannot pass
In 1961 the physicist Rolf Landauer showed that erasing one bit must release at least a fixed amount of heat, written kT ln 2. At room temperature that is about 3 zeptojoules, a few thousandths of a billionth of a billionth of a joule.
Chips still use thousands of times more energy than that for each operation, but every generation gets closer. Ordinary computing levels off at the limit. Reversible computing does not erase, so the limit does not bind it, and the energy per operation can keep falling.
Energy per bit operation
Move across the chart
- Until now
- Ordinary computing
- Reversible computing
Illustrative, after a 2014 ForskerTV talk, University of Copenhagen
Platform
Two ways in
Write new software in Roop, or bring the models you already run to the compiler.
For the models you run
Never Singular compiler
For teams running AI models today who want a route towards reversible chips without rewriting them.
Explore the compilerRoop
Every program comes with its own undo
You write a program once, and Roop builds its exact reverse. When something goes wrong, the work is run backward and truly undone, rather than patched over.
Slide the beads along a rail. Let go, and every bead runs back to exactly where it was. Roop does the same for a program.
Roop is open source under the MIT licence.
Roop on GitHubCompiler
Start from the models you already run
The Never Singular compiler builds a reversible core from a model you already use: a part that runs forward and then exactly backward, back to where it began.
A model is a stack of layers. Hover to pull it apart, and press to flip a layer over and back. The compiler is built to give every layer an exact way back.
Proof
Checked, not claimed
We test each step on real machines and prove it where we can. Three results show the idea working.
On a graphics card
0
Bytes lost
A block compiled from the model runs forward, then backward, on a standard NVIDIA graphics card, and every byte comes back exactly as it started.
In memory
4.8x
Less peak memory
A deep Roop network rebuilds each step by running backward instead of storing it. The results stay identical.
In the language
100%
Of reversible functions proved
Every reversible Roop function has a reverse, and machine-checked proofs show it undoes the function exactly.
Bring a model
If your team runs AI models at scale, bring one you use today. We will compile it with you and show you what we find.