Cartesi

Friday's here and so is your Cartesi Weekly 🐧

"Build me a Cartesi app, make no mistakes." Dream prompt aside, Shaheen Ahmed put Cursor to work on an end-to-end DeFi prototype on Cartesi, integrating a Chainlink Labs price feed to power the app logic. It shipped, and the result is a solid look at what vibe coding on Cartesi can do. Maybe try one yourself this weekend:
→ https://x.com/riseandshaheen/status/2047247344828395616

"Full Linux environment" won our Q1 poll by a wide margin, so we spent this week unpacking why that matters. 96.3% of the top 1M web servers run on Linux. 100% of the top 500 supercomputers. Over 47 million developers trust it every day. Yet most projects still ask builders to start from zero. Cartesi doesn't. This is what Linux onchain actually unlocks: Monte Carlo risk engines, PyTorch and TensorFlow inference, NumPy and Pandas quant stacks, and games with real mechanics, all verifiable onchain and secured by Ethereum:
→ https://x.com/cartesiproject/status/2046576376766140921

On the contracts side, a new PR entered review this week. rollups-contracts#514 adds Claim Staging: instead of accepting new claims the moment they're submitted, they now sit in a short review window before finalization. Safer and more transparent by default. Keep an eye on all tech developments in real time on Discord:
→ http://discord.gg/cartesi

On the ground, @yoojei88 represented Cartesi as an ambassador at Web3 Festival in Hong Kong this week, trading notes with builders and projects across the space. This is how our message compounds IRL beyond X:
→ https://x.com/yoojei88/status/2046488517916922104

We opened the week with a simple question. What are you shipping? Programmability has evolved with Cartesi. More tools, more compute, more of what devs actually need. We want to see more answers roll in, and tag us when you do:
→ https://x.com/cartesiproject/status/2046212981714039101

And it’s a wrap for this week. Have a great weekend.

Repost: https://x.com/cartesiproject/status/2047662410237120655

IYKYK 🐧

That is exactly why Cartesi is bringing a full Linux environment to Web3.

When you build with tools that have been battle-tested for decades, the infrastructure just works. See the great thread by Jahir Skeikh here:
→ https://x.com/jahirsheikh8/status/2046606338873303180

Repost: https://x.com/cartesiproject/status/2046937831378231394

The community has spoken 🐧

"Full Linux environment" won last month's poll on X. You told us what matters most: the ability to use any language, library, and tool you already love, without learning a new toolchain.

Let's unpack why that actually matters more than it sounds 🧵↓

1/ 96.3% of the world's top 1M web servers run on Linux.
100% of the top 500 supercomputers run on Linux.
47M+ developers worldwide already trust it every day.

Linux is the foundation the modern internet was built on.

Yet most blockchains still ask devs to start from zero.

2/ The result? Millions of builders locked out of Web3.

Cartesi removes that wall.

It brings a full Linux runtime to Ethereum rollups, so devs can build with the stacks they already master: Python, JavaScript, C++, Go, Rust, and every open-source library refined over decades.

3/ What does this actually unlock?

→ DeFi with real risk engines (Monte Carlo, VaR)
→ ML inference with PyTorch or TensorFlow
→ Quant engines in Python with NumPy + Pandas
→ Games with rich mechanics & deep logic

Decades of battle-tested tooling. Now verifiable onchain.

4/ Why go Linux?

Because it's not an experiment of an immature industry. It's the infrastructure that already runs the world: the cloud, the servers, the supercomputers, the tools billions of people depend on daily.

Cartesi brings that entire world onchain, secured by Ethereum.

5/ Stage 2 on L2BEAT. Fraud-proof system on mainnet. A Linux runtime inheriting Ethereum's security and decentralization.

The next wave of builders shouldn't have to reinvent their skillset to ship on Ethereum. With Cartesi, they don't.

Start building: https://docs.cartesi.io/

Repost: https://x.com/cartesiproject/status/2046576376766140921

Friday's here and so is your Cartesi Weekly 🐧

On the contracts side, Cartesi Machine Solidity Step v0.14.0 is now live. This release updates the machine-related onchain smart contracts to be compatible with Cartesi Machine Emulator v0.20.0, keeping the full stack aligned as infrastructure matures.
→ https://github.com/cartesi/machine-solidity-step/releases/tag/v0.14.0

Speaking of the emulator, we put together a deep dive into what shipped with Machine Emulator v0.20.0. Months of engineering work went into how proofs, performance, and security are handled. The thread breaks down every change and why it matters:
→ https://x.com/cartesiproject/status/2044038802151485454

