Cartesi Machine

At its core, the Cartesi Machine is a deterministic emulator of the RISC-V instruction set architecture. This guarantees that any computation, given the same initial state and inputs, will produce an identical, verifiable output every time. This determinism is the foundation for verifiable off-chain computation, allowing complex application logic to be executed outside the blockchain while remaining provably correct.

Unlike typical smart contract VMs, the Cartesi Machine boots a complete, minimal Linux operating system. This provides a standard environment where developers can run applications written in any programming language (C++, Python, Rust, etc.) using mainstream libraries, compilers, and tools. It effectively removes the technical constraints of the EVM, enabling the development of sophisticated decentralized applications (DApps) with familiar software stacks.

The machine executes application logic off-chain, avoiding the prohibitive gas costs and throughput limits of on-chain computation. Only the final result and a compact cryptographic proof (a Cartesi State Hash) are submitted to the blockchain. Through optimistic rollups and interactive dispute resolution, any invalid result can be challenged and adjudicated on-chain with minimal computational overhead, ensuring the system's security inherits from the underlying blockchain.

The entire state of the Cartesi Machine—including memory, registers, and storage—can be captured as a cryptographic hash. This machine snapshot serves as an immutable, concise representation of the computation's state at any point. It enables features like:

• State synchronization between participants.
• Efficient verification by replaying from a known snapshot.
• Composability of different computational steps.

The architecture separates computation from data. Large input data (like machine learning models or game assets) is made available off-chain through Data Availability Committees (DACs) or other solutions. The machine only needs a cryptographic commitment (e.g., a Merkle root) to this data on-chain. This design allows DApps to process gigabytes of data without bloating the underlying blockchain, solving a key scalability challenge.

Each Cartesi DApp runs in its own isolated Cartesi Machine instance, creating an application-specific rollup (often called an AppRollup). This provides:

• Sovereign scalability: The app does not compete for block space with others.
• Customizability: Developers can choose VM configurations and data availability models suited to their app.
• Modular security: The security of one AppRollup is independent of others, containing any potential faults.

The Cartesi Machine is a deterministic RISC-V instruction set architecture (ISA) virtual machine. This means:

• It executes computations with perfect reproducibility, a prerequisite for generating verifiable proofs.
• Developers can write logic in any language that compiles to RISC-V (e.g., C++, Rust, Python).
• It provides a full Linux OS environment, allowing the use of standard libraries and tools.

The core mechanism is generating cryptographic proofs of off-chain execution.

• The machine's state transition is hashed at each step, creating a Merkle tree of the entire computation.
• A Verification Game (interactive fraud proof) or a zk-SNARK can be used to compactly prove the result's correctness.
• The final, succinct proof is submitted on-chain for settlement, ensuring trustless verification.

It acts as a scalable off-chain execution layer for blockchains.

• Complex, computationally intensive logic (e.g., AI inference, complex games) runs off-chain on the Cartesi Machine.
• Only the final state and a tiny proof are posted to the underlying L1 or L2 (like Ethereum or Optimism).
• This moves the computational burden off-chain while maintaining cryptographic security guarantees.

The system comprises several key components:

• Cartesi Node: Software that hosts and runs the RISC-V VM off-chain.
• Cartesi Rollups: A framework that uses the machine for optimistic rollup or zk-rollup style settlements.
• On-chain Verifier: A smart contract that validates the submitted proofs.
• This architecture decouples execution from consensus and data availability.

Enables blockchain applications previously deemed infeasible due to gas costs or EVM limitations.

• DeFi: Complex financial simulations and risk calculations.
• Web3 Gaming & AI: Running game engines or machine learning models verifiably.
• Data-Intensive Oracles: Performing verifiable computations on large datasets.
• Scientific Computing: Reproducible, trust-minimized research computations.

Contrasts with traditional blockchain virtual machines:

• EVM/SVM: Limited, sandboxed environments with high on-chain cost per operation.
• Cartesi Machine: Full Linux environment, unbounded computation off-chain, standard toolchain.
• Key Difference: The EVM is the execution environment. Cartesi uses the VM to generate a proof about an execution, which is then verified on-chain.

The core function is providing verifiability for any computation run on its Linux OS. Developers can write code in standard languages (Python, C++). The machine produces a cryptographic hash of the entire computation state. If a result is disputed, the blockchain can adjudicate by recreating the precise execution steps, enabling trustless collaboration on complex tasks without centralized servers.

Applications feed data into the Cartesi Machine via the Cartesi Rollups framework. Inputs are recorded on the base layer (e.g., Ethereum, Polygon) as calldata, ensuring data availability. The machine processes these inputs in a deterministic order, allowing any observer to reconstruct the exact state. This mechanism is crucial for applications requiring reliable external data, such as decentralized exchanges or oracle computations.

When participants disagree on a computation's result, the Cartesi Machine enables an optimistic rollup-style dispute resolution. The system performs a binary search over the execution trace to pinpoint the first step of disagreement. This "fault proof" is then verified on-chain in a single step, minimizing gas costs. This makes it economically secure to run arbitrarily large computations.

The machine's state is defined by a machine snapshot hash, encapsulating the entire OS, libraries, and application code. This creates a portable and reproducible computational environment. Any party can instantiate an identical machine from this hash to verify results independently, eliminating "it works on my machine" problems and ensuring deterministic execution across all nodes.

By providing a full Linux runtime environment, Cartesi allows developers to use mainstream software stacks (e.g., Node.js, TensorFlow, NumPy) without rewriting for a constrained EVM. This drastically lowers the barrier to entry, enabling the porting of existing open-source libraries and tools directly into decentralized applications, unlocking new use cases in DeFi, gaming, and data science.

A virtual machine that, given the same initial state and input, will always produce the same final state and output. The Cartesi Machine is a deterministic VM, which is critical for:

• Consensus: All nodes can independently compute and agree on the correct result.
• Verifiable Computation: Enables the creation of succinct proofs that a computation was executed correctly.
• Trustlessness: Removes the need to trust a single operator's computation.

A rollup instance dedicated to a single decentralized application (dApp), powered by its own Cartesi Machine. This architecture provides:

• Sovereignty: The dApp has its own execution environment and state, isolated from other applications.
• Flexibility: Developers can choose their own virtual machine configurations and consensus parameters.
• Scalability: Computation and storage are not shared, preventing congestion from other dApps.