CTSI官方中文社区

Friday's here, and so is the Cartesi weekly update 🐧
https://fxtwitter.com/cartesiproject/status/2047662410237120655?s=20

"Build me a Cartesi app, no mistakes allowed." Putting that dream aside for now, Shaheen Ahmed has developed an end-to-end DeFi prototype on Cartesi using Cursor, integrating Chainlink Labs' price data to drive the app's logic. The prototype is live, showcasing Cartesi's vibe coding capabilities. Why not give it a try this weekend:

→ https://x.com/riseandshaheen/status/2047247344828395616

The "complete Linux environment" won overwhelmingly in our Q1 survey, so this week we're diving into its significance. A whopping 96.3% of the top million web servers run on Linux. All of the top 500 supercomputers are Linux-based. Every day, over 47 million developers trust Linux. Yet, most projects still require developers to start from scratch. Not Cartesi. What Linux truly unlocks on-chain are: Monte Carlo risk engines, PyTorch and TensorFlow inference, NumPy and Pandas quant stacks, and games with real mechanisms—all verifiable on-chain and secured by Ethereum:

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

On the contract side, a new PR is under review this week. rollups-contracts#514 added a claim staging feature: claims will go through a brief review window before final acceptance rather than being instantly approved. This is more secure and transparent by default. Stay updated on all tech developments in real-time on Discord:

→ http://discord.gg/cartesi

This week, @yoojei88 represented Cartesi at the Web3 festival in Hong Kong, engaging with industry developers and project teams. This is how our vision spreads in real life beyond the X platform:

→ https://x.com/yoojei88/status/2046488517916922104

At the start of the week, we posed a simple question: what are you launching? As Cartesi evolves, so does programmability. More tools, more compute power, more of what developers really need. We look forward to seeing more answers, feel free to tag us when you share:

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

That's it for this week. Have a great weekend!

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

Those in the know, know 🐧

This is exactly why Cartesi is bringing a full Linux environment into Web3.

When you're building with tools that have been battle-tested for decades, the infrastructure naturally runs smoothly. Check out Jahir Skeikh's awesome post:

→ https://x.com/jahirsheikh8/status/2046606338873303180

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

The community has spoken🐧

"Complete Linux environment" won in last month's X forum vote. You told us what matters most: the ability to use any language, library, and tool you already love, without having to learn a new toolchain.
https://x.com/cartesiproject/status/2038965085939605533?s=20

Let's explore why this is more important than it sounds🧵↓

1/ 96.3% of the top 1 million web servers worldwide run on Linux systems.

All of the top 500 supercomputers in the world run on Linux systems.

Over 47 million developers worldwide rely on Linux every day.

Linux is the cornerstone of the modern internet.

However, most blockchains still require developers to start from scratch.

2/ The result? Millions of developers are kept out of Web3.

Cartesi breaks down this barrier.

It brings a complete Linux runtime environment to Ethereum Rollups, allowing developers to build with the technology stack they’re already proficient in: Python, JavaScript, C++, Go, Rust, and various open-source libraries that have been refined over decades.

3/ What does this really bring?

→ A true risk engine (Monte Carlo, VaR) for DeFi

→ Machine learning inference using PyTorch or TensorFlow

→ Building quantitative engines in Python using NumPy + Pandas

→ Games with rich mechanics and deep logic

Decades-tested tools. Now verifiable on-chain.

4/ Why use Linux?

Because it is not an experiment from an immature industry. It is the infrastructure that powers the world: cloud, servers, supercomputers, and the tools that billions rely on every day.

Cartesi brings the whole world on-chain, secured by Ethereum.

5/ L2BEAT Phase 2. Anti-fraud system on the mainnet. A Linux runtime inheriting Ethereum's security and decentralization features.

The new generation of developers does not need to relearn skills to deploy applications on Ethereum. With Cartesi, they don’t have to.

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

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

Friday has arrived, and so has the Cartesi weekly report 🐧
https://fxtwitter.com/cartesiproject/status/2045125694997647424

On the contract side, Cartesi Machine Solidity Step v0.14.0 is now live. This version updates the on-chain smart contracts related to the machine, making them compatible with Cartesi Machine Emulator v0.20.0, thereby maintaining consistency across the entire tech stack as the infrastructure matures.

