DeFi has achieved remarkable things under tight constraints. Protocols like Uniswap have been skillfully engineered to balance user value, gas minimization, and security simultaneously. But look closely at the codebase of any major DeFi protocol and you'll see the same pattern: brilliant workarounds for a limited execution environment.
The Ethereum Virtual Machine was not built for the kind of applications DeFi developers actually want to build. Solidity is a niche language. The EVM has no file system, no access to standard libraries, no floating-point arithmetic, and gas costs that punish complexity. Every feature you want has to be approximated, stripped down, or rebuilt from scratch.
The result is a DeFi landscape full of impressive applications that are simultaneously constrained versions of what they could be.
Outside of web3, developers type ‘import math’ or ‘import numpy’ and immediately have access to battle-tested implementations. That's abstraction. It's how modern software gets built efficiently. On the EVM, none of that exists. Developers have to teach the EVM how to calculate a logarithm step by step, from scratch, on top of building the actual dApp logic. Every instruction is an opcode, and every opcode costs gas.
The EVM has a 30 million gas cap per block. A full implementation of a typical risk management tool would require billions of instructions. The math is brutal: it would cost more to use the dApp than what it could ever save users. And on any shared L1 or L2, every dApp competes for the same block space. Smaller protocols are effectively priced out during the moments when activity matters most.
When you combine the need to reinvent the wheel with the need to pay for every spin of it, it becomes clear why sophisticated DeFi tooling has never been built onchain. The issue isn’t a lack of ambition, but a structural ceiling.
Cartesi's thesis is straightforward: the biggest gains in scalability come not just from more transactions, but from fundamentally more powerful computation. The centerpiece is the Cartesi Machine, a RISC-V-based virtual machine that boots a full Linux OS.
This isn't a minor technical detail. It's the core differentiator.
Because the Cartesi Machine runs Linux, it inherits 40+ years of open-source software development. Every library, every tool, every programming language that runs on Linux can now run as part of a verifiable onchain application. Python, Go, Rust, C++, JavaScript. Not a blockchain-specific language. Not a stripped-down DSL. The real thing, with real libraries.
And unlike the EVM, the Cartesi Machine pushes the instruction limit far beyond. It has proven to handle over 3.6 billion instructions within the average interval between Ethereum blocks. That's orders of magnitude more compute than the EVM provides, available to a single application.
True Bonding Curves, Not Approximations
On the EVM, bonding curve implementations use integer math approximations because floating-point operations aren't available. Inside a Cartesi Rollup, you implement a bonding curve using Python's math libraries with full numerical precision. The formula runs exactly as designed, not as a gas-optimized compromise of it. Every buy and sell updates the supply deterministically and produces verifiable results anchored to Ethereum.
Onchain Risk Management: The Nucleus Proof-of-Concept
The $61 million exploit on Curve Finance illustrates one of DeFi's most consequential gaps. The protocol's founder had substantial loans backed by the native CRV token, nearly triggering a cascade of liquidations across Aave, Frax Finance, and other interconnected protocols. A spread could have been avoided with simple onchain risk controls that checked statistical estimations of a token's historical price behavior before approving a loan of that size. Building those controls on the EVM is not feasible. Running statistics on historical price data requires billions of opcodes. The cost makes it impossible.
Nucleus, a hackathon-winning project built on Cartesi, demonstrates exactly what becomes possible when this constraint is removed. On the surface it looks like a standard lending protocol. On the backend, it runs complex statistical risk analysis using open-source Python code, including NumPy and other libraries, all executing inside the Cartesi Machine and settled onchain via Cartesi Rollups. It can set collateral limits based on actual analysis of onchain data, not just a spot price check. With the same approach, developers can run Scikit-learn, PyTorch, or any other machine learning library as part of their dApp's logic.
This is the kind of tool that could make DeFi systematically safer. And because it lives onchain, it can be composed with and referenced by other protocols, potentially functioning as a public good for the entire ecosystem.
DCA and Advanced Order Types
DCA Monster, built on Cartesi, demonstrates what's possible: a DEX with stream swaps and conditional swaps, with core AMM logic written in Python running inside the Cartesi Machine. The developer had full access to Python's ecosystem to implement the logic cleanly, without fighting EVM constraints.
Running complex logic offchain is only valuable if the results can be trusted. The Cartesi Machine is self-contained (no external influences mid-execution), reproducible (same input always produces the same output), and transparent (full visibility into internal state). These properties enable Cartesi's fraud-proof system: computations run offchain, but disputes are resolved onchain through Permissionless Refereed Tournaments (PRT), a bracket-style mechanism that lets honest participants win even against large-scale Sybil attacks.
This system earned Cartesi a Stage 2 classification on L2BEAT, one of the highest maturity designations in the optimistic rollup space, placing it in rare company among only three other rollups.
Cartesi's architecture gives each dApp its own dedicated rollup chain. Your protocol doesn't compete for block space with unrelated activity, fees become predictable, and developers control gas metering, data availability solutions, and other infrastructure choices specific to their use case. A high-frequency trading protocol has different requirements than a lending platform. With Cartesi, both can be optimized for their actual needs.
Cartesi Rollups can be deployed as an L2 on Ethereum, an L3 on top of existing rollups like Optimism or Arbitrum, or as sovereign rollups, giving protocol designers full flexibility in how they architect their system.
DeFi has accomplished extraordinary things while operating under a severe execution constraint. The EVM imposed a ceiling. Not just on what could be built, but on who could build it. Only developers who learned Solidity, understood EVM quirks, and could optimize gas usage could participate.
Cartesi removes that ceiling. The millions of developers who know Python, Go, Rust, and C++ can build onchain applications using the tools they already know. The 40 years of battle-tested open-source software that powers the internet can now power DeFi.
Anything ranging from simple stop orders to complex financial analysis has so far had to happen offchain in web2 fashion, accessible only through centralized services. Cartesi is the infrastructure that brings it onchain, verifiable, and composable.
The execution layer has always mattered. Cartesi is what it looks like when you get it right.
Want to build?
Start at docs.cartesi.io and check the llms.txt at docs.cartesi.io/llms.txt for vibe-coding reference.
Join our newsletter to stay up to date on features and releases
Dive into the postmortem of a temporary liveness bug that froze the PRT dispute game, locking funds owned by Cartesi. The issue was quickly identified and fixed, serving as a valuable stress test that strengthened the protocol’s robustness.
Written By R&D Unit
Cartesi’s PRT Honeypot is the first Rollup application equipped with the PRT fraud-proof system, putting the appchain stack to the test. It marks a key milestone toward decentralization and trustless security, aligned with L2BEAT’s standards.
Written By Marketing Unit
Discover the key benefits this collaboration will bring and explore some of the early projects already leveraging this integration to build truly innovative dApps.
Written By Marketing Unit
© 2026 The Cartesi Foundation. All rights reserved.
