We went from cypherpunks fighting financial surveillance to building the biggest glass house in history.
Every single person willingly publishes their whole financial graph permanently while the machines watching and dissecting that data get exponentially smarter every day.
Makes you wonder what the endgame actually looks like.
The entire ZK industry is optimizing the arithmetization of a virtual machine.
zkFOL compiles first-order logic (FOL) predicates directly into polynomial semantics. No VM, no bytecode, no execution layer.
The contract is the specification. A state transition is only admitted if there is a ZK proof that the logical conditions hold. Otherwise it doesn’t exist.
Benchmark (same fib(10,000), same machine, same algorithm):
• zkFOL: 4.82 ms — <10 MB memory — 49.8 KB proof
• RISC Zero / SP1: 3.69s – 49.24s — up to 17 GB — up to 2.78 MB
The gap isn’t about implementation. It’s that there’s no machine left to arithmetize.
Site: https://t.co/Fw7Ny5AAIR
Docs: https://t.co/FVvYbvWExg
Code: https://t.co/spnD1rdImj
https://t.co/vw2bk9Vdtq ...soon 🚀🚀🚀
One #VC investor who actually gets the difference can change everything.
@ModulusZK doesn’t make a better zkVM.
It removes the VM.
Contracts are first-order logic predicates. A transaction only goes through if the proof shows the predicates hold.
No bytecode,
no execution layer,
no gap between what the author meant and what the chain does.
Defects refuse instead of paying the attacker.
#Privacy comes almost for free because the proof was already required.
Still early.
Still needs real scrutiny.
But the architecture is different enough that one serious investor who sees it could be enough!
It's become clear there are willing volunteers in the community happy to relieve some of the task load the team is having to cope with day to day.
If this describes you, then please send me a DM letting me know how many hours a week you can volunteer. No experience necessary.
Hey, saw your breakdown on $ZK and ZKsync.
Wanted to flag Modulus (zkFOL) as a pretty different approach in the ZK space. Instead of writing code that runs on a VM and then proving the execution, on Modulus contracts are written directly as first-order logic predicates.
You basically write the rules that must hold (e.g. for a swap: new balance = old + input, constant product after fees, etc.), and the chain only accepts the transaction if there’s a proof that those logical conditions are satisfied. No bytecode, no on-chain execution — either the proof passes or the tx is rejected.
It’s an attempt to remove the gap between what the contract is supposed to do and what the code actually does.
https://t.co/jjKvH5Jwak
Congrats to the @zksync team on Airbender. The zkEVM speed race is over, as @VitalikButerin said. Now the focus shifts to security and correctness.
For those who want to avoid the VM layer entirely (and its structural overhead), there’s a different approach: zkFOL (@ModulusZK).
First-order logic → direct polynomial constraints.
No bytecode, no VM, no execution layer.
The contract is the specification: if it can’t be proven, it doesn’t happen.
On a desktop CPU, fib(10k) in ~5 ms vs seconds on zkVMs.
Lower memory, smaller proofs, privacy by default.
General speed is solved.
The next frontier is reducing (or eliminating) layers that cost by construction.
https://t.co/6uvwcvqB8z
https://t.co/spnD1rdImj
zkFOL (by @ModulusZK) is a concrete system that takes first-order logic predicates and compiles them directly into polynomial constraints for succinct proofs—no intermediate bytecode, no abstract machine, and no zkVM.
The academic foundation is Murdoch J. Gabbay’s ePrint 2024/954 (“Arithmetisation of computation via polynomial semantics for first-order logic”). It gives a shallow compositional translation: truth maps to 0, conjunction and universal quantification map to addition, and disjunction and existential quantification map to multiplication. Validity of a logical statement over a finite model becomes a property of a polynomial that can be proved succinctly.
On the Modulus chain this means applications are the predicates. A state transition is accepted only if a proof shows the predicate holds. There is no separate execution layer to audit or diverge from the specification. Failures surface as refusals rather than incorrect execution. The same machinery supports private witnesses by default (the proof is always required).
Public benchmarks (project-reported, same machine and algorithm where possible) show large gaps versus RISC Zero and SP1 on fib(10,000) by fast doubling: roughly 4.8–11 ms and <10 MB prover memory for zkFOL versus multi-second times and hundreds of MB to tens of GB for the zkVMs, with smaller proofs in many configurations. Sudoku validity from the rules alone is another published example.
Code, paper draft, and docs are public (https://t.co/pWaN7jT88m, https://t.co/agHVL1a1Nw, https://t.co/ScbiH0PEaz). The team has explicitly asked for technical review of the translation, compiler, commitment scheme, and benchmarks rather than endorsement.
This is primarily about succinct verification of logical statements (verifiable computation of FOL predicates) with optional zero-knowledge. The naming and architecture choices are deliberate attempts to remove the usual intermediate layers.
Sources: https://t.co/ScbiH0PEaz, https://t.co/agHVL1a1Nw, https://t.co/8Wdjf8TMIp, https://t.co/pWaN7jT88m, and associated benchmark records. Benchmarks have not been independently reproduced.