
If we ship FOCIL (EIP-7805), Frame Transactions (EIP-8141), Keyed Nonces (EIP-8250) and Recent Roots (EIP-8272) in Hegota, we get native, trustless, censorship resistant private transactions on Ethereum next year.

research @ethereum, protocol architecture

If we ship FOCIL (EIP-7805), Frame Transactions (EIP-8141), Keyed Nonces (EIP-8250) and Recent Roots (EIP-8272) in Hegota, we get native, trustless, censorship resistant private transactions on Ethereum next year.

ethmagicians link: ethereum-magicians.org/t/tho…

Thoughts on pqai, Hegota, and FOCIL tldr: Let’s accelerate pqai without rushing or stopping everything else. We can parallelise workstreams to keep shipping EIPs that are ready while the cryptography, designs, and specs for PQ are being worked on and finalised. We need to accelerate Ethereum’s transition to post-quantum, post-AI cryptography. Let’s take this as a given. There are two ways to think about what we need to do to enable this acceleration. 1) We deprioritise everything that is not pqai critical. That means all the features we were planning to ship have to wait until after we switch to hash-based cryptography across all layers of the protocol. To me, the downside of this approach is that we put all our eggs in one basket: if we end up taking 3 years to ship pqai, then Ethereum doesn’t move, at all, for 3 years. That’s “full sequential” mode, and it doesn’t account for important parameters, including how ready features are and what skillsets we have among researchers and client teams (e.g., not everyone is a PQ expert). The only case in which this is inevitable is if we find out that there is an actual break in our cryptography. In that case, I would argue we should be ready to make choices that go far beyond pq2027 ones, and have a concrete plan for what we need to do if we have to ship a minimal, ugly, emergency fork in a couple of weeks. 2) We parallelise. We keep working on the core, minimal features that were already SFI’d by core devs and the community, while accelerating our transition to pqai. To me, this second approach makes sense when you look at where the forks are: - Glamsterdam is delayed: most of the work is reaching out and making sure smart contracts don’t break because of repricing EIPs. - Hegota is in its devnet phase and can keep progressing with FOCIL and Frames in the meantime. Some core devs in all client teams have already worked on these features, they are specced, and now it comes down to “making it work” on the implementation side. - Importantly, the major PQ/AI upgrades are not yet ready: the specs and the cryptography are not frozen (x.com/soispoke/status/212091…). On the CL side, we don’t even know exactly what we mean by “PQ consensus” yet. Is it PQ Gasper? PQ Decoupled Consensus? With or without aggregation (and leanVM)? We need a lot more eyes on it, but it’s not realistic to think that all core devs across all teams would be able to chime in and accelerate progress there. Process-wise, I think it’s also important not to DFI features before we even know what we are going for. For example, we will realistically need more time to ship PQ DC than PQ Gasper, and we should ideally settle on which option to go for before making decisions about Hegota. In other words, the scenario I want to avoid is people DFI’ing features like FOCIL (and others) to get a false sense of security (“we deleted features, so surely we can go faster”), when the reality is more complex and nuanced. I also think these decisions hurt ACD’s credibility, and that we need a strong ACD the ecosystem can rely on, especially during times of uncertainty. Zooming in - On the EL, my opinion is that we need Frames for PQ (the only nuances are about how “light” Frames should be). In practice, we could also take the ugly/sequential approach there and ship another transaction type. But given the readiness of Frames, what they would unlock in Hegota and in the future (plus the fact that they’re already SFI’d, of course), there is no reason to settle for a hacky alternative. - On the CL, we can apply the same type of thinking. For FOCIL, I think the most reasonable path is to derisk it as much as possible so we ensure it is (1) forward compatible with PQ, and (2) minimal enough that it doesn’t delay Hegota and/or take up too many resources from nodes (bandwidth/compute) at a time when we need those for PQ. FOCIL in Hegota The good news is that FOCIL is well suited for this, because of two core properties: - Extensibility: We can fine-tune FOCIL to determine its transaction coverage. I think of it in terms of tiers: if we just want to cover regular/legacy transactions, we get FOCIL in its minimal form (lowest complexity, lowest node resource consumption). On the other hand, if we want FOCIL to cover all types of Frame transactions now and in the future, FOCIL becomes more complex and consumes more resources. In between, FOCIL can cover a limited set of Frame transactions. - Boundedness: Inclusion lists are amongst the easiest objects to deal with in the protocol. They’re bounded in terms of both size (8 kB) and gas limit (MAX_VERIFY_GAS_PER_IL). We can also cap the gas and size per IL transaction. Inclusion lists are also ephemeral and only useful for the duration of 1 slot, after which they can be forgotten about. And they never go onchain, so they don’t grow Ethereum’s state, which is one of our scarcest resources. For Hegota, I think FOCIL should sit in between and support a limited set of Frames with clear bounds on inclusion lists. A good approach for shipping FOCIL and Frames in general on devnets is to start with minimal FOCIL, make sure it’s ready, and then extend its transaction coverage gradually. This is a good way to guarantee we can ship FOCIL and Frames as soon as Frames are ready to go. PQ FOCIL “PQ FOCIL” can mean two different things, and we should differentiate them. The first is inclusion lists being able to cover PQ transactions. Here, the simple answer is that FOCIL, without any changes, would be able to include PQ transactions using leanSPHINCS signatures. But it would be able to include a lot fewer: a leanSPHINCS signature is around 5-7 kB and an IL is capped at 8 kB, so probably just 1 PQ transaction per IL, which means up to 16 PQ txns per block (because there are 16 includers, each of them building 1 IL per block). I think that’s fine and good enough for Hegota. Later, we will probably want FOCIL to cover PQ proofs as well, and for that we will need changes to FOCIL so each IL can include an 8288 proof (around 300 kB). The good news is that by then, we will need the machinery to handle these big recursive proofs being propagated on the network anyway. These are I*/J* considerations, but we should plan ahead and make sure the CL has the capacity to handle bigger ILs down the road. The second is inclusion lists being PQ/AI resistant. This one is easy: just replace IL BLS signatures with leanXMSS signatures, which would increase their size by 2.4 kB (each IL becoming 10.4 kB instead of 8 kB). But it also raises an interesting question: how important is it for ILs to be signed with PQ sigs? What is the worst attack that could happen if an adversary forged an IL signature? The worst an adversary can do with forged IL signatures is make every includer look like an equivocator. Nodes ignore ILs from an includer who signed two different lists, so forging a second IL for each of the 16 includers switches FOCIL off for that slot. So the worst thing that can happen is that FOCIL gets neutralised, which is of course far from ideal but a lot less concerning than consensus breaking or funds being stolen. Keep in mind that the adversary would also have to spend significant resources to break the keys of all 16 includers, who are only known a few minutes in advance. An adversary could also publish ILs on behalf of offline includers, but an IL can only force in transactions that are valid and fit in the block, which is what any includer can already do. And the extra load is bounded, because nodes forward at most two ILs per includer. So even though I think we should generally switch to PQ sigs across all layers of the protocol, this one is definitely not the most urgent or worrying. ILs could potentially keep BLS signatures in Hegota and move to PQ signatures with the rest of the CL. Closing thoughts I agree we should accelerate pqai, and prioritise every upgrade that is ready (PQ registration, leanSPHINCS). But DFI’ing everything else won’t make the parts that aren’t ready arrive any sooner. It only guarantees that Ethereum ships no user-facing features while we wait. PS: I want to be clear that I’m incredibly excited about the future of Ethereum. Thinking about PQ and ZK made me realise that we could completely rethink Ethereum as a cryptographic world computer, and accelerating towards this vision is very bullish. We just need to be careful not to sacrifice its other properties along the way (e.g., credible neutrality, privacy), and we have a very bright future ahead of us.
I agree there are some nuances but I still think the pqai2027 timeline doesn't make a lot of sense for points that could be more grounded, we need to think about: - what to settle on from the cryptography side (specific signature schemes for leanSPHINCS and XMSS on the EL and the CL, leanVM specifics and what it means to FV a project of that size and complexity, choosing the hash function) - how easy we want to be able to switch to something else in case the hash we chose ends up breaking as well - we also need to differentiate PQ Casper and DC versions with or without aggregation because these involved widely different tradeoffs - 8288 is not just signature aggregation, it also currently includes leanSPHINCS and leanSTARK (now leaning towards leanPCS, which gives users the possibility to prove any statement and thus the flexibility to chose any signature scheme they like)

