vitalik.eth (@VitalikButerin)

Ethereum is both an abstract philosophical concept (the ontological Turing machine) and a practical research and development effort that aims to answer this question that pertains to the nature of Ethereum. How the nature of "Ethereum" as a protocol comes to be determined through the ACD governance mechanism, how cryptographic truth comes to be defined, and how convergent consensus is reached using majority representation of Ethereum's observers is what reduces the ontology of the world computer down to what we today call the Ethereum network. Here's how the world computer comes to be defined:

Glamsterdam with EIP-7928 (Block-Level Access Lists) is approaching the final mile, and things look great: * Significant throughput increase thanks to parallelism * Faster and simpler sync via snap v2 * Future-compatible with zkEVMs, partially stateful nodes, inclusion lists, and trie migrations When we started working on the idea, we saw it as a nice scaling feature and didn’t yet realize that adding state diffs would have a bunch of positive side effects: making tracing faster, improving inclusion list quality under FOCIL (EIP-7805), and helping nodes catch up faster after being offline. Glamsterdam will be one of the biggest forks we’ve seen, and it took correspondingly long, but the result will be worth it.

The cryptographic world computer: My attempt to express in somewhat concise terms the true meaning of basically everything planned to happen to Ethereum starting from the fork after Hegota. It's really not just a blockchain anymore. It's a hybrid architecture that combines together blockchains and modern cryptography, to enable much more powerful properties. FOCIL, EIP-8288, Lean consensus, state management, formal verification, advanced mempool improvements (including privacy), and the longer-term specter of obfuscation all mentioned.

Testing out some of the mobile offline local knowledge apps that people have been trying to build (see here ) Definitely getting much better than the one I tried to build myself 2 months ago. But also still much slower and less effective at difficult questions than the models that can run on a laptop. It's weakest at specialized travel-related queries (eg. my eval is "Tell me the best vegan restaurants in [city I am currently in]", unfortunately none of these performed well on that) Looking forward to seeing these continue to improve! I hope we can soon get to the point where you can comfortably look up any facts about the world that you care about without needing to access the internet at all.

Glamsterdam will bring snap sync to the next level. With snap v2, the Block-level Access List, which is basically a state diff, is used to replace the traditional healing phase. The result, it becomes faster and simpler to sync a node. Clients are ready with Glamsterdam. Snycing has never been that smooth.

qwen3.8-flash-next ethereum client 100+ GB of local downloaded wikipedia + gutenberg + science articles what else? (Getting rid of the need for centralized pinning services in IPFS is definitely high up the prio list)

Note: you can repoint your wallet RPC to localhost, though make sure to set your node up so it functions as an RPC. However, many in-browser dapps will not work as effectively this way, and many others hardcoded their RPC to their own server. I am increasingly becoming a fan of avoiding browser dapps entirely and just doing everything by command line. Just did a full end-to-end test: updated my ENS record using a local python script reading and sending through my local node.