→ https://github.com/cartesi/machine-solidity-step/releases/tag/v0.14.0

Speaking of the emulator, we delved into the updates of Machine Emulator v0.20.0. We have invested months of engineering effort to address issues related to proofs, performance, and security. This post analyzes each change and its significance in detail:

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

Building DeFi applications that can handle real data on the EVM is no easy task. Fortunately, with Cartesi, developers can use the libraries they are already familiar with. The latest tutorial shows how to leverage Pandas to bring Python's data manipulation capabilities on-chain. Please bookmark this post:

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

The discussion around the execution layer is heating up. Cypher reposted our article, which deeply analyzes how the protocol is forced to make compromises, what changes occur after removing these limitations, and why Cartesi's approach is so outstanding:

→ https://x.com/NxtCypher/status/2043728740870418599

This week is World Art Day, and we certainly want to celebrate with some original digital artworks that complement the ultimate art form—code. Click here to check it out:

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

Cashtags have created a buzz on the X platform, and $CTSI is part of it. We have always loved seeing you tag us. Want to feel more vibrant? Then head over to the CoinMarketCap community and don’t forget to give us a like:

→ https://coinmarketcap.com/community/profile/cartesiproject/

That's all for this week's content. However, as the penguin says, every day is building time. See how it wraps up perfectly:

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

Have a great weekend!

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

Topic tags come pouring in like raindrops.

$CTSI has joined the chat.

Run everything. Verify everything. Driven by Linux, secured by Ethereum.

https://cartesi.io

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

Last week we released Cartesi Machine Emulator v0.20.0.
https://fxtwitter.com/cartesiproject/status/2044038802151485454

Let's take a deep dive into the new features behind this latest version, which is the result of months of engineering improvements in proof, performance, and security.

Here are the changes and their significance. 🧵↓

1) First: Support for zero-knowledge proofs through RiscZero zkVM.

Now anyone can prove that a computation ran correctly without having to rerun it. In short, this means that there is no need to redo all the work to verify whether the answer is correct.

Execution only needs to be done once.

2) The engine used for verifying machine states has also received a significant upgrade.

The old Merkle tree has been replaced with a faster hashing tree, accelerated by utilizing modern CPU instructions and multithreading technology.

Verification speed has significantly improved. After scaling, the overhead in this area will increase rapidly.

3) Previously, the Cartesi machine had to keep all data in memory.

Now, state can be stored on disk. This opens the door to handling larger workloads that were previously unmanageable.

It provides more room for builders. This means that more ambitious applications can be developed.

4) The C API has added two important features.

Proof generation now supports arbitrary subranges of address space. And a new function for collecting root hash values at configurable intervals and performing subtree bundling.

During long execution processes, the efficiency of building hash values is higher.

5) In terms of security: The interpreter has been hardened against maliciously crafted inputs.

This has been validated through extensive fuzz testing, essentially stress testing every edge case that an attacker might try to exploit.

In short: Trusted robustness.

6) What does this mean for Cartesi?

These improvements enhance Rollups nodes and help advance the upcoming Dave anti-fraud system, making it more efficient and reliable.

The end result? A more robust underlying infrastructure built by developers.

7) Special thanks to the technical contributors for releasing such an important outcome.

Full release address: http://github.com/cartesi/machine-emulator/releases/tag/v0.20.0 As always, feel free to join Discord for the latest updates and participate in discussions on the Machine channel: https://discord.gg/cartesi

Reprinted: https://x.com/cartesiproject/status/2044038802151485454

Another Friday, it's time for the Cartesi weekly report 🐧
https://fxtwitter.com/cartesiproject/status/2042588979443438064

Cartesi Machine Emulator v0.20.0 has been officially released. Months of engineering achievements are gathered here.

Builders no longer need to re-execute Cartesi computations to generate cryptographic proofs that they are running correctly. This is thanks to the zero-knowledge proof support provided by RISC Zero zkVM. The verification speed has also greatly improved, employing a brand new hash tree implementation, which is significantly faster than before.

The machine can also store state on disk rather than fully loading it into memory, which is crucial for handling large workloads. Additionally, the interpreter has been strengthened to withstand maliciously constructed inputs and has passed extensive fuzz testing validation. Full version release:

