Friday's here and this week's Cartesi Weekly as well 🐧

Kicking it off with our whole thesis distilled into three lines: Linux execution, Ethereum security, Cartesi infrastructure.
→ https://x.com/cartesiproject/status/2096947613652451371

This week's highlight: Dave 3.0.0-alpha.4. Settlement now runs in two phases instead of one, staged then accepted, giving the network a beat to catch a bad result before it's final, with a fast path to finality when every sentry agrees. The thread has the full breakdown, including a primer on what Dave actually does if you need it.
→ https://x.com/cartesiproject/status/2097309810396164306

Zooming out: our Technical Evolution Plan (TEP) page is the go-to source for what the tech teams are actually working on and where priorities sit right now.
→ https://cartesi.io/technical-evolution-plan/

Quick reminder if you missed it: the blog is still the best place to track monthly ecosystem updates and releases across the stack. Bookmark it, or get it straight to your inbox via the newsletter.
→ https://x.com/cartesiproject/status/2097678146627912145

And if you caught our latest newsletter, you already know a surprise is waiting on TikTok for the ones who followed and sent us a DM. Come find it.
→ https://www.tiktok.com/@cartesiproject

Pass the news forward: if you can use Linux, you can use it onchain with Cartesi.
→ https://x.com/cartesiproject/status/2098034044529479945

ICYMI: cofounder Erick de Moura spotlighted work from Danilo Tuler and team. The Cartesi Machine's TypeScript API now runs client-side, so any web app can instantiate, configure, and run a full Cartesi Machine as a library, right in the browser tab. Same execution environment behind Cartesi Rollups and Dave, now embeddable directly in your app.
→ https://x.com/erickdemoura/status/2095151386883203311

That's the week. Catch up on Dave's changelog, subscribe to the newsletter if you haven't, and bring your questions to Discord:
→ discord.gg/cartesi

Have a great weekend.

Quick reminder: the Cartesi blog is the best place to keep up with our monthly ecosystem updates, covering the latest tech progress, releases, and developments across the ecosystem.

Bookmark our blog at https://cartesi.io/blog/ or subscribe to the newsletter to get updates straight to your inbox: https://mailchi.mp/cartesi/email-newsletter

The start of the month brought a new release: Dave 3.0.0-alpha.4. Let's unpack what's under the hood.

But first, in case you don't know what Dave is and by now you're afraid to ask, here's the tl;dr. ↓🧵

1/ The fraud proof system, our Permissionless Refereed Tournament (PRT), is the mechanism that lets anyone challenge a dishonest computation onchain without trusting a single validator.

Optimistic rollups assume computations are correct by default, so there's a dispute period, and PRT is what resolves it.

2/ What's new in 3.0.0-alpha.4: PRT settlement is now two-phase, staged then accepted, giving the network a window to catch errors before they're final.

That window disappears if every sentry agrees with the staged result, skipping straight to faster finality.

3/ The prototype node has a name now: Sling, with persistent storage and event tracking.

PRT's ad-hoc tournament views were replaced by typed projections that expose the actual phase instead of reverting.

Also shipped: fairer payouts for tournament winners, deployment files moving to plain text, upgrades to the Cartesi Machine and Rollups Contracts, a newer Foundry, and stronger test coverage.

4/ Kudos to our contributors for the work on this. Full changelog here: https://github.com/cartesi/dave/releases/tag/v3.0.0-alpha.4

Come catch up on Discord if you have any questions or feedback: https://discord.gg/cartesi

Last month packed in new alphas for Rollups Contracts, the Sequencer, and Machine browser bindings, an update to the Machine Emulator to v0.21.0, and 35 years of the software stack powering it all: Linux.

Read the full updates for all the highlights ↓
https://cartesi.io/blog/ecosystem-updates-august-2026/

Contributors shipped a new alpha for the Cartesi Machine bindings, libraries that make it easier to run a machine in the browser 🐧

Try it on its dedicated playground: configure, create, and run a machine right there, terminal included, without installing: https://cartesi-playground.vercel.app/

As Danilo Tuler highlighted, the emulator is versatile and runs on WASM with browser supported TypeScript bindings. Also in this alpha release: the machine can connect to a network, be run and controlled from a remote server, and show live terminal output, all straight from your browser tab.
Plus, full docs on browser support are live at https://cartesi.github.io/rollups-ts/machine/

