Building on Ethereum often feels like trying to write complex software inside a calculator due to the restrictive nature of the EVM. Cartesi changes this by providing a dedicated Linux environment where you can finally use the same programming tools as traditional developers.

This means you no longer have to sacrifice functionality or settle for basic features just because you are on a blockchain. By moving heavy processing into a verifiable off-chain space, you get the computational freedom of a real computer while keeping Ethereum's security.

Read on to discover how Cartesi transforms decentralized computing. 👇

What is Cartesi?

Cartesi is an application-specific Layer 2 rollup framework that lets developers build decentralized applications using Linux software stacks. Through the Cartesi Machine, computations run off-chain on a RISC-V virtual machine, while blockchain contracts verify results with Ethereum-level security.

The Cartesi project was founded in 2018, when its whitepaper introduced a hybrid onchain and off-chain execution model. From the start, the focus was enabling complex computation without rewriting applications in Solidity, using familiar programming languages and Linux tooling.

To optimize scalability, the protocol is designed for compatibility with modular data availability layers like Celestia and Avail to reduce the cost of posting rollup data. This potential integration allows high-compute applications to process massive datasets while maintaining affordable transaction fees.

A technical breakthrough occurred in late 2025 when Cartesi achieved Stage 2 security status on L2BEAT, a distinction held by only three projects. This transition to a fully permissionless system ensures that the fraud-proof mechanism operates without centralized intervention.

How Does Cartesi Work?

Cartesi's architecture separates execution from consensus by running a deterministic Linux environment off-chain, while inheriting Ethereum’s security through its modular rollup framework and fraud proofs.

The following technical components define this unique decentralized computing infrastructure:

• Cartesi Machine: This RISC-V virtual machine executes Linux stacks, allowing developers to run complex computations in a verifiable and deterministic environment.
• Linux Execution Environment: Developers write application logic using standard Linux tools, libraries, and languages, avoiding smart-contract-only development constraints.
• Deterministic Execution: Every operation within the VM yields identical results, ensuring that off-chain processing remains fully verifiable by the underlying blockchain.
• App-Specific Rollups: Each application operates on its own dedicated chain (rollup), providing high-performance throughput without competing for block space with other projects.
• Cartesi Node: This off-chain component manages application state, handles user inputs, and generates the outputs required for secure final settlement on Ethereum.
• Fraud Proofs: This challenge-response mechanism allows honest validators to dispute incorrect state transitions, ensuring that malicious actors cannot compromise network integrity.
• RISC-V Architecture: This open standard instruction set enables the protocol to support a wide range of standard programming languages and software libraries.
• The Input Box: This Ethereum contract serves as the primary gateway for users to send data and instructions to the off-chain application.
• Vouchers and Notices: These cryptographic outputs allow the off-chain environment to interact with the main chain, facilitating asset withdrawals and verifiable updates.

How to Use Cartesi

Cartesi provides a versatile environment for interacting with decentralized computing, offering specialized pathways for both end-users and software engineers.

Cartesi For Users

Users can interact with the Cartesi ecosystem by participating in network security, governance, and exploring various decentralized applications built on this modular framework.

Engage with the project through these specific methods:

1. Use App-Rollups: Visit Cartesi’s Rollup Lab to interact with high-performance applications and find inspiration for building complex gaming, DeFi, or AI projects.
2. Acquire CTSI Tokens: Purchase Cartesi (CTSI) on major exchanges like Binance or Uniswap and transfer them to a personal Web3 wallet like MetaMask.
3. Stake via Explorer: Visit the Cartesi Explorer, connect your wallet, select a staking pool, and delegate your tokens to earn network participation rewards.
4. Cast Governance Votes: Navigate to the governance hub, browse active proposals, and use your staked balance to vote whether ecosystem projects receive funding.

Cartesi For Developers

Software engineers can leverage a full Linux stack to build computationally intensive applications using familiar languages like Python, C++, or JavaScript.

Start building with these essential resources and tools:

1. Initialize Project: Run the command "cartesi create [app-name] --template python" within the CLI to generate a standardized boilerplate for your decentralized application.
2. Code Logic: Write your application business logic in your preferred language using standard libraries, treating the Cartesi Machine as a Linux-based environment.
3. Build in Docker: Execute "cartesi build" to package your code into a deterministic RISC-V image that ensures identical execution across all network nodes.
4. Deploy Locally: Test your dApp by running "cartesi run", which spins up a local node environment to simulate the onchain execution cycle.
5. Deploy to Testnet: Follow the official deployment framework to configure your environment and utilize the Cartesi CLI to move your application logic onto public testnets like Sepolia.

