Cartesi Ecosystem Updates - March 2026

Newsletter/Mar 27, 2026/Marketing Unit

As March comes to a close, so does Q1 2026, and the quarter had a clear through-line: progress continued and the ecosystem moved forward. We kept building, testing, and shipping.

Meanwhile, conversations about what DeFi actually needs from its infrastructure, and what an expressive and performant execution environment unlocks for developers, are gaining traction. Cartesi is well equipped to address these challenges and empower builders to fully realize what DeFi can be, advancing our mission to help Web3 reach its true potential.

Keeping up with tradition, it’s time again to revisit what contributors delivered across tech, dev tooling, community, media, and more. Let’s dive into the past month’s key updates.

Tech

March delivered strong progress on the infrastructure side. The latest release of the Cartesi Rollups Node(v2.0.0-alpha.10) prioritizes making the system more robust and reliable for developers and operators running applications in production.

A key theme of this update is stability under pressure. Improvements to database transaction safety mean that data integrity is better protected during complex or high-load operations. Alongside this, smarter shutdown behavior ensures that long-running processes and multi-application deployments can wind down cleanly, reducing the risk of data loss or inconsistent states when things stop unexpectedly.

For operators managing infrastructure at scale, the update introduces per-service log levels, giving teams more granular visibility into what each component of the node is doing. Rather than sifting through a single stream of output, operators can now tune logging to exactly the level of detail they need, per service.

The CLI has also been extended with new commands for inspecting tournaments, commitments, and matches, making it easier to monitor and debug the fraud proof system directly from the command line. Rounding out the release, more accurate error handling and reporting means issues surface faster and with clearer context, shortening the feedback loop when something goes wrong.

Recent alpha releases of the Cartesi CLI (v2.0.0-alpha.32 and 33) focus on streamlining the developer experience and ensuring environment consistency. The CLI has been updated to support the latest core components, including Rollups Node alpha.10, Rollups Contracts v2.2.0, and PRT v2.1.1, ensuring developers are working with the most current stack.

A new version of PRT, Cartesi’s permissionless dispute mechanism, has been released to improve the reliability of the fraud-proof system.

Version 2.1.1 introduces a fix to the bond refund process. In a permissionless dispute system, participants put up bonds when submitting or challenging claims. Getting those refunds right is critical to keeping the system fair and trustworthy, and this update ensures participants are correctly reimbursed once disputes are resolved.

Beyond this, the release includes fixes for Docker environments, smoothing out a common friction point for teams setting up or running PRT locally and in production. Updated configuration files further reduce the setup overhead, making it simpler to integrate PRT with the broader Cartesi ecosystem.

Taken together, these changes reflect a continued focus on making Cartesi infrastructure production-ready for the teams and projects building on top of it.

Developer Advocacy

Dev advocacy team slayed throughout March, wrapping up the DeFi content series started last month with its six-episode run, and a stream of demos, resources, and educational threads keeping the builder momentum going.

Contributor João Garcia shipped the last three episodes on why the execution environment matters for DeFi. The fourth video explored how Cartesi enables stateful application logic that can match TradFi-level performance while moving beyond typical L1 constraints. The fifth unpacked the execution layer constraints holding DeFi back, and how Python, NumPy, and PyTorch become usable onchain through Cartesi's Linux environment. The sixth made the case for app-specific rollups and why dedicated compute per dApp matters for computation-heavy financial systems.

Catch the full series on YouTube Shorts:

On the demos front, a new tutorial showed how to integrate NumPy into Cartesi apps, enabling advanced numerical computing, matrix operations, and scientific calculations directly in your app. The message is simple: if it runs on Linux, it can run onchain:

A bounding curve demo also dropped, walking through how to integrate bonding curves into Cartesi apps for onchain price discovery driven purely by buys, sells, and the algorithm:

Contributor Shaheen Admed shipped fresh code snippets for Rust, Go, and C++, alongside vibe coding resources, removing any remaining excuse not to build DeFi your way in the language of your choice. Shaheen also walked through all the CLI commands for the Rollups pre-release, helping developers get up to speed ahead of the production-ready final release:

And speaking of that, testing has taken center stage, with contributors pushing the SDK to its limits. Curious dev minds can explore the findings in this Discord channel.

Rounding out the month, a benchmarking thread laid out the compute power of the Cartesi Machine in concrete terms, covering useful instructions per block, throughput, compute cycles, and what a full Linux OS running on a dedicated appchain actually unlocks for builders:

Ecosystem

On the ecosystem front, one of the features currently in active development is recoverable app funds, a safety mechanism designed to give DeFi applications built on Cartesi a meaningful protection layer.

The idea is simple: if something goes seriously wrong with an application, a trusted party can step in, freeze the app, and ensure users can still get their money out based on the last confirmed state. In a nutshell, think of this as an emergency off-switch that protects users without erasing the record of who owns what.

In practice, this trusted party would be a multi-sig wallet, meaning multiple people need to agree before any action is taken, keeping the process secure and accountable. The app enters a protected mode where no new activity is allowed, but existing balances remain accessible and provable. Developers who want full autonomy can also opt out of the feature entirely.

This is still being specified and refined, but the direction is clear: serious DeFi infrastructure needs serious recovery guarantees, and this feature is how Cartesi delivers them.

PRT Honeypot v2 is still standing: a live, real-money security challenge specifically built to test what it would actually take to break a rollup's fraud-proof system on mainnet, where anyone can try to drain the pot to their own wallet and directly stress-test Cartesi's PRT fraud-proof system.

The catch: only the Cartesi Foundation can actually withdraw. 50,000 $CTSI are sitting in a contract, permissionless and open to anyone who thinks they can crack it, with the pot expected to grow throughout the year.

The fraud-proof system hasn't been broken once. Beyond the bounty, Honeypot v2 holds another distinction: it is one of the few rollups to have reached Stage 2 maturity on L2BEAT, making Cartesi one of a small group of projects to have reached this milestone.

Community

On the community side, March was a reminder of something easy to take for granted: the people building with and around Cartesi are genuinely here for it. Resilient ecosystems are built by people who stay engaged when it matters, and ours did. There’s no shortage of penguins, and we love spotting community creations on the feed. Here’s one of our favorite little gems to share with you:

Have you met our companion yet in the Telegram group? The Cartesian Plushie AI is part of the conversation, jumping into chats, sharing insights, and adding a bit of personality along the way. If you haven’t interacted with it yet, now’s a great time to join our Telegram community and have some fun.

Media

On the media front, the series shipped by our DevAd Lead, João, wrapped up, capping a quarter of technical storytelling aimed at builders and researchers who care most about execution environments.

Its core idea highlighted that with Cartesi, DeFi can be built around what finance actually needs rather than what the blockchain can run. Floating-point math is viable onchain, enabling robust pricing and risk models. NumPy, QuantLib, and the full quantitative finance stack are now accessible to web3 developers. Stateful, long-running financial processes can run onchain. A full Linux environment brings real languages and mature libraries while staying verifiable on Ethereum, and app-specific rollups let computation-heavy financial systems scale independently without competing for blockspace.

The execution layer is the conversation we should've been having all along, and the content resonated with thought leaders on X, who went on to amplify these reflections:

The demos published resonated as well, and we loved the conversations they sparked, the engagement they earned, and the way the connoisseurs highlighted that primitives from traditional software, brought verifiably onchain, are exactly the ground where Cartesi innovates:

Finally, to provide more context for our audience, we reshared an explainer video on app-specific rollup architecture, a must-watch for anyone willing to understand more about building computation-heavy applications:

That’s a Wrap

That's it for March and for Q1. From node releases and SDK news, to DeFi education and live demos, the ecosystem kept moving across every front. April is already lined up. Stay tuned, and if you haven't yet, subscribe to the newsletter for a chance to get some Cartesi merch delivered to your door, as another merch box is hidden in this month's edition.

In the meantime, keep building and keep the conversations going. Join the community on Discord, follow the latest on X, and find us across all channels here: https://linktr.ee/cartesi

Keep building with Cartesi and contributing to further strengthening our appchain framework and Ethereum's rollup ecosystem.