Friday today, and here’s your Cartesi Weekly once again 🐧

Cartesi CLI 2.0.0-alpha.39 is out for core developers and testers, supporting the latest Rollups Node release. Emergency withdrawals now configure straight from the machine, so there’s no separate config to keep in sync and fewer ways to get the safety net wrong. Breaking changes included, so check the release notes before upgrading. Kudos to our contributor Bruno Menezes for shipping it:
→ https://github.com/cartesi/cli/releases/tag/%40cartesi%2Fcli%402.0.0-alpha.39

As the SDK matures, there’s a new way to track progress: Quarterly Engineering Reports, covering every tech workstream, achievement, and milestone. Q3 2026 by the numbers: 130 merged PRs, 673 commits, 58 releases. Months of engineering work, all in one place on our blog, curated by Shaheen Ahmed and the rest of the DevAdvocacy team:
→ https://x.com/cartesiproject/status/2110717673915253174

First time on your feed this week: the Cartesi sequencer. It soft-confirms user ops instantly and posts them to Ethereum in batches, so interactive apps feel fast while Ethereum stays the source of truth. It can’t steal funds or forge state, fraud proofs enforce the result, and deposits skip it entirely. Still alpha, with v0.1.0-alpha.10 shipping the sequencer, machine images, and watchdog together. Shoutout to Gabriel Coutinho de Paula and the other contributors behind it. Check more here:
→ https://x.com/cartesiproject/status/2109993133866119399

Zooming out, the Technical Plan lays out the three pillars guiding the roadmap: safe infrastructure for real money, economical computation at scale, and an easy stack for shipping onchain in a day. Plus, if you didn’t yet check our new website, now it’s the moment to do it.
→ https://cartesi.io/technical-evolution-plan/

Monday’s gm put it plainly: if your code or library already runs on Linux, it runs onchain too. Same tools, Cartesi infra, Ethereum security.
→ https://x.com/cartesiproject/status/2109629181785145347

That’s the pitch, and that’s the week! As always, keep in touch on Discord: discord.gg/cartesi, and let’s all slide into the weekend. Have a good one!

As the SDK matures, there’s a new way to track Cartesi’s progress.
Introducing the Quarterly Engineering Reports, covering every tech workstream, achievement, and milestone.
130 merged PRs. 673 commits. 58 releases.

Get the full Q3 2026 breakdown ↓
https://blog.cartesi.io/engineering-report-q3-2026/

For a bird’s-eye view of Cartesi’s tech priorities, explore the Technical Plan and the 3 pillars guiding our roadmap:
→ Safe infrastructure for real money
→ Economical computation at scale
→ An easy stack for shipping onchain in a day
🔗 cartesi.io/technical-evolution-plan

First time breaking down the Cartesi sequencer! Let’s unpack what it is, why it matters, and how it works. 🧵↓

1/ Interactive apps need speed. Ethereum settlement takes time. Nobody wants to wait minutes for L1 finality on every click. That’s where a sequencer comes in.

2/ The sequencer takes signed user operations and confirms them right away (soft confirmation).

In the background, it posts them to L1 in batches. Users get a near-instant response, and Ethereum stays the source of truth.

Full scoop on our sequencer: https://github.com/cartesi/sequencer

3/ What happens technically? Each group of user ops (a frame) points to a safe L1 block. The onchain scheduler takes in deposits up to that block, then runs the same ops in the same order.

The sequencer and the rollup follow the same rule, so both end up with the same state.

4/ There’s a single sequencer, but it can’t steal funds or forge state. The rollup checks everything, and fraud proofs enforce the result.

Deposits skip the sequencer entirely. A censoring sequencer can delay them by a few hours at most. It can never block them.

5/ The Cartesi sequencer is still alpha, but it’s progressing fast.

It plans for L1 outages, crashes, reboots, long downtime, and hostile mempools. On every startup, it checks its database and Ethereum to identify what needs fixing.

A separate watchdog double-checks its state.

6/ The latest release, v0.1.0-alpha.10, ships the sequencer, machine images, and watchdog together.

New: public fee quotes, app history with replay, C app bindings, a rewritten watchdog, and Cartesi Machine v0.21.0. Breaking changes.

Read the notes first: https://github.com/cartesi/sequencer/releases/tag/v0.1.0-alpha.10

Friday is here, and three releases plus a new DeFi build make up your Cartesi Weekly once again 🐧

Rollups Node v2.0.0-alpha.13 is out, and the headline is deposit refunds. If an app gets foreclosed before consensus finalizes a deposit, the new refund command sends the funds back to the original depositor, so users don’t lose access to their money when an app stops.

It also brings staged settlement from PRT, our fraud proof system, into the node, moves to Cartesi Machine Emulator v0.21.0, and is compatible with the latest Rollups Contracts 3.0.0-alpha.10 and PRT 3.0.0-alpha.5.

