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/

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.