PolkaVM is a new general purpose user-level RISC-V based virtual machine, with modern features and functionality.

This talk will detail Ethereum's governance processes around facilitating network upgrades, and provide an overview of what protocol upgrades are being planned.

This talk would explore the original cypherpunk ethos from an Anthropological lens discuss how it can evolve to stay relevant by considering the evolving global scenarios: to remain relevant, cypherpunk principles must expand beyond technical resistance alone and engage with broader societal concerns from a social science lens. It will argue for reframing privacy and censorship resistance as essential to collective safety and freedom, and for cypherpunk values to break from web3 discourse and gain a central place in the broad mainstream discourse.

Blockchain tech can be more than just a ledger: it can be a scalable global computing network, moving away from transaction-centric blockchain design into a decentralised computer one, changing usage patterns, development patterns and tooling. The Join-Accumulate Machine (JAM) is a new protocol aiming to make the usage of blockchain core radically un-opinionated, and to enhance the scalability and efficiency of blockchain networks. By enabling parallel data processing and reducing redundancy, JAM enables seamless collaboration between different applications, storing all application states in a shared environment. This approach facilitates more efficient data accumulation and consensus mechanisms, leading to improved performance and resource utilization. The adoption of JAM represents a significant advancement in blockchain technology: offering a pathway toward more scalable and robust decentralized systems. It is a forward-looking discussion on the future of Web3: showing blockchains can go beyond transactions, enabling decentralized computing with continuous execution flow.

Gavin will provide an update on the latest developments on JAM, including achieved milestones by teams working around the JAM Implementer’s Prize, the JAM toaster and JAM tart, an exciting onchain Execution of DOOM which showcases JAM’s potential, and how to apply any application onchain: even those that don't resemble a blockchain/L2.

Multi-proposer consensus protocols let multiple validators propose blocks in parallel, breaking the single-leader throughput bottleneck of classic designs. Yet the modern multi-proposer consensus implementation has grown a lot since HotStuff. THisworkshop will explore the implementation details of recent advances – DAG-based approaches like Narwhal and Sui’s Mysticeti – and reveal how implementation details translate to real-world performance gains. We focus on the nitty-gritty: how network communication patterns and data handling affect throughput and latency. New techniques such as Turbine-like block propagation (inspired by Solana’s erasure-coded broadcast) and lazy push gossip broadcasting dramatically cut communication overhead. These optimizations aren’t just theoretical – they enable modern blockchains to process over 100,000 transactions per second with finality in mere milliseconds​ redefining what is possible in decentralized systems.

We are building CorePlay, an actor-like framework on top of JAM. JAM is a next-generation blockchain architecture that allows smart-contract-like services to extend the base functionality of the chain. Each service inherits the security of the JAM validator set, and there can be a total of 341 service instances running in parallel per block. By using JAM, we gain access to continuations, deterministic gas metering, and synchronous composability. We think that these actors are the next evolution after smart contracts and writing bare blockchains. Actors will provide a similar level of logic encapsulation as smart contracts while gaining access to the same level of performance and blockspace as blockchains. Right now, we are seeing a push in the direction of vertical and horizontal scaling of blockchains. Vertical scaling only works up to a certain point but enables state locality and thus, synchronous interactions across the whole state. On the other hand, horizontal scaling increases the potential scaling horizon by sharding the execution and/or the data. JAM also scales horizontally by having execution and data sharding. However, it still allows synchronous interactions between the shards to make these shards operate as one instance.

This talk will give a high-level overview of the architecture of an actor and how the inherited properties of JAM enable developers to write simple and secure code. Also, it will go into detail on how actors will interact with each other synchronously.
Lastly, it will shed some light on the required orchestration infrastructure for scheduling and driving these actors.

With their dreams of new ‘Network State’ empires, resource extraction, and colonial domination, today’s tech overlords are the descendants of Europe’s mediaeval Crusaders: well-financed, zealous fanatics remaking the world in the name of their greater good. Through a psycho-political reading of scarcity, chauvinism, and colonialism, The Chain Mail Gaze connects Crusader ideologues’ desire for blood, land, and booty, to emerging ‘frontiers’ mediated by contemporary technologies.

This talk is about the fringes of my Ethereum Social Layer research project. Despite six months research, the central question remains unclear to me: just what is the Social Layer? Rather than present a safe definition - in order to appear competent and professional - I will instead bring you on a tour of the competing definitions swirling around in my mind. We will descend, iceberg theory style, from the surface level or seemingly superficial definitions – the Social Layer is the community or Crypto Twitter – and then fall further into stranger, more esoteric answers, such as the Polycentric Ethereum, transglobal agorist fraternity and, of course, Technopolic cult of the hash function.