EIP-8288 is exciting, and one of the most exciting parts is the unlock for privacy protocols. Today, every privacy transaction comes with it's own zk proof, and all of them are verified independently. With leanSTARK/leanPCS, they can be aggregated in the mempool and batch-verified once (=less data, less compute). Using privacy protocols will become cheaper and more native to Ethereum.
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 tick These 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: ethresear.ch/t/sphincs-minus… 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: vitalik.eth.limo/general/202… ). 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. firefly.social/post/x/212092…

leanPCS is a total bull I think the amount of use cases it will unlock is beyond what we can imagine today, and not having to go through the friction of convincing everyone we need to enshrine a new ISA is the best path forward. EIP coming soon, stay tuned!
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 tick These 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: ethresear.ch/t/sphincs-minus… 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: vitalik.eth.limo/general/202… ). 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. firefly.social/post/x/212092…

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 tick These 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: ethresear.ch/t/sphincs-minus… 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: vitalik.eth.limo/general/202… ). 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. firefly.social/post/x/212092…

“The PQ timeline of 2028 already felt like a big acceleration, and pulling it even sooner seems borderline too fast”
[1/2] happy sunday! last week's post-quantum articles from @potuz_eth and @ethlabs_org both seem critically important and caught me off guard, so i spent a wifi-free flight over the Atlantic processing them and trying to articulate my strong initial reaction. link below.