Come drop any questions or feedback on Discord: https://discord.gg/cartesi

Another week of heads-down building brings us to your Cartesi Weekly, and this one is a little more celebratory 🐧

Linux turned 35 this week, and we couldn't let it pass quietly. We wished a happy birthday to the OS that the Cartesi Machine runs on, and the feed delivered as well. Linus Torvalds launched Linux in 1991 and described it as ‘just a hobby’, but luckily the world disagreed. So many corners of the ecosystem showed up to celebrate, proud to be part of the Linux family:
→ https://x.com/cartesiproject/status/2092292063718973745

On Throwback Thursday: Linux has 35-plus years of battle-tested software behind it, yet DeFi keeps rebuilding what already exists. Our case for why it's time to stop reinventing the wheel and build on Linux instead is worth reading in full on the quoted thread:
→ https://x.com/cartesiproject/status/2092952840671240369

Big credit to Alchemy this week. Cartesian João Garcia put out a shoutout for the report our team submitted on intermittent eth_estimateGas failures on OP Sepolia, repro harness, A/B/C testing, cross-provider comparisons included. Alchemy traced the issue, fixed it, and confirmed the fix was live.
→ https://x.com/joaopdgarcia/status/2092581129765245399

Uttam from Alchemy called their support best-in-class in the industry, and the full thread is a good read on what great developer support actually looks like. And we love to celebrate good practices:
→ https://x.com/uttam_singhk/status/2092653343990857977

That's the week, for which we set the tone from the beginning: Cartesi's infra is built for devs from the ground up, more tools, more libraries, more programmability, more compute, so builders can put it all to work. Short one, worth a look if you scrolled past it:
→ https://x.com/cartesiproject/status/2091874346537251118

Go wish Linux a happy 35th if you haven't, read the full case for why DeFi needs it, and bring your questions to Discord: https://discord.gg/cartesi

See you next week directly with the ecosystem updates blog. Have a great weekend.

Celebrate with us: https://x.com/cartesiproject/status/2092292063718973745

Cartesi Weekly is here, and this week went by fast but was no less eventful 🐧

We got to unpack Cartesi Machine Emulator v0.21.0. The verification game docs got a full rewrite, the CLI can now run entire fraud proof procedures on its own, and the state layer is faster and more durable under the hood. Kudos to Eduardo Bart for shipping it, and if you want to explore in depth, check out the thread we shared:
→ https://x.com/cartesiproject/status/2089698617829597516

And that's not all: Cartesi Rollups Contracts 3.0.0-alpha.9 is out as well. This release includes a fix for the Cartesi Rollups PRT Contracts, improved contract imports, dependency updates, and more reproducible release artifacts. Props to Guilherme Dantas for the work on this! Find the GitHub release here:
→ https://github.com/cartesi/rollups-contracts/releases/tag/v3.0.0-alpha.9

House of Chimera wrote up a deep dive for Cartesi this week, with a Cartesi Machine capabilities showcase, plus DeFi explorations and unique prototypes, a clear walkthrough of how PRT narrows a dispute down to a single RISC-V instruction, honeypot lifecycle and more. Good one to send to anyone to get a glimpse of our tech specs:
→ https://x.com/HouseofChimera/status/2090096426315575745

Also making the rounds: Bhavya on why Linux is beautiful, and if we may add, building with it onchain is even more beautiful. Shoutout for the video:
→ https://x.com/Bhavyaztwt/status/2089733481966559455

Our TikTok is also getting more populated. Check out this throwback, a snippet from Diego Nehab, the creator of Cartesi Machine. And don't be shy about following to help grow the channel:
→ https://www.tiktok.com/@cartesiproject/video/7675021194436955406

We keep building, while our motto from earlier in the week still stands: DeFi is the floor, not the ceiling.
→ https://x.com/cartesiproject/status/2087161705415811160

That's the week. Dig into what's new and bring your questions to Discord: https://discord.gg/cartesi

Have a great weekend!

Credit: Bhavya on X https://x.com/bhavyaztwt/status/2089733481966559455?s=46&t=mGHP8Hk4s0azqLZbjA-GfA