Reminder: you can now sync an ethereum node within half a day and with aggressive settings the space it takes up on disk can be under half a terabyte. EIP-4444 and hard work by client teams on optimizing snap sync has improved things *a lot*. Glamsterdam will improve the sync situation further still (eg. Nimbus's new sync protocol uses it)

HABEMUS TESTNET — DAISUGI v0.1 A post-quantum Ethereum testnet using hash-based SPHINCS signatures with non-native account abstraction. Big thanks to @riva_labs and @GiulioRebuffo. Coming next: • Frame Transactions • Signature aggregation via LeanSPHINCS Believe in somETHing. Link ⬇️

A year ago, we soft-launched Tor VPN Beta as a way to extend Tor's privacy protections beyond the browser to an entire Android device. Since then, we've been able to learn from how people are actually using it in real-world scenarios. Learn more about what makes our per-app circuit isolation different from commercial VPNs, the surprising UX lesson when trying to bypass blocks, and the mobile foundation we're building for what's next.

A note on recursive STARK mempools (EIP-8288) This is an EIP that I am hoping we can get included in I-star (the fork after Hegota) that you can think of as the next step after Frames, that would unlock extreme amounts of power. Particularly: * Ultra-cheap quantum-safe signatures (SPHINCS-). Much of the cost savings comes from the fact that the signature data (~3 kB) does not have to go onchain * Ultra-cheap quantum-safe privacy protocols. Status quo minimum cost for private txs is ~300k if you engineer very well (no one does), status quo quantum-safe is ~10M gas, this could reduce it to low tens of thousands. * Universal support for your favorite new signature or proof scheme without needing EVM changes. Whatever you use (Falcon, ML-DSA, some other lattice-based thing, something code-based or isogeny-based or even more esoteric), you can just wrap it client-side in a STARK, onchain gas cost low tens of thousands just like privacy protocols. Hopefully, Ethereum will never need "please support my favorite cryptographic algo" politics again. * Private account abstraction: keep your account logic private, and in a private location onchain. Then you can make one transaction to change the ownership of all your onchain state - accounts, defi positions, privacy protocol notes, everything - without revealing which objects' ownership you're changing. Here's how it works. Your transaction can include a type of frame that we call a "dependency frame". The frame is a list of statements, asserting claims like "message hash M was signed by SPHINCS- public key P" and "data hash D was proven to satisfy a statement defined by verification key V". When you send your transaction, you send it in an envelope, which includes a signature or a STARK for each statement in a dependency frame. Once the transaction reaches the mempool, nodes aggregate them. Each node runs a loop: wait one tick (eg. 500ms), aggregate all new envelopes (either single-tx or multi-tx) that you've seen, remove any transactions that are expired, generate a STARK recursively proving all dependencies, and send a new multi-tx envelope containing that STARK. Hence, the bandwidth load is bounded: each node's outbound is one STARK (~100-300 kB) per tick, plus each transaction getting broadcasted through the network once (as happens already). The block builder acts as "yet another mempool node", receiving envelopes from the mempool (plus any side channels), generates its own STARK covering the subset of transactions it intends to include in the block, and adds that STARK to the block. Total onchain overhead: one STARK (100-300 kB), plus 96 bytes for each statement being proven. This is what I've called before ( ) "The Proof Singularity". Today, we have all the ingredients to actually implement it. As a developer, this requires a somewhat different workflow than you are used to, but it is conceptually simple. Any signatures or STARKs, you put into a separate frame. Then the main logic that today is verifying a signature or STARK, you replace with checking for the existence of a frame that includes the correct statement as a dependency. Examples of useful statements: * [tx sighash] verifies against [the pubkey at sload(0)] * there exists a secret and a merkle branch such that hashing secret+0 and applying the merkle branch outputs (public) root R, and hashing secret+1 outputs (public) nullifier N * there exists a secret address A, salt S and signature Z such that sload(0) = hash(A, S) and a merkle proof of address A inside a recent ethereum state contains some pubkey D where [tx sighash] was signed by D [this is private account abstraction; all variables except [tx sighash] and sload(0) are private; you can also make D a STARK verification key] * there exists an ML-DSA signature signing [tx sighash], that verifies against an ML-DSA pubkey whose hash is sload(0) At the core, this is moving any compute and data other than bookkeeping "business logic" outside the core path of Ethereum execution, sharding and parallelizing it via the mempool. Notice also that this requires agreeing on a _language_ (aka. an ISA) for the recursive STARKs to define statements in. The current leading candidate is RISC-V. So this would also de-facto be Ethereum adding RISC-V (or something else we decide on) as a canonical ISA - a big decision that should be done carefully, but that I think will be necessary to drive Ethereum forward.

We've published the EF Protocol cluster's priorities and our first shared Hegotá EIP tier list, with input from ~60 researchers and engineers across all 9 Protocol teams. We're aggressively targeting a quantum-resistant Ethereum L1 no later than December 2029. That has implications for what we propose including in Hegotá, and how much capacity we leave for the forks after it. Keeping mainnet safe remains our first priority. We'll be on r/ethereum for an AMA on September 16 at 2pm UTC. Please come ask us about the priorities, the tier list, or anything else you're curious about. Tier and priorities posts and question form can be found below in this thread:

My third (and last) post in my series on obfuscation (iO): local mixing Local mixing is a very different philosophy from the other two, no prior background in lattices required, and very different tradeoffs (eg. in terms of computational overhead, it's viable today; the entire question is verifying the security of what's ultimately a novel family of cryptography). I highly encourage following their work, they plan to publish much more soon.