A program runs. It produces a result. Somebody else, somewhere else, later — possibly much later — needs to know that result is what the program actually produces.
Today they have two options. Trust whoever ran it. Or run it again, and hope they can find the same program, the same inputs, and an interpreter that behaves identically.
jetmora makes the second option cheap, exact, and permanent.
That last word is doing more work than it looks. Keeping a result is easy. Keeping the ability to check it is the hard half, and it is the half that quietly gets lost. A record you can no longer execute is only half preserved.
Verification by re-execution, not by proof. This matters, because “verifiable computation” usually means zero-knowledge proofs — verify the answer without re-running the work. That is a fine thing and it is not this.
A zero-knowledge proof tells you the computation was performed correctly. It does not tell you what the computation was. For a clinical analysis, a safety calculation or a compliance check, seeing the work is the requirement.
H(source) · H(input state) → H(output state)Ninety-six bytes. Comparison is a single equality check no matter how much work was done. A verifier never has to send you a result — it publishes a hash, and agreement is one line.
Disagreement is just as cheap, and considerably more interesting: it names the exact computation to go and look at.
Programs are written in a small BASIC and compiled to Bitcoin Script. The hash is taken over the parsed program, not the emitted bytes — so formatting is invisible and meaning is not, and the thing a human reads is the thing that is identified.
Which has a useful consequence. The same program compiled two different ways, executed by two different interpreters, should produce the same output hash. If it does not, something is wrong — and that is a far stronger test than running one artefact twice, because identical bytes share their bugs.
| the log | An append-only Merkle tree of entries, published by one operator. It records what it is given. It does not adjudicate. |
| the entry | A state transition: previous state in, new state out, signed. An entry contains everything needed to replay it. |
| the covenant | The program. Written in BASIC, compiled to Script, and readable back out again by a decompiler. |
| the anchor | The tree head, committed periodically into a proof-of-work chain. One small transaction. This is what makes one history objective. |
There is no coin, no consensus, and no global ordering. Logs are independent: anyone may run one, and the same computation may be recorded in several. Duplication is not a conflict — it is corroboration.
| latency | A state transition is an append, not an agreement. There is no round trip to wait for, so a physics simulation can tick at frame rate. |
| parallelism | No global sequence to serialise into. Adding a log adds capacity with zero coordination. |
| cost | No protocol fee, because there is no shared block space to ration. Operators charge for the service; the protocol has no opinion about money. |
A million transactions per second is throughput. Physics needs latency, and no amount of throughput buys back a round trip you did not take.
This is the honest trade, and it is stated first rather than buried.
A log can misbehave. It can drop an entry, or show different trees to different people, or sign two conflicting histories. What it cannot do is hide any of it: a Merkle log that equivocates has published the evidence of its own lying, permanently, and anyone can show it.
An entry whose state transition the program would refuse is recorded — but it does not advance anything. It sits in the log as a signed claim that someone asserted otherwise. Evidence, not history.
On a shared chain, a script that exhausts memory is everyone's problem: every node must validate it, so one bad program is an attack on all of them. That is why several instructions were removed from Bitcoin in 2010, and they have been contentious ever since.
Here, logs are independent and verification is voluntary. A log does not execute the programs it carries — it records signed entries — so an expensive or malicious computation reaches only whoever chooses to run it, and its cost can be calculated before anyone does.
A bad actor only gets to shoot themselves in the foot while everyone else carries on.
Which is also why the limits are the operator's and not the protocol's. A ceiling written into a protocol becomes a number nobody can promise to hold — and that is the whole problem this design exists to escape.
Programs that hold value and enforce their own rules — covenants — are a good way to build things. They do not ask permission, they do not care who you are, and you cannot talk them out of their rules.
They have one structural weakness, and it is not in the program.
A covenant on a public chain must pay a fee to move, and it commits to a maximum fee when it is created — a number written permanently into the script, because the script is the coin and the coin cannot be edited. Raise the network's minimum above that number and the covenant can no longer pay to move. Not slower. Not dearer. Stuck, with whatever it holds inside it.
Fitting that number honestly to the published rate is the correct thing to do. It is also what leaves no room at all: measured against live covenants, one of ours dies if the floor rises by one percent.
The flaw is not the number. It is that one side of the arrangement is bound forever and the other is not bound at all — and the unbound side sets the value.
jetmora's answer is not to argue about the fee. It is that a covenant here never references one. Operators charge for their service, in whatever currency they like, and that price can move freely forever without being able to kill anything — because nothing immutable depends on it.
And because state is portable between logs, an operator who overcharges watches covenants leave. Exit is what disciplines the price, and no single chain can offer that at any fee level.
BSV is the payment rail. Jetmora is the computational rails.
A proof-of-work chain is good at the discrete and the valuable: ownership, stakes, settlement, timestamps. It is bad at variable outcomes, because every branch costs a transaction and must be anticipated in advance.
So: commit on the payment rail, compute on the computational rails, settle back on the payment rail. One fee, many steps. And a settlement contract can verify a jetmora result in script, by walking a Merkle path to an anchored root — no relayer, no oracle, no bridge multisig.
With one limit stated plainly: a chain can verify that a log said something. It cannot verify that the something is correct. That is what re-execution is for.
Underneath the applications there are only two primitives: a witnessed claim, and a witnessed computation on it. Everything below is those two, pointed somewhere different.
| science | Reproducibility is not “here is my repository.” It is here is the execution — same program, same inputs, same intermediate states, or a provable divergence. |
| medicine | A trial's analysis plan, committed and timestamped before the data arrives. Then the data arrives and it runs. Provably not adjusted afterwards. |
| standards | A safety standard is a computation. Published as a program, a manufacturer proves compliance by running it, and a regulator verifies without trusting anyone's spreadsheet. |
| engineering | A load rating becomes a program, with the formula version pinned to a date. |
| oracles | It cannot make an oracle honest. It makes one accountable: statements are signed, append-only, and cannot be quietly revised. A track record becomes something you can compute. |
| agents | Do not give an autonomous agent a wallet. Give it a battery: a program that bounds what it can do, with no key to steal, and every action recorded, signed and auditable by construction. |
The first thing built on it is a slot-car game, which sounds like the least serious item on that list and is in fact the reason any of the others can be trusted.
Physics is a hard test: non-linear, iterative, sensitive to rounding. The correctness criterion is unambiguous — the car leaves the track or it does not. And crucially, a human can feel when the model is lying, instantly, before any test catches it.
You cannot debug a physics model you cannot feel, and you cannot feel a dosing calculation. Every other domain has to trust its tests. This one has someone who knows.
Three of the eight references in Bitcoin's white paper are Haber and Stornetta's digital timestamping papers. Merkle-linked records, witnessed, tamper-evident — and no coin anywhere. Their commercial implementation published a weekly hash in a newspaper's classified advertisements, which is this design's anchor done in newsprint.
The coin was never the point of the record. It was the payment for the consensus. Remove the need for open permissionless agreement and the coin has no job left to do.
Coinless systems did not stop working — they stopped being called blockchains. Certificate Transparency secures the certificate ecosystem of the entire web and is barely mentioned in this industry. Git is a Merkle tree everyone uses without discussing.
The record-keeping here is a thirty-five-year-old tradition. Running programs inside the log is the part with no precedent.
Bitcoin's scripting language had more instructions in 2009 than it does now. Concatenate, multiply, substring, shift — all live until the middle of 2010, when a dozen of them were switched off after crashes, and never switched back on.
So there are programs in the early blockchain written in a language nothing can read any more.
| one chain | disabled those instructions and cannot execute such a script at all |
| another | re-enabled them, but reassigned three of the numbers to newer instructions. A 2009 program still runs — and quietly computes something different |
| jetmora | keeps the original assignments and puts its own instructions in space that was never used. The 2009 program runs as written |
That is not fidelity for its own sake. It is the half-preserved record, arriving in concrete form: the programs are still there, still readable, and no longer runnable. If a program is the thing being witnessed, then being able to run it in fifty years is the whole point.
We have not gone looking yet. The claim follows from the numbering rather than from evidence, and it is checkable by anyone: find an early output using one of those instructions, and run it three ways. If nothing was ever mined that used them, that is worth knowing too.
Early, and deliberately public while it is still moving.
The specification is a file of test vectors rather than a document: prose about what an instruction does cannot be executed, and two honest implementations will still diverge on overflow and edge cases, silently. A vector fails instead. An implementation that reproduces the vectors is conformant.
The first run of that suite found three divergences between historical and current Bitcoin Script, one of which was an error in the vectors themselves — written from familiarity rather than from the source. It was caught immediately, which is the entire argument for building it this way.
A real covenant — the physics of a slot car, 212 lines of program, 3,669 bytes, 2,179 instructions — was compiled once and executed on three implementations that share no code:
| one | an independent Bitcoin Script interpreter, written by other people, years ago |
| two | ours — the same program with 44 instructions renumbered, its own serializer, written the same day |
| three | a plain JavaScript reference, which is not a Script interpreter at all |
All fifteen cases agree. The JavaScript reference agrees on all ten that produced a result. The other five are lifted-throttle cases where the covenant refuses to advance — and both interpreters refuse identically.
That last part is worth more than it looks. Agreement on a failure is still agreement — and it is what tells you the disagreement is in your test rather than in the implementations. It happened twice while building this, and both times it pointed at the right thing.
A test with only one implementation can never do that. It has nothing to disagree with.
Three paths, no shared code: different instruction numbers, different serializers, different interpreters, written years apart by different hands. That is what makes the agreement evidence rather than a tautology — and it is the whole claim, executed against real work instead of a demonstration.
| paper | Light Speed Transfers — anchor transfers: value locked on chain, ownership moved by signing forward, exit always available. v0.1 is design; the three problems it has not solved are named in it |
| specification | spec/log.md — normative, with its open items listed |
| vectors | vectors/core.json — public domain (CC0), because the specification should not make implementations derivative of it |
| source | github.com/sun-dive/jetmora — Business Source License 1.1 for the code, converting to Apache 2.0 in 2030; the specification stays Apache 2.0 |