Crypto spends a lot of time asking how to make zkEVMs faster.
zkFOL asks a more disruptive question: how much of the virtual machine do we need in the first place?
A zkEVM proves that @Ethereum-compatible code executed correctly. @ModulusZK’s zkFOL approach expresses applications as logical conditions and proves that a proposed state transition satisfies them, compiling those conditions into polynomial constraints. That changes the starting point for building an application. (https://t.co/8FlZgMeXLv, https://t.co/agHVL1a1Nw)
So why isn’t zkFOL getting more attention?
My view: crypto understands a faster version of an existing product more easily than a different architecture.
“Better zkEVM” fits an established story: #Solidity developers, Ethereum compatibility, existing applications, familiar investment categories.
“Build applications around provable logical conditions” requires people to rethink the development model and explain why developers would switch.
Existing investment, tooling and commercial commitments may also make that conversation uncomfortable. But limited attention does not prove deliberate suppression. Some skepticism is reasonable: a compelling idea still needs reproducible results, independent security review and applications people actually use.
@ModulusZK publishes striking benchmark results against SP1 and RISC Zero. Those are specific zkVM comparisons on selected workloads, not evidence that #zkFOL has already outperformed production zkEVMs across real @Ethereum applications. The results deserve investigation; the broader conclusion still needs testing. (https://t.co/ScbiH0PEaz)
What could this mean for zkEVM companies?
If zkFOL delivers meaningful advantages in production, companies whose main advantage is proving efficiency could face pressure on pricing and margins.
Teams with strong developer relationships, liquidity, distribution and settlement infrastructure may be better positioned to adapt. They could integrate new proving approaches, support a second application model or build services around it.
Ethereum compatibility would still have value. A new architecture does not automatically migrate existing contracts, assets and users.
For investors, the distinction is crucial: technical success and investment returns are separate questions.
A cheaper proving system could create enormous user value while reducing revenue for some infrastructure providers. An incumbent could adopt the technology successfully. A technically impressive newcomer could struggle to attract developers.
The questions become: who captures the savings, who owns the customer relationship, and does adoption create revenue or token demand at all?
How would a transition likely happen, if zkFOL succeeds?
My expectation is gradual adoption:
-Independent teams reproduce results and test the security assumptions.
-Narrow applications adopt it where expressing explicit rules offers a measurable benefit.
-Integrations connect those applications to existing wallets, assets and settlement systems.
-Developers choose it for new products; established applications migrate only when the benefits justify rewriting and reviewing them.
-Both models coexist, with adoption expanding where the evidence is strongest.
This also changes what security review focuses on. A proof can establish that a transaction satisfies the rules you wrote. It cannot establish that you wrote every rule your business needed. Specification mistakes, oracle assumptions and integration failures still matter.
🚨zkFOL deserves serious scrutiny now. Demonstrating a useful new approach is a meaningful achievement before a complete chain ships; establishing production security remains a separate milestone.
The industry should be willing to test an architecture that challenges its assumptions.
And zkFOL’s strongest case will be made by independent results, useful applications and developers choosing it because it works.
Roman on the private threshold multisig point: @ModulusZK ’s zkFOL stack (public as of early October, https://t.co/pWaN7jT88m) arithmetizes first-order logic into a hash-based SNARK via Zinc/Zip. Their paper notes Zinc is hash-based and plausibly post-quantum, so it sits on the side of STARKs/FRI rather than KZG.
Their BitLogic write-ups describe the exact pattern you want: a 3-of-5 (or general threshold) proved as “required signatures exist” without revealing which keys signed or what the public keys are. Private state is the default; the chain only checks the proof.
Caveat: this is their own L1 (predicate = contract, native verification), not an audited Ethereum L1 verifier or a mainstream wallet yet. Proofs are small and fast in their benchmarks, but there’s no drop-in Plonky3-style Ethereum implementation. Might still be relevant as a construction for the hash-based private threshold case.
Request for review: zkFOL, a direct arithmetisation of first-order logic, now public.
@ModulusZK compiles application rules written as first-order logic predicates straight to polynomial constraints. There is no bytecode and no zkVM. A state transition is accepted only with a proof that the predicate holds. The contract is the specification; a rule that cannot be proved does not execute.
The implementation is the construction in Murdoch J. Gabbay’s ePrint 2024/954, “Arithmetisation of computation via polynomial semantics for first-order logic”: truth maps to 0, conjunction and universal quantification to addition, disjunction and existential quantification to multiplication, with no encoding into an abstract machine.
Public material:
• Repo: https://t.co/VQWEq5XGFy
• Draft: https://t.co/nnEHwZ8wAp…
• Docs: https://t.co/agHVL1a1Nw
The published desktop-CPU comparison, fib(10,000) by fast doubling against RISC Zero 3.0.5 and SP1 6.3.1, is 4.82 ms and under 10 MB versus 3.69–49.24 s and 312 MB–17 GB. Those figures are ours. They have not been independently reproduced.
What we want is a technical review, not an endorsement. In particular: soundness of the shallow translation outside the finite models in the paper, the compiler from predicate to constraint system, the commitment scheme and any setup assumption, and a rerun of the fib benchmark.
If you review proof systems or polynomial commitments, a written objection is as useful as a confirmation. Repo, draft, and ePrint are linked above.
@0xJaehaerys@cryptodavidw@benediktbuenz@ronrothblum@pumatheuma@SuccinctLabs@BruestleJeremy@RiscZero@drakefjustin@0xAlbertG@ant_sabado@AnnaRRose@zeroknowledgefm@IOHK_Charles@VitalikButerin@EliBenSasson
Shout out to @0xAlbertG@ant_sabado and the @Nethermind team for their work on Zinc & Zinc+.
To my knowledge @ModulusZK's tech stack, zkFOL, is the first to verify Zinc+ proofs on chain.
zkFOL
~20 lines stating sudoku rules. Solves 17-clue puzzle, proves & verifies it, from that statement alone
The same fib spec runs forwards & backwards off one witness
fib(10,000) ~10ms vs 3.69s-49.24s. 370x-4,930x
Prover memory <10MB vs 17GB. 1,700x
Do you feel in charge?
zkFOL
~20 lines stating sudoku rules. Solves 17-clue puzzle, proves & verifies it, from that statement alone
The same fib spec runs forwards & backwards off one witness
fib(10,000) ~10ms vs 3.69s-49.24s. 370x-4,930x
Prover memory <10MB vs 17GB. 1,700x
Do you feel in charge?