Podcast Transcript

Cartesi Linux Appchains: When to Use Them

João Garcia Developer Advocate, Cartesi

When does a dApp need its own Linux execution environment? Cartesi developer advocate João Garcia explains how app-specific rollups isolate computation, reuse Python and other mainstream libraries, and support verifiable AI and games. He also explains when ordinary Solidity contracts are the simpler choice. This conversation was published in May 2025; the research prototypes and release plans are what Garcia described in the interview.

  • Published 16 May 2025
  • Runtime 27:25
  • Operator
  • Recorded in English
Cartesi Linux Appchains: When to Use Them: podcast episode with João Garcia, Developer Advocate, Cartesi
// The short version
  • At 03:12, João Garcia explains that with an app-specific rollup, people hosting a node run only the applications they choose to host. Dedicated execution reduces competition with unrelated applications, the noisy neighbor problem; it does not remove every infrastructure bottleneck.
  • At 07:05, Garcia distinguishes booting Linux from merely compiling a language to RISC-V. A full operating system brings a filesystem and standard libraries, so developers can reuse more of their existing software stack. Cartesi Machine documentation explains the execution environment.
  • At 08:36, Garcia separates verifiable machine learning from LLMs. He describes regression and KNN examples, cross-compiling PyTorch and scikit-learn, and experimental work on deterministic LLM execution. He presents research progress, not a production performance benchmark.
  • At 15:29, Garcia recommends keeping Solidity when an application does not need extra compute or particular libraries. He argues against rebuilding an ordinary token contract in Cartesi solely to use a preferred language.
  • At 23:20, Garcia says there is no silver bullet. Interoperability between rollups still requires design work, and a coprocessor offers a different set of benefits from a rollup. His advice is to combine complementary protocols and reuse existing tools. The Dave research paper gives the fraud-proof design and assumptions.

Why build with Cartesi Linux appchains?

Watch this part · 0:00

Kevin 0:00 Hi everyone. Today I’m talking with João Garcia, developer advocate at Cartesi, a Linux-based app chain infrastructure that you can use to develop specific applications that are verified through a rollup. And the best thing about it is that you basically can use any general purpose library or language that you basically have available on Linux as well.

Kevin 0:25 So really exciting episode, a little bit techy as well, but if you’re eager to build a new project or if you are on the lookout for great infrastructure, that’s your episode. What are the three main reasons why developers should go for your platform, for your solution?

João 0:45 Well, three main reasons. I think the first one is definitely empowerment. They are able to do more. They are able to use more tools, right? So they are empowered to create applications that are different than any other Web3 project. So you can use different tools, like anything that would run on Linux would run on a rollup created using Cartesi, right?

João 1:14 I think the second one is great support from community. We have everything laid out for everyone in our Discord. Every contributor is active right there. And we really provide great support for everyone. And I think the third one is honestly insurance and security.

João 1:42 You are able to use the best fraud proof possible with our tools. We just developed the Dave, which L2BEAT recognized as an amazing fraud proof. But besides that, everything that we do is open source. All of our discussions are in the open. Our developments are all in the open. So everyone can watch Discord and know what we’re building.

João 2:09 So I think everyone can trust that we’re doing good for good and I think I think those are three good reasons.

How do app-specific rollups avoid the noisy neighbor problem?

Watch this part · 2:17

Kevin 2:18 Awesome. Awesome. So the vision is is aligned with with the end consumer, with the developers basically. Um, like getting a little bit deeper on that. Um, I mean that was already super helpful, but from a purely developer perspective, let’s say I’m building uh something. Um, like why would I specifically, like what value do I hope to to get from the tech itself?

Kevin 2:46 Like why do I want to have this this uh Linux based uh rollup approach over just having something else like smart contracts or even having whatever I would use otherwise?