What is the CTSI Token?

CTSI is the fundamental utility asset for Cartesi. It powers the governance processes, plays a central role in the ecosystem's economics, and will align incentives to support dApp growth through the Validator Marketplace.

CTSI Tokenomics

The total supply of Cartesi (CTSI) is capped at 1 billion tokens, with approximately 89% already in circulation. CTSI was launched in 2020 on Binance Launchpad, and all unlocks have been completed, meaning the only remaining issuance originates from staking rewards.

As part of core funding allocations, the 2025 Cartesi Foundation treasury was distributed like this::

• Ecosystem & R&D: The largest share of the treasury is now dedicated to Core R&D (36%) and Ecosystem growth (12%), ensuring continuous technical evolution and developer support.
• Mining Reserve: 25% of the supply remains dedicated to the Mine Reserve, which autonomously distributes rewards to stakers and node operators via the RewardManager.
• Foundation Operations: Approximately 41% of Foundation spending is allocated to global initiatives, marketing, and operational growth to expand the protocol's market presence.
• Strategic Liquidity: The Foundation maintains a highly diversified treasury with only 18.55% held in CTSI, ensuring over 4 years of runway to weather market volatility.

Supply Allocation

The network utilizes a reward mechanism where new CTSI issuance is managed via a dedicated Mine Reserve to incentivize node operators. According to the 2025 transparency report, the Foundation maintains a solid treasury with a projected runway of 4 years and 4 months, ensuring stable funding for core R&D and ecosystem growth.

The CTSI supply remains strategically distributed, with 59.83% of the Foundation’s tokens deployed to generate staking rewards and 40.17% held in wallets for operational needs. Staking rewards are distributed autonomously through the RewardManager, which is funded by the Mine Reserve to secure the protocol until the reserve is fully depleted.

To maintain economic viability, the Foundation has diversified its treasury, with CTSI representing only 18.55% of total assets, while 65.16% is held in fiat. This allocation allows the protocol to transition toward a revenue-generating path and value-accruing mechanism through a diverse array of upcoming products, such as the proposed Validator Marketplace.

CTSI Staking Mechanics

Staking is the primary method for securing the Cartesi network, allowing token holders to participate in the consensus process and earn rewards while protecting the protocol from malicious actors.

Participate in the network using these mechanics:

• Node Delegation: Users can delegate their CTSI to professional node runners via the staking portal, allowing them to earn rewards without managing complex hardware.
• Selection Probability: The chance of a node being selected to produce a block is directly proportional to the amount of CTSI staked within that specific pool.
• Reward Distribution: Stakers receive a portion of the newly minted tokens, which are distributed automatically based on their individual contribution to the pool.
• Slashing Protection: The architecture includes security measures to ensure that honest participants are not penalized, maintaining a fair reward environment.

Best Projects on Cartesi

Cartesi’s ecosystem includes dApps that showcase Linux execution in different ways. These include a public security challenge, an onchain fantasy console, a modular DeFi protocol for streamable tokens, and a decentralized service for verifiable large language model inference.

Here are three projects worth trying, with quick steps to start.

1. Honeypot

Honeypot is Cartesi’s “hack me” rollup dApp on Ethereum mainnet, launched in September 2023 to pressure-test Cartesi Rollups with real funds. The current Honeypot V2 is the first application equipped with the PRT fraud-proof system and maintains a balance of approximately 50,000 CTSI.

Use it like a hands-on security challenge:

• Identify Targets: Open the Honeypot listing in Rollup Lab and follow the project link to the live dashboard to analyze the current contract state.
• Review Logic: Study the “Honeypot deep dive” to understand Output Validation and how machine commitments define the security of the challenge.
• Test Vulnerabilities: Attempt withdrawals outside the intended path or exploit any other vulnerability that could let you drain the CTSI funds locked in the smart contract.
• Observe Disputes: Track the network's live activity to see how challengers can dispute executions, prompting defenders to submit fraud proofs.

Cartesi treats Honeypot as a live testbed for its fully permissionless architecture. Reaching Stage 2 security status in late 2025, this dApp serves as the primary proof of concept for the protocol's decentralized fraud-proof mechanism on Ethereum mainnet.

2. Rives

RIVES is an onchain fantasy console powered by Cartesi, built around a deterministic emulator (RIV) that runs both in your browser and inside validators. It’s live on Base mainnet and lets you play retro titles like Snake, Tetris, and DOOM.

Engage with the console using these instructions:

1. Visit Rives.io: Navigate to the official gaming portal to browse the library of community-created cartridges and view high-score leaderboards for active games.
2. Connect Wallet: Link your Web3 wallet to the platform to record your gameplay sessions and secure your rankings on the immutable blockchain ledger.
3. Play or Create: Select a game to play directly in your browser or use the Rives SDK to develop and upload your own unique game cartridge.

Behind the scenes, RIVES uses Cartesi Rollups so gameplay can be validated instead of trusted. In 2025, the team talked about moving through Node V2 work and teased a mobile version, keeping the focus on verifiable play and creator tooling.

3. Locale Network

Locale Network is an open source IoT attestation infrastructure that brings trustless sensor data verification to the blockchain. By utilizing Cartesi’s Linux runtime and RISC-V machine, it creates a deterministic environment where device readings are verified through cryptographic signatures.

Verify real-world data with these steps:

• Register Device Identity: Assign a decentralized identifier to your hardware using the L{CORE} SDK to ensure the device owns its cryptographic identity.
• Sign Sensor Readings: Use the embedded C or Python SDKs to generate JSON Web Signatures for every data point captured by the device.
• Execute TEE Attestation: Process signatures within a Trusted Execution Environment to verify device authenticity before the data is committed to the rollup.
• Finalize on Arbitrum: Settle verified attestations on Arbitrum Orbit chains, where Cartesi’s fraud-proof system handles any disputes to guarantee the correctness of the sensor data.

By running SQLite inside the Cartesi Machine for complex queries, Locale Network eliminates the need for expensive per-proof fees. This architecture allows developers to bridge physical assets to onchain ecosystems while maintaining a completely self-hostable and decentralized hardware stack.

4. ThinkChain

ThinkChain is a decentralized service that brings verifiable Large Language Model inference to smart contracts. By utilizing EigenLayer operators and the Cartesi Machine, it enables protocols to perform AI-driven tasks without compromising on decentralization. It supports many popular models, including DeepSeek-R1 and Qwen2.5, through a simple Solidity interface.

Integrate AI into your smart contracts with these steps:

• Select Your Model: Choose from integrated LLMs like SmolLM2 or DeepScaleR depending on your application's complexity and performance needs.
• Request Inference: Send a completion request via the Solidity Completer contract, specifying your prompt and desired callback for the results.
• Verify Off-chain Execution: Track how EigenLayer operators run the selected model within a deterministic Cartesi Machine to generate a signed, verifiable result.
• Receive Onchain Results: Once the solver submits the aggregated signature, your designated callback contract automatically receives and decodes the AI's response.

ThinkChain solves the onchain AI dilemma by offloading the massive computational weight of LLMs to EigenLayer co-processors while using Cartesi to maintain the integrity of every inference. This framework allows developers to build sophisticated AI agents that can analyze data and execute logic with the same level of trust as a standard smart contract.

Cartesi Security

Cartesi employs a secure permissionless dispute resolution system called Dave (pending implementation after the current fraud proof system in use, PRT), which allows any honest participant to challenge invalid claims. This multi-party interaction ensures that even a single honest node can defend the network against a majority of malicious actors.

Mathematical finality is achieved through a multi-round bisection game that isolates the specific instruction where a disagreement occurred. By verifying only the disputed step on the base layer, the system significantly reduces the data required for onchain settlement.

The protocol achieves Stage 2 security, a milestone Vitalik Buterin describes as the "removal of training wheels" where the system becomes fully permissionless. This status ensures that no centralized entity can override the results of the decentralized fraud-proof mechanism.

Pros and Cons of Cartesi

Understanding the trade-offs of the Cartesi protocol is essential for evaluating its role in the evolution of modular execution layers and decentralized computing.

Cartesi Founders

Cartesi was established in 2018 by Erick de Moura, Augusto Teixeira, Diego Nehab, and Colin Steil. This diverse team combined expertise from top-tier academic institutions and software engineering to develop a unique Linux-based virtual machine architecture.

The founders envisioned a modular execution layer where developers could utilize traditional software stacks for decentralized applications. Their collective background in theoretical computer science and business has driven the protocol’s evolution into a production-ready ecosystem.

Final Thoughts

Today, developers utilize Cartesi's modular execution layer to create compute-heavy applications like fully onchain games and AI-driven protocols.

By leveraging the full Linux stack, builders can execute intensive tasks that remain impossible within the standard Ethereum Virtual Machine.

For 2026, Cartesi's roadmap prioritizes full RISC-V enshrinement and improved convenience for DeFi app developers to optimize high-performance decentralized computing.