Designing, verifying, correctly implementing and later improving core distributed protocols like consensus, which are critical for safety and reliability of decentralized systems, is notoriously difficult and error-prone. One of the biggest challenges here is dealing with the inherently concurrent nature of decentralized systems. But it’s too important, and we can’t really afford to get it wrong, so we need to take it seriously and do a much better job here. But how?

In order to make a breakthrough in this area, we would benefit from revisiting the fundamentals and trying to rethink distributed and concurrent programming from the first principles. How should we approach concurrency in distributed algorithms in a natural way and with confidence? How can we avoid excessive synchronization, prevent deadlocks and resource leakage? How can we make distributed and concurrent systems more simple, flexible, and reliable? In this talk, I will share with you some insights into the fundamentals of distributed and concurrent programming that could help us to overcome these difficulties and make a breakthrough for the future of decentralized computing!

Without clear goals for what our network should provide, we end up optimising for our means rather than for our ends. In this talk, I'll discuss the goals of our network — scale, hardness, verifiability and censorship-resistance — and how some of the means ("local building", "solo staking") should be re-evaluated in light of their contributions to these goals, given advances in protocol research.

How private blockchain differs from transparent blockchain: core components:
- Blended private and public state
- Client-side proof generation
- zero-knowledge property (not just a snark)
- Anatomy of a private smart contract
- Private composability

What does it all mean for developers? What is the right mental model to approach building private dapps?

Rebased rollups introduce a novel paradigm blending the advantages of based and non-based rollups to provide synchronous composability, credible neutrality, and reduced latency without incurring the full cost and latency penalties associated with Ethereum-based rollups. By becoming "based on-demand" for durations shorter than a full Ethereum slot, rebased rollups efficiently utilize Ethereum’s existing proposer set to facilitate faster transaction confirmations and increased throughput.

This presentation explores the technical challenges posed by current Layer 2 (L2) rollups, particularly fragmentation and loss of synchronous composability, and analyzes existing solutions including mesh and hub-based approaches, highlighting their limitations concerning credible neutrality and economic security. We present rebased rollups as a practical solution, detailing their architecture, security trade-offs, and mechanisms such as preconfirmations and dynamic attestation tracking.

We conclude by outlining how rebased rollups horizontally scale economic security and transaction throughput, providing Ethereum-aligned synchronous composability with latency comparable to centralized sequencers, ultimately balancing decentralization, neutrality, performance, and cost-effectiveness for the broader Ethereum ecosystem.

Recent advancements in MPC allow it to be used to power internet scale applications and protecting end-users from some of the risks of wide blockchain adoption. MPC had a lot of challenges - many rounds of communication, intensive compute requirement, large communication overhead, inability to scale horizontally and more. We are not on the verge of solving the critical issues and bringing MPC to the general public. We will explore the problems and solutions (new and old) that make this happen.

General purpose zkVMs provide excellent developer experience in an ecosystem
known for complex tooling. However, they currently require clusters of GPUs to
generate proofs in acceptable time, and are still far away from providing client-side
proofs to the masses, which is required by privacy use cases, for example.

While several optimizations focus on the prover software, compiler-based
optimizations on the VM, ISA and guest program are still underdeveloped.

In this talk we will present our work on these techniques, including automatic
synthesis of ZK precompiles and ZK-friendly program optimization. Our
experiments integrating these optimizers in powdrVM and other zkVMs show that
the techniques are framework- and prover-agnostic, and have the potential to
improve proof generation performance by one order of magnitude and more.

The Bybit hack earlier this year, where attackers compromised the AWS-hosted Safe frontend and tricked Bybit into signing malicious transaction resulting in the loss of $1.4 billion, highlighted a longstanding problem: the web—and by extension, (d)apps—is fundamentally built trust rather than verification.

This talk will examine how IPFS can be used to distribute web applications in a way that reduces these risks. By using content addressing and local verification, developers can ensure users load exactly the code that was published, minimizing reliance on trust-based distribution.

We’ll cover best practices for deploying dapps to IPFS, focusing on recent advancements to enable native IPFS support in browsers by leaning on HTTP as the foundation for interoperability.

Journalists in politically-isolating environments face increasing threats from commodity spyware, often relying on NGOs for digital security support, not without bottlenecks and privacy risks. Recent abuses of mobile forensics tools, such as Cellebrite, highlight the dangers of centralized mobile security falling into the wrong hands. This proposal introduces a distributed Cyber Threat Intelligence (CTI) network integrating Traffic Light Protocol (TLP) and zero-knowledge proofs (Semaphore) to enable privacy-preserving, trustless indicator sharing. By leveraging honeypot-driven threat indicators and decentralized pub/sub mechanisms, at-risk users can safely contribute to and benefit from a broader CTI ecosystem without exposing personal metadata.