Ethereum creator Vitalik Buterin is exploring a new concept for how modern computing can be divided into two parts: a “glue” component and a “coprocessor.”
The idea here is simple: split the work. The “glue” handles general, low-intensity tasks, while the coprocessor handles the heavy, structured calculations.
Vitalik broke it down for us, saying that most computation in systems like the Ethereum Virtual Machine (EVM) is already divided this way. Some parts of the process require high efficiency, while others are more flexible but less efficient.
Take Ethereum, for example. In a recent transaction where Vitalik updated the IPFS hash of his blog on Ethereum Name Service (ENS), the gas consumption was spread across different tasks. The transaction burned a total of 46,924 gas.
The breakdown is as follows: 21,000 gas for the base cost, 1,556 for calldata, and 24,368 for EVM execution. Specific operations like SLOAD and SSTORE consumed 6,400 and 10,100 gas, respectively. LOG operations consumed 2,149 gas, and the rest was eaten up by various processes.
Vitalik says that about 85% of the gas in this transaction went to a few heavy operations, such as reading and writing to storage, logging, and cryptography.
The rest is what he calls “business logic,” simpler, higher-level things like processing data to determine which record should be updated.
Vitalik also points out that the same thing can be seen in AI models written in Python. For example, when running a forward pass on the transformer model, most of the work is done by vectorized operations, such as matrix multiplication.
These operations are typically written in optimized code, often CUDA, running on a GPU. However, the high-level logic is in Python, a common but slow language that accounts for only a small portion of the overall computational cost.
The Ethereum developer also believes that this model is becoming increasingly common in modern programmable cryptography, such as SNARKs.
He points to trends in the STARK proof space, where teams are building general-purpose provers for minimal virtual machines like RISC-V.
Any program that requires a prover can be compiled to RISC-V, and the prover can prove the RISC-V execution. This setup is convenient, but it comes with overhead. Programmable cryptography is already expensive, and adding the cost of running the code inside a RISC-V interpreter is a lot.
So what do developers do? They get around the problem. They identify specific, expensive operations that take up a lot of computation, like hashes and signatures, and they create specialized modules to prove these operations efficiently.
They then combine the general RISC-V proof system with these efficient, specialized systems, giving them the best of both worlds. This approach, Vitalik notes, is likely to be seen in other areas of cryptography, such as multi-party computation (MPC) and fully homomorphic encryption (FHE).
Where glue and coprocessor come into play
According to Vitalik, we are seeing the rise of “glue and coprocessor” architecture in computing. The glue is general and slow, and is responsible for processing data between one or more coprocessors, which are specialized and fast. GPUs and ASICs are ideal examples of coprocessors.
They are less general than CPUs, but much more efficient for specific tasks. The challenge is finding the right balance between generality and efficiency.
In Ethereum, the EVM doesn’t have to be efficient, it just has to be familiar. By adding the right coprocessors or precompilers, you can make an inefficient VM almost as efficient as a natively efficient one.
But what if that doesn’t matter? What if we accept that open chips will be slower and use a bonding and coprocessor architecture to compensate?
The idea is that you can design a core chip that is optimized for security and open source, while using proprietary ASICs for the most intensive computing.
Sensitive tasks can be performed by a secure main chip, while heavy lifting such as AI processing or ZK verification can be outsourced to ASIC modules.
