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.
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.
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.
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.
| 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 — Apache 2.0 |