Evan You - State of Vue 2026

This talk discusses the latest advancements in Vue, specifically focusing on the upcoming Vapor Mode, which has seen significant development with new features like type inference and JSX support. The speaker also highlights the recent release of Vite 8, emphasizing its architectural overhaul that boosts build speeds significantly by replacing previous tools with the new Rolldown engine, all written in Rust. Furthermore, the session introduces Void, a new deployment platform designed for Vue applications that streamlines the process of turning static Vue apps into full-stack solutions deployed on Cloudflare Workers. The speaker details how Void integrates seamlessly with existing frameworks and simplifies deployment while providing powerful backend capabilities.

All right. Um happy to be back. Um how many of you are here for the first time? Okay, great. Um so, today's talk um so, just a note, I always use state of view as kind of the placeholder title, but today's talk is going to be about a lot of stuff, but let's start with view. Um I'm going to skip the boring things about view like the

stats growing like we're at like 9 million weekly downloads or how what percentage of view 3 usage is now. Think we can leave view 2 behind at this point, so I'm going to stop mentioning that. Um the interesting thing about view going on obviously is Vapor Mode. Um so, we're not releasing Vapor Mode today, but Vapor Mode has been going on. We've been quiet about it, but

it has If you look at the minor branch, it's like 1,200 commits ahead of main right now. Uh there's actually been a lot of work going into it uh by Edison and it's almost ready. Some of the main things that's been shipped in the past few months in the beta in the 3.6 beta including type inference for Vapor components, uh V DOM teleport suspense in Vapor components,

rendering Vapor slots in V DOM components. Uh Vapor Mode support in View Router, JSX support View or View JSX Vapor and the 3.6 when you create view around the scaffolder, you now get a 3.6 option scaffolds a Vapor app out of the box. Um and Vapor Mode will be coming very soon. Uh and please be patient because I have been working on so many other things that

I think the detour is worth it. So, I did you know, I took the detour to work on V2 when I was working on V3 which, you know, dragged on the V3 release for a very long time. I think this time it'll also be worth it. So, please be patient with us. And and the interesting thing about the view ecosystem is we are seeing an interesting wave

of view tooling renaissance. Um many of you have probably been using the official view language tools for a very long time. Um it's been particularly challenging topic because language tooling support is has always been this really, you know, specialized field where you need to understand how LSPs work, you need to understand how view's compiler pipeline uh you need to also understand how TypeScript work, you need to,

you know, plum all these things together, but now with AI, this whole surface is actually uh collapsing really fast and becomes more manageable for people to explore new ideas. So, first of all, the official view language tools has undergone major improvements in the past few months. It actually went from 300 plus open issues down to fewer than 30. So, Johnson and Circle, Circle is here, I believe,

um has been working really, really hard on improving view language tools and closing issues. So, I want to give a big shout out to the hard work. Uh on the other fronts, we're seeing a few other community led initiatives uh trying to reimagine what view tooling could be like. So, one of these is the V's project. Um so, if you're interested, check it out. It's by a

Japanese view community member, now a team member, uh Ubuge, and he's been essentially writing this whole Rust-powered view tool chain including the compiler, linker, formatter, type checker, and everything on top of Oxc. and there is also experimental uh effort in integrating the view-specific linking parts back into Oxlink as a plugin. Um so, definitely check it out. Crazy performance. Um this is currently still unofficial, but obviously uh

we are keeping an eye on it and see how far this could be pushed. And then there's also Further which is uh made by another team member, Pigax. Um so, interestingly, these are like independent efforts, but kind of have overlapping, you know, fields. Um this is an Again, uh started as a language tools alternative implementation, but now is also evolving into a full compiler plus LSP implementation.

Again, written with Rust. Um And then there's also Golar which is a TSGo-based embedded language support framework inspired by Volar. Volar is the lower level framework that's powering view language tools made by Johnson. Originally, Volar was created to support view language tools and now it's inspiring uh this architecture is inspiring Golar which is TSGo-based. Um and TSGo and Golar is also framework-agnostic, so it has view support

which um interestingly, you can also try today and it's made by Arvid who is the author of TSGo-linked which is the type-aware linting engine that Oxlink is is using for type-aware linting. So, a lot of uh different efforts going on and right, where will we be heading for say native tooling for view? Honestly, at this moment, it's a bit early to tell, but it's exciting that these