→ https://github.com/cartesi/machine-emulator/releases/tag/v0.20.0

Dave 3.0.0-alpha.0 version is now live, updating Cartesi's anti-fraud system PRT, which ensures the integrity of on-chain computations and is now even more robust.

This version adds support for emergency withdrawals, allowing users to retrieve funds at any time, even in extreme situations. Furthermore, it has enhanced the security of the tournament process and improved the overall error handling mechanism. Learn more:

→ https://github.com/cartesi/dave/releases/tag/v3.0.0-alpha.0

Millions of Python, Rust, and Go developers have been shut out by EVM. DeFi has always relied on workarounds for constrained execution environments. We have previously articulated why Linux on-chain is the execution layer that DeFi has been waiting for. ICYMI:

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

We have been releasing videos showcasing real applications of Cartesi. Check out our recently released integration tutorials to use in your applications:

• Chainlink Oracles

• On-chain NumPy using the Linux tech stack

• Building Bonding Curves from Scratch with Python

All content is consolidated in one post for your convenience:

→ https://x.com/cartesiproject/status/2042226240267141535?s=20

Spoiler: More demonstrations are coming soon.

Want to continue the discussion or have any technical questions? Join our Discord server to engage with our contributors and other community members:

→ discord.gg/cartesi

Have a great weekend!

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

We are building an open platform.🐧

You have already seen the demo and experienced the integration. But now, let's dive deeper into the true possibilities of building applications with Cartesi.

DeFi relies on robust infrastructure, and we are making it unprecedentedly simple to build powerful and complex dApps:

Chainlink Oracles: Reliable price data is crucial for lending, perpetual contracts, and prediction markets. We demonstrated how to integrate Chainlink Oracles into Cartesi applications with just a click, fetching, adding timestamps, and putting ETH prices on-chain.

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

NumPy and Python: Performing complex mathematical operations on the EVM is cumbersome. With Cartesi, you can use tools you are already familiar with. We brought Python's scientific computing stack on-chain with NumPy. Now, you can natively perform matrix multiplication, linear algebra, and statistical simulations using a full Linux system.

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

Bonding Curves: The engines behind platforms like Pump(dot)fun and Uniswap. No order books, no intermediaries. Everything is in the math. We built one from scratch on Cartesi with Python, where prices change in real-time with every buy and sell.

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

More demos. More integrations. More open-source builds are coming soon. Stay tuned.

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

The construction of DeFi relies on various workarounds for constrained execution environments, leaving millions of Python, Rust, and Go developers shut out by the EVM.

Cartesi changed all that.

Linux. 40 years of open-source experience, running on-chain. The execution layer that DeFi has always awaited.

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

Reprinted from: https://x.com/cartesiproject/status/2041501766269968654

Late congratulations: Satoshi Nakamoto's birthday (April 5, 1975......), is also Easter for some of us. This is a good day to believe that things can last forever, and it is worth celebrating in any case.

The entire Cartesi team wishes all friends celebrating Easter a happy holiday!🐣

Retweeted from: https://x.com/cartesiproject/status/2040776546315833825

After another week of hard work, we welcome this week's Cartesi Weekly Report. Let's take a look at the changes that have occurred in the ecosystem this week🐧
https://fxtwitter.com/cartesiproject/status/2040053011549143463

In terms of development, contributors have been busy. The core team released Rollups Node v2.0.0 alpha.11. This version focuses entirely on throughput, operational tools, and stability. By introducing polling scheduling, the nodes can now ensure fair processing of all applications, preventing a single high-load dApp from dragging down others. Additionally, it comes with a brand new CLI diagnostic tool for direct on-chain checks.

→ https://github.com/cartesi/rollups-node/releases/tag/v2.0.0-alpha.11

Besides the node updates, Rollups Contracts 3.0.0 alpha.3 has also officially launched. The main new features of this update include preliminary support for emergency withdrawals and significant improvements to the Merkle root for claim events.

→ https://github.com/cartesi/rollups-contracts/releases/tag/v3.0.0-alpha.3