João 3:01 That’s actually a very good question. I think there are two main reasons why you would want that and we can split them. So I’m gonna go first for point A and then for for point B. Cartesi, what you do with our rollups framework is you create an app-specific rollup. And that means that every person who’s hosting a node that wants to run an application is running that application specifically.

João 3:28 Of course, there are mechanisms that we’re creating for you to be able to run more than one application in a single node. But the core idea is still the same. You only host the applications that you want to. So you’re not wasting resources running other applications. And at the same time, you avoid applications starving each other of resources.

João 3:51 So in a shared rollup where every application runs in the nodes together, one application is consuming resources as the other. If one is getting many, many, many requests, receiving so many inputs, the other ones will be starved of computing power. So it’s, in our case, what we end up doing is giving every application a full CPU in this sense.

João 4:19 So no application is ever going to be, is ever going to have a problem because of another one, right? Each application works and is independent. And the second one is Linux itself, which I think is a great reason. But when we just say Linux, people don’t seem to understand what Linux brings as an advantage, right?

João 4:42 There are many advantages, but whenever you’re running Linux, almost everything that was created for computers is created in Linux first. And okay, some games are probably not, but whatever service that you’re running, that that game is running, probably the server, the backend is running in Linux. Whatever bank software, whatever social network, the servers that run, that host the data, that hold the data, that host the processing logic is being run in Linux.

João 5:19 So libraries like machine learning libraries, gaming libraries, mathematical libraries, all of that is made for Linux first. That means that everything that was created in the past can be used. So you’re not stuck with just the libraries that Solidity has. You now can use libraries from Python, from JavaScript, from Rust, Go, whatever language you want, code however you want, using whatever language you want, of course.

João 5:49 And that brings backwards compatibility in the sense that everything that was created works, but also brings forward compatibility in the sense that everything that will be created will work because everything will be created for Linux first. Right. And I think that’s awesome. And yeah, I think, I think that kind of covers it.

Kevin 6:10 Cool stuff. So just to make sure I fully understand, uh, basically app chains in general will solve the so-called noisy neighbor problem, right? You’re basically separated from other independent projects and that, as you mentioned yourself, it’s basically you are not influenced by the CPU usage or whatever execution they basically have to perform in any way.

What does Linux add beyond a RISC-V runtime?

Watch this part · 6:11

Kevin 6:39 So that’s the first advantage. The second advantage basically is, well, I don’t need to learn a new programming language or something like that as well because I’m able to tap into the Linux ecosystem, into general purpose languages like Python, whatever. Um, in contrast to lots of other app chains that are out there, which oftentimes have these domain specific languages.

João 7:02 Yes, exactly. Just to just to add to that something that I forgot mentioning and I think it’s kind of relevant, right? We created this RISC-V emulator and put Linux on top of it. But the important thing of, we could theoretically run the languages directly on RISC-V, like just compile them to RISC-V and run.

João 7:25 But in this case, we would be doing like some other protocols that do that. We would be running using the C language here, a freestanding language. So that means the minimum essentials just to run the language. But you lose some resources like having a file system, being able to deal with some standard libraries that allows you to process some information in different ways.

João 7:49 So you get even more flexibility and more powerful by having an operational system inside there.

Kevin 7:56 I mean that that’s oftentimes the issue, right, when people or projects say, hey, you can use C++, C, Python, whatever, but then it’s just heavily restricted.

Can Cartesi run verifiable AI and LLMs?

Watch this part · 7:57

8:08 Yes.

Kevin 8:09 Right? So that’s kind of a really cool thing if you really have access to all that, to the full ecosystem. And that’s actually quite impressive from a technical perspective. One of the use cases that you have on your website, which of course is a hot topic, right, is verifiable AI. Would you mind sharing some light into that?

João 8:34 Yeah, of course. I think verifiable AI is a very nice thing that we’ve been doing for a while. But I also think that people overestimate a little bit what the word AI is, because whenever someone say AI, everyone thinks of AI agents and they immediately think of LLMs, right? Because ChatGPT made all that noise and then DeepSeek and every everyone else, right?