things are happening. So, I would say, let them cook and see how far they can push this. And I think the um this little competition between these alternative explorations will end up benefiting all view users in the end. Okay. So, that's it for view. I'm going to save more time for the things that we want to talk about later. But big announcement, uh Vite 8 is here.

Uh so, we released it yesterday. So, if you have not caught up with the news, uh please go read the the blog post, the announcement. Um Vite 8 is probably the biggest milestone that we've hit for in the history of Vite. It is um the biggest architectural upgrade since Vite 2. So, every major upgrade between 2 and 8 are incremental. There are no fundamental changes. It's just

small breaking changes, but Vite 8, it does not have a lot of breaking changes. The fundamental change is internally, we have now completely replaced ESBuild and Rollup with Rolldown. And Rolldown is completely written from the ground up in Rust powered by Oxc and has a unified pipeline for both dev and production builds. And um you'll probably see at least 5 to 30 times faster builds when you

upgrade to Vite 8. Uh there shouldn't be any noticeable Um so, there is a migration guide, but for most apps, it should just literally be bumping the version and you'll see faster builds. there are also a few notable features, built-in dev tools. Um this is for um build only right now. And then there is built-in TSConfig path support, so you can drop the Vite plugin TSConfig paths

if you're still using that. Um built-in browser console forwarding for agents. If you use Vite with agents, you can now forward the browser console errors directly to the to your terminal, so your agents see them. Uh and then there's the experimental bundled dev mode for extremely large projects that are suffering from slow initial page load if you have just way too many source modules. And there are

more. So, check out the details in the uh Vite 8 announcement blog post. Um we are really excited to have more people try it and let us know how it works for you. Um it's been in beta for quite a long time, so we are pretty confident it's going to be you know, working well for most of you, your apps. So, please upgrade. And another thing I

want to mention is uh we are actually approaching the fifth anniversary of the Vite team creation. Vite as a project wouldn't have been where it is today uh thanks to the community and the team that contributed to it, that made it what it is, right? So, um Matias, uh aka Patak, the cat, uh has been a very uh you know, important force in pushing Vite to where

it is today. So, Matias had took a break from open source uh due to personal reasons, but he's now back and we want to give him a warm welcome back with this uh celeb- uh you know, anniversary celebration. So, we actually have an event at vite.dev/live March 19th at 3:00 p.m. UTC. So, we're uh have an online sort of re-premier of the documentary and have the team

members all together and re-watching it. So, uh feel free to come join us um in celebrating this 5-year anniversary. Okay. So, um outside of Vite, a lot of things been going on at Void Zero as well. Um we shipped major improvements to Oxlink and Oxc Format in the past few months. Note most notably, the JS plugin alpha for Oxlink just landed. If you've been on the fence

about moving to Oxlink because you have that, you know, just this ESLint plugin that you really, really need, but you couldn't use it in Oxlink, it most likely works now because uh the JS During this whole process, we have managed to reach 100% uh conformance on ESLint's own built-in rules, 99.9% conformance with like Stylistic, the ESLint Stylistic preset. Um so, most known plugins should just work out

of the box with Oxlink now. Obviously, we hope you um to use JS plugins selectively uh so that it doesn't completely tank the performance, right? It's still faster than using ESLint with those plugins, but um the the fewer JS plugins you use, obviously, the faster it is. Uh but that said, we have worked really hard to make Oxlink as compatible as possible to make migration easier, so

you no longer have excuses now. Um and uh proper view support is still work in progress. This is the challenging part because the view ESLint plugin is not a typical ESLint plugin. Uh it has its own pipeline in parsing view templates, instantiating the ASTs, and all that. So, um we are exploring proper support for it, and it'll come later this year. But, there is also the and

you know, exploration on integrating the V's view linting part into oxlint V as a WebAssembly plugin. And from what I can tell, Ubiquitous already has it working to some extent. So, we're excited to see where this goes. ox format Uh it's it's now in beta. It actually reached beta last month, and we have also proudly reached 100% Prettier conformance. In fact, in this whole process, we found