To integrate the new node infrastructure, we also released the latest alpha version of Cartesi CLI. This version integrates the updated Rollups Explorer and is ready for core developers to test. Please download the alpha version, run the process, and leave your feedback on our Discord server so we can improve the official version.

→ https://discord.gg/cartesi

At the end of Q1, we asked you which feature of Cartesi you think is most important for your builds. The results are in, with full Linux environment leading by a large margin.

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

In April and at the beginning of Q2, we once again emphasized our core philosophy: Linux execution. Ethereum settlement. No joke, we are officially live. Click here for a detailed explanation of the architecture:

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

Looking at the broader field, L2BEAT released the ecosystem update for March. They highlighted our recent infrastructure upgrades, improved developer tools, and ongoing educational outreach around Linux-based execution.

→ https://x.com/l2beat/status/2039719948667293879

A reminder, we are continuously expanding our content coverage. You can check our latest updates and articles anytime on CoinMarketCap, and we welcome developers to join the Linux era of Web3. Join the discussion and follow our page on CoinMarketCap:

→ https://coinmarketcap.com/community/profile/cartesiproject/

This week's content ends here. Wishing you a pleasant Friday and weekend, and we will continue to work hard.

Retweet: https://x.com/cartesiproject/status/2040053011549143463

April 1st, but this is no joke. Linux execution, Ethereum settlement. We will continue to release in the second quarter. Click the link below to quickly understand the basic concepts of Cartesi 🧵
https://fxtwitter.com/cartesiproject/status/2039327737253634458?s=20

1. Most blockchains require you to learn a new programming language or work in a narrow and restricted environment. Complex logic, datasets, mature libraries... these are not compatible.

Developers have to sacrifice their ideas to implement on-chain applications.

And this is exactly the problem Cartesi aims to solve.

https://cartesi.io/blog/abstraction-scalability/

2. Cartesi runs a complete Linux operating system in the form of smart contracts, secured by Ethereum.

Software tools, languages, and libraries accumulated over more than 40 years can be used on-chain without any rewriting. Python, Rust, C++, SQLite, etc.

As long as it can run on Linux, it can run on Cartesi.

https://cartesi.io/blog/linux_in_web3/

3. The engine behind it is the Cartesi Machine, a RISC-V based virtual machine running the Linux operating system.

RISC-V is an open hardware standard trusted across the software industry. By putting it on-chain, developers can obtain a real, deterministic computing environment rather than an approximation.

https://cartesi.io/blog/grokking-cartesi-virtual-machine/

4. The Cartesi Rollups framework enables its deployment. Each application will become an application chain (L2 or L3), with its own execution environment.

Application-specific, high throughput, and capable of handling complex logic that EVM was never designed for.

https://cartesi.io/blog/understanding-cartesi-rollups/

5. Security is not just a claim, but validated. Cartesi's fraud prevention system (PRT) allows anyone to challenge the computation results. Disputes are resolved through an efficient tournament without the need for massive computational power.

Result: One of the few Stage 2 Rollup projects on L2BEAT.

https://l2beat.com/scaling/summary?filters=%7B%22stage%22%3A%7B%22values%22%3A%5B%22Stage+2%22%5D%7D%7D

6. The ecosystem also includes CartesiScan for tracking on-chain application chain activities, and Cartesi Explorer for $CTSI staking and governance access.

Fully open-source. Built transparently by a focused team and contributors.

Want to dive deeper and communicate with us?

https://discord.gg/cartesi

Retweet: https://x.com/cartesiproject/status/2039327737253634458

The following are the implications of each feature for you as a developer:

🐧 Use any language, library, or runtime you are already familiar with. No need to learn a new toolchain.

🔁 Your smart contracts will operate as expected. Cartesi extends existing functionality on the EVM.

🧩 Each dApp has its own Rollup instance. No shared state means no contention.

✅ Heavy logic runs off-chain. Ethereum validates the results. Both worlds, zero compromise.

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

We are conducting an official vote on the X forum, and you are also welcome to join the discussion here.

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

Another month is about to end, and the Cartesi ecosystem continues to move forward. Developers are constantly releasing products, technology is advancing rapidly, and the community is providing strong support.

Follow the "Ecosystem Updates" blog, published monthly, to keep you informed about the latest developments in the project.

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

Reprinted from: https://x.com/cartesiproject/status/2037530196711264480