Building DeFi apps that handle real data on the EVM is hard. Luckily, with Cartesi, builders can use the libraries they already know. The latest tutorial shows how to leverage Pandas to bring Python's data manipulation power onchain. Bookmark it:
→ https://x.com/cartesiproject/status/2044763094363386215

The execution layer conversation keeps getting louder. Cypher amplified our article breaking down how protocols are forced into compromises, what changes when you remove those limits, and why Cartesi's approach speaks for itself:
→ https://x.com/NxtCypher/status/2043728740870418599

World Art Day passed this week and we couldn't fail to mark it with some original digital art complementing the ultimate form of art: code. See here:
→ https://x.com/cartesiproject/status/2044450277760041254

Cashtags took the X feed by storm and $CTSI was right in the mix. We always love to see you tagging us. For more of that energy, take a stroll on CoinMarketCap community and show us some love there too:
→ https://coinmarketcap.com/community/profile/cartesiproject/

That is all for this week. It's build time everyday though, the penguin said so. Watch him close it out in style:
→ https://x.com/cartesiproject/status/2043676245544845464

Have a great weekend.

Repost: https://x.com/cartesiproject/status/2045125694997647424

They say code is poetry, but making offchain Linux execution verifiable onchain feels like a true masterpiece.

Happy World Art Day to all Web3 builders out there from all of us at Cartesi.

t’s raining cashtags.
$CTSI enters the chat.

Run anything. Verify everything.
Powered by Linux, secured by Ethereum.

→ https://cartesi.io

Repost: https://x.com/cartesiproject/status/2044400867835871711

Another Friday means another Cartesi Weekly 🐧

Cartesi Machine Emulator v0.20.0 is out. Months of engineering work in one release.

Builders can now generate cryptographic proofs that a Cartesi computation ran correctly, without re-executing it. That's ZK proof support via the RISC Zero zkVM. Verification also gets faster, with a new hash tree implementation that’s significantly quicker than before.

Machines can also run with state stored on disk rather than fully in memory, which matters for larger workloads. And the interpreter has been hardened against adversarially crafted inputs, validated through extensive fuzzing. Full release:
→ https://github.com/cartesi/machine-emulator/releases/tag/v0.20.0

Dave 3.0.0-alpha.0 is live with updates to PRT, Cartesi's fraud proof system that keeps onchain computations honest, and is now even more robust.

This release adds Emergency Withdrawal support, so users can always recover their funds even in edge cases. It also tightens security in the tournament process and improves error handling throughout. Explore further:
→ https://github.com/cartesi/dave/releases/tag/v3.0.0-alpha.0

Millions of Python, Rust, and Go developers have been locked out by the EVM. DeFi has been built on workarounds for a limited execution environment. We wrote about why Linux onchain is the execution layer DeFi has been waiting for. ICYMI:
→ https://cartesi.io/blog/defi-execution-layer/

We've been shipping videos to show Cartesi in action. Check the integration tutorials we dropped recently to use in your app:
• Chainlink oracles
• NumPy onchain thanks to the Linux stack
• Bonding curve from scratch in Python

All in one thread ready to be bookmarked:
→ https://x.com/cartesiproject/status/2042226240267141535?s=20

Spoiler: More demos are coming soon.

Want to keep the conversation going or have any tech questions? Join our Discord and connect with our contributors and the rest of the community:
→ discord.gg/cartesi

Have a good weekend!

Repost: https://x.com/cartesiproject/status/2042588979443438064

We're building in the open. 🐧

You've seen the demos. You've seen the integrations. But here is a closer look at what's truly possible when you build with Cartesi.

DeFi relies on robust infrastructure, and we're making it simpler than ever to build powerful, complex dApps:

Chainlink Oracles: Reliable price data is everything for lending, perpetuals, and prediction markets. We showed how to integrate a Chainlink oracle into a Cartesi app with just one click, fetching, timestamping, and delivering ETH prices onchain.
→ https://x.com/cartesiproject/status/2027020985531301888

NumPy & Python: Complex math on the EVM is painful. On Cartesi, you use the tools you already know. We brought Python’s scientific computing stack onchain using NumPy. Matrix multiplication, linear algebra, and statistical simulations are now natively possible using a full Linux stack.
→ https://x.com/cartesiproject/status/2029557685969170605