multiple bugs in Prettier itself that we had to fix that Prettier is like have these tests ignored and just, you know, and we're like, we need to fix these uh so we can we are actually 100% more con- conformant to Prettier than Prettier itself, in a sense. And additional file format through Prettier itself. So, uh ox format itself, the core, is focused on JS and TS, but

we also can format multiple other things by just invoking Prettier, which includes view files. We also ship native Tailwind class sorting uh if that is something you rely on. Okay. So, oxlint, oxformat, and Vite 8. We also ship Vitest 4.1, which bumps Vite dependency to Vite 8, right? So, we have all these new things that we shipped, which means a new generation of tooling generally has arrived.

So, if this is what you've been using say a year or two ago, right? You probably been using like webpack, TS sub, Jest, ESLint, Prettier. Now, we proudly say that Void Zero is providing you all faster and better alternatives to all of them. You can use Vite, Vitest, TS down, oxlint, oxformat. That's still a lot of configuration files, though, right? Can we do better? Well, you bet.

The answer is yes. What if all you need is a single vite.config.ts file? And that is what's possible with V Plus, which we are releasing today in public alpha, fully open source under MIT. So, we originally we had this plan to have a commercial license tied to it, but we have decided if we want to make JS developers really as productive as possible, which is the mission

of the company, the only way to do it is to make it truly open source. So, V Plus is going to be free for everyone to use. >> [applause] >> Thank you. So, um obviously V Plus is more than just combining these things individual pieces we built together. There's something more on top of it, right? So, there's the obvious things like dev, build, lint, format, test, and

pack. These are just proxying to these existing tools that we have built. But, there are things like VP create, which is uh scaffolding, self-explanatory. And there is a few things that need probably needs attention. So, first there's VP check. Um this is a sort of a compound command that includes the format, lint, and type check all in one command. So, it's also type checking through TS go.

So, you are doing formatting, syntactic linting, type aware linting, and type check all in the same command, in the same pass. And it'll report everything together. So, um you can also add {dash} {dash} fix, which means the format will just be auto formatted out of the go. So, one command to do all the verification. Actually works really, really great when you're working with agents, because you no

longer need to tell the agent to say, run format first, then lint, then type check. Just VP check, and there it is. Okay. So, the other thing is, V Plus now has the capability of managing your Node.js versions. It has the capability to manage your package managers. It has the capability to run tasks in your mono repos, and cache them. So, which means oh, it also can

set up like Git commit hooks. It can also do, uh lint staged capabilities. So, which means you should be able to eliminate Husky, lint staged, Turbo Repo, or NX, fnm. Uh all these things can be now replaced by just VP, a single binary to do it all. So, for the package manager part, we did not build a package manager ourselves, because pnpm is excellent. So, the VP

install part is more like a corepack equivalent. It will recommend pnpm by default, and it'll delegate the actual package manager tasks to pnpm, in- including workspace setup, etc. Uh but, it will uh it you can easily specify the version of pnpm you want to use by just using the same package manager field that corepack respects, right? Uh a note Node 26 is actually removing corepack support, so

good time to just use VP install uh if you have gotten used to just um not caring about which package manager you're using, right? Um you can of course use npm or yarn or even Volt if you want. VP install is actually uh package manager agnostic, which means you can use it to manage the specific version of package manager you want. So, if you have multiple projects

you're juggling between, one is using pnpm, the other is using yarn, you can just use VP install in all of them, and it'll automatically pick the right package manager with the right version to do the installations. VP env uh is a uh Node.js version management thing. So, the idea here is um it respects {dot} node-version files or the engines field uh in your package.json. So, when you

cd into a directory, it'll just automatically use the right node version. So, this feature is also uh so, when you install VP, we turn it on by default, but you can easily opt out by just saying VP env off, it'll just leave it alone. Uh it won't if you don't want to use it, you you don't have to. But, the idea here is when you have it

on, every other command you run is guaranteed to be using the right node version that you have specified with. Also, when you do VP install, for example, VP install G, um it'll remember the version of node that you installed something globally with, so that when you invoke that global binary, it's always invoked with the right node version that you installed with. And the nice thing is, even