[1/2] happy sunday! last week's post-quantum articles from @potuz_eth and @ethlabs_org both seem critically important and caught me off guard, so i spent a wifi-free flight over the Atlantic processing them and trying to articulate my strong initial reaction. link below.

guess not anymore, I have formally proved that a validator will take at most 604497386198401696480443941423039233672056843956262611240144118453974882764353409596694785910843529629961798654508 or roughly 6 × 10^113 RISC-V steps to verify any Ethereum block. this is an extremely conservative bound, more steps than there are atoms in the observable universe (~10^80). but ... it's finite, and it holds for every block with a gas limit up to 200M, no matter what's in it. until now the only answer we had was ∞. the proof covers the whole stateless validator: - input decoding - every possible transaction - every EVM call frame - every precompile - computing the state root the bound is carried from the source program through every compiler pass down to RISC-V steps. it took ~423k lines of Lean, written by a swarm of @claudeai agents: Opus 5.5 orchestrating, Sonnet 5.5 agents building proof packages in parallel. every step is checked by Lean's kernel, and the official evm.fast verifier Built on @yukonresearch in collaboration with @zksecurityXYZ, @Veritylab, @ethereumfndn which then rebuilt and re-checked all of it with an independent kernel replay taking 13 hours of verification. now the fun part, making the number smaller ... full submission: github.com/Layr-Labs/evm.fas…
What's the most work that could possibly be required to verify an Ethereum block? Today, we can't prove an answer. All we know is the validator always finishes. evm.fast is an open challenge to change that: contributors compete on a leaderboard to find mathematically guaranteed bounds for verifying Ethereum, no matter what's in a block. Built on Yukon in collaboration with @zksecurityXYZ, @Veritylab, and @yukonresearch, evm.fast seeks provable limits that keep verification cheap, predictable, and possible on modest hardware. Try it yourself: evm.fast