Bonding Curves: The engine behind platforms like Pump(dot)fun and Uniswap. No order books, no middlemen. Just math. We built one from scratch in Python on Cartesi, with prices moving in real time with every buy and sell.
→ https://x.com/cartesiproject/status/2032094462193910107

More demos. More integrations. More building in the open is coming up next. Keep watching this space.

Repost: https://x.com/cartesiproject/status/2042226240267141535

DeFi got built on workarounds for a limited execution environment, and millions of Python, Rust, and Go devs have been locked out by the EVM.

Cartesi changes that.

Linux. 40 years of open-source, onchain. The execution layer DeFi has been waiting for.

→ https://cartesi.io/blog/defi-execution-layer/

Repost: https://x.com/cartesiproject/status/2041501766269968654

Satoshi’s birthday today (April 5th, 1975… or was it?) and Easter Sunday, for some of us. A good day to believe in things built to last, and something worth celebrating either way.

Happy Easter to everyone celebrating, from all of us at Cartesi. 🐣

Repost: https://x.com/cartesiproject/status/2040776546315833825?

Here's what each one means for you as a builder:

🐧 Use any language, library, or runtime you already know. No new toolchain to learn.

🔁 Your smart contracts work as expected. Cartesi extends what's already on the EVM.

🧩 Each dApp gets its own rollup instance. No shared state, no contention.

✅ Heavy logic runs offchain. Ethereum verifies the result. Both worlds, zero compromise.

Bonus resources: https://docs.cartesi.io/

We are running the official poll over on our X thread, but we invite you to discuss it here as well.

Repost and vote: https://x.com/cartesiproject/status/2038965085939605533

Another month is coming to an end, and the Cartesi ecosystem keeps moving forward. Builders shipping, tech evolving, community supporting.

Catch the latest in the Ecosystem Updates blog, your monthly window into everything happening across the project.
→ https://cartesi.io/blog/ecosystem-updates-march-2026/

Repost: https://x.com/cartesiproject/status/2037530196711264480

Ethereum for trust. Cartesi for execution.

Repost: https://x.com/cartesiproject/status/2037167798368284834

Most devs spend their time crafting web3 workarounds, rewriting from scratch what already exists in traditional software.
Cartesi asks: what if you didn't have to?
Run any complex code, verifiably, onchain.

New week. Same mission. GM 🐧

Most devs spend their time crafting web3 workarounds, rewriting from scratch what already exists in traditional software.
Cartesi asks: what if you didn't have to?
Run any complex code, verifiably, onchain.

New week. Same mission. GM 🐧

Repost: https://x.com/cartesiproject/status/2036080871761952825

Friday here, and for whoever is ‘monitoring the situation’, here comes your Cartesi Weekly 🐧

On the tech side, contributors cooked and Rollups Node v2.0.0-alpha.10 is out, one step closer to public release. This update introduces production-grade reliability, tighter resource management, crash recovery, and database transaction safety. Multiple applications can now run on the same node without interfering with each other, and the Machine Manager handles extended downtime gracefully without memory pressure building up. Explore here:
→ https://github.com/cartesi/rollups-node/releases/tag/v2.0.0-alpha.10

The latest Cartesi CLI pre-release is live. Developers are encouraged to test the Rollups and share feedback on Discord. Everyone’s input shapes what ships next, so jump in and help make the final release production-ready:
→ https://github.com/cartesi/cli/tree/prerelease/v2-alpha

Contributor Shaheen Ahmed walks us through all the commands here:
→ https://x.com/riseandshaheen/status/2034275490303967287?s=20

Our DevAd Lead Joao Garcia continues highlighting DeFi constraints, making the case for how Cartesi’s execution layer addresses them and why it’s important for each dApp to have its own dedicated compute instead of competing for block space. App-specific rollups architecture are key:
→ https://x.com/joaopdgarcia/status/2033891295131730373?s=20

And speaking of app-specific (or appchain) design, catch up with this explainer video:
→ https://x.com/cartesiproject/status/2034631132315275348?s=20

On the community side, remember we’re also active on Reddit, Farcaster, Instagram, and YouTube. Join us across all channels to stay in the loop:
→ https://linktr.ee/cartesi

As the month wraps up, stay tuned for next week’s newsletter, with the usual merch giveaway included. Make sure you’re subscribed:
→ https://mailchi.mp/cartesi/email-newsletter

That’s it for this week. More building, less talking. We keep shipping.

Repost: https://x.com/cartesiproject/status/2034993537205584040

Rollups Node v2.0.0-alpha.10 is out. One step closer to public release.

