CTSI官方中文社区

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

GM from Cartesi, the best ever!

Linux has been the driving force of the internet for decades, and now, thanks to Cartesi, it also powers on-chain applications.

Thanks to ItsFOSS for the inspiration.

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

Can you have both fish and bear's paw? A calm evaluation of non-interactive ZK fraud proofs

https://mp.weixin.qq.com/s/tfV5s2lZ3VEPWHqULHDFvQ

Let's learn together - - - what is the future of social application chains?

https://mp.weixin.qq.com/s/U0A44cwZ1IQhuvgdCB9Qgw

It's Friday again, time for our Cartesi weekly report, bringing you the latest updates from the entire ecosystem this week 🐧

In terms of infrastructure, Dave 2.1.1 has been launched on devnet and all supported testnets (Ethereum Sepolia, Arbitrum Sepolia, OP Sepolia, and Base Sepolia). It has also been published to the Cannon registry, so you can pull it directly and test the fraud proof system on any of these networks immediately. For all the details, chat with contributor Guilherme Dantas in the rollups channel on Discord:
→ https://discord.com/invite/cartesi

Thanks to contributor Shaheen Ahmed, developers now have new code snippets for Rust, Go, and C++, as well as vibe coding resources. Now, there's no excuse to not build your own DeFi applications with Cartesi in your language of choice:
→ https://x.com/cartesiproject/status/2031007146637410765

A new demo version has been released, showcasing how to integrate margin curves into your Cartesi application for price discovery, where everything is determined by buying, selling, and algorithms:
→ https://x.com/cartesiproject/status/2032094462193910107

Why is this important? Listen to what Macky_DeFi has to say:
→ https://x.com/Macky_DeFi/status/2032105736172429398

DevAd leader Joao Garcia continues his DeFi series, analyzing the execution layer constraints that hinder DeFi development, and how Cartesi opens up new design spaces through libraries like Python, NumPy, PyTorch, etc. As long as it runs on Linux, it can run on Cartesi and on-chain:
→ https://x.com/joaopdgarcia/status/2031363751983620539

This week we are keeping up with the emoji trend:
→ https://x.com/cartesiproject/status/2031731970322137384

Check this out: a modified WebCM (Web Cartesi Machine) version that enables multi-agent serverless coding in the browser through vibe coding. What does it say:
→ https://rkat.ai/demos/webcm/

That's all for this week's content. Come join us on Telegram, interact with other Cartesianists, and speak your mind!
Forward: https://x.com/cartesiproject/status/2032456798352072748