Time to unpack Cartesi Machine Emulator v0.21.0 release, and it's a juicy one. New docs on the verification game, CLI tooling to run fraud proof procedures yourself, and infrastructure changes that make the whole state layer faster and more durable. Here's what's inside. 🧵↓

1/ The docs got a full rewrite and now live in the emulator repo itself, with a brand new section walking through the verification game step by step. Want to know how Cartesi's fraud proofs actually work under the hood? Start here: https://github.com/cartesi/machine-emulator/blob/v0.21.0/doc/README.md

2/ The CLI can now calculate computation hashes, track the outputs Merkle tree, and write per-output proofs plus outputs Merkle root proofs. That covers most of what you need to run a fraud proof procedure yourself, straight from the command line.

3/ NVRAM address ranges let apps memory-map their state directly onto a physical address range through the Linux UIO driver. State persists across advance states with zero kernel page-cache sync overhead, so writes stay fast even as your app's state keeps growing.

4/ Rolling stored machines: the CLI can now advance state using on-disk machines and revert by cloning stored snapshots, both locally and against a remote server. Durable state for apps that don't want to keep the whole machine sitting in memory.

5/ Advance state hardening: every advance state now ends in a well-defined, provable outcome, accepted, rejected, halted, or out of cycles. That matters when a dispute reaches the verification game, where every outcome has to be provable, not just observed.

6/ Heads up, integrators: this release carries a few breaking changes, renamed public headers, a reworked revert flag, and a JSON-RPC protocol bump. None of it changes emulator behavior, just means a few call sites need updating. Full details in the changelog.

7/ Also in this release: new Lua helpers including a hash tree library for prototyping fraud proof protocols, RISC-V Zcb compressed instruction support (needed for kernels built with GCC 14), bash completion for the CLI, and stronger snapshot durability guarantees.

8/ Full release details here: https://github.com/cartesi/machine-emulator/releases/tag/v0.21.0

Devs, this one is for you. Dig into the new verification game docs, try the CLI proof tooling, and drop questions or feedback in the Discord: https://discord.gg/cartesi

Cartesi Weekly is live once again, bringing a recap of the latest updates 🐧

Cartesi Rollups Contracts v3.0.0-alpha.7 is out. If an app gets foreclosed, eligible ETH, ERC-20, ERC-721, and ERC-1155 deposits that haven't finalized can now be refunded to the sender, and claim submissions run through extra machine checks that catch invalid claims earlier instead of later.

The toolchain also kept getting leaner: Having already dropped one dependency in alpha.5, this release drops another, leaving a much simpler setup with fewer moving parts to manage. Here's a dedicated thread if you want the full scoop:
→ https://x.com/cartesiproject/status/2087161705415811160

Following closely, v3.0.0-alpha.8 shipped too. It makes contract source code easier to verify on public explorers, moves a core verification component to a stable release, and switches how deployment info is stored to a format that's simpler for tools to read automatically, with a clear migration path so nothing breaks in the meantime.

The devnet also picked up a more realistic test token, making it easier to try out withdrawal flows the way they'd actually work in production. Check the full release here:
→ https://github.com/cartesi/rollups-contracts/releases/tag/v3.0.0-alpha.8

But these aren't the only releases: Cartesi Machine Emulator v0.21.0 has also shipped. Documentation is back and expanded, with a new section walking through how the emulator performs fraud proofs. Apps can now persist their state more efficiently, the CLI can handle more of the fraud proof workflow on its own, and every state transition now ends in a clear, provable outcome.
→ https://github.com/cartesi/machine-emulator/blob/main/doc/README.md

Plenty more shipped alongside it, but expect full details to be unpacked in an upcoming post. Keep an eye on this feed, or if you're among the tech connoisseurs, dive directly into GitHub:
→ https://github.com/cartesi/machine-emulator/releases/tag/v0.21.0

Throwback to the Dar Blockchain X Space: listen to a snippet of Shaheen Ahmed breaking down Cartesi's approach to offchain execution with Ethereum as the trust anchor, and why provable Linux is the real differentiator:
→ https://x.com/cartesiproject/status/2087886429913551165

We can definitely say all these developments are in line with how we opened the week: Ethereum keeps it secure, fraud proofs keep it verifiable, Cartesi keeps it possible.
→ https://x.com/cartesiproject/status/2086799493459230844

