09 - Network State Conference 2026 - Evan Forbes on Multi-Gigabit Zcash

Hello. So, I'm an engineer on Zcash. Zcash's development is very decentralized. So, the taxonomy can be a little bit confusing. But, more specifically than Zcash, I work at Valor Group. More specifically than that, I work on Zecora, which is the really high-performance Zcash client. And then, more specifically than that, I make the blocks big and fast. So, what we really want is these payment systems that work like Zcash. So, they're permissionless, they're censorship resistant, and they preserve privacy. And this is really difficult because there's so many different bottlenecks in different areas. So, as other speakers have presented today, we have things like Tachyon, and we have things like PIR, which those things address different bottlenecks. And then, around like cryptography and privacy, along with that, we have bottlenecks around throughput, so that everyone in the world can use Zcash at the same time. And then, we have latency, so that it's actually usable. When you go to like pay a for any random item, it's quite quick. So, this is like the the UX that we all sort of dream about and know and are used to and expect out of our payment systems. It has to be like this fast. One of the bottlenecks is block propagation. So, this is how big the block can get. The bigger you can make it, the higher throughput it is. And Zcash previously didn't really need that high of throughput or that low of latency. However, it did need this robustness. So, there's typically these trade-offs when we think about these block propagation protocols. Robustness is where data can enter the network at any given point, and the topology of the network can change arbitrarily. Networks get congested, and they change in unpredictable ways. So, Zcash has to be able to handle any arbitrary configuration there. And this is quite difficult. So, there's a the first thing that we optimized for was just robustness. We didn't really have to think about throughput or latency. And this is basically a If you're familiar with these thing protocols, it's a pull-based protocol. It's quite slow, uh quite low throughput, but uh works pretty pretty dang well. However, we can actually preserve that robust quality of where the network can kind of look however it needs to look in that moment, and we can learn on the fly of what's the highest throughput and lowest latency path for the data to take. So, this is like um if you imagine like a school of fish or a swarm of like birds flying, this is uh more or less what the network looks like. We follow a few simple rules, and from those rules, even though we only have a local view, we can we can find the highest throughput, lowest latency path, or at least close. So, this is coming to a testnet near uh near you where we have this uh multi-gigabit uh throughput, and much much faster blocks. Um We're able One of the fundamental problems with proof of work comes from its superpower. Proof of work is permissionless. It's censorship resistant. And that means that anyone can produce a block. So, as you produce a block uh it can happen that someone else produced a block at the same exact time. And this is problematic because now and you lose money effectively. It's It's like uh some layers of complexity with mining pools. It It's basically the fundamental problem of two people producing blocks at the same time. This is This is the bound on making things lower. So, there's different approaches. You have this uh DAG approach where we simply let all blocks contribute to the chain or most blocks. And then there's a separate approach that we're working on now, which is similar to Autobahn, which is another thing from proof of stake that we're sort of adapting for proof of work. And it's very similar in DAGs in that we eliminate this problem. Both of these things allow us to make the blocks much much much faster and much much higher throughput. That's it. Thank you.