Vite is amazing, I think we can all agree on that statement. But what is Vite actually!? Why is it so great, faster than webpack and the "de-facto standard of the web" already?
Alex is joined by Vite Core Team member Matias Capeletto, better known as Patak, to talk about all these questions.
Learn about the future of Vite, how it uses two bundlers under the hood and why almost every framework adopted it. Enjoy the episode!
Links marked with * are affiliate links. We get a small commission when you register for the service through our link. This helps us to keep the podcast running. We only include affiliate links for services mentioned in the episode or that we use ourselves.
Chapters
Chapter 1
Welcome to DejaVue
How did you get into programming?
Working on Open Source Full Time
What is Vite?
Why is Vite so fast?
Rollup and ESBuild?
VoidZero and Rolldown
The Scope of Vite
Vite Environment API
Converging Frameworks
Funding in Open Source
React as "the last framework"?
CRA Deprecation
Where can people follow you?
Last Words
Vite is amazing, I think we can all agree on that statement. But what is Vite actually!? Why is it so great, faster than webpack and the "de-facto standard of the web" already?
Alex is joined by Vite Core Team member Matias Capeletto, better known as Patak, to talk about all these questions.
Learn about the future of Vite, how it uses two bundlers under the hood and why almost every framework adopted it. Enjoy the episode!
Links marked with * are affiliate links. We get a small commission when you register for the service through our link. This helps us to keep the podcast running. We only include affiliate links for services mentioned in the episode or that we use ourselves.
Creators & Guests
Host
Alexander Lichter
Web Engineering Consultant • Founder • Nuxt team • Speaker
Guest
Matias "patak" Capeletto
Vite Core Team & Open Source @ StackBlitz
Editor
Niki Brandner
Audio Engineer and Video Editor
What is DejaVue?
Welcome to DejaVue, the Vue podcast you didn't know you needed until now! Join Michael Thiessen and Alexander Lichter on a thrilling journey through the world of Vue and Nuxt.
Get ready for weekly episodes packed with insights, updates, and deep dives into everything Vue-related. From component libraries to best practices, and beyond, they've got you covered.
Alexander Lichter:
Hey, everybody. Welcome back to DejaVue. It's your favorite Vue podcast. You just don't know it yet. And as you might hear it, we are we are not alone here.
Alexander Lichter:
Actually, it's the two of us. Michael is on vacation, and, of course, I don't wanna do a podcast alone. Probably could, but it would be more or less a YouTube video. Anyway, long story short, I have an amazing guest here with me. If you watch the video, you might be, like, a bit confused.
Alexander Lichter:
Like, why is not a cat sitting in front of the microphone? Because it's the one and only Matias Capeletto, also known as Patak. How are you doing?
Matias Capeletto (Patak):
Hey, Alex. Doing great here. Thanks a lot. Very nice to talk to you.
Alexander Lichter:
Yeah. Likewise. As usual, it's always great to to have a chat. And then now we talk about on the podcast all about Vite, what's going on there, latest news. But before, maybe a little bit about you personally because, like, usually, when we have guests in the podcast, we wanna capture a bit of the history, how they got into programming and so on and so on.
Alexander Lichter:
So right now, you're doing open source at Stackblitz. So you work on open source full time. But how did you get there? Like, how did you get started with maybe programming, first of all?
Matias Capeletto (Patak):
That's long, long, long ago.
Alexander Lichter:
That's fine. That's fine.
Matias Capeletto (Patak):
I study electronic engineer and always liked it more the programming side. I did my first open source with c plus plus Like, I got, like, a good summer of code and did a library for Boost. I did that for a while, but then, like, I ended up working on, like, a graphical engine for the web for a long time, not doing anything related to open source, but that introduced me to the web, like, in the time of Internet Explorer six and, like, it was yes. SVC was not even available, like, everywhere. Like, she has to give a and, yeah, like, I got at one point working in a company where I was, like, focusing on education and, like, there was a lot of an agency with a lot of people joining per week.
Matias Capeletto (Patak):
And we started using open source as a tool to, like, help developers, like, learn skills, also, like, soft skills, like, you learn, like, when you send a PR, you talk with the maintainer. Not not to be, like, sending a lot of PRs everywhere, but, like, it is a really good tool if you do it right. And we have this small, like, open source club where, like, every week we will, like, share the PRs that we were doing. And I started again doing open source in around the Vue ecosystem, like Vue use. Because of that, like, I wanted to, like, be part and not only say, like, hey.
Matias Capeletto (Patak):
You should do PR because this is good for you, but, like, also, like, be part of that group. Quickly, it's starting to, like, get back to me, like, the doing open source. And VueUse took me to VitePress and VitePress, at one point, I ended up, like, sending a few PRs to Vite. In the times when Evan was doing this crazy sprint to go from Vite one to Vite two, and that this was, like, incredible to see Evan work there. And, like, I started, like like, doing documentation, PRs, and, like, working on rollup compatibility.
Matias Capeletto (Patak):
There was, like, there was at that point, it wasn't, like, very polished, so I was reporting issues and, like, everyone was closing them before I hit the, like, open issue button. Wow. So it was very it was very nice. Yeah. Like, at one point I decided that we'd look at, like, a very interesting project to learn and to also be involved with, like, maintainers that for me was, like, my heroes for a long time.
Matias Capeletto (Patak):
A lot of the people from, like, framework authors were starting to get into Discord. We created, like, the Discord with other people from the community, and it was, like, a really interesting time. And Evan had to refocus on Vue because, like, he spent a lot of time with Vite at that point.
Alexander Lichter:
And Vue two Vue three was still outstanding, right, at that point, I think?
Matias Capeletto (Patak):
I I think that that was already released at that point, but there it was there was still, like, a lot to do because, like, the transition between v two and v three, like, it still is
Alexander Lichter:
Still ongoing.
Matias Capeletto (Patak):
Ongoing
Matias Capeletto (Patak):
in in certain ways.
Alexander Lichter:
Maybe it was around time of, like, script setup and so on coming, like, 3.2 or something like that. Yeah. Because I remember it. I was like, okay. Let's shift the focus back.
Alexander Lichter:
Yes.
Matias Capeletto (Patak):
Yeah. Yeah. And so, like, he created, like, the team, the Vite team, so, like, to focus on daily maintenance of it. And Anthony Fu, underfin that now is working on rolldown, And like me, like, we're the initial group. We quickly are starting to, like, involve other people, like some people that were helping from the Svelte side, for example, that already migrated from Snowpack to Vite.
Matias Capeletto (Patak):
And so, yeah, like, that started the the story with with Vite that later on, as you said, luckily, Eric Simons, the CEO of Stackblitz, like, contacted me, and Vite was extremely aligned with what they needed because they they had this online IDE that could load note, like, could run note in the browser. And it was, like, loading very fast. But then when the build tool step and npm install of, like, the tool came up, it was, like, very slow. And Vite was exactly the piece they needed to so, like, the whole experience will be very fast. Vite was very lean and, like, very fast for so, like, in the in development mode.
Alexander Lichter:
When would you say that, like, Eric from Stackblitz contacted you to say, hey. Do you wanna wanna work as an open source maintainer and getting paid by Stackblitz? Like work on Stackblitz, but spend your time on Vite. Like, how long did it take you from, let's say, your first contribution to Vite? And how did you do that?
Alexander Lichter:
Like in your free time, I guess, after after hours?
Matias Capeletto (Patak):
I was at the beginning doing it after hours and a little bit, like, in the hours because, like this was part of like this open source, like
Alexander Lichter:
True.
Matias Capeletto (Patak):
Work, like education, like working with other people there in that company. But I was already working part time there, so I had some time. I was able to arrange things so like slowly I was more and more spending time on the open source side and like less on that company. I have already decided that I would just like jump into open source because I saw I saw like the growth, and I saw how things were going.
Matias Capeletto (Patak):
And I knew that if I do this for a year, like, even, like, just, like, without any pay at all. So I already decided, like, I will just do this for a year. And I arranged it with, like, the the company I was working. I, like, told them, like, I will just do this because this is, like, an incredible opportunity for me. And, yeah, I I jumped it and I knew that I had doors open.
Matias Capeletto (Patak):
Like, it's just like, I don't want to say that I jumping into the into the void there. And, luckily, this I think that when I did that, I already got contacted by Eric maybe, like, two months after that or something like that. And then just to give a this was like a year less than a year after the creation of the vite team, and we were just, like, creating vitest.
Alexander Lichter:
Oh, okay.
Matias Capeletto (Patak):
At that particular point, like
Alexander Lichter:
yes
Matias Capeletto (Patak):
there was the the time when Vitest was, like, in this sponsorware mode, like, kind of a steal mode before, like, opening. And Anthony Fu was, like, yeah, calling, like, crazy, and, like, everybody in that, like, little community that we formed was like, it was a very, very interesting time. And, yeah, like I joined in that. I think like the first contact with Eric was in December and I ended up like February.
Matias Capeletto (Patak):
I was starting to work there and it has been amazing because I think that this setup where the companies hire open source developers to work full time is like really interesting both for the developers and for the projects because you can do long time planning.
Matias Capeletto (Patak):
You can, it is very different just being able to code on your nights, you know, like, compared to, like, you have the time to properly do it. So it was great. And then after that, like, there was, like, other companies getting other people involved because it just grow. And I and now, like, we we have Void Zero also that, like, it's just, like, taking things to a completely different level.
Alexander Lichter:
Exactly. But before we jump into that whole angle, I mean, there there's so many points we could talk about. It's so crazy because it's really a remarkable project.
Alexander Lichter:
But for everybody maybe listening and heard like, oh, yeah. Vite, I heard about it.
Alexander Lichter:
I kinda also, like, use it, but I don't actually know what it is doing. Like, yeah, before, there was something like Webpack, right, in the past, and we don't use it anymore. And there are also other things. Like, maybe if you would explain, like, the average developer out there, what Vite is, what would you say or what do you say if people ask what it is?
Matias Capeletto (Patak):
First, like, something that is important there is that, like, if people are using Vite and they don't realize, that is one of the best compliments they can give to a build tool. Like, it isn't getting in your way. It's doing their job. Normally when yeah. Normally, when you realize it's it's that it is not it is not not the best.
Matias Capeletto (Patak):
But so like, I think like everybody is familiar with Webpack, but if not, like when you build a Vue application, you code like with like single file components in like your dot Vue. And if you feed that dot Vue to a browser, like it will not know how to, like, cope with it. More or less because, like, in Vue in particular, you can, like, import directly from a CDN, like, and get it done. But you need to normally imagine that you have, like, tailwinds or you have, like, any, like, JSX in React. Like, you need a tool that will get your source code.
Matias Capeletto (Patak):
You are using TypeScript, for example. Like, you need a tool that will take all this source code and will compile it into only HTML, CSS, and JS that the browser know how to execute. That is like baseline, but these build tools also do a lot more for you. And they will, for example, trishake your code. So, like, if you have a lot of, like, functionality that you're not using at all, you can create, like, smaller bundles and only send to the browser what is actually going to be needed.
Matias Capeletto (Patak):
And then your application can run faster. And then you have, like, browsers, like, depending on how what is your target users, these build tools will also, like, downgrade your code to, like, the lower common denominator that you need. So it will run across all the browsers, and it will transpire certain syntax. It will do things from, for example, stripping the types, like removing all the type information that you like, it helpful while you develop, but later on, it's it shouldn't be there when you execute it. Absolutely.
Matias Capeletto (Patak):
So this is, like, the build tool during, like, build time. But all these build tools, this process is costly. It's like it tree shaking and compiling and creating this bundle takes time. So what happened is that you also have like a dev mode in these tools where you have different trade off because you have your source code directly there. In the case of, Webpack, for example, how it was before, it will still generate the bundle at the beginning, but it generate the bundle in a certain way that later on, there is a lot of annotations for doing what is called model replacement.
Matias Capeletto (Patak):
So, like, when you change a particular module, only that module is sent, and then it's, like, replace it into the whole thing. And then you can have this experience where you are editing a file, like changing some letters, like a paragraph, and you see it right away on the other side. Vite, in particular, what really set it apart was that browsers at that point were, like, a lot more advanced than when Webpack started. So, like, we could use directly ESM, like modules in development mode. So, like, if you see how dev mode work in bit, like, we don't bundle anything.
Matias Capeletto (Patak):
We just start a smart dev server that, like, when the browser requests the first index. Html, like, we transform that one and give it back with the right path. So to keep, like, asking for the scripts for the CSS, and the browser will ask for, like, give me this TS file. And Vite on the other side, like, will grab that only one module and we'll strip the types of that particular model and give that something that the browser can consume. And all the tree is, like, recreated on the browser side, but at the model level, let let's say.
Matias Capeletto (Patak):
And this was really interesting because instead of having, like, when you start Webpack, you will have to wait for the bundle to be generated before giving it to the browser.
Alexander Lichter:
I can remember, like, back in the times, that always took a while. Yeah.
Matias Capeletto (Patak):
Yes. And Webpack is a JS tool. So it's not like what we have right now with some, like, Rust, like, ES build, that is written in Go or, like, Rolldown in Rust. That is, like, that process is extremely fast, so it enables some other things. But in the like, with Vite, you will, like we will print how much time it took to start the thing.
Matias Capeletto (Patak):
Mhmm. And that was kind of like yeah. It was started, like, in less than a hundred milliseconds because basically we don't do anything. So it was just like
Alexander Lichter:
It's a process, basically.
Matias Capeletto (Patak):
Yeah. It's just like loading the config file and printing. Yeah. It took us nothing. And it was very magical at first because if your application doesn't have like, let's say, 10,000 modules that at the end end up adding up, then it's it's really, like, for most most applications, except, like, some like, mostly enterprise application, it was just, like, magical.
Matias Capeletto (Patak):
It felt like opening just a static server and just seeing the files there, you know?
Alexander Lichter:
And It's a good old experience. It's just like, hey, here's a server and we can just, just go using the things.
Matias Capeletto (Patak):
Yeah. Yeah. And then HMR also was a lot simpler, the model, because we we could also replace at the, like, module level. It was extremely fast. It scaled very well no matter, like, how many modules you had.
Matias Capeletto (Patak):
So it really allowed for, like, this close feedback loop that was, like, incredible. Like, grabbing, you know, like, the color wheel in CSS, like, in a CSS color in the source code, not in the browser. Yeah. Yeah. And in the source code changing it and then seeing it, like, in real time on the other side.
Matias Capeletto (Patak):
It really changes that you can create by exploration, even, like, changing something and seeing, like, oh, I like it here, you know? And then if there is complete time in the in the middle, like, you cannot do that. Like, if it's choppy and, like, you cannot explore to say that, like, what you want. It was, like, really special. And Vite was not alone in that particular time when, like, when Evan, like, we talked about Vite 2, Snowpack, WebDev Server, WMR from the folks of Preact.
Matias Capeletto (Patak):
They were all working on similar setups. And I think that depending on just, like, how the JS ecosystem will arrange, like, we will be talking about the Snowpack at this point because basically what needed to happen is that the ecosystem will say, okay, let's choose one. Let's work together, because that is, I think, another of the special things that happened with Vite. It was not only the speed in development or maybe like the zero configuration feeling that, again, we were lucky because in the time of Webpack, Webpack needed to explore a lot, like, and give a lot of flexibility because people were not using TypeScript.
Matias Capeletto (Patak):
Like, it was like Flow and TypeScript and, like, maybe something else.
Alexander Lichter:
Coffeescript. Yeah. Yeah. Yeah.
Matias Capeletto (Patak):
So, like, when Vite was started, like, the ecosystem already decided on a lot of, like, common patterns. So, like, Vite could say, okay, TypeScript work for by default. And we didn't even need to care about Flow. Nobody was using it at that time. And so that helped us a lot with, like, giving proper defaults.
Matias Capeletto (Patak):
And then what helped us a ton was Rollup that had these, like, beautiful plug in system. And the WMR actually pioneer this idea of having plug ins that work at both in built and in-depth, the same exact code. And this is one of the main changes between bit one and bit two that, like, Evan adopted the same strategy. And that really, like, altered, like, a a lot of innovation between frameworks that were able to use this plug in system that's very, very approachable, very easy compared to, like, the way that Webpack worked, for example, is very approachable. That created not only frameworks starting to migrate to it, like, easily because they could write their plugins, but framework could start to collaborate between themselves to create shared plugins.
Matias Capeletto (Patak):
And then there there's a lot of extra pieces now that Vite is only one piece of the whole puzzle. Like, you have things like the whole UnJS umbrella, for example, that was extracted from Nuxt. And all these, like, little pieces that you need to build frameworks are like, you can use directly there. And also, like, Nitro, for example, that likes like Vite but for the server. So you can write your server and you have it deployed anywhere.
Alexander Lichter:
Easily. Yes.
Matias Capeletto (Patak):
Yes. Exactly. So so like it now it feels like the I I I said the other day that Vite doesn't have an ecosystem, but, like, it's part of it because it is, like, all this project together, like, decided that, okay, we will share at a higher level, and Vite was that piece. But Vite exists because of, like, the ecosystem, and it's, like, it's not the other way around to me.
Alexander Lichter:
That makes sense. Also, I mean, on the other hand, if people say, like, oh, yeah. Every framework has a Vite plugin. So in a way, like, yeah, Vite wouldn't be there if frameworks wouldn't bet on it. But that shared piece of, let's say, infrastructure or let's say the shared piece of, like, the build tool everybody uses right now except Next.js is also there for a reason.
Alexander Lichter:
So I wanna dive into two topics there that you mentioned. A lot once again, which is which is pretty amazing. And if anyone, of course, has any questions, just put them in the comments, for example, on YouTube or just write us on on our socials. We're happy, like, to to answer them or just tag DejaVue on the socials, and we get into that.
Alexander Lichter:
So you mentioned the speed of Vite compared to something like Webpack before. Of course, mainly because of that unbundled mode. So, okay, we don't have to, like, build the bundle beforehand. That would take a lot of time for start up. Now it's like, okay, we start up a server and just serve the things and transform them basically on the fly.
Alexander Lichter:
But is there anything else that contributed to the speed factor of Vite there compared to webpack?
Matias Capeletto (Patak):
Yeah. So, like, this worked, this on the fly worked because we had native tools that were actually extremely fast that allows us to, like, for example, to do type stripping or to convert JSX on the fly, like, really, really fast. And that was ESBuild. That was this build tool, like, writing in Go. So Vite used it that to, like, do this kind of, like, type stripping, for example.
Matias Capeletto (Patak):
And we also use it in, for example, to optimize dependencies because, like, one of the problems, like, when I said this, like, if you have 10,000 files, then, like, this model does not break because, like, it it's still more or less the same time as before, but it's it's not, like, as magical, let's say. Yeah. There is a lot of things that you can do because, like, you can break your project in a monorepo and then, like, only load certain pieces and, like, there is a lot to do. But that amount of files, you can reach it very quickly if you do things like importing Lodash that has one module for each of the functions. And then because of how the dev, mode works, like you cannot tree shake during development.
Matias Capeletto (Patak):
This was like one of the trade offs. Normally that's not a problem. But if you have a lot of this kind of dependencies, then you will end up, like, with loading a lot of modules. So what we, like, Evan at one point end up doing is that introduces this step during development that on call start, it will grab all your dependencies. There is a very quick scan phase using ESBuild that is not, like, compiling anything.
Matias Capeletto (Patak):
It's just, like, looking for the import. And then, like, it knows, it find out all your dependencies and the one that are missing can be found, like, later on in the process. And it will bundle all your dependencies together. And then you have, like, instead of having, like, Lodash with, like, hundreds or as many modules, you have like a single tidy module that you're going to import. And if they are like 10 dependencies and maybe some shared pieces, you're going to have like some common pieces because it's kind of like you're bundling everything together.
Matias Capeletto (Patak):
And then that is called the start and this is cache. And then on warm starts, and the next time you run it, then it's going to be like this optimized step is already there. And you just, like, start with your source code and you just import this, optimize it by ESBuild bundles for your dependencies. And then automatically, when there is a new dependency, you can like, the application reloads if needed because if the dependency doesn't have anything in common, it can directly, like, load a new like, the new optimized dependency without you having to reload the page. And that's ESBuild was incredible.
Matias Capeletto (Patak):
Like, it really allow it to do this kind of stuff that before it was, like, impossible.
Alexander Lichter:
Wow. Yeah. I I mean, it sounds like especially also with the native power of Go to just be fast while doing that. Like, no JavaScript tool could possibly do that in the same time. So that's interesting.
Alexander Lichter:
But then you you also mentioned rollup as the bundler that's used by Vite under the hood, and now you also mentioned ESbuild. So what's the relation between the two of them in Vite itself?
Matias Capeletto (Patak):
So during development, we don't use rollup. Like, what we have is a rollup pipeline to execute all the plugins on each of the modules, but it's not really rollup because there is, like, no bundling. During build time, you can think of it as a very opinionated roll up setup that is, like, pre done for you. So there during build, like, we are using roll up, and then ES build during build is used it to also, like, strive the types, for example, for each module before giving them to roll up to speed up the process. It was always like problematic because even if we do a lot of effort on Vite to try to squash any kind of difference between dev and build, we always had these two very different tools like ESBuild and Rollup.
Matias Capeletto (Patak):
Each of them as any open source project or any software project will have their own bugs, their own queries. So there was always this idea of how we could unify the tooling, internal tooling in Vite because that could simplify a lot. And it seemed like one of the possibilities, like we had this in the why guide for a long time because people were asking, why don't you use ESBuild during build? Because that will be a lot faster. And the answer was that ESBuild is not as flexible as short app.
Matias Capeletto (Patak):
Like, the kind of plugins that you can write, it's like you have a lot less control. And this is completely intentional because ESBuild has, like, smaller scope, but this is why it's very fast. It it's going to do things in a certain way that, like, if you let people, like, put a lot of plugins there, you end up, like, losing
Alexander Lichter:
Oh, the speed. Yeah.
Matias Capeletto (Patak):
Yeah. The the speed there. But at one point, that was a real possibility that ESBuild will continue to evolve and maybe start to add more flexibility, like, evolve their plug in system in a way that we could use it and give, like, maybe an opt in way. If you don't need that much customization, maybe you can opt in into using ESBuild during build. But all that changed it, I don't know if that will have ever happened to be honest because it was very clear that the scope was not growing at one point there on ESBuild's side.
Alexander Lichter:
Evan Wallace, like, who is, no. It was Evan Wallace, I think. Right? Yeah.
Matias Capeletto (Patak):
It's it's Evan Wallace.
Alexander Lichter:
He's also, like, what I remember from issue is, like, clearly saying to some things like, hey. I don't want to implement that. And then it doesn't go into ESBuild because it's out of scope because it's yeah. So so I guess that
Matias Capeletto (Patak):
That is completely respectable and, like, it's it's why open source some open source projects work well. Like, we we did a lot of that with Vite at the beginning too because, like, there were a lot of people that wanted to migrate from Webpack, and they had, like, these very esoteric setups or maybe, like, people from Electron's side. And we were very say, like, okay. Like, look. Vite is for is a front end tool, and and we're going to keep it like, this will be our scope, and this is why we can keep it simple because, like, we are not going to open it up with, like, tons of config options.
Matias Capeletto (Patak):
Yeah. And we can talk a little bit little bit how things are changing also there because, like, as the Vite gets more adopted, like, responsibilities for the project also start to change a lot. But I think that this story about, yes, build and and roll up, like, is a good segue into Void zero and Rolldown because this is what happened. That at one point, Evan saw the growth of Vite, and something needed to happen because enterprise was was starting to use a lot Vite And we are starting to have a lot of use cases where the model and the way that we were developing bit was not scaling as fast as, like, the user side.
Matias Capeletto (Patak):
And, also, there were all these, like, little paper cuts that maybe users will not see them, but we knew that they were there. Like, these these things, like, ESbuild and rollup, having, like, these two completely different system in our internals. So Evan, like, created VoidZero, and they're starting to work on Rolldown. And there is another piece here of the puzzle that is OXC. Boshen was also, like, working on this piece before.
Matias Capeletto (Patak):
And OXC is like native Rust version of Babel, and it's, like, another incredible project. And with that piece, like, they build Rolldown that actually, it's very interesting because Rolldown, the first try, I think it was before, even before Vite, they tried it. Really? Like there was this Rolldown repo.
Alexander Lichter:
Interesting.
Matias Capeletto (Patak):
Yeah. They tried for a Vite and then they end up, that project didn't end up working or it's not working, but, like, yeah, it it takes a lot of time and efforts to actually take a project like Rollup and say, like, okay. Let's port it to Rust because Rollup is also a moving target.
Matias Capeletto (Patak):
Lucas is doing an amazing job there and keep improving things.
Alexander Lichter:
And it's also like it's it's a it's a complex thing in the end. Right? That's the other thing. It's like used for for, like, so many projects and with Vite, with so many frameworks and then all the the tiny the tiny details you have to pay attention. And then porting all of that over to Rust, make sure it works, somehow also figure out, okay, what maybe are the limitations?
Alexander Lichter:
What's can we, like maybe, okay, we need feature parity at some point. We want extra features. We want also, like, something API wise that's, I think, closer to esbuild on the other hand.
Matias Capeletto (Patak):
Yeah. Yeah. This was, like, if you want to replace roll up and ES build, you need something that will take the scope of both of them. Yes. So it should be it should be like as fast as ESBuild, but with the flexibility of Rollup.
Matias Capeletto (Patak):
It is like a a tall order. These folks that were working on Rolldown, they want to work a lot of related people want to work, rspack at ByteDance. And then, like, they move it to back to work on on RollDown again once Evan created that team. And, yeah, like, this this is, like, the next evolution of it. Now already rolled down, it is like the one point o beta is already there, and there is Sapphi-Red and Hiroshi are working for Void Zero.
Matias Capeletto (Patak):
Like, these are people from the Vite and the Vitest team, and that they have been working on this version. This, like, it's in another repo. It's called rolldown/vite. And it's the same bit, but instead of having roll up and is built, it's full rolldown And this simplifies a lot in internals and, like, you could have, like, the dev optimization can be exactly the same as, like, the normal where you bundle your dependencies with, now roll down on on both sides, roll down during build and roll down on on dev.
Matias Capeletto (Patak):
And, yeah, like, they have been working with we have this tool called Ecosystem CI that allow us to test, I think, like, 25 of the biggest project using Vite. Like, all the frameworks, the Vitest, like, all storybook against Vite main. And they have a a version of that that is, like, against roll down Vite, and they are working, like, one by one, like
Alexander Lichter:
Make it all work.
Matias Capeletto (Patak):
yeah. Making making it all work. And there is, like, details that are because, like, some features are not yet implemented, but they are working their way and also, like, porting back things to the main Vite. So, like, things stays together at the same level.
Matias Capeletto (Patak):
And soon, we are thinking now that on Vite seven, we're going to be able to give, like, with an environment variable.
Matias Capeletto (Patak):
Like, if you're using vite/core, another, like, package is going to be installed at least these roll down bits, and then you're going to run directly this roll down bit version. And this is, like, done with an environment variable. So, like, you can set it up globally, like, for your project, and then, like, everything, like, all your tools, Vitest, like, your framework, everything will use, like, this version, like, easily. And this will allow us on Vite seven to quickly get a lot of feedback from the whole ecosystem. To me, it's amazing that, like, the work that they have done in roll down is, like, they are cut off to all the team at at Void Zero because they have done an incredible job pulling out something like this that really is probably going to be released, like, with all the ecosystems CI green.
Matias Capeletto (Patak):
So, like, that's the best. It's it's just amazing. Yeah. Looking forward to that, like, we are thinking on Vite seven to be released after, Node 18 is end of life. So this is April.
Matias Capeletto (Patak):
So around, like, if everything goes right, it will be like around May that we can release this version. And then, yeah, it will depend on how things evolve at, like, maybe Vite eight, we could default to it.
Matias Capeletto (Patak):
So a lot of exciting stuff there.
Matias Capeletto (Patak):
And also for the future, because roll down now that we have something that is so fast, we can actually start to think again of is the unbundled mode the best thing that we we can do now? Because if we have like this tool that is so fast, like maybe we can offer, let's say at first, at least offer for this project that has, like, 10,000 modules, like, in enterprise bundle mode for development that work, like, more akin to how, like, Webpack work it.
Matias Capeletto (Patak):
But this will allow us to have even less difference between build and dev. If it is, like, really fast, then you can yeah. You can you can have, like, a very good experience. It is interesting because, like, a lot of why Vite is Vite is this unbundled mode. But now at the end, like, we may have that mode, and it will be, like, the two options.
Matias Capeletto (Patak):
But we will see long term how how that works. I I see that maybe in two years, there will be some decisions to make there because if this bundle mode works so well, we need to see, like, what to do with the unbundled one.
Alexander Lichter:
Yeah. Why support both if, like, there's one clearly superior mode and it's working well for any size of project? It's fast.
Matias Capeletto (Patak):
Yeah But But but
Matias Capeletto (Patak):
but we need to see how it it may still be that there are trade offs, so that we we have to we have to see it, but but this is already, like, long term.
Alexander Lichter:
But but just to say that
Matias Capeletto (Patak):
It is very interesting that, like, all these, like, doors that start to open because of having a tool that is as fast as ES build, but as flexible as Rolldown.
Alexander Lichter:
Absolutely. No. I'm I'm also, like, looking forward to it a lot. I follow all the the things closely for all the listeners that, maybe haven't listened to episode 31. That was where I also talked with Evan You in at VueFes Japan, all about void zero.
Alexander Lichter:
So, like, the brief frame of, like, oh, why company, why VC money? So if people interested in that, definitely check that out. It was a a lovely episode there. And, that gives also a little bit more context. Also, from Evan's side, it's like, okay.
Alexander Lichter:
When did this come up? And so on and so on. But, yeah, it's crazy how things developed in in the last couple years there with, like, Vite becoming the de facto standard. Right? And now in a way, okay, there are basically two build tools roll up for for build, the s build for dev.
Alexander Lichter:
Let's merge them to one, like, also being in control in terms of, like, adding future features heads. Like, one thing that I've seen and I know a lot of people miss from the good old Webpack days is, like, topic of chunk controls. Right? Like
Matias Capeletto (Patak):
Mhmm.
Alexander Lichter:
Hey. I want to have my chunk with fine grain control. It's not that easy in roll up. Right? In roll down, it will be hopefully.
Matias Capeletto (Patak):
Yeah. Yeah. Totally. Yeah. Because also now that there is proper resources to, like, implement all these features, this go back also to the story about the scope of it.
Matias Capeletto (Patak):
Like, at the beginning, we could say no to a lot of people and say for, like, we answer a lot of issues saying like, look, use Webpack. Like, this is not a use case that we are interested in supporting, because we want to maintaining an open source project, like, can be really hard if you just keep growing the scope. Yeah.
Alexander Lichter:
Feature creep as well. Like, okay, we need more and more, more, and then, yeah, how's the equipment maintainable? Exactly.
Matias Capeletto (Patak):
And the rollup plugin system helped us a ton to say no to a lot of things because we, we could say no, but you can do your own plug in. But there were certain things that we couldn't do, and we we will just say, like, we had to accept that this is the the limit of, like, what our team can do and, like, also, like, what we can do with the current tools that we have. But rolldown simplifying things internally and also, like, the grow that we had. At one point, it started to be we cannot say to people, like, go to use Webpack because, like, the ecosystem now a lot of the ecosystem migrated to Vite. And if you go to use Webpack, then you cannot use Vitest in the same way.
Matias Capeletto (Patak):
You can not use a lot of, like, plugins that are available. So, like, there are efforts like unplugin that allows you to write plugins in a way that also work in Webpack, but not everything will be working in the same way. True. So there is a lot of benefits on being part of, like, a a huge ecosystem. This is also, like, the other interesting arc that happened is that from one side, rolled down was targeting also these, like, huge use cases, like, being able to, like, cope with, like, huge code bases.
Matias Capeletto (Patak):
But at the same time, we are starting to need more flexibility to cope with, like, other cases. One thing, for example, will be, like, Electron and like making Electron a first class citizen or like rack native, maybe not only focus on like web app, you know, like the
Alexander Lichter:
Go beyond that. Yes.
Matias Capeletto (Patak):
Yeah. Go beyond that. And also, like, web app, I understand it to be a lot more complex, like, in their server setups. So, like, you could have, like, a node server or, like, next to your database, but then you have, like, an edge piece like that, like, you route things through it. Vite was created in a way where, like, there were two default environments.
Matias Capeletto (Patak):
Like, you have, like, your client environment, and then you have this SSR environment that you could also use, like, that was running in Node. And some people adapted it to also run-in, like, worker d or, like, to to run it in Cloudflare or, like but there was no formal concept of, like, I don't have two environments. Like, I have three. How I do that? And then people are starting to say, Okay, then I will just create several Vite dev servers.
Alexander Lichter:
That's why we have Nuxt, for example. Yeah, exactly. So
Matias Capeletto (Patak):
and this is also what vinxi did, allowed you to create, like, for each of your environment, like, different bits, like, plug in pipeline directly. vinxi was, like, developed also, like, to make Vite and Nitro, like, work together in a way that you could create frameworks with it using, like, several orchestrating several bit servers. SolidStart was the first consumer of vinxi, and then TanStackStart, starts, and that they are like Tanner and Ryan are always close. Oh, yeah. Working closely together, Telestackers are also adopted vinxi.
Matias Capeletto (Patak):
And this is starting to show that vite was being pushed, like, far away from its scope. It was not the most efficient way to have, like, several bit servers. And there was this need, like, this idea that you only had these two environments, like client and SSR, and they were, like, hard coded. It always felt that some more general instruction was, like, did it here. Like, we had a lot of API, for example, where we get this Boolean if it is a SSR or not.
Matias Capeletto (Patak):
And then we needed to pass that Boolean in other APIs and it worked it. Like, all the story of being able to do SSR in Vite was part of why Framework adopted Vite. So, like, it was incredible that we had that story. This was interesting because it was adapted from a version done by SvelteKit in the time of Snowpack. Oh, okay.
Matias Capeletto (Patak):
But by Rich Harris. Yeah. Where they had this idea of during dev had also an unbundled dev server for the servers code. This idea was, like, also adopted as part of Vite 2. And, yeah, like, this is at one point, all these was, they steal it into creating Vite node for Nuxt also.
Matias Capeletto (Patak):
A lot of like roads get into Nuxt because like there was a lot of pieces that were created during the Nuxt two to three, the transition
Alexander Lichter:
Yes.
Matias Capeletto (Patak):
That, like, Nitro and that later on, like, really play a very important role. And ViteNode allowed you to execute using the vite dev server, but, like, running the code that was generated by the vite dev server in, like, another any anywhere. So, like, you could do it in a thread or you can do it in a, like, worker. This piece was needed for Nuxt 3 to connect to Vite and Nitro, and then was the key to create Vitest. Like, when Anthony had already done Bitnode, and he used that as the engine of Vitess.
Matias Capeletto (Patak):
And Vitnow for a long time leave it inside Vitess repo. And at one point, we're starting to see that other project was adopting it. And this was a very interesting feature. So, like, Vladimir Sheremet, that's, like, one of the mains leads on Vitest now. He already had, like, rewriting the whole Vitez note as part of his work in Vitest, and he moved that into Vite Core.
Matias Capeletto (Patak):
We already see that's runtime API, and this was, like, the ability of, like, creating these runners that will, like, run code compiled by the vite dev server, like, but in other like, you could, like, do it inside Mini Flare, for example, like, to run workerd, simulate it in your local machine or in a thread. And we did that, and the people from Cloudflare got very excited and
Matias Capeletto (Patak):
a lot of Yeah. I got a lot of feedback because this could allow them to create abstractions for like how to frameworks could represent like the edge environments, but at the like, share it across all the frameworks. And it was in Vue.js Amsterdam on the previous year that we we started we got in the middle of the conference, we got, like, feedback from Igor Minar, from the from the Cloudflare team and say, like, this is amazing, but it's not enough. And like this
Alexander Lichter:
We need more.
Matias Capeletto (Patak):
All we need.
Matias Capeletto (Patak):
And there was like a lot of other discussion in the middle, like for example, like vinxi, the idea of like, given that the ecosystem is starting to like converge into needing the orchestrate several environments, could it could take that responsibility? Even if it is more maintenance, maybe the team is already at a place that we can take it. And so, like, we scratched the run time API, and created this environment API that was, like, a huge refactoring internal refactoring. And now we released that in Vite six at the end of last year, and that's just opened up a ton of possibilities because Vite now has the flexibility to create as many environment as you need. And, like, each each environment, like, you you can really represent, during build and and dev how your application works.
Matias Capeletto (Patak):
And we are seeing now, how frameworks are starting to to adopt it. And, like, there is, like, a lot of work. We released it as backward compatible. So, like, all the framework were still using this, like, layer that hide the environment in, like, these two still client and SSR.
Alexander Lichter:
That was still working.
Matias Capeletto (Patak):
It was still working as before. But you can as a framework, you can opt in and say, like, no. Like, I have these are my three environments. This is how I want to build them.
Matias Capeletto (Patak):
This is how you do that for each of them. Like, for example, like, if you have an an edge environment, like, Cloudflare can start to say like, give you a environment factory function directly from Cloudflare SDK, where you can say in your Vite app, okay, this environment is going to be a Cloudflare or a WorkerD environment. So and they configure everything so that works during dev in a certain way. And the code is executing inside MiniFlare, for example.
Alexander Lichter:
That sounds so flexible. Like, it's also made that you can actually represent in all the different, let's say, intricacies of, oh, yeah, Cloudflare workers with their limitations, with their bindings and benefits and so on. Like, having the option that integrations are really more integral and not just like, oh, yeah. You have these two environments and that's it.
Matias Capeletto (Patak):
Yeah. Yeah. Totally. It is very interesting to see now TanStack start. They decided that they are going to move back to using Vite and environment API and Nitro directly because, like, vinxi is that piece in particular is no longer needed for them because they like, Nitro is getting more powerful also.
Matias Capeletto (Patak):
It's also going to be rewarded to have, like, environment API support. And, yeah, it's it's very interesting. It's like a lot of appreciation for what Nikhil did with vinxi because it is like, this is how it works also. That's like there are pieces in the ecosystem that if enough frameworks end up using, it makes sense to have it in core or or have, like, this common piece that and and share as a higher level.
Alexander Lichter:
100%. And and also to, like, just say, okay. We try it out. If it doesn't work, it's also fine. But, of course, then, like, okay.
Alexander Lichter:
Nitro and Vite had to work together in a certain way to say, okay. Different routers, let's say, to create. I think that was, like, the how vinxi was naming that. So, okay, we have these different pipelines. And, of course, ideally, like, Vite and Nitro together would be enough to facilitate for the case of handsets start, solar start.
Alexander Lichter:
And it's so nice that we come back to that by saying, okay. Look. Vite, in a way, matured, quote, unquote, say, okay. This is something this is a need of a lot of meta frameworks. Now we can make that happen.
Alexander Lichter:
We make it so flexible that it's not only good for meta frameworks, but also integration with, as we said before, Cloudflare, WorkerD, so and so on. And, eventually, the piece of code that was needed to, like, okay, we prototype that is not necessary anymore. And I remember, like, I I watched the stream of Ryan and Tanner a couple weeks ago, where they announced a Tanstack solid router. And then they were also talking about DaVinci and how they are moving back. And also Brandon Roberts was there from Analog, and they were all saying of, like, yeah.
Alexander Lichter:
Oh, this Vite plug in, they share, or he this server function approach will just, like, reuse. So it's so nice to also see that collaboration, which is, like, across frameworks, like, really affects the whole ecosystem. And in a way that this also feels like something that that Vite and all projects around really stands for. It's not like, oh, I don't know, React versus Angular, Vue, Svelte, really like, hey, everybody's working together and all the authors have that common ground as well.
Matias Capeletto (Patak):
Totally. Totally. And I don't know if like, if final users end up seeing all that, but like maintainers, like they normally talk between each other and like there is a ton of influence and like, it is very normal in open source.
Matias Capeletto (Patak):
Like if you do it right, like, taking ideas from other project and adapting it to yours and, like, you give credit to that and say, like, hey. Like, this was inspired by this other project. And, like, you give credit where it belongs. If you do like that in a right way, it it's why open source works so well.
Matias Capeletto (Patak):
You know? Like, not only sharing of code, but also sharing of ideas and, like, even strengthens the relationships, like, between all the maintainers. Like, there is a for a project like Vite to work, there is so many small things that need to happen in, like, changes in TypeScript, changes in note, and changes. And it is very good that all these maintainers are able to work together in in a piece that lets them do that once because it's not like we will all have to do, like, repeat all this work. At least it's it's the same with with Nitro that now all the details of how to compile, like, the source code to each of the platforms and, like, don't have issues with any of the difference between them and, like, that we can do that in a unified way that then later several frameworks can share, and they don't have to repeat all this work.
Matias Capeletto (Patak):
And then frameworks can focus on what make them difference and, like, focus on new features and keep exploring. I think that we are going to see talking about, like, Ryan and, for example, like, all all the things that happen with signals too in frameworks. Like, there is so much going on, and it really feels that this year, we are going to see everything is kind of mature at this point, And but there is still, like, so much to do. So it it will be, like, a very interesting year for sure.
Alexander Lichter:
It will be. But I I think that also means that there are, like, less, let's say, less frameworks coming out, but more like the frameworks are maturing and also converging in a way to get, like, closer together. I think we've seen this with, like, all the frameworks except Next.js adopting Vite and that in a way also moving closer together to say, okay. If you have a Vite plug in, it doesn't matter if you use, like, Vue or Angular or Svelte.
Alexander Lichter:
You can use the Vite plugin. If it's, like, a general Vite plugin. Right? Anywhere. That's fine.
Alexander Lichter:
And now for the meta frameworks as well to say, okay. We have Nitro. We have Vite. And then, yeah, each of them, they have their own, let's say, model of reactivity. Lots of things are based on signals, but then solid signals are slightly different than Angular signals, of course, but the concept is still the same.
Alexander Lichter:
And then, well, at some point, we get to a point where maybe we can share more things and really get to a a point where we get closer and closer and closer together. I really wouldn't mind that. But on the other hand, it's also still great to see that people are innovating, and there are new things coming out. You'd like libraries. I've seen, like, Tan stack form to the release of that, for example.
Alexander Lichter:
So there are a lot of things in the broad web development ecosystem that are framework agnostic that are happening, and, that's great for every developer out there.
Matias Capeletto (Patak):
Yeah. Yeah. Yeah. Yeah. Like or Vue Vapor coming out.
Alexander Lichter:
Definitely.
Matias Capeletto (Patak):
And and that is also a story of, like, sharing because it is, like, adopting what, like, Solid has been and Ryan have been, like, saying, like, hey.
Alexander Lichter:
That's good. Yeah. Exactly. And as you mentioned before, the whole inspiration part as well, like, I I'm all for that as well. Like, hey.
Alexander Lichter:
Try to fit things that you think are good ideas into your ecosystem and see if it works. Also, one example, like, Vue's reactivity transform, it was tried out. It didn't work out well. Svelte Runes, for example, works so well. They look very similar to activity transform even though, of course, under the hood, there are a few other things happening.
Alexander Lichter:
But it's so nice to see that also one thing that might not work out in a certain community will be fine in another one. It's worth, like, trying it out, exploring these directions.
Matias Capeletto (Patak):
Totally. Totally. Yeah. And then, like, different framework has, like, different, like, kind of mindset that make some of the features work. I I think it's, like, it is a very interesting time.
Matias Capeletto (Patak):
At the same time, tooling feels so much better than before. Like TypeScript, like, we we have Node running, like, with the type stripping. Yes. Yeah. It's it's it's just amazing that, like, maybe at one point, like, we are also going to have it in even in the browser.
Matias Capeletto (Patak):
So, like, we can even, like, simplify things even further there.
Alexander Lichter:
I'm really curious also about the proposal of, like, the type annotations in the browser. There are a lot of a lot of opinions on that, the TC39. You said, like, oh, yeah. You just have annotations, and that's fine. But I'm really curious how that will evolve.
Alexander Lichter:
Also, same with, like, signals in the browser, like, in the actual ECMA script standard that will be super interesting to see. Frameworks will leverage them under the hood, and we maybe have, like, a shared VueUse or similar for signals, like, for I don't know. We have then, like, a a solid adapter and a Vue adapter and angular adapter, but the functionality you just have to write once.
Alexander Lichter:
That could be Could be really cool.
Matias Capeletto (Patak):
It it made me think, like, I I hope that we can, as a community, scale funding in the same way as, like, all the complexity and all the teams that are creating all this tooling. Because it's it's very interesting, like, now Void Zero, as you you say, like like, I recommend seeing your episode to understand. It is impossible to do roll down on OXC and, like, port v to use roll down without, like, a company like Void Zero. At Indeed, we are very lucky because, like, we not only have Void Zero, but, like, StackBlitz hire me and also Ari Perkkiö for Vitest. I don't know, like, Anthony Fu with NuxtLabs.
Matias Capeletto (Patak):
We have In vite a lot of support and there are other project that have support also, but there is a lot. I was talking with someone from Node, for example, today that they are doing so much at Node. And a lot of them, to me, like, a lot of the people should be working full time. Yeah. And companies should be, like, throwing money at all of them so they can focus on improving node that everyone is using.
Matias Capeletto (Patak):
And there is, like, a tragedy of the commons there that nobody does it at the end.
Alexander Lichter:
Exactly. Exactly.
Matias Capeletto (Patak):
And, hopefully, like, there is, like, some initiatives, maybe even at the government level. Like, for example, in Europe, they could be, like, open source directly. It feels a little bit bad that we can maybe need to start, like, doing some bureaucracy to us from the government money, but like at some point
Alexander Lichter:
Better than not getting money, right?
Alexander Lichter:
That's the other thing.
Matias Capeletto (Patak):
Yeah, there are interesting initiatives also, for example, like the Open Source Pledge.
Alexander Lichter:
Yes, that's right.
Matias Capeletto (Patak):
And that, like Sentry, that is also an amazing company because they are hiring Ryan Carniato. They're hiring like a lot of open source developers.
Alexander Lichter:
TK Dodo as well from, yeah, TanStack Query.
Matias Capeletto (Patak):
Like Nate Moore is working for them too now. They started this open source pledge initiative. The idea is that for a company, you have to put every year $2,000 per year per developer. If all the companies will do this, like, there will be a lot of funding, like, to properly maintain things. And right now already, I think, like, 31 companies, have been working on this, like, joined the pledge.
Matias Capeletto (Patak):
Like, at StackBlitz, we joined it last year, like, at one of the first twenty. And I think, like, it's a very good way to formalize a little bit. Like, you can put more if you want, but at least at least you can do this. I I think they like, these companies together, they have put already, like, 2,500,000 million dollars In open source.
Matias Capeletto (Patak):
So it just start to add up to a good number when you when you count.
Alexander Lichter:
And I really hope there are more following. Right? As you said, like, this is a good start. And, I mean, if you take a look at the list, Sentry, of course, Stackblitz, VoidZero also in there, Sanity
Matias Capeletto (Patak):
Yeah, That's true.
Alexander Lichter:
HeroDevs.
Alexander Lichter:
So, like, we have a lot of, like, companies with a big name in open source, also like Laravel, for example, in there, really, really cool, Convex, and so on so on. So it's really great to see that. I think also if we see more, let's say, agencies or maybe also, like, companies of a bigger scale there that will also, like, drive it so much by just saying, okay. At least these company did they then also, like, can show themselves, hey. We are interested in giving back to open source, and we value the contributions there.
Alexander Lichter:
But, yeah, I I really hope that will be the case. I remember, for example, as you said, Node, I was talking with, Matteo Collina, actually, last week, during during DEVWorld, where he gave a talk. And, also, he he was saying, yeah. The the Node. Js budget is, like, 300 k a year.
Alexander Lichter:
And this year, it's only hundred 50 k. And we only got require ESM, because Bloomberg was sponsoring that in the end. So in a way, he said, like, yeah, if we need features, well, either do them yourself or find a company that can basically find the funds for that, which is it's in a way sad because you have all these, like, clever people there and all these, like, amazing opportunities. But, yeah, the the funding is simply not there.
Matias Capeletto (Patak):
Yeah. But I I I think that hopefully this will this will keep evolving and, like, more projects, like, initiatives, like the open source pledge, more companies, like, hiring open source developers like that. If you are, like, someone in the position to do it, I completely recommend because there is always so many opportunities later on to work. Like, I mean, it can be like it can be fifty fifty. Like, it can be like 20% on open source and like 80% on the project.
Matias Capeletto (Patak):
Like, for example, for Ari Perkkiö, like, he's working now 50% for Vitest and 50% on Bolt that we didn't mention. But, like, yeah, StackBlitz also had this crazy thing happening last year where, like, Bolt was created this agentic, like, using Claude to generate, like, if you want to generate that Vite application right now, I think, like, you can go to bolt.new ask for it.
Alexander Lichter:
Yeah. Or like any framework, actually, right?
Matias Capeletto (Patak):
Yeah.
Alexander Lichter:
So like, hey, build a even, like, say, build a slideshow with SliDev. It's really amazing. Yeah.
Matias Capeletto (Patak):
I I I'm thinking that for the vite Docs at one point, maybe it will be interesting, like, instead of having these static starters, you know, like, for each framework that directly in the docs at one point, you could say, like, had a prompt. No? And, like, I start from, like, a blog about something, and then you you kinda start from a lot higher place. But, like so Ari Perkkiö is working, like, half of his time on Bolt. And, like, he's doing things with, like, Vitest there, for example.
Matias Capeletto (Patak):
And, like, it it's just amazing because open source developer has, like, a a very interesting perspective that can give in the way that you can give feedback about product or, like, that it's it's very interesting. And even if you work like me, like, 100% on, like, on the Vid side, there is always opportunities because one of the things that we did with the StackBlitz for example, was organizing ViteConf. This was, like, a huge opportunity for, like, collaborating at the level of, like, doing something interesting for the Bitcoin ecosystem and at the same time, like, something helpful for, like, a Stagrid because, like, getting closer to this growing ecosystem was always, like, very, very interesting. Like, this ViteConf was where they announced Bolt last year.
Alexander Lichter:
True. True that. Yeah. And I mean, also, like, showing once again, as a company showing that you're deeply invested into open source will also help attracting talents all over the world as well and just gives you a really good reputation and position. I mean, who who dislikes a company?
Alexander Lichter:
It's just like, hey. We're all in open source. We I don't give you 20% time or even more, as you said, fifty fifty or even hire people, full time to work in open source. Yeah. That's something more companies should do for sure.
Matias Capeletto (Patak):
Yeah. Yeah. Yeah. Hopefully. Hopefully, they do.
Matias Capeletto (Patak):
Because we we need we have a lot to maintain. All these things that we have to have been talking about, like, there is so many things that daily are happening, like, so many issues that are open, so many interrelationship, like this this ecosystem CI. Today, Dominik G, for example, like, just said, like, he was, like, going through each of the projects that we had. And for a long time, after environment API, I think that was one of the first time that we released it, Vite six, without everyone in green. And this was like already pre discussed with like some of the framework and this was, they were failing just some edge cases.
Matias Capeletto (Patak):
So it was like still like, it it was not going to affect, like, most users. But this particular, like, I think in the last two weeks, he has been going one by one and making sure, and, like, today was all green for the first time
Matias Capeletto (Patak):
Wow.
Matias Capeletto (Patak):
In a lot of, months. And that is, like, a lot of work that, like, it goes unnoticed. But having with the consistency, I all green now on bit main is amazing because the work that sapphi-red is doing, for example, on roll down bit, he can know that, like, then on main is green, like and and it's, like, it's very good information to inform how roll down beat is working and that because if there is a red on main, like like, it's already not working.
Matias Capeletto (Patak):
Yeah. Exactly. So there is so much. Like, there is so many people involved. Like, it is impossible to mention also, like, a shout out.
Matias Capeletto (Patak):
Like, to be honest with you, you know who you are and thank for everything you do.
Alexander Lichter:
Yeah. I can only agree. I mean, we see it also in the Nuxt team with, like, all the contributors. And then just think of that with all the frameworks, like, as I said before, it is a lot of work, but, thankfully, also, for example, Dominik g, in this case, also shout out, is also possible thanks to a lot of, like, spare time in the end.
Matias Capeletto (Patak):
Yeah. Yeah.
Alexander Lichter:
People just investing their time, not seeing any kind of money from it. Also, like what you did in, let's say, your free time in the end.
Matias Capeletto (Patak):
That that is most of it, to be honest. Like, a lot of open source is, like, done by because you love to do it because you just love to build things together with people.
Alexander Lichter:
People don't go to open source for the money, obviously. Yes.
Matias Capeletto (Patak):
It's not the best way to get money, but it should change as we have been discussing because it, like, so much depend on it. A lot of companies now, like, are going to like, they already are, but, like, there there is going to be huge securities issues if you don't have properly funded maintainers for your project. Like, you need to take care like, if you are a huge company, like, you need to think that these people are part of of your product. You know? Like, these are external, but they are still, like, huge influencing, like, the quality of your own product.
Matias Capeletto (Patak):
So, hopefully, like, this will be something that with time, it will be, like, a lot more commonplace.
Alexander Lichter:
Same. Same. Can only agree. I mean, Daniel Roe actually a couple episodes ago here in in January for the predictions for 2025, and he was like, this year, same like this year, hopefully, we'll solve sustainability in open source. So I'm I'm crossing my fingers very, very much to come on.
Alexander Lichter:
We we can do it somehow. But there are so many ways in the end where, like, sometimes, like, tiny contributions better, for example, like, you can sponsor people on GitHub and so on. There are also, of course, funds, like the open prototype funds for technology. There's also, there there are a couple of ways where you have to either apply. And as you said before, they're also here, there are some governmental programs to apply for.
Alexander Lichter:
But I also recently saw that, Stackblitz created own OSS fund.
Matias Capeletto (Patak):
Yeah. Yeah. This is, like, part of our like, the open source pledge. Like, we were we're already like, for the past two years, we have been funding not only, like, me and, like, Ari Perkkiö joining last year, but, like, also, like, sponsoring the big team Mhmm. And sponsoring other open source, like, some open source developer working on Wasm.
Matias Capeletto (Patak):
That is very important for web containers. That is what the technology that allows you to run nodes in the browser, like so we have been doing this. One of the main sponsor external sponsor that we did during the past two years was with Johnson because he wanted to do Volar to be also framework independent. At the at the beginning, Volar was, like, view only, and he wanted to be able to have, like, a toolkit to build IDE tooling that any framework can use. And so, like, we took it with them, with with him, and and we end up, like, sponsoring for two years the initial development of this, like, Volar as framework agnostic.
Matias Capeletto (Patak):
And Katie did an amazing job, like, together with other people from from the team. Now it's, like, used by MDX, by Astro, and it's powering a lot of IT tooling. Hopefully, like, even more in the in the future. Now this year, what we did with the fund, we want to diversify a lot more. So we we created, like, the success of Vault also let us go a little bit higher.
Matias Capeletto (Patak):
So we created, like, a 100 k for the year open source fund, and we announced it a couple of week ago. And we are keep vetting on this share infrastructure because this is something that, like, we really believe on. So, like, we for example, we started sponsoring Pooya for the work on Nitro and UnJS. We keep a sponsor, Anthony Fu, Vladimir because also, like, for Vitest. And then also, like, the Unify, a lot of pieces.
Matias Capeletto (Patak):
Also, our the dependencies of Bolt too. Like we discussed it like directly with the whole team and there were a lot of proposals. A lot of the dependencies we are able now to also sponsor. This also will count as our open source pledge.
Alexander Lichter:
I see, yes.
Matias Capeletto (Patak):
Renewal for this particular year. Like, we are way above the required 2,000. I've seen that at this point, we are around 5,000, but with established hiring, so like that may
Alexander Lichter:
shrink.
Matias Capeletto (Patak):
Per developer may shrink depending on how much, like, a StackBlitz will grow. But I love that part of, like, working there and ended up being also, like, helping like other open source developers. Like this is something that like with Eric, again, like the CEO, we have like from the beginning, like there was this idea of like how we do more. And like BigConf was one part of, like, this giving back to the community. And then, like, what we did with Johnson, and this is, like, continuing continuing that.
Matias Capeletto (Patak):
And I hope that we we could do more, like, in the in the future.
Alexander Lichter:
Fingers crossed for that. But I mean, also that's, as you said before, tied a bit also to the success of Bolt or general Stackblitz. So it's also great that Bolt exploded, especially in times of AI having a tool where it's not like, oh, yeah, React only, or can especially do well for React. Like, hey, I need framework out there. If you wanna build a SvelteKit application, you just go for it.
Matias Capeletto (Patak):
And that will be extremely important. These are discussion that we have internally, that there is this worried about AI being trained on a lot of React code and only generating by default React code. And we have, like, established this in a position always of being very friendly with the whole ecosystem, like, with I don't know. Like, the tutorial from SvelteKit was, like, using web containers to run SvelteKit in the browser. And then after that, we got inspired from them, the tutorial kit dev, to be able to, like, anyone can create one tutorial using the same technology.
Matias Capeletto (Patak):
And there was, like, always this idea of, like, yeah. Let's try to make it very easy to make a starter for everybody, not only like the main player, you know, like, like everybody. And I think that, like, it's important, like, in this, in this era, as you said, like that a lot of them, maybe a smaller frameworks will have like less training data for for them, you know? And and then it is an imbalance that we need to see how to manage. Because long term, we need to keep evolving.
Matias Capeletto (Patak):
Like, it is also not only about, like, React against other. It is about even React will keep evolving. So, like, if you only train and, like, your model is fixated on a particular year of that framework, it's going to be generating things that are, like, Kron as Yes. As it it evolve it. So I think there will be a lot of very interesting stuff to do long term and even to do things like maybe a user of Bolt, like, it is a Svelte user.
Matias Capeletto (Patak):
And, like, he shouldn't be needing to say, like, generate a Svelte app dot every time. And so, like, we could maybe at one point have, like, branded versions of Vault where you go and you are like, it is a red version. You know? Yeah. And it's like, it this is, like, a Svelte for you or, like, you have a green version for, like, view and then whatever you ask is really going to generate view apps because it is your preference.
Matias Capeletto (Patak):
And this is how you can already do this because you can modify the the prompt, the system prompt, like you can change it. And so you could say there, like, always do Vue. But I think there are possibilities to even be, like, go farther there.
Alexander Lichter:
But I guess it's all also like a lot of exploration, a lot of trying out things in the future. On that note, it was really interesting. I was talking with Steve from Builder.io about that that's, like, will also be released. This was in q and a of a talk he gave also DevRel, where I was like, do you think React will be the only framework left because AI is trained so well in it? And and he actually said something quite interesting.
Alexander Lichter:
He said no. I was like, okay. Great. Yeah. But it's actually said that, Misko, who was former Angular team lead and, like, was a lot into Qwik, of course, as well, created it.
Alexander Lichter:
He made an experiment to say, okay. He was just, like, feeding an LLM like for, like, a fully new framework, just some trained data, and and it could perform pretty well. So in a way, it's not necessarily only the amount of data because, of course, if you also think about that, a lot of code out there, not saying necessarily React code, just in general code, is also not really high quality. Mhmm. So I think it's also a lockdown of, like, how how well are the ecosystems doing.
Alexander Lichter:
Right? How many examples are there? And that's, in a way, benefits the user that's saying, okay. I want an example for I don't know. Even if you just take something like Nitro, how can I read in form data in Nitro or, like, binary data and deal with with that?
Alexander Lichter:
If there are examples for that. Perfect. Yeah.
Matias Capeletto (Patak):
Yeah. And and you can generate, like, this data, like, in in programming. Like, it's you can generate it in a synthetic way, maybe, like, for new features. Like, you you will need to you will need to do these kind of things in the future. And hopefully, yeah, models get, like, faster to train and, like, are trained in a maybe monthly, weekly basis.
Matias Capeletto (Patak):
So, like, you know, like
Alexander Lichter:
More recent, yeah
Matias Capeletto (Patak):
Yeah. It's not like because we also need that, like, for example, for these features, like, adding it to the docs. And, like, if if you're going to be starting from the docs, you need, like, the model to generate with the most recent version. So, like but this it's just incredible how fast everything is, like, changing in this regard. Like, some models are getting a lot better, very fast.
Matias Capeletto (Patak):
So I think we will we will get to a point where this will not be a a problem. Like, with all the love to React, React is not good for anyone that React is the end of history. Agreed. Like, it is good that we have a lot of different frameworks exploring different alternatives because, like, yeah, we also, like, as Evan always say that, like, there are very different people that likes different things. And and sometime, it is also about what clicks for you.
Alexander Lichter:
Oh, we have a 100%. Which causes the work.
Matias Capeletto (Patak):
It's not about, like, which framework is better than the other because, like, a lot of we we live in, like, Wonderland. Like, all the frameworks are so amazing right now.
Alexander Lichter:
Yeah. You can build amazing things with all of them. That's the best part. It's a lot about understanding. And sometimes just like, okay, you don't really have to try out a new framework, but because you if you know one already, but you just do it for let's see how they do things.
Alexander Lichter:
Maybe this works better for me. You're like, hey. Maybe this is an interesting concept. So it it never hurts to look into that. But regarding React and Vite, making a little circle back there
Matias Capeletto (Patak):
Yeah.
Alexander Lichter:
There was also something happening recently. So create React app. For everybody who is, like, hasn't heard of that, create React app was the more or less the way to go to create a new React app as package name sounds. It was, well, de facto deprecated. Nobody said it officially, but it was not really recommended by anyone except, I think, still in the docs.
Alexander Lichter:
And then at some point, it was like, yeah. We should maybe deprecate it. A lot of people in React ecosystem pushed for it, and it happened. It's, got deprecated. And a lot of people, once again, in the React universe said, like, yeah, there is only, like, one logical recommendation to say instead of create React app, you should use something else, and that would just be, like, Vite.
Alexander Lichter:
I mean, we have, like in Vite, you have all the things with you can choose your framework. You can say, okay, React with TypeScript, JavaScript, whatsoever. Same with Vue. You you can start whatever you want there. So that would be kinda natural, but somehow it didn't happen like that.
Alexander Lichter:
Right?
Matias Capeletto (Patak):
Yeah. Yeah. It's it's a it's an interesting story because there are, like, two things going on there. Like, one is, like, create react app that was not, like, maintained for a long, long time. Like, two years ago, it should have been deprecated because it was hurting a lot of new users.
Matias Capeletto (Patak):
Like, there was a ton of, like, backlinks to it in tutorials, in videos, and, like, everybody that did, like, explaining how to start, like, two years ago that there is a lot of information in Internet, like, we're pointing to it. So if if people will end up, like, installing something that they were was using outdated code, like it was not even working, I think, for React 19. They're like it was only working for React 18. It was a very bad experience. So that was extremely welcome that at the end, they deprecated, and now, like, users will receive, like, a proper message warning them, and then they can go to explore, like, modern alternative that are well maintained.
Matias Capeletto (Patak):
And the I the thing about Vite is is, like, a longer story also with, like, the React team at one point decided that they wanted to push very heavily to new users into using a full framework like Next.js or Gatsby, it was, I think, in the in the documentation. Oh, yeah.
Alexander Lichter:
I guess, in back times. Yeah. Yeah. The idea there was that if you are not, like, using a framework, then you are creating your own. That there there is certain truth into into that. But at the same time, like, because of how React is evolving, like, with React server components, and they need at least, like, server to, like, work to be able to do React server components. And, like, React as a library is evolving to a place where if you want to use fully the vision of the React team, you need a framework that does a lot of things. Also, like, Next.js is, like, the example of a framework that some of the React team members are also collaborating there.
Matias Capeletto (Patak):
So this is, like, what they recommended. And Vite, they didn't want you to recommend because like our bare templates that you create with create Vite is like very minimal. Like we use it for our back reproductions because it is like, there has nothing in the sense of like testing setup or, like, tailwind. The idea is that you have, like, the minimal setup for your framework and you can do something else, like, on top later on.
Matias Capeletto (Patak):
It's a little bit different than with create rack up because, like, with Vite, adding new functionality is, like, just, like, installing a plug in in your Vite config is not that hard. Like, adding a new framework, adding tile win, like, normally, it's just, like, one line of code that you copy and paste. It's it's not hard to do. But at the same time, like, we for example, in Vue, you have create view. And create view is like a a starter where you can also have, like, do you want testing or not?
Matias Capeletto (Patak):
Like, do you want, like, set up a storybook? Do you do you want to have tailwind or not? Do you know? Like, and this it's a more complete option. So, like, for Vue users, we we were saying, like, yeah, go to create Vue, for example.
Matias Capeletto (Patak):
But there was never that for React. There were a lot of templates maintained by the community, but none of them were the go to to send them. So the option they had is to recommend like this simple Vids setup.
Alexander Lichter:
It's bare minimum. Yeah.
Matias Capeletto (Patak):
The bare minimum that is also SPA, like a single page app. And this is also something that the React team, like, with the idea of, like, you need, like, a full framework, you need a server, like, didn't want to promote. So for a long time, Vid was mentioned as a, like, a site in the docs.
Alexander Lichter:
Yeah. It was exactly. It was, like, hidden in the collapse of the files.
Matias Capeletto (Patak):
Hidden in the collapse. So it was it was a little bit, like, sad in a sense because they're, like, one thing is, like, what the React team wants to promote, that is completely understandable. Like, we also do the same in Vite. Like, we document the scenes that we want to promote.
Alexander Lichter:
Yeah.
Matias Capeletto (Patak):
But also the way that React was being used by a big chunk of the community, the React community, is it was different. It was like there is a lot of just using, like, a bit tagging React and, like, assembling the pieces. And because bit is not that hard to, like, assemble the pieces yourself, it doesn't feel that you're creating your own framework.
Alexander Lichter:
Yeah.
Matias Capeletto (Patak):
And there is a lot of single single place application that are like, it makes a ton of sense. For example, if you build enterprise dashboard that is not public, I mean, like, something terminal that the user will have for two hours open. Like, it make complete sense to have, like, a single place application that you
Alexander Lichter:
Definitely.
Matias Capeletto (Patak):
Just used.
Alexander Lichter:
You don't need anything server like there. Yeah.
Matias Capeletto (Patak):
No. One thing that happened is that when they deprecated, they converted that aside into a node. Mhmm.
Alexander Lichter:
So it
Matias Capeletto (Patak):
was not collapsed. It's there was, like, a big
Alexander Lichter:
Little upgrade.
Matias Capeletto (Patak):
Yes. But there was, like, a lot of pushback after that from the community, and they keep talking. Mark Erikson, like, the, like, maintainer of Redux, he was one of the people that were pushing initially again, reopening the topic.
Alexander Lichter:
He even rewrote I think he's sending, like, a PR and, like, rewrote a part of that. I remember. Yeah. Yeah.
Matias Capeletto (Patak):
Yeah. Two years ago, I seen, like, Theo was the one, like, doing a lot of noise about this. And now I it seem like Mark was the one that reigniting everything. After, like, they they did these changes, like, he also proposed a lot of things in the docs that they didn't end up there. They added some docs about how to, for example, how to build a framework.
Matias Capeletto (Patak):
This was the new page that they added. Like and it was, like, the way it was worded, it was clear that they didn't wanted you to do it. Yeah. It was, like, you could do it,
Alexander Lichter:
but you can rather use one of these other solutions. Let's say.
Matias Capeletto (Patak):
Yeah. Yeah. It was like, if you really want to go that way, like, we cannot stop you. It's this kind of way.
Alexander Lichter:
Yeah.
Matias Capeletto (Patak):
So he created a new PR where he showed directly what will be, like, interesting way to for example, like, instead of having this page about how to create a new framework, it was, like, how to create start from scratch. That it was, like, more, like, positive way. Like and yeah. And and in that, like, arrangement, he also will will mention Vite's more, like, prominent in the start team, getting a starting guide. And Ricky from the React team, like, got that was he was already involved, I think, in the previous changes.
Matias Capeletto (Patak):
He got the PR and created the new PR based it on that, but, like, also with some other things. And and now Vitt is, like, mentioned directly together with Parcel Yes. And Airspark as options. And then there this create a framework was rename it as start from scratch. So I think that it ended up in a very good way.
Matias Capeletto (Patak):
I see the community is a lot happier now in how it is represented.
Alexander Lichter:
Agreed. And I'm happy also that there were people as I remember like, I know, Ken Wheeler and and Dax, and a lot of people just like wrote, right? Like, Vite Vite Vite on the social on social networks, just like reposting that with the same.
Matias Capeletto (Patak):
On that hand, I I have to to say that, like, it is always hard to be on the open source side, Maintainer side. Like, for the React team to get all these, they also want to go in a certain direction. And, like, we also, like, like, in the Vue community also experience a lot of, like, move like behavior, let's say, from, like, the Vue two or, like, composition API when that appear or, like, even when Svelte mentioned runes. Like, it is always hard. But I I think it there is a lot of value that in this particular case, they end up, like, listening to the community because it it was something that I really think that it it will help, React, like, to it will help a lot of people that are starting to learn React
Alexander Lichter:
I agree. Yes.
Matias Capeletto (Patak):
To to start with this more, like, simple, not like full framework, thing. At at least, like, I when I started learning, like, I think that it was good to just, like like, have a single page application and put some React component and see it work and not have to think about, like, a full framework like nature. Yes. Just, like, to start with. You know?
Alexander Lichter:
100%. I also feel the same. Like, usually, when I teach Vue, for example, it's like, I don't start with Nuxt straight away. It's, like, very simple, very bare bone. Play.vuegis.org, and there you go.
Alexander Lichter:
It's, like, the the easiest start with, like, even not even a a build step, so to say. Right? It's all in browser. You have the the compiler straight away showing you what's there And then starting off, like, okay. The basics are there.
Alexander Lichter:
Let's create our own application with feed and so on and so on. Because especially at the beginning, if you know HTML, CSS, and JavaScript, like, there are a lot of things that can overwhelm you a lot, especially if you have we had the reflux too, like, this wizard with questions like, hey. Do you want this module due and TypeScript testing and so on and so on? And you if you really have no idea, like, what is all of this? I guess I need all of them.
Alexander Lichter:
So yes. Yes. Yes. Yes. And then you end up with a lot of files that you don't know what they're doing.
Alexander Lichter:
So, like, having that step by step experience is really beneficial, I would say. Yeah.
Matias Capeletto (Patak):
Yeah. Yeah. Yeah. And now and now there's, like, other options. Like, there is this crate I think it's, like, create TanStack router or like a time router app, or like, I don't know what is the name, like, but it's like a simpler setup, but using like dynamic stack router.
Matias Capeletto (Patak):
And also, like, you have like react router that, like, if you do like create react router.
Alexander Lichter:
Yes. Previously Remix, right?
Matias Capeletto (Patak):
Previously Remix, that now, like, it is like also a simple setup, like using V10 and rack router. And that are more like complete replacement for create rack up. It will be interesting to see, like, what is going to end up, like, taking the place of Curvy App because it was very clear at one point, like, everybody was just going there. Yeah. And every tutorial will just say, like, yes.
Matias Capeletto (Patak):
Create React app is how you start. And now the recommendation is, like, at least from the React docs, it's more open. But I think, like, there will be some conversions even, like, outside of the of the React docs.
Alexander Lichter:
Oh, yeah. Just, like, how users Yes. Yes. I agree. I'm I'm also really, like, curious.
Alexander Lichter:
As you mentioned, the create TS router app, I also had to look up the name from from Jack Harrington. It's super interesting to say, okay. So TanStack based, of course, TS router app, TanStack router. They're straightaway putting things in, like, of course, addons like, hey. Please add, I don't know, TanStack query, Sentry, and so on and so on, but add solid support.
Alexander Lichter:
So you have, like, one tick to say React or solid, especially for new applications. This is super interesting, and I think especially where where Tanner and Ryan moving. Like, I see a lot of people in the React universe very positively about the whole, like, 10 stack stack, so to say, from, of course, very, like, forms out now, but the router, obviously. Yeah. I'm I'm curious where also, like, decline in positivity in Next. Js and React might shake up the ecosystem there.
Matias Capeletto (Patak):
Also, like, I feel that is, the same thing that Ryan said that is very interesting. I want to see React and Next explore the way they are going because they are the now, the only one that are exploring full throttle that particular line.
Alexander Lichter:
Yes.
Matias Capeletto (Patak):
So it's it's very interesting, like, where where they are going. But, yeah, it it is a like, in particular, with Next.js Js is a little bit harder to share between, like, all the others. So it will be very interesting to see how the ecosystem continue to evolve. My take always is that, like, sharing have a ton of positive outcomes, like, in the ecosystem.
Matias Capeletto (Patak):
Like, what you say about, like, they are not new frameworks. It is true at the level of, like, Solid, Vue, React, Svelte, like, this big, like, workflow.
Alexander Lichter:
Component level frameworks, so to say. Yeah.
Matias Capeletto (Patak):
Yeah. But meta frameworks, now that it is easier to build one because there are all these shared pieces. So like from analog for, like, the brand that it's working on. Yes. Or like in React now, you have, like, Redwood is working on a reboot.
Matias Capeletto (Patak):
Yeah. You have, like, Waku.
Alexander Lichter:
Waku, exactly, yes.
Matias Capeletto (Patak):
Then, like, now with an TanStack Start, like, the Remix folks with React Router, and that is, like, four big ones. Yeah.
Alexander Lichter:
And not even interesting Next. Js there. So, yes, in addition to Next.
Matias Capeletto (Patak):
Yeah. And and there is a lot more like, Vike also and, like, Rakash was at one point, like, I don't know. Like, it is hard to get, like, a lot of traction, but, like, the dimension was there are big players.
Alexander Lichter:
Yeah. So I think that's that's indeed something that we'll see more and more with all these tools, underlying libraries tools available to just people building meta frameworks with their vision or contributing to some. So I'm definitely looking forward to that. On that note, I think, well, we're in for for one and a half hours more than that. We also drifted away from the the view focus a little bit, which is more than fine because I I think it's still good to know what's going on in the general web ecosystem even though a lot of people here probably won't write React more than good.
Alexander Lichter:
Still, Patak, now one last question. Where can people find you, follow you, and get more of what you what you do?
Matias Capeletto (Patak):
Like, now, like, I'm most active on Blue Sky. So, like, if you go there, like, you can put patak.dev, and you're going to find me or, like, if yeah. My web page is also patak.dev. So there you you can have, like, all the all the links. But if not, like, yeah, Discord, GitHub, where came came chat.
Alexander Lichter:
Everywhere there. Yep. Please give him a follow. The link's in the show notes or in the description on YouTube, of course. But, like, thank you so much for joining.
Alexander Lichter:
I think that was a lovely episode all around Vite. What it is, I hope everybody out there has a clear understanding now what's what's going on there. And if you have any questions, please, as we said before, drop them in. We'll go through them. Happy to answer them.
Alexander Lichter:
And, well, is there anything else and and new things to share around Veed that, might come up soon?
Matias Capeletto (Patak):
Well, we have the next week. Well, with this I've seen that this episode yeah. Now now Veeda is after them. So, yeah, I I hope, like, if you are around, I think you're going to hear a lot of very interesting Veeda stuff in the conference.
Alexander Lichter:
Otherwise, we'll also probably link to some things in the show notes. If if I manage to do it while being at the conference, let's see. But maybe the live stream or so, definitely, yeah, keep an eye on. There will be some interesting teasers at the Vu Amsterdam, some amazing things coming up. Jack, thank you so much for joining.
Alexander Lichter:
Any, last words?
Matias Capeletto (Patak):
Thanks a lot again. It was really lovely to be talking to you. And and, yeah, like, let's let's do it again, like, in in a year. And for sure, there will be a lot of interesting developments to keep talking.
Alexander Lichter:
100%. Thank you so much. If that's not the latest episode, check out the latest episode of DejaVue, otherwise the older ones. Also the link from Void Zero that you mentioned before or any that you like. Until next time.