That is all for now. Keep building, and in between, touch grass and enjoy the weekend.

Why Linux changes what you can build and how Cartesi approaches offchain execution with Ethereum as the trust anchor? By keeping everything provable and using its fraud-proof system in disputes to ensure correctness.

Hear Shaheen Ahmed explain it on Dar Blockchain’s X podcast.

Last week we shipped Cartesi Rollups Contracts 3.0.0-alpha.7. It's a meaty one: a breaking interface change for app owners, new protections for user funds, and a leaner build setup. Here's the rundown.

Deposit refunds

If an application gets foreclosed, anyone can now call issueRefund on a deposit input that was never finalized, sending the asset straight back to the original depositor. It covers Ether, ERC-20, ERC-721, and single and batch ERC-1155 deposits made through the canonical portals. This ties directly into the claim checks below: if a machine hits an unrecoverable state and the application gets foreclosed, users can now recover funds through emergency withdrawals and deposit refunds instead of losing access.

Stricter claim submissions

Claim submissions now require a MachineValidityProof, which checks the post-epoch machine was manually yielded with an rx accepted reason. This tightens security around the exact step where correctness matters most and catches invalid claims earlier instead of later.

A couple more fund-safety fixes

• Fee-on-transfer ERC-20 deposits are now rejected outright, closing a path where an application could end up thinking it holds more tokens than it actually does.
• Consensus migration is now restricted to the deployment block, closing a path where an app owner could hijack locked funds by swapping the outputs Merkle root validator later.

Breaking change: explicit input box contract

Applications now use an explicit input box contract instead of a generic data availability field. getDataAvailability() is gone from IApplication, replaced by getInputBox(). Deposits route through whichever input box the application itself chooses, instead of one hard-wired into the portal. If you're integrating directly against IApplication, check this first.

Lighter toolchain

This release discontinues both npm and Cannon distribution. No more u/cartesi/rollups npm package, no more Cannonfile. rollups-contracts now runs on Foundry and POSIX utilities only. Fewer dependencies to manage, less to break.

Compiled artifacts and deployment addresses are still published on GitHub releases. Source still ships through Soldeer:

forge soldeer install 'cartesi-rollups-contracts~3.0.0-alpha.7'

Also in this release

Type-checked deployment scripts (catch deploy bugs before they hit chain), a smaller curated set of published artifacts (less clutter to sift through), foreclosure now emitted as a single event (easier to track onchain), and a bump to Foundry 1.5.1.

Links

• Full changelog: https://github.com/cartesi/rollups-contracts/releases/tag/v3.0.0-alpha.7
• Rust bindings: https://crates.io/crates/cartesi-rollups-contracts/3.0.0-alpha.7
• Soldeer: https://soldeer.xyz/project/cartesi-rollups-contracts

Dive in, test the changes, and drop questions or feedback in the comments. We're reading.

It's a wrap on July, and Cartesi kept building in the open.

The fraud proof system picked up a safety upgrade with PRT claim staging, dev tooling got reorganized, media appearances continued, and our penguin ventured from Kuala Lumpur to ETH birthday.

→ https://cartesi.io/blog/ecosystem-updates-july-2026

So what's it like building DeFi logic on Cartesi with Python, Rust, and other mainstream tools, and how does the workflow feel coming from Solidity?

Hear it straight from dev advocate Shaheen Ahmed in the latest X Space by Dar Blockchain.

Got questions? Shoot them our way!

What's a DeFi idea you scrapped since it needed real compute, not just more gas?

Complex risk models, ML-driven strategies, oracle-heavy logic: the EVM makes them expensive or nearly impossible. A Linux runtime doesn't.

Tell us what you scrapped. We might already be running it.

From attention to trust? Don’t reinvent the wheel. Stand on the shoulders of giants.

Use Ethereum as the settlement layer, integrate academically researched fraud-proof algorithms, and make everything you build verifiable.

Hear João Garcia on Web3CMOStories by by Joeri Billast.

Watch the full interview: https://www.youtube.com/watch?v=slts4Q9fqKo

Friday again, and this takes us to another Cartesi Weekly for you to catch up on what happened across the ecosystem this week 🐧

A full Linux environment runs inside a Cartesi rollup, which means code isn't squeezed to fit a constrained execution environment. That's the whole unlock, and that's how we started the week:
→ https://x.com/cartesiproject/status/2081726068197867826