João 8:59 [unclear] AI in itself is so much more than that. AI starts from the basic concepts of AI, like linear regression, like KNNs. So there are many AI algorithms that we think about when we think about AI. So we started with these simple examples, and we started by using some techniques, because compiling libraries to RISC-V was not that trivial at first, and now it is.

João 9:28 But we started by doing things like KNNs, like linear regressions, and we had to use a mechanism. A friend of mine did it, Marcos, shout out to him, called m2cgen. So you basically transform the machine learning model into direct Python code, and it worked fine. Then we managed to actually cross-compile the libraries from machine learning like PyTorch and scikit-learn to our machine.

João 10:00 So you’re actually able to fully use those machine learning libraries in RISC-V, in Linux, in our machine. So that’s some cool things. Unfortunately though, lots of those models like LLMs, they require an amount of resources that to be able to verify them, you would need super hyper ultra computers if you want to, or you would need GPUs, right?

João 10:27 And then GPUs have the whole problem of being non-deterministic. So in a sense you would have to do some workarounds on that. We, at first, LLMs sounded like something very complex to do, but we’re striving forward in it. And I think we’re making some very good progress on it. And in a hackathon, internal hackathon that we do with our developers, with our contributors, one guy called Eduardo, who’s like this amazing dev, he actually found a way to run things in the Cartesi Machine, but delegate the complex computations, just the matrix multiplications that you use on LLMs to the host machine.

João 11:15 So instead of using just one CPU, you use just one CPU for the emulated part, but you can delegate the deterministic calculations to the host machine, which is sort of crazy, but we basically improved by a bunch the processing power. And now we are able to start running LLMs deterministically, which is also very awesome.

João 11:36 And yeah, and we’re we’re studying that, how we can make some progress in there.

Which DeFi and onchain gaming use cases need this compute?

Watch this part · 11:41

Kevin 11:42 Yeah, I mean, uh, building uh on the bleeding edge is always mostly research, right? That’s just part of the game. And that being said, I’m curious, like, what other use cases are you currently exploring? Because general purpose basically means you can do lots of stuff, right? And I’m pretty sure there’s also some things maybe you shouldn’t or can’t do in some sense.

Kevin 12:08 So that would be interesting as well.

João 12:09 So um, I think, I mean, you mean general use cases inside machine learning or general use cases as a whole?

Kevin 12:18 Okay, what you are personally most excited about.

João 12:20 I think we cannot left uh untouched the point of DeFi. Of course, after all, it’s the world we’re into, right? So there’s a solution that I find really, really cool that’s called DCA Monster. So what it does is the cost dollar averaging strategy for investment, but it does with a minimum granularity.

João 12:44 That means you get the minimum granularity that a token has, which is like 10 to 18 or whatever, and you change, you you start swapping the assets in a, in very very very very very tiny batches. So you can basically say, I want to exchange this one token to dollars or to USDT, right? But I want to do it in a matter of a month.

João 13:14 So every second for that month, you will be swapping that granularity part, which is actually really cool. And you wouldn’t be able to do it otherwise if you didn’t have a machine capable of performing these calculations in, to this level with this facility, right? So it’s essentially an automated market maker that works pretty nice.

João 13:34 And so this is a solution that I really find funny. And of course, uh, as someone who’s a little geeky, I really love games. We have two gaming solutions that I always like to mention. One of them is called RIVES. RIVES.io is the website and it’s a, it’s an on-chain custom console where people can actually create games, sell games, and play those games deterministically.

João 14:02 It started by running Doom. So people would be able to play Doom, send the logs of their gameplay. So every instruction they sent to the game, to the blockchain, and their gameplay would be verified. This is very cool for, um, let’s say speedruns, for example, uh, for competitions, for tournaments, which is, which is very nice.

João 14:24 And then, um, there is another one that just launched recently. It’s called World Tycoon. So do you remember SimCity?

Kevin 14:32 Yeah, sure.

João 14:33 Yeah. So we made SimCity on chain there. We just finished this grant. I’m actually evaluating it right now to do some code reviews. But it’s SimCity on chain. You deposit your assets first. And if you’re able to start making money with your city, you can actually get the assets that other people deposited trying to make their city and in case they fail.

João 15:00 So there is this whole dynamic with tokens on SimCity that turns to be pretty fun.

When should developers use Solidity instead of Cartesi?

Watch this part · 15:05

Kevin 15:05 Love it, cool stuff. I mean, GameFi is always a big topic, a big part of blockchain and crypto space in general. Are there some things that you think Cartesi is not really super suitable for, like it’s not ideal?

João 15:28 That’s actually a very good question. So, if we take applications in a vacuum, I think I don’t see why people wouldn’t want to use it, but I don’t think people should be using Cartesi and creating. So if you don’t need the processing power, if you don’t need the specifics of, um, if you don’t need specific libraries to run, to run your software, to execute your vision, then maybe you should just be sticking to Solidity, right?

João 16:09 So Cartesi was not made for you to say, hey, I can do this on Solidity, but I rather do it on JavaScript, so I’m just going to write using Cartesi. That’s not the intended idea. Of course you can, anyone can use the application however they want. But I think if something is simpler in Solidity, sometimes you just use it.

João 16:29 There’s no issue there.

Kevin 16:31 Okay. So, so it’s basically more about educating developers and making sure that like, if you want to build one of these standard Solidity smart contracts or something that is being built all the time, just follow the best practices there instead of some kind of reinventing the wheel with Python there.

João 16:50 Yeah, exactly. I mean, since like the whole concept of Cartesi using Linux, using all those libraries is to not reinvent the wheel, right? Do not try to recreate extremely complex libraries for machine learning, for example, as you mentioned, in Solidity. Just use what you have. So use the rollup that will allow you to do that.

João 17:11 Do not try to reinvent the wheel. And the opposite is also true, right? We already have some things that work really well for regular token creation. So do not try to reinvent the wheel, recreate this fully on Cartesi as well. I mean, things are supposed to run together, not competing with each other.

João 17:32 So use the best use case of each.

What unusual games have developers built?

Watch this part · 17:33

Kevin 17:34 I like it. Like we have already talked about some interesting or useful use cases. Have you discovered or seen in your community any crazy or super funny ones, like that you say, okay, I’m I’m not sure if that’s useful, but it’s it’s an interesting one?

João 17:56 Sorry, what do you mean again?

Kevin 17:58 Like, are you aware of any crazy solutions, use cases that people have built on your your platform, or is it just useful things so far?

João 18:10 Oh, no, no, no. There are some crazy fun things. There was this, I love this one. I think it’s not on, I I think it’s not on mainnet anymore, but it was, uh, maybe it is. It was a meme battle. So what people would do is bet on a meme.

João 18:35 So we would have like Shaquille O’Neal versus Sonic and you would simulate a fight of two, the two of them, and you would actually see them battling each other and people were able to bet on their favorite fighter. Uh, so it was a little crazy and it was AI automated, so it was kind of like a zero player game.

João 18:55 It was really funny and there was one that was so degenerate, I think it’s actually happening. It’s called Bubble Wars, where you invest some assets there and you become a bubble based on the number of tokens that you deposited in the application, right? And then you use on-chain physics to move your bubble.

João 19:14 So propel it to some direction and if it touches another bubble, it steals the assets of that person.

19:21 That game. Oh wow. I was,

João 19:23 and you increase and your bubble increase in size. So it’s really degenerate, but it’s really funny.

Kevin 19:29 Wow, that sounds super painful. Like just imagine, um, either you you have collected that many and and some of these big parent bubbles, like as you have seen on, I think it was called Agar.io, or like what’s the name of the original game?

19:48 Yeah, it’s like Hole.io, [unclear].

Kevin 19:50 Yeah, crazy. Okay, that’s indeed actually one I could imagine would be taking off, uh, if marketed properly, right? Because I mean that can be viral. That’s that’s fun. Cool. Um, like I’m not sure like how, like, it sounds like it, but how deeply you have been involved in the actual infrastructure, uh, itself, like infrastructure work.

What makes fraud-proof design difficult?

Watch this part · 20:06

Kevin 20:17 Uh, can you share a couple of core learnings that you had during the initial development, right? Like what were some of the core challenges, what were or what are core challenges now to make this, let’s say, more verifiable or whatever?

João 20:35 So I was not in Cartesi at the beginning because Cartesi was, the idea of Cartesi, I think, started in 2018. That’s when the first white paper was created, right? And I just came like two years ago.

20:51 Okay.

João 20:51 But from things that I’ve been learning now, that I see them happening now and the team’s working on it and struggling with it, I think the creation of fraud proofs was something that was very delicate and very beautiful to see the way it was created, it was proposed. I think all the little things that you have to think when you’re designing a fraud proof algorithm, like the liveness of the chain, the amount of cost that you need to be able to participate, that you have to stake to be able to participate on a fraud proof.

João 21:34 All of those things being decided together until the algorithm coming together. It’s crazy. So at first we had this fraud proof called PRT. We’re launching a practical version of it real soon. And we already have the paper for Dave, which is like an improved version. But it was very interesting to see the struggles and the pain points that we found in each fraud proof and how we had to tackle each and every one of them.

João 22:03 Gabriel Coutinho, who’s leading the development of those fraud proof algorithms, he’s been kind of explaining them to me as they were conceived. And I was flabbergasted all the time because every time they would hit a wall, but genius minds were actually able to break those walls, right? He would just tell me how the meetings go.

João 22:26 Like, hey, Augusto, I just found a bug. This won’t work. And Augusto, who is one of the founders of Cartesi, would say, okay, I need some time to think and go to the whiteboard, draw some things and come up with a solution. It was just awesome. But yeah, I think that was the most delicate part.

What are the limits of appchains and the value of modularity?

Watch this part · 22:42

Kevin 22:43 Love it, love it. I mean, cryptography, if I can pronounce it, is always a super challenging topic, right? So I love to see that you have some cool team dynamics in your company as well. So, um, I would have one last question for you. What are some three key takeaways you either from working at that project you had for yourself or that you want to tell developers to to onboard or to use Cartesi?

João 23:18 Okay. So key takeaways, I think there is no silver bullet. There is not one protocol or one stack that you can use that does everything. So everyone has its limitations. Even even if you think of us, uh, designing our solution, Cartesi also has its limitations, right?

João 23:43 Even though you’re running Linux and you can do all you can do in Web2, you have to go around some things to, to, for example, if you want some degree of interoperability between rollups, you have to think well. So that’s why we ended up creating other solutions like the coprocessor that, um, do not, that deliver other benefits.

João 24:06 It does not deliver the rollup mechanism, but a fast finality coprocessor solution, which is really nice. So I think the first thing is there’s no silver bullet. I think the second thing is people who try to reinvent the wheel end up falling on the trap and they stay for so long trying to create something new instead of just using what’s out there, that they lose the opportunity of doing something that’s actually relevant, right?

João 24:43 And the third one, I think, is protocols should work together. I think that’s the most important thing. We had some amazing partnerships with, uh, EigenLayer to create our coprocessor, with Espresso, with Avail, and the solutions that come out of merging the knowledge of two different teams that are very good and specialized at some things, you can create something that’s even cooler, right?

João 25:15 So if you check out, for example, our integration with Espresso, you can see that you’re going to use our execution environment with, with their data availability and sequencing and create something that’s very different than anything that everyone has ever seen. So pick whichever is best from everyone, so you can make the perfect solution from you, for you.

João 25:39 Yeah, I think I think working together is, should be the the motto of this, should be the ethos of the ecosystem as a whole.

Kevin 25:48 I love it. Yeah, I mean, that’s the spirit of Web3, right? Like as people like to say, it’s all about community and building something that people really want.

25:58 Yeah, exactly.

Kevin 26:00 Awesome. Hey, any last words from you? Anything that people should do after watching this session?

How can developers get started with Cartesi?

Watch this part · 26:01

João 26:07 Yeah. Recently, I heard we, I got the feedback that we have really good docs. So try and experiment and play around with Cartesi. Join our community. Just even if you don’t want to code, just join to see what’s being, what’s being done there, what is being cooked, so you can learn a little bit more about it.

João 26:27 And if you, if you want to talk, if you have any doubts, just reach out to me on both Discord or Twitter. I’m there. And see you soon.

Kevin 26:38 Cool stuff. Definitely will put the links into the video description as well. And yeah, thank you again for your flexibility and your time. And it was really cool talking with you. Lots of new stuff that I’m really eager to further tap into as well. And one last thing for all developers here, all non techies, having a great documentation is so underrated.

Kevin 27:03 So kudos to you guys. Cool.

João 27:03 That’s very true.

Kevin 27:04 Nice one. Hey, thanks man. Was great chatting. Have a great rest of your day.

João 27:13 See you. See you.

Kevin 27:13 Wavect, the Web3 software company that understands what you want.

Transcribed from the original audio with Whisper large-v3 and AI-reconciled with the original automatic captions. Unclear speech is bracketed; speaker labels and translations are editorial aids. No complete human listening pass. The recording remains authoritative; statements reflect its date. Product plans and AI experiments, including the planned practical PRT fraud-proof release and the hackathon work on deterministic LLM execution, are what Garcia described in the interview. The interview was published in May 2025; that publication date does not establish its recording date. These plans and experiments are not a current production guarantee.

Questions this episode answers

In this interview, João Garcia describes Cartesi as a framework for app-specific rollups with a RISC-V machine running Linux. Application logic executes offchain in a reproducible environment, while fraud proofs provide a way to dispute incorrect computation. The appeal is dedicated application compute plus familiar languages and libraries.
Garcia explains that unrelated applications on a shared rollup compete for execution resources. An app-specific rollup gives an application its own computational space, so another application’s activity does not consume that same execution budget. This isolates application computation; it is not a guarantee that settlement, data availability or hosting can never become bottlenecks.
Garcia says developers can use mainstream languages including Python, JavaScript, Rust and Go, and reuse libraries supported by the Linux environment. He discusses cross-compiling PyTorch and scikit-learn to RISC-V. Compatibility and resource requirements still need checking for the actual application; this is not a claim that every dependency works unchanged.
At 15:29, Garcia recommends Solidity when the application does not need additional computation or specific Linux libraries. A standard token contract is his example. He frames Cartesi as a way to enable otherwise difficult workloads, rather than a reason to rebuild simple Solidity functionality in another language.
No. In this conversation, verifiability concerns reproducible execution of a model or computation. It does not establish that the model’s answer is factually true. Garcia also distinguishes smaller machine-learning workloads from resource-intensive LLMs and describes deterministic LLM work as an experiment in this interview, which was published in May 2025.
Garcia treats them as different tools. He says Cartesi created the coprocessor, in a partnership with EigenLayer, to deliver other benefits. It does not deliver the rollup mechanism but offers a fast finality coprocessor solution. He brings it up while explaining that Cartesi has limitations, for example that interoperability between rollups needs careful design. His closing advice is to choose the tool for the workload and combine protocols rather than assume one stack solves everything.

Want this kind of thinking applied to your product?

We build MVPs and act as fractional CTOs for founders who’d rather ship than talk.