when you are switching between node versions locally, between projects, your global installations will still be there and still invoked with the right Node.js versions they were installed with, right? This is my personal pet peeve with fnm is every time I switch node versions, I lose all my global packages, which is really annoying. Um okay. So, enough talk, let's do some demo. just run the VP help, right?

So, um VP comes with this global binary, which means you need to install it with curl uh fs ssl https v.plus pipe it into bash. And that's it. So, I'm not going to run it here, because I'm not sure about the the the network here, but this is how you install it. Once you install it, you will have VP. And if you just run VP, it'll actually

give you this really nice uh interactive list of commands you can run with. So, I'm just going to say create. I'm going to create a mono repo, because that is the best thing to demo things Use everything recommended. It sets up, you know, AI agent integrations, IDE set up pre-commit hooks that'll automatically do formatting linting on your staged files. Please ignore this temporary TS down warning. We'll

get rid of it. Um So, VP demo. And if you look at the code, it's a pretty standard uh pretty standard mono repo. So, we have uh directories. One is apps. So, this is a website app. And one is the um the utils, which is a package internally. So, the utils is a uh right now it's still it's still using TS down, but like actually it's just

importing here. So, uh and so, we will tweak it so that the config is just going to be there, and um the idea is this package is a library. You intend to either use it internally, or you want to publish it. So, you will use VP pack to package it, generate the DTS files, and all that. That's handled by TS down. This apps/website is an app. So,

it's a typical Vite app, right? So, you will do VP dev, VP build, VP preview. And they're living in the same thing uh living in the same mono repo, and they can have dependencies. So, what apps/website can depend on package utils. So, if I do VP uh env, uh I can say VP env which node, it'll tell me which node version I am using right now. This

is the default. So, if I uh come here and say add {dot} node-version, I want to use version 25. Uh hmm, okay. If I reload this, VP env which node. Now it's using Node 25 inch Why is it still 24? Okay, sorry. Um But, when you run VP run, it'll be using Node 25, for sure. Okay, so when you do VP run, the nice part here, the

DX, is um it actually shows you all the scripts that's available in your mono repo. Um so you get a get to see these are root scripts, right? And these are package scripts. So you can selectively run them and there's a fuzzy search, so I can do like uh build, I can see which package build I want to run. I can just run it from here. And

notice that there's something here. It says zero to cache hits because we didn't enable cache at all. So I'm going to go VP run ready, which just runs everything, type check, builds, everything. So it ran six tasks. And nothing is cache hit because I didn't enable cache at all. So now I just do dash dash cache. Still no cache hit because this is the run that actually

caches stuff. Now if I do dash dash cache again, it's immediate. All cache hit, right? So there's VP run, there's VP M, there's I think that's uh most of the things you would probably want to know on top of this, right? So um So this is V plus and uh we're excited to announce that V plus is going to be open source and uh everyone can start

using it. Uh in fact, V 3.6, the minor branch, has fully migrated to V plus. Um so check it out for a real world case on how it's being working. And it's released today fully open Just a single, you know, curls and to install in on your system. So uh this is probably the fastest way for you to go from zero to something working on a fresh

system. So uh you don't even need to install Node.js or PNPM or anything. It just just install VP and it'll manage all of them for you. And the docs is available at vplus.dev. It's live. Thank you. >> Okay, so um still have some time, so I'm going to do one more thing. Um so we've built all this tooling, we've built V plus, we've built, you know, all

the things you need from going from a fresh system to having your running V app. But there's still a lot of gap between having a V app and all the way having something live in the cloud, right? You still need to pick a framework, you still need to pick a deployment platform, still need to pick a database, an ORM, authentication, what if you want to do queues,

crons, all the stuff? It's, right, the back end is the back end story has never been part of the V story. So we're going to change that. Introducing Void, the V native deployment platform. the acronym, this is just a joke, but it acronyms V optimized isomorphic deploy. So what is Void? Right? Uh is it just another deployment platform? So the idea is Void turns any V app

into a truly full stack app, deployed at the edge on Cloudflare Workers with a single plugin. We actually got the Void package. So if you install Void, employ uh import the Void plugin, put it into your V config, and then voila, you have Void deploy and it goes live at the edge. No no Cloudflare account required, no Cloudflare infra knowledge required, and you just Void deploy and

