
Parallel Relay-and-Execution Distributed Architecture designed to scale out smart contracts [email protected]
Deterministic Parallel VM
Joined January 2023
- Tweets373
- Following33
- Followers166
- Likes301
New benchmark report for Crystality-REVM — Deterministic State Parallelism now LIVE for REVM users @base, @OPLabsPBC, & @Scroll_ZKP. ⚡️Higher concurrency, near-linear scaling.
Six representative Solidity contracts tested on 1–64 cores, compared against high-performance chains like Sui , Aptos , & Sei.
Full report + test suites: github.com/preda-devteam/tes… — download and reproduce the benchmarks.
A 🧵👇
Crystality & PREDA | Parallel EVM Runtime retweeted
Managing state is one of the most difficult challenges, and until we have a sustainable solution, we face a trade-off:
Scaling while allowing state to grow too large harms decentralization because fewer people can afford the required hardware.
Scaling while repricing state growth impacts the application layer.
Not scaling the chain goes against what many in the community want: affordable transactions and enough block space to support adoption. It also isn't a sustainable solution, as state would continue to grow anyway.
Supporting PQ security and privacy will require more gas per transaction. Without increasing the gas limit, we'd effectively reduce throughput.
For Glamsterdam, we're facing this trade-off with EIP-8037 and EIP-8038, which propose repricing state-related operations, including state access and growth. As gas limits increase, state grows disproportionately quickly, and without mitigating the negative impact through repricings, we'd have to increase hardware requirements.
Interestingly, state is growing slower than originally anticipated in EIP-8037. Still, at a gas limit of 200M and without shipping EIPs that address this problem, we would add ~255 GiB of new state every year.
Crystality & PREDA | Parallel EVM Runtime retweeted
My personal summary of the recent discussions:
PQ has become the biggest focus for Ethereum. There's still disagreement, but it feels like people have mostly agreed on "how we're doing it" and the remaining debate is about "when" or "how fast".
I see two camps: those pushing for two forks in 2027, including complicated features like Frame Transactions, Decoupled Consensus, and leanVM, and those who think these timelines are unrealistic and that we shouldn't rush the transition, even if it takes until 2028.
Glamsterdam will be the largest fork since PoS, and it took a while (>1y; still not shipped). Complex features take time and 100% uptime is important. Thus, shipping the PQ transition much faster is somewhere between ambitious and impossible.
Focusing on PQ might mean pulling FOCIL and other features from Hegota. That's a pretty big step, given that we've already agreed to ship it as a headliner.
On the other hand, it seems reasonable to ship Hegota with only Frame Txs much faster than e.g. Glamsterdam, and DC could be nicely pipelined alongside, receiving significant focus from CL core devs.
The truth is probably somewhere in between: Frame Txs can ship faster without having to deal with the FOCIL interactions, and (PQ-)DC could be more complex than some might think (for it to work efficiently, we need leanVM's aggregation too).
One possible path would be Frame Transactions in Hegota, slimming the fork down with no big feature on the CL, and Decoupled Consensus in I*. Whether I* happens in 2027 or 2028 doesn't matter too much, imo. The main question is whether pulling FOCIL accelerates the PQ transition. I think it does, and we should have that discussion.
Overall, people are aligned on where we want to go. Now it's mostly about figuring out how fast we can get there.
pqai27: Our view on post-quantum and post-AI timelines.
We shared this on Ethereum Magicians as input into the Ethereum governance process.
ethereum-magicians.org/t/pqa…
The noise level across crypto X is noticeably rising again. Honestly, bullish.
That’s how the whole X stuff works. You need heated tech debates on roadmaps, gas repricing, and which L2s are the real ones.
And, parallel threads on lawsuits, layoffs, and who could be a spy in Vitalik’s orbit.
The signal and the circus. Both are back.
2
17
Crystality & PREDA | Parallel EVM Runtime retweeted
Scaling Ethereum is important.
Here's my Devcon 2026 talk about the past, present and future of scaling:
youtu.be/Jvc_mZM6SJY?si=ilqW…
Crystality & PREDA | Parallel EVM Runtime retweeted
We solved "Stack Too Deep" for Solidity :)
Especially good time to revisit the desigb choice of peer-to-peer digital cash system
18 years ago today, Satoshi released the #Bitcoin whitepaper.
What a legend! 🙌
1
12
Dropping Exciting news! Our Parallel AMM paper was accepted to ACM PPoPP 2027 on October 27!
We redesigned the constant-product AMM to enable parallel execution of swaps, even for the same token pair within the same logical liquidity pool.
To our knowledge, this is the first of its kind algorithm design.
We’ll share the paper once it’s published, along with a closer look at the algorithm and how it works.
Stay tuned
2
27
Well, this year’s 1024 Developers’ Day might be the last one celebrating humans writing the code.
1
15
Excellent piece on PropAMMs today on Ethereum: execution quality increasingly depends on offchain coordination, with Builders playing a growing role in transaction ordering and market efficiency.
See these emerging use cases (which are rarely seen in this cycle) keep exposing the limits of existing blockchain abstractions, pushing us to rethink how modules of blockchain are designed.
And that's what makes this evolution increasingly exciting.
Can we see the endgame from where we stand today? Probably not.
And that's the most exciting part.
Kudos to (link below)👇
1
18
Crystality & PREDA | Parallel EVM Runtime retweeted
Parallel execution is coming to Ethereum with the next upgrade, Glamsterdam
among many benefits, Block-level Acess Lists (BALs) can enable lighter-weight client experiments like below!
I started writing smart contracts in 2018, and one thing always bothered me: why did running my own RPC mean running a full node, or an archive node if I wanted historical state?
My app only cared about my contracts, a few dependencies and some ERC20s. Why did I need to keep up with everything everyone else was doing on Ethereum just to serve those reads?
The annoying part was keeping that smaller set of state up to date. Reading a value at one block was doable, but knowing what changed in the next block meant executing it or asking a node that had. A transaction could reach my contract through several other contracts, so just filtering transactions by their destination wasn’t enough.
I mostly forgot about it. RPC providers got reliable enough for what I needed, and I had other things to build. I still didn’t love the setup, but it stopped being something I spent time thinking about.
Then over the weekend, I was looking through Glamsterdam’s EIPs and realized block-level access lists might make this practical.
BALs include the state changes made during a block, including the new values, and the block commits to that list. So once you have the initial state you care about, you can follow its changes without re-executing every transaction.
So I started vibe coding it. It’s called skim.
You tell it which accounts and storage slots you care about, or let it discover the state your simulations read. It fetches the initial values from Ethereum’s P2P network through SNAP, checks their Merkle proofs, and keeps them updated using BALs. Your eth_calls then run locally. If a call needs something it hasn’t fetched, it gets that from peers too, just with more latency. No upstream RPC provider for those reads.
It can also keep historical versions of the state you’re tracking. That was another thing I wanted: being able to query my app’s past state without keeping everyone else’s history. It exposes a JSON-RPC interface, so existing tools can use it for the methods it supports.
It still receives full payloads and BALs. The state it maintains is selective, not everything it downloads. There’s also a consensus light-client implementation now, but that path isn’t active on Sepolia yet because the required Gloas light-client data isn’t being served by the peers tested so far. For now, the head is still trusted.
It’s still an experiment, and I’m working through correctness bugs and longer-running tests. I’m not presenting it as a production node replacement.
But it’s pretty satisfying to finally build something around a complaint I’ve had since 2018. I wanted a small client that knows the parts of Ethereum my app actually uses, and that’s what I’m trying to make.
github.com/leekt/skim
Frontier talent gathers at Frontiers.
We bring RETH++, our take on the next frontier of Reth
to the show
teapawt.org/PREDALang/status/21085…
Frontiers: Day 1 teapawt.org/i/broadcasts/1XxygwApP…
22
Meet RETH++ (took my cofounder 2 hrs to explain the name). Built on Reth, it brings
Parallel execution within a single HOTSPOT contract
Parallel state-root computation
Partitioned state storage to EVM's EL
🤖 Made with AI
Using txns from the Crystality-adapted contracts, RETH++ achieves up to 8.09× block-building speedup over Reth.
🤖 Made with AI
1
5






