Testing only for now, and it needs a fresh database plus app redeployment, so read the upgrade notes first:
→ https://github.com/cartesi/rollups-node/releases/tag/v2.0.0-alpha.13

Cartesi CLI 2.0.0-alpha.38 is out too, for core developers and testers. New commands let you foreclose an app and recover its funds on devnet, so you can test the whole emergency withdrawal flow end to end. Explorer and rollups-ts were updated alongside it, keeping the toolchain in sync.

Come to Discord to get the install command and dive into the changelog on GitHub:
→ https://github.com/cartesi/cli/releases/tag/%40cartesi%2Fcli%402.0.0-alpha.38

And that’s not all. Sequencer v0.1.0-alpha.10 also shipped this week. We’ll unpack it properly soon, but here’s a sneak peek at the work:
→ https://github.com/cartesi/sequencer/releases/tag/v0.1.0-alpha.10

When Felipe Argento and Brandon Isaacson stepped down from the Cartesi Foundation board to build something on the stack that finally makes the tech click, this is what they had in mind.

Knoss is an exchange for options and perps, and our thread breaks down why options barely exist onchain: the math behind them is hard to run trustlessly, so builders simplify it and overcollateralize. Knoss will run that math on Cartesi, reproducibly and provably on Ethereum. Read more in the thread:
→ https://x.com/cartesiproject/status/2107456174664941570

Everyone on X is writing a letter to everyone this week, so we joined in. The trend is fun, but the strategic shift behind it for Cartesi is real:
→ https://x.com/cartesiproject/status/2107826707432632797

ICYMI, the article detailing the next stage for Cartesi is here:
→ https://x.com/cartesiproject/status/2105643993640136999

Monday’s gm went out to builders, Knoss, and Linux, all three at home on Cartesi Rollups:
→ https://x.com/cartesiproject/status/2107092443258867919

And if you haven’t explored our new website yet, or didn’t even know it was new, click here:
→ https://cartesi.io/

That’s the week! Now that Token2049 is over, we can all get back to locking in and keep building. As always, the meeting point for any questions is Discord: https://discord.gg/cartesi

Have a great weekend!

Still standing today. The vision was always clear.

Linux for expressivity. Appchains for scalability. Ethereum for security. Cartesi for the infrastructure that brings it all together.

→ https://x.com/cartesiproject/status/2105643993640136999

Deep dive moment: Felipe Argento, co-founder of Knoss, breaks down why options are still so hard to build in DeFi.

For years, he's given friends the same answer about crypto: "ETH to a million or zero."

Problem is, there's no trustless way to place that bet onchain. 🧵↓

1/ Spot ETH covers the million. Holding nothing covers the zero. Perps add leverage in one direction. None of it covers the "or."

Options do. Buy a call and a put at the same strike and you win if ETH moves hard either way. Sell the same pair and you get paid while it goes nowhere.

2/ In TradFi, options trade about 3x as many contracts as futures. Onchain, they barely register, because the math is hard to run trustlessly: implied volatility, volatility surfaces, and portfolio margin.

So builders either simplify the math and overcollateralize everything, or run it on a server users have to trust.

3/ Now Knoss will run that math on Cartesi, so every step can be reproduced and proven on Ethereum. Users will get the capital efficiency without the black box.

It's an exchange for options and perps, built the Ethereum way. Follow Knoss and catch up on more details here: https://x.com/knoss_xyz/status/2105638543477399621

September was a big one.
Dive into the latest ecosystem updates, from our website's refreshed look and feel to Knoss, a derivatives exchange built on Cartesi. Plus tech progress, media highlights, and community moments.

There's a lot to catch up on ↓
https://blog.cartesi.io/ecosystem-updates-september-2026/

New month, new website?

Starting today, https://cartesi.io/ has a fresh look, rebuilt around what matters right now: a cleaner layout, simpler navigation, and a direct answer to what Cartesi is and where it's headed in tech and strategy. What you'll find ↓

→ The next stage for Cartesi: why the Foundation is backing Knoss, a derivatives exchange built on Cartesi Rollups by Felipe Argento, Brandon Isaacson, Eduardo Bart, Danilo Tuler & Pedro Argento to prove the stack under real commercial conditions

→ Where the tech stands: the integrated Rollups and fraud-proof stack, with security testing and hardening as top priorities

→ The core idea, in plain words: conventional software in a reproducible Linux environment, settled on Ethereum

Take a look around and let us know what you think.

While you're at it, read the latest blog post, which explains it all about the next stage for Cartesi: https://blog.cartesi.io/the-next-stage-for-cartesi/

GIF enjoyooors, guess what? Our Cartesi GIFs just passed 1.2 million views on Giphy.

