Cartesi primary sources — 2026-05-12

Classification takeaway

Cartesi is best cataloged as optimistic off-chain compute and Linux-rollup infrastructure rather than as a generic L2 or generic appchain brand. Its key reusable mechanism is the split between base-layer rollups contracts, a deterministic RISC-V Linux execution machine, and node middleware that turns on-chain inputs into proof-carrying outputs. The most important analytical caveat in the current materials is that Cartesi’s permissionless fraud-proof path is explicit but still separate from the authority-first settlement posture described in parts of the current rollups stack.

Primary sources reviewed

1. Cartesi Rollups overview — https://docs.cartesi.io/cartesi-rollups/1.5/

   • Best first-party overview of the rollups architecture.
   • Explains that Cartesi Rollups execute a deterministic RISC-V Linux machine off-chain, fed by ordered inputs read by the node, with outputs becoming verifiable and possibly executable on the settlement layer after the dispute window.
   • Important because it shows Cartesi is application-specific rollup infrastructure, not just a generic scaling token or middleware SDK.

2. Cartesi Rollups architecture docs — https://docs.cartesi.io/cartesi-rollups/1.5/core-concepts/architecture/

   • Best source for the explicit layer split.
   • Separates on-chain components (InputBox, CartesiDApp, factory, portals) from the off-chain layer (Rollups Node plus Cartesi Machine) and names the output types and query surfaces.
   • Important because it makes the real control surface legible: base-layer input ordering, asset relay paths, node behavior, and output publication.

3. Cartesi Machine docs — https://docs.cartesi.io/cartesi-rollups/1.5/core-concepts/cartesi-machine/

   • Best source for the execution environment itself.
   • Describes the Cartesi Machine as a deterministic RISC-V virtual machine that runs an entire Linux OS in isolation and processes requests as reproducible state transitions.
   • Important because it explains why Cartesi should be compared against other verifiable-compute and rollup-execution frameworks rather than only against ordinary EVM L2s.

4. Cartesi Rollups Contracts docs/book — https://cartesi.github.io/rollups-contracts/

   • Best source for settlement and contract-level posture.
   • States that the contracts provide data availability, consensus, and settlement to Cartesi Rollups applications; are permissionless to deploy on any EVM chain; and currently implement authority-based and quorum-based settlement modules while planning future support for Dave fraud proofs.
   • Important because it surfaces a transitional architecture: modular settlement exists today, but the fully permissionless fraud-proof path is still a distinct track.

5. Cartesi Rollups Node README — https://github.com/cartesi/rollups-node

   • Best source for middleware responsibilities and current validator reality.
   • Explains that the node reads advance-state inputs from contracts, sends them to the Cartesi Machine, stores vouchers / notices / reports, exposes GraphQL and REST APIs, bundles inputs into epochs, and currently supports only the Authority consensus mechanism when closing epochs and submitting claims.
   • Important because it shows where practical authority still sits in the current stack: validator choice, epoch closure, and claim submission.

6. Cartesi Machine Emulator README — https://github.com/cartesi/machine-emulator

   • Best implementation-facing source for the VM and verification model.
   • Describes the emulator as the basis of Cartesi’s verifiable computation framework: deterministic, portable, high-performance RISC-V emulation with Linux support, state Merkle trees, transition access logging, cycle-level execution control for interactive fraud-proof bisection, and optional RISC Zero integration.
   • Important because it grounds the system in concrete execution and proof primitives instead of only high-level product language.

7. PRT introduction docs — https://docs.cartesi.io/fraud-proofs/prt/prt-introduction/

   • Best source for the permissionless fraud-proof branch.
   • Explains that Permissionless Refereed Tournament (PRT) replaces player-bound final-state claims with computation-hash commitments and bracket-style disputes, specifically to avoid Sybil fragility in naive many-player fraud-proof systems.
   • Important because it gives Cartesi a distinct comparison point against both classic optimistic-rollup dispute games and newer validity-proof stacks.

8. Official whitepaper — https://cartesi.io/cartesi_whitepaper.pdf

   • Canonical first-party design document.
   • Useful as the original framing for the Cartesi Machine, blockchain interface, node interface, and off-chain computation-verification model. Downloaded locally as cartesi-whitepaper.pdf.

Why it stays in the active corpus

• Cartesi adds a distinct lower-bound branch for application-specific rollups that want full Linux execution rather than contract-only logic.
• It makes the control-plane split unusually legible: inputs and assets come through base-layer contracts, execution happens in a deterministic Linux VM, and practical coordination happens through node middleware and settlement modules.
• It is especially useful because the current materials do not flatten the transition problem: they show both the permissionless fraud-proof aspiration (PRT / Dave) and the authority-first reality of parts of the deployed stack.

Follow-up comparison threads

• Compare Cartesi directly against RISC Zero / SP1 / Boundless so optimistic off-chain Linux execution, zkVM proving, and proving-market layers do not get flattened together.
• Compare Cartesi directly against optimistic-rollup fault-proof systems so full-OS execution, dispute games, and validator / epoch-control surfaces remain explicit.
• Compare Cartesi directly against app-specific rollup frameworks and execution-coprocessor stacks so portal design, middleware dependence, and settlement-module choice do not disappear into a generic L2 label.