goes live at the edge. So what can you do with it though? Like what can you build with it? So here's how it works. Um it gives you two back end full stack capabilities with auto infra provisioning. if you import DB from void/db, you get a D1 database locally and remotely. Locally it's simulated through Miniflare. Import KV, you get a KV namespace. Import storage, you get R2

bucket. Import AI, you get Workers AI or bring your own keys. Import auth, you get full authentication powered by Better Auth. DB schema is default to uh Drizzle. So if you have a Drizzle schema, it powers the end-to-end type safety throughout the entire stack, source of truth. Uh migrations are auto generated and auto applied on deploy. Crons, queues, just create a directory, put the files in there,

and they will go live when you deploy. And everything you do it locally and then you Void deploy, it goes live in the cloud. You don't even need to sign up for Cloudflare, you don't need to go to the dashboard or anything. It's all through the CLI. We will have a dashboard eventually, but right now you don't really need a dashboard. it also, all of these things,

right, they work with not just plain V apps, but also V-based meta frameworks. So the idea here is we have a happy path that V-based meta frameworks will be able to enjoy the uh these features as part of Void's platform SDK. So the Void plugin composes with V-based meta frameworks, which means if you use Nuxt, you can put Void plugin into the Nuxt V config, and you

get these capabilities as well. If you use other frameworks like SvelteKit or TanStack Start or whatever, as long as V-based, it will likely just compose with Void plugin, right? So um you get to use the meta framework you and enjoy these back end capabilities. So this SDK turns V-based meta frameworks into truly full stack uh things and with uh streamlined deployment. Void itself can also be used

as framework on its it actually is a pretty capable meta framework in itself. It has a rendering framework agnostic pages routing system. So you can use view files as page components, or you can use JSX or even Solid files, Svelte files. You can have island components. Uh you can have markdown pages as page components. It has ISR, which means you can just export, revalidate, uh and it'll

just cache your page with a 60 second stale or revalidate header at the edge on Cloudflare CDN. It has SSG if you want to build locally fully to static. So mixed rendering models, it gives you the ability to mix and match and choose ideal deployment model. Of course, the platform also supports deploying pure static sites. In fact, the staging documentation, which I can just briefly show you

right now, is a VPress site that's hosted on Void itself. So every Void app actually gets a void.app domain. Um so you probably want to grab that really fast once you're once you're in. this is what it looks like when you build um an actual app using Void's page routing system. So you can have a layout. The index view will go into the layouts component slot. Every

page component has a corresponding server.ts file in which you have actions and uh loaders and actions. Both are fully type end-to-end typed. Loader return values flow into your component automatically as props. And components have typed action and use form helpers on the client to invoke server-side actions. everything is driven by your Drizzle schema. So the Drizzle schema generate DB types and you can also get uh action

validators by inferring your uh validation schema from your Drizzle Any standard schema compatible validators, Zod, Valibot, ArcType, you name it. Put it into your uh action handler and you get fully typed client and server uh communication mutations and data loading. Um and the navigation model is actually inspired by Inertia. I don't know how many of you how many of you use Inertia with Laravel. Um but it's

actually a pretty pretty cool model that has never been seen in the JS world. So I'm pretty excited to um show this to people. And uh let's do some demo. if I go into uh this is a kitchen sink Hm, okay. So if you see here, I have AI, auth. So this is under pages, right? So every page every view component is just a page. Uh you

you you just write the view code you already know. So this is an example of a loader. define handler, this is just a helper to give you context. If you don't need any args, you don't even need it. So here I'm just returning a plain object. So this is just a list of uh AI models that's available. So this isn't a a model that's available on Cloudflare's

Workers AI. And these are the things you need to provide your own keys with. But the idea here is you're just returning some value And you can infer the return type from this handler. So infer props type of loader. It'll extract the props type. Uh you just import that props type from your server component and then use it in define props. that value becomes your props here.

Fully type safe. And how do you use AI features? You just use fetch. Fetch API AI, um this is not using our type fetch helper. We actually have a fully typed fetch helper, too. So, if you use this instead of um import fetch from uh void client. This fetch well, it's hm type is not fully working right now, I think. So, this fetch should also be fully