I’m all for prioritising PQ more, but shipping 4 forks in 2027 (Glamsterdam, Hegotá EL, Hegotá CL, I*) is just not going to happen. We need concrete, grounded plans that are ambitious and doable. Those take time to put in place, and rushing is always going to be a losing game.
It’s unlikely we’re “pqai” in 2027. Shipping forks is slow and painful, but that’s what it takes to have 100% uptime. The alternative would have to be worse (i.e. ECDSA actually shown to be degraded).

How high can EIP-8141's frame validation cap go without excessive block delay under mempool DoS? We ran an attack campaign to find out. The result: 300k gas (vs. 100k today) looks viable with in-client defenses -- making room for privacy transfers and PQ signatures.

Devcon 9 is coming to Lisbon! 🇵🇹 October 11–13, 2027 Building on Mumbai, we're bringing Ethereum's builders together with more friends and allies working toward a freer, more open internet.

Quantum computing poses a serious threat to the cryptography blockchains currently rely on, while advances in AI compress best estimates for the threat's timeline. That's why experts gathered in Cambridge to coordinate research upgrading our cryptography to be quantum-resistant.

This weekend we launched EthLib, a Lean4 library for Ethereum! The goal is to bring Ethereum's primitives, specifications and theorems into one place, building a shared foundation for formally specifying and proving things about Ethereum. github.com/ethereum/EthLib

The Cambridge workshops were the best events I’ve been to in years Spectacular people, and a real sense that we’re accelerating towards post-quantum secure technology unlocked by AI and formal verification Bullish
a list of all 69 participating orgs: * 3mi labs * aarhus university * aria * axiom * aztec foundation * bar-ilan university * binius * blockstream * carnegie mellon university * category labs * cnrs * complutense university of madrid * consensys * epfl * elte / university of birmingham * etherealize * ethereum foundation * ethlabs * ideal * imperial college london * inria * ku leuven * lambdaclass * ledger * lfg labs * lirmm / university of montpellier * math, inc. * mavan / bitmine * microsoft research * miden * mit / nyu * nethermind * nvidia * nyx foundation * offchain labs (prysm) * onetimelabs * pauli group * powdr labs * project eleven * ream * riva labs * seoul national university * shielded labs * silence laboratories * stellar development foundation * succinct * symbolic software * tachyon foundation * technical university of munich * technion * tel aviv university * trail of bits * uc san diego * universite de rouen normandie * university of cambridge * university of luxembourg / layerzero labs * university of minnesota * university of pennsylvania * university of warwick * veridise * world foundation * xi'an jiaotong-liverpool university * zcash * zero latency labs * zisk * zksecurity * zodl * a16z * 20squares * zero knowledge podcast thank you all for taking time away from your lives to come and share your brilliance with us

a list of all 69 participating orgs: * 3mi labs * aarhus university * aria * axiom * aztec foundation * bar-ilan university * binius * blockstream * carnegie mellon university * category labs * cnrs * complutense university of madrid * consensys * epfl * elte / university of birmingham * etherealize * ethereum foundation * ethlabs * ideal * imperial college london * inria * ku leuven * lambdaclass * ledger * lfg labs * lirmm / university of montpellier * math, inc. * mavan / bitmine * microsoft research * miden * mit / nyu * nethermind * nvidia * nyx foundation * offchain labs (prysm) * onetimelabs * pauli group * powdr labs * project eleven * ream * riva labs * seoul national university * shielded labs * silence laboratories * stellar development foundation * succinct * symbolic software * tachyon foundation * technical university of munich * technion * tel aviv university * trail of bits * uc san diego * universite de rouen normandie * university of cambridge * university of luxembourg / layerzero labs * university of minnesota * university of pennsylvania * university of warwick * veridise * world foundation * xi'an jiaotong-liverpool university * zcash * zero latency labs * zisk * zksecurity * zodl * a16z * 20squares * zero knowledge podcast thank you all for taking time away from your lives to come and share your brilliance with us
6 days, 4 workshops, 1 incredible group of people