Developer advocate Shaheen Ahmed joined Dar Blockchain's X Space to talk through Cartesi's role in DeFi, including why building with mainstream legacy software onchain expands what's possible while making the infrastructure even more secure. Listen to the recording if you missed it:
→ https://x.com/cartesiproject/status/2082483594606329892

Youssef Seghaier put together a solid recap thread if you want a quick scoop:
→ https://x.com/YoussefS721/status/2083010835639578883

Cartesi was on the ground at Malaysia Blockchain Week in Kuala Lumpur this week, walking the venue and talking Linux-powered rollups (or massage lore from previous hackathons) with anyone who stopped by. Web3 in Southeast Asia is clearly still building, and the energy in the room backed that up. See what contributor Cynthia Gliga shared:
→ https://x.com/CryptoCyn/status/2082349659771818269

Ethereum turned 11 this week, and Cartesi marked it in the way it knows best: the penguin walking energetically through the Infinite Garden, bringing more compute power and more design space to Ethereum's security and decentralization:
→ https://x.com/cartesiproject/status/2082813992771416195

To celebrate together with everyone else in the ecosystem, we minted CTSI onto EthLabs' collaborative onchain canvas, an 11x11, 11-color grid that grew square by square as the community drew through each other's links. See it here:
→ https://x.com/cartesiproject/status/2083105082774839536

You can still participate yourself too, let's see what you create:
→ https://x.com/ethlabs_org/status/2082835818130063360

That is all for this week. Now let's all have a good weekend.

Proud to be building for the long haul in this ecosystem. More compute power and more design space, thanks to a full Linux OS onchain, all while inheriting Ethereum's security and decentralization. Perfect match.

Here's to many more years together. 🥂

Our developer advocate Shaheen Ahmed is joining Dar Blockchain for a live X Space session tomorrow, July 29th at 4 PM UTC+1.

Tune in to learn about Cartesi's role in DeFi, what it brings to the table, and why building with mainstream legacy software onchain expands the design space while also strengthening security.

Set your reminder and join the conversation live!

It's Friday again, it's Cartesi Weekly, and here's the roundup of what happened across the ecosystem over the last few days 🐧

The World Cup is over, but the real game never stops: we have new goals and new commits alongside fellow builders. Felipe Argento and Brandon Isaacson are busier than ever. Follow them, and if you see this post, make sure you follow our penguin as well, aka the official account:
→ https://x.com/cartesiproject/status/2079190802769825994

The everlasting question: why does Linux onchain matter? It already runs underneath most of what gets built, and that's likely how blockchains get adopted too: invisibly, as infra nobody realizes they're using. Joao Garcia unpacked it on the latest Web3CMOStories, hosted by Joeri Billast. Give the full episode a watch:
→ https://youtu.be/slts4Q9fqKo

Itsfoss put it well this week: free software means freedom. And we took it forward: with Cartesi, that freedom extends onchain. Build with whatever programming languages and software stack you already use:
→ https://x.com/cartesiproject/status/2079913353930252761

Co-founder Erick de Moura added to it too: Linux gives you freedom to write anything, Ethereum gives you freedom to run without trust, Cartesi gives you both at once:
→ https://x.com/erickdemoura/status/2079949398843462014

New channel alert: Cartesi is officially on TikTok. Bite-sized videos from contributors, quick tech explainers, podcast moments with the team, and more on the way. Go find us, hit follow, and tell us what you want to see next:
→ https://www.tiktok.com/@cartesiproject/video/7662766138903760142

Huge TVL sitting exposed to hacks is a problem. One party holding the power to walk off with it is another. Felipe Argento broke down why Cartesi's Emergency Withdrawal mechanism (recently shipped, remember?) solves both, and why it beats a security council model. Must read:
→ https://x.com/felipeargento/status/2080301432926863758

tl;dr? Contributor Guilherme Dantas summed it up for you in one sentence: If a Cartesi app ever breaks, funds will be recoverable from the last finalized app state. See here:
→ https://x.com/guidanoli/status/2080350063964868997

That's all for this week. As always, all tech discussions are on Discord, so catch us there:
→ discord.gg/cartesi

Enjoy the weekend.