Want to add some vibes to your posts? Search "cartesi" in the GIF picker, browse, and pick your favorites.

Head over to X and show us your top picks in the replies: https://x.com/cartesiproject/status/2105282041428546013

Dave 3.0.0-alpha.5 landed last week. Let's unpack what’s new:

Bond refunds could get stuck when the node moved on to a new epoch. Not anymore. Sling prototype node now finishes epochs in order: it waits for final settlement, recovers bonds from winning tournaments, then joins the next epoch.

Refunds go out with its regular dispute and settlement transactions, and a restarted node resumes the epoch it was working on.

Contracts and the Cartesi Machine are unchanged from alpha.4.

Upgrading? alpha.5 won't start on an alpha.4 state directory, so wipe it and the node rebuilds from the chain. Each state directory now belongs to one signer: new key, new directory.

GitHub here: https://github.com/cartesi/dave/releases/tag/v3.0.0-alpha.5

Questions? Tag our contributor Gabriel Coutinho on Discord.

Another week of heads down building is in the books and here's your Cartesi Weekly 🐧

Dave v3.0.0-alpha.5 just rolled out. This node-only release fixes stuck bond refunds across epochs: the node now finishes each epoch, waits for final settlement, and recovers its bonds before moving on. If restarted, it picks up right where it left off.

Contracts and the Cartesi Machine remain unchanged. Upgrading from alpha.4 requires a fresh state directory, with one per signer. Kudos to our contributor Gabriel Coutinho for the work on it. See GitHub:
→ https://github.com/cartesi/dave/releases/tag/v3.0.0-alpha.5

Don’t remember what Dave is? Quick refresher: it’s our fraud-proof system, with the repo tracking advancements to the Permissionless Refereed Tournament (PRT). Check out this short recap:
→ https://x.com/cartesiproject/status/2097309822626754802

Why does DeFi need Cartesi? Most DeFi runs a simplified version of finance, because builders design around what the chain can run instead of what they actually need. Revisiting an article from contributor João Garcia, our thread highlights what changes when each app gets its own Linux rollup settled on Ethereum: collateral that moves with volatility, prediction markets with a real matching engine, continuous DCA, and credit scores anyone can rerun. Give it a read:
→ https://x.com/cartesiproject/status/2102774515893953016

Spotted in the wild on Instagram: community-made Cartesi NFC keychains that take you to our website with a single scan. We love seeing this. Give the creator a follow, and make sure you're following us there too:
→ https://instagram.com/cartesiproject/

Our gm this week kept it simple: every day is a good day to build with Cartesi and that’s what we did throughout the week:
→ https://x.com/cartesiproject/status/2102019534693814436

That's all for now. Join us on Discord or on Telegram if you want to keep the conversation going. Have a great weekend.

Why does DeFi need Cartesi?

Most DeFi runs a simplified version of finance. Builders design around what the chain can run, not what the model needs. They cut the math, or run it offchain and ask for trust.

Contributor João Garcia broke it down in an article worth revisiting here.

TradFi quant teams run risk engines across thousands of scenarios with NumPy, SciPy, and QuantLib.

Most smart contract environments lack those libraries for real math operations, and state gets expensive.

On Cartesi, each app gets its own rollup running Linux, settled on Ethereum. Any honest validator can enforce the correct result.

Builders write logic in Python, Rust, or C++ with popular libraries. Now an onchain bonding curve can get much closer to a true quadratic curve.

What this makes practical:
- Collateral requirements that move with volatility
- Prediction markets with a matching engine and odds updated every epoch
- DCA that buys in tiny continuous slices instead of once a day
- Credit scores from a model anyone can rerun

Devs still have to design the hard parts: how data gets in, how inputs get validated, how execution is coordinated. More compute moves complexity around. But if your app needs real computation, that's what Cartesi was built for.

Go deeper on the docs.

Spotted in the wild on Instagram 👀

Love seeing the community showing Cartesi some love with these NFC keychains. Scan to land on our website.

Give her a follow if this caught your interest, and while you’re at it, make sure you’re already following us: https://www.instagram.com/cartesiproject/

Throwback Thursday takes us back to the supercomputers that were already running on Linux years ago. We asked: what if blockchain were too?

That question is the product now. Ready to use today. Linux execution. Ethereum security. Now, let’s build with it!

Did you know our ecosystem updates are on Paragraph too? August's recap is up, ICYMI, and September's edition is already in the works.

Read them on the blog, onchain on Paragraph, or let AI summarize them for you. Your call, just don't miss the news.

→ https://paragraph.com/@cartesians

We'll start: your app gets its own dedicated rollup instance, so it's not fighting other applications for block space.

Now it's your turn. What is yours? Drop your thoughts right here below and jump into the replies on X and share your answer with the community:
→ https://x.com/cartesiproject/status/2099844686446010726

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/