Ethereum provides trust, Cartesi provides execution.

Forwarded from: https://x.com/cartesiproject/status/2037167798368284834

Most developers spend a lot of time creating workarounds for Web3, rewriting existing code from traditional software from scratch.

Cartesi asks: What if it doesn't have to be this way?

Run any complex code on-chain in a verifiable manner.

A new week, the same mission. GM 🐧

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

The weekend is here, and for those who are "monitoring the situation", here is the Cartesi Weekly Report 🐧

On the technical side, contributors have completed work, and Rollups Node v2.0.0-alpha.10 has been released, bringing us one step closer to a public release. This update introduces production-level reliability, stricter resource management, crash recovery, and database transaction safety. Now, multiple applications can run on the same node without interference, and the machine manager can gracefully handle long downtimes without causing memory pressure. For more details, please see:
→ https://github.com/cartesi/rollups-node/releases/tag/v2.0.0-alpha.10

The latest command-line interface (CLI) pre-release version from Cartesi is now online. We encourage developers to test Rollups and share feedback on Discord. Everyone's opinion will influence the development of future versions, so come and participate, helping us prepare for the final release:
→ https://github.com/cartesi/cli/tree/prerelease/v2-alpha

Contributor Shaheen Ahmed has detailed all the commands for us:
→ https://x.com/riseandshaheen/status/2034275490303967287?s=20

Our head of development consulting, Joao Garcia, continues to emphasize the limitations of decentralized finance (DeFi), explaining how Cartesi's execution layer addresses these issues and why every decentralized application (dApp) needs its own dedicated computing resources, rather than competing for block space. Application-specific aggregation architecture is crucial:
→ https://x.com/joaopdgarcia/status/2033891295131730373?s=20

Speaking of the design of specific applications (or application chains), take a look at this explanatory video:
→ https://x.com/cartesiproject/status/2034631132315275348?s=20

In terms of community, remember that we are also very active on Reddit, Farcaster, Instagram, and YouTube. Please join us through all channels to stay updated:
→ https://linktr.ee/cartesi

This month is coming to an end, so look forward to next week's newsletter, which will once again include giveaway activities. Please ensure you have subscribed:
→ https://mailchi.mp/cartesi/email-newsletter

That's it for this week. Do more, say less. We continue to deliver results.
Retweet: https://x.com/cartesiproject/status/2034993537205584040

Rollups Node v2.0.0-alpha.10 has been released. One step closer to the official release.

This update aims to bring the node to production-grade standards: stricter resource management, crash recovery, database transaction safety, and proper handling of long-running and multi-application deployments.

This means:

Now, multiple applications can run on the same node without interfering with each other, and the machine manager can easily recover after long downtimes without causing memory pressure.

The likelihood of your application crashing is lower, and even if issues arise, it can recover gracefully.

→ https://github.com/cartesi/rollups-node/releases/tag/v2.0.0-alpha.10

This is the solid foundation you need before preparing for production environments and launching on the mainnet.

Dear developer friends, come and experience the latest Cartesi CLI prerelease version, test Rollups, and join our Discord server to provide feedback and interact with our contributors!

→ https://github.com/cartesi/cli/tree/prerelease/v2-alpha

Forwarded from: https://x.com/cartesiproject/status/2034268766033650115

Rollups Node v2.0.0-alpha.10 has been released. One step closer to the official release.

This update aims to bring the node to production-grade standards: stricter resource management, crash recovery, database transaction safety, and proper handling of long-running and multi-application deployments.

This means:

Now, multiple applications can run on the same node without interfering with each other, and the machine manager can easily recover after long downtimes without causing memory pressure.

The likelihood of your application crashing is lower, and even if issues arise, it can recover gracefully.

→ https://github.com/cartesi/rollups-node/releases/tag/v2.0.0-alpha.10

This is the solid foundation you need before preparing for production environments and launching on the mainnet.

Dear developer friends, come and experience the latest Cartesi CLI prerelease version, test Rollups, and join our Discord server to provide feedback and interact with our contributors!

→ https://github.com/cartesi/cli/tree/prerelease/v2-alpha

Forwarded from: https://x.com/cartesiproject/status/2034268766033650115