This is all about making the node production-grade: tighter resource management, crash recovery, DB transaction safety, and proper handling for long-running and multi-app deployments.

Here's what it means:
Multiple apps can now run on the same node without interfering with others, and the Machine Manager recovers from extended downtime without memory pressure.

Your app is less likely to go down, and when something does go wrong, it recovers gracefully.
→ https://github.com/cartesi/rollups-node/releases/tag/v2.0.0-alpha.10

That's the kind of foundation you want before production readiness and mainnet.

This is a notice for you dev frens, come check the latest Cartesi CLI pre-release, test the Rollups, and swing by Discord to drop feedback and mingle with our contributors.
→ https://github.com/cartesi/cli/tree/prerelease/v2-alpha

Repost: https://x.com/cartesiproject/status/2034268766033650115

GM from Cartesi, the GOAT.
Because Linux has powered the internet for decades and now it powers onchain apps thanks to Cartesi.

Props to ItsFOSS too for the inspo.

Repost: https://x.com/cartesiproject/status/2033543921276801043

Friday again, and it's time for our Cartesi Weekly, with the latest from across the ecosystem this week 🐧

On the infrastructure front, Dave 2.1.1 is live on devnet and all supported testnets: Ethereum Sepolia, Arbitrum Sepolia, OP Sepolia, and Base Sepolia. It's also published to the Cannon registry, so you can pull it directly and start testing the fraud-proof system across any of these networks today. Come chat with contributor Guilherme Dantas in the rollups channel on Discord for all the details:
→ https://discord.com/invite/cartesi

Devs got fresh code snippets for Rust, Go, and C++ thanks to contributor Shaheen Ahmed, along with vibe coding resources. There are no excuses now to build DeFi your way with Cartesi using the language of your choice:
→ https://x.com/cartesiproject/status/2031007146637410765

A new demo dropped showing how to integrate bonding curves into your Cartesi apps for price discovery, where everything is dictated by buys, sells, and the algorithm:
→ https://x.com/cartesiproject/status/2032094462193910107

Why does it matter? Hear it again from Macky_DeFi:
→ https://x.com/Macky_DeFi/status/2032105736172429398

DevAd Lead Joao Garcia continues his DeFi series, unpacking the execution layer constraints that hold DeFi back and how Cartesi opens up a new design space with Python, NumPy, PyTorch and similar libraries. If it runs on Linux, it runs on Cartesi and onchain:
→ https://x.com/joaopdgarcia/status/2031363751983620539

We hopped on the emoji trend this week:
→ https://x.com/cartesiproject/status/2031731970322137384

And check this out: a modified WebCM (Web Cartesi Machine) vibe-coded to let multi-agents write code in the browser, serverless. Say what:
→ https://rkat.ai/demos/webcm/

That's a wrap for this week. Join us on here on Telegram to chat with other Cartesians and ask anything you have on your mind!

Repost: https://x.com/cartesiproject/status/2032456798352072748

Friday once again, which means it is time for your Cartesi Weekly, with a roundup of what happened across the ecosystem this week 🐧

The latest monthly recap from L2BEAT is out, highlighting key technical developments across the L2 landscape. Check out the Cartesi excerpt here:
→ https://x.com/l2beat/status/2028472035152654589

How much more powerful could DeFi be if it could rely on traditional libraries? A new tutorial dropped showing how easy it is to integrate NumPy, enabling advanced numerical computing, matrix operations, and scientific calculations directly in your dApp. With the Cartesi VM, if it runs on Linux, it can run onchain:
→ https://x.com/cartesiproject/status/2029557685969170605

DevAd Lead João Garcia continues his series exploring why DeFi works the way it does today and how it can evolve. The latest episode dives into Cartesi’s ability to enable stateful application logic that can match TradFi-level performance while moving beyond typical L1 constraints.
→ https://x.com/joaopdgarcia/status/2028818702242656630

Head over to YouTube to catch the rest of the shorts if you missed them:
→ https://www.youtube.com/@Cartesiproject/shorts

And speaking of L1 constraints, check out a thread we put out benchmarking the compute power of the Cartesi VM. Think more useful instructions per block, greater throughput, more compute cycles, and the versatility to run a full Linux OS.

It is time to build by leveraging the progress already made in mainstream software, with all that compute dedicated to your own dApp thanks to the appchain framework, without competing for shared resources:
→ https://x.com/cartesiproject/status/2029210293847638026

That’s all for now. We. Keep. Building.

Repost: https://x.com/cartesiproject/status/2029920030197166106