Vitalik Endorses LeanPCS for EIP-8288 to Scale Ethereum
Vitalik Buterin endorses leanPCS for EIP 8288, explaining how aggregated proofs could make Ethereum quantum safe while reducing on chain data requirements.
Ethereum co founder Vitalik Buterin has expressed strong support for leanPCS as part of EIP-8288, a proposal designed to make large cryptographic operations more efficient on Ethereum. His latest explanation outlines how the approach could support quantum safe signatures, STARK proofs and other computationally intensive operations without storing bulky cryptographic data directly on chain.
Buterin sees leanPCS as a practical route to broader cryptographic capabilities, potentially allowing Ethereum to implement these improvements sooner than previously expected.
How EIP 8288 Reduces On Chain Cryptographic Data
EIP-8288 focuses on handling computational data that needs to be verified once, after which the blockchain only needs to retain the result. This includes digital signatures, STARK proofs, Merkle branches and fully homomorphic encryption computations.
The proposal uses off chain aggregation to reduce the amount of information Ethereum nodes need to broadcast. Users first generate and publish their STARK proofs, SPHINCS signatures or polynomial commitment openings. Nodes collect these objects and produce new STARK proofs containing claims about the underlying operations.
These claims can establish that a particular public key signed a message, that a program executed on specific data produced a particular output, or that a polynomial evaluates to a particular value.
Instead of repeatedly transmitting complete signatures and proofs, nodes share hashes of inputs and outputs, generally around 64 to 96 bytes per claim, alongside a single STARK proof for each processing interval.
The proofs are subsequently aggregated again until a master proof can verify the statements included in a block. Ethereum only needs to store the relevant statements and their compact cryptographic commitments rather than the original bulky data.

Why Vitalik Buterin Prefers LeanPCS Over LeanSTARK
Buterin compared three approaches within the EIP-8288 framework, namely leanSPHINCS, leanSTARK and leanPCS.
LeanSPHINCS focuses on a specific hash based signature scheme. Its implementation could allow users to create quantum safe accounts, multisignatures and regular transactions while paying approximately 4,096 gas for a 64 byte signature. However, its functionality remains limited to that particular signature scheme.
LeanSTARK offers greater flexibility because users can generate proofs for different computations. It could support multiple signature schemes, including lattice based cryptography, privacy protocols, hidden multisignature logic and private account abstraction. The latter could allow one key to control several accounts without publicly connecting them.
However, implementing leanSTARK requires Ethereum to agree on an instruction set architecture, or ISA, that defines the language used to write these programs. Buterin considers this a significant protocol decision because the ISA would be difficult to upgrade. Reaching agreement on its design could therefore take considerable time.
LeanPCS offers a different route. PCS stands for polynomial commitment scheme, which proves that a polynomial evaluates to a particular value. According to Buterin, these schemes are among the most important components of STARK systems. With EIP 8288 providing the necessary verification mechanism, a STARK could potentially be verified for approximately 20,000 to 40,000 gas.
Over the past few weeks I've gone from thinking leanPCS is total bull to being a total bull. So let me explain some of these buzzwords in more detail.
At the core, 8288 is about hyper-scaling data and execution for any computation that needs to get performed on a piece of data once, the chain learns the answer, and then we never need to see that data again. This sounds very specific, but it includes most "heavy" things happening on Ethereum:
- Signatures
- STARKs
- Merkle branches
- FHE computation
- ...
Really the first two are the most important.
Once we go quantum-safe, signatures get bigger (65 bytes ECDSA -> 1-6 kB WOTS/SPHINCS depending on params) and ZKPs get much bigger (200-1000 bytes with groth16, PLONK, etc -> 128 kB with STARKs). This is unsustainable to put on chain, and 8288 fixes this.
8288 works by aggregating STARKs in the mempool. First, you as a user generate the STARK or SPHINCS signature or PCS opening (more on that last one later), and publish it. Then, each node listens. Each tick, each node takes all of the new objects that it has seen, and generates a STARK containing a list of "claims":
"pubkey P has signed message M"
"program X run on data D has output Y"
"p(X) = Y for some polynomial P whose hash is H"and a proof that it has seen a signature, STARK or PCS opening verifying those claims. So the only information getting re-broadcasted is:
(i) hashes of inputs and outputs (~64-96 bytes per claim)
(ii) a single STARK proof per tickThese aggregate proofs themselves get re-aggregated, and eventually you get to a single "master proof" in the block, that verifies that all of those statements are true. And so the only other data that has to actually go on chain is the statements (the (P, M), (X, D, Y), (X, Y, H) tuples I described above), not the actual signatures or proofs. This gets put into a specialized frame type.
Now, let's get into the leanSPHINCS vs leanSTARK vs leanPCS part.
The core distinction is: what is the underlying object that the user is creating?
In leanSPHINCS, it's a signature, and specifically this particular type of purely-hash-based signature: https://t.co/HOazliHq9N
If we add leanSPHINCS, then users will be able to make quantum-safe accounts, and pay only a little bit of gas (4096 for the 64 bytes) for each signature. So we get scalable quantum-safety for regular accounts, multisigs, etc. But it's only one specific signature scheme, you can't do anything else.
In leanSTARK, it's a STARK. This means it's fully general: the user runs whatever computation they want, and publish a STARK of it. So you can use it for:
- Any signature scheme (including eg. lattice-based ones if you like those)
- A multisig that hides its internal logic
- Privacy protocols
- Private account abstraction: authorization logic that depends on some value hidden elsewhere in the state, so you can have one key that controls all your accounts without publicly linking them to each other
Basically, it's a free for all, in the same way the EVM is a free for all.
But leanSTARK has a practical downside. The protocol would have to specify the language in which users write their programs (we call this the "ISA"). So we would have to agree on that language. This is a really big deal - it's the first big case of "Ethereum moving beyond the EVM" - and so it's likely to take time to agree on the details of it, especially since the ISA would be hard to upgrade. There are benefits to taking longer on this, figuring out the ideal ISA, and then even giving access to it inside regular contracts.
LeanPCS is the third option. PCS stands for "polynomial commitment scheme": a proof that P(x) = y. The most important thing to know about PCSes is that they are by far the most important "hard" component of a STARK (see here: https://t.co/EEQWMU0gAf ). If you have a "magic PCS oracle" (which from the EVM's point of view, 8288 is), you can verify a STARK in ~20-40k gas.
The most important gain with PCS is that there is far less that we need to choose. Specifying a PCS only requires specifying a field, and there is a natural option: the 128 bit binary field (technically, we can go more general than that, and say the 2^k-bit binary recursive tower field, going up to 256)
LeanPCS is less efficient than leanSTARK onchain, because you would have to put multiple claims to prove one thing. But it's arguably more efficient offchain, because you have much more flexibility to choose proof systems.
But most importantly, leanPCS gives you the same generality as leanSTARK, in a way that could potentially be implemented very quickly. And once we figure out the ISA, we can add leanSTARK later.
So there is a route to getting "the cryptographic proof singularity" much faster than any of us expected, and that route runs through 8288 with leanPCS.
— vitalik.eth (@VitalikButerin) November 16, 2026
https://t.co/dUHONMh75g
LeanPCS Could Bring General Cryptographic Capabilities Sooner
The main reason Buterin now favors leanPCS is the balance it offers between implementation speed and flexibility. Unlike leanSTARK, it does not require Ethereum to settle on a new programming language before moving forward.
Its main advantage is the freedom to select different proof systems off chain while relying on a standardized polynomial commitment mechanism for verification. This gives developers room to experiment with different cryptographic approaches without waiting for a complete agreement on an instruction set.
There is a trade off. LeanPCS may be less efficient on chain than leanSTARK because proving a single operation can require multiple claims. However, it offers greater flexibility during off chain proof generation. Buterin believes this approach could deliver much of leanSTARK's generality while being considerably quicker to implement.
He sees this as a potential shortcut towards what he calls the cryptographic proof singularity, where Ethereum could support a much wider range of cryptographic applications earlier than expected. LeanSTARK could still be introduced later once the network settles on an appropriate ISA.
EIP 8037 Addresses Ethereum's Long Term State Growth
Alongside cryptographic improvements, Buterin also supports EIP-8037, which proposes increasing gas costs for creating new Ethereum state. The proposal aims to make the cost of adding permanent blockchain data more consistent with the storage burden placed on network nodes.
This becomes particularly relevant as Ethereum considers higher gas limits. According to the proposal, a Geth node's state database was approximately 390 GiB in January 2026. Following the increase in the gas limit from 30 million to 60 million, average daily state growth rose from around 105 MiB to 326 MiB.
EIP-8037 introduces a cost per state byte mechanism designed to target approximately 120 GiB of annual state growth at a reference block gas limit of 150 million. Its purpose is to prevent permanent data creation from expanding without corresponding costs.
The proposal is listed for inclusion in the Glamsterdam upgrade, alongside other changes intended to improve Ethereum's network sustainability. Together, EIP-8288 and EIP-8037 address two different technical pressures, the growing size of cryptographic operations and the long term storage requirements of the blockchain.
EIP-8288 is still a draft. Its currently published specification does not yet formally include leanPCS as a verification option. Buterin's November 16 endorsement describes a proposed direction rather than an approved or implemented Ethereum upgrade.
If you find any issues in this article or notice missing information, please feel free to reach out at team@etherworld.co for clarifications or updates.
To promote your Web3 articles, events, and projects, you may reach out anytime via EtherWorld PR for submissions and collaboration.
Related Articles
- Ethereum Mandate Lawsuit Over Staff Retaliation
- Vitalik Buterin Backs EIP 8288 for Ethereum
- Vitalik Buterin Tests Private AI Agents With Tor & zkAPI
- Vitalik Buterin on ZKsync's Faster Ethereum Proofs
- Vitalik Warns Ethereum About a Cryptographic Threat
To follow blockchain news, track Ethereum protocol progress, and read our latest stories, subscribe to our weekly today.
Join the EtherWorld & Avarch Internship Program and build your career in blockchain, content, social media, video, podcast editing, or operations. Send your resume and brief introduction to contact@etherworld.co.
Disclaimer: The information contained in this website is for general informational purposes only. The content provided on this website, including articles, blog posts, opinions, & analysis related to blockchain technology & cryptocurrencies, is not intended as financial or investment advice. The website & its content should not be relied upon for making financial decisions. Read full disclaimer & privacy policy.
To stay updated on blockchain news, Ethereum protocol progress, and our latest stories, subscribe to our weekly digest and YouTube channel for ELI5 content.
To promote your Web3 articles, events, project updates, and Press Releases, reach out anytime via EtherWorld PR for submissions and collaboration. For other queries, email contact@etherworld.co.
If you’d like to support our work, share the content and consider donating at avarch.eth.
Join our community on Discord and follow us on Twitter, Facebook, LinkedIn & Instagram.