typed. Unfortunately, TSC is having some issues here, but um it actually give you auto complete on the all the available API routes. But, AI server.ts is really just um calling the endpoint. Hm. Oh. So, this one is actually not using the API we designed for, so I will need to pick another more interesting demo. So, let's just look at more standard demo. So, here's the database, right?

So, you have a special schema thing, which points just points to the schema.ts file in your DB directory. And here, we're just using standard Drizzle schema for SQLite because D1 is SQLite based. Uh there's some syntax highlighting issues, so if you look at this, we have the notes table, and we can infer a insertion uh using create insert schema from the Drizzle Valibot integration. And you can

pass this insert schema into your action here, so it automatically do both type and runtime validation on your action calls here. So, on the client side, db.view, we have a use form helper from the Void view adapter. And you can use form with named actions, and these are fully typed. and then the form helper, the delete form, the So, the form can be used in normal forms

very easily. And everything is fully typed and integrates with the backend code with minimal ceremony. Okay, so let's see what else. So, there are queues, revalidate, and etc. So, I'm not going to go into all of them, but you get the idea. This is a kitchen sink app. It just shows what is possible, right? So, uh if I invoke the Void CLI here, it also has this

really nice interactive thing. So, you can it has a built-in MCP. So, if you use an agent with it, uh the MCP can do things like MCP gives you the full doc search locally. The doc is shipped within the package itself. The MCP The MCP is also local. And the MCP also has a code mode endpoint, which talks to the deployment server, so you can say uh

what is the log from my last deployment and why did it fail, and it'll fetch that for you. Um and then you have code generation, so you can generate a model, which will generate automatically generate a schema for you, so you can say void gen model posts title string content string, etc. It'll generate the schema for you. Um the DB you can do reset, seed, execute, migrate,

etc. DB studio will actually fire up a local Drizzle studio instance to for you to look at the SQLite database locally. You can also do um void remote equals one, set the env variable to one, and you can actually develop locally with remote databases actually on an already deployed app. And then, custom domain is also supported, manage secrets, look at the project status, login, logout, etc. All

the things you'd expect from a CLI. So, if I say project status, right? So, I had a lot of failed deployments because I've been fixing bugs, but this one is live, right? So, let's do local development, so I'm going to start the local development here. oops, why am I stuck in full screen? So, 5136. So, this is the kitchen sink app, right? Right now, all of this

is local. So, hello world. Um this is running against local SQLite database. There's KV, there's storage. Everything is simulated. AI is interesting because actually, this is running through a proxy to talk to a real model that's running in the cloud uh even locally. there's off, fully powered by um fully powered by Better Off, but it's running locally. So, let's deploy it. I'm going to say void deploy.

Let's [snorts] hope this works. It was broken this morning, and I had to fix it on the spot, but let's [snorts] see if it works. It runs the migrations for you if it hasn't been applied yet. And it'll atomically abort if finds the migration failed. Oh, okay, it failed. But, I have already had a successful deployment early earlier, so It's running in the cloud. So, this is

actually a live void.app. >> [snorts] >> And uh yeah, so this is running against real databases. So, hello And if I refresh it, it's there. So, something that you can only demo when you're in the uh So, this is again uh what model are you? Okay, so this is working. Revalidate. So, this is the ISR feature that Next.js uh Vercel Next.js has. So, the idea here is

you visit it, it tells you this was last render time, and now it's cached. So, matter So, for the next 60 seconds, it'll give you this stale cached response until but it's already rendered the next one. So, 6660 seconds later, uh you'll get a refreshed timestamp. You can also manually revalidate it, so um and you get a new timestamp here. So, Void. It gives you all of

these features uh with just a single feed plugin. And yeah, nothing else, really. It's just a feed plugin, and you get all of this running in the cloud. Right now, this is still in obviously, this is still very early because we started working on this only a short while ago, but uh we believe this is going to change the way you think about going from zero to

something working in the cloud, and we want to combine this with V Plus. So, V Plus with Void allows you to go from a fresh machine to working app with all these features in the cloud in under 5 minutes. And that is what we define as making JavaScript developers as productive as they can be. And uh check out V Plus at vplus.dev. >> And uh you can

also request to join private beta for Void at void.cloud.