Vite 8.0 Is Out

by kothariji • 4 months ago

560 199 4 months ago

Currently, the Oxc transformer does not support lowering native decorators as we are waiting for the specification to progress

Does Oxc also support TS runtime features like constructor parameter properties and enums? I seem to recall in the beta that they had enabled --erasableSyntaxOnly, presumably because Rolldown / Oxc didn't support doing a full transform.

ameliaquining• 4 months ago

Yes, those work fine: https://playground.oxc.rs/?options=%7B%22run%22%3A%7B%22lint...

For that matter, TypeScript's version of decorators ("experimental decorators") also works: https://playground.oxc.rs/?options=%7B%22run%22%3A%7B%22lint...

What's not supported is the current draft proposal for standardized ECMAScript decorators; if you uncheck experimentalDecorators, the decorator syntax is simply passed through as-is, even when lowering to ES2015.

slopinthebag2• 4 months ago

Awesome. Standard decorators support is not a dealbreaker for me, but enums and other types of non-erasable syntax would be.

Do you know what the status is on using Rolldown as a crate for rust usage? At the moment most rust projects use SWC but afaik its bundler is depreciated. I usually just call into Deno for builds but would be nice to have it all purely in Rust.

Benjamin_Dobell• 4 months ago

TC39 decorators emit just landed in tsgo about 24 hours ago. Hopefully they're available in Vite 8 soon. I'm using them in GodotJS https://github.com/godotjs/GodotJS/commit/a4bafef9f14c103b09...

krona• 4 months ago

It doesn't support const enum, unlike esbuild which supports them well enough to be credible.

https://github.com/oxc-project/oxc/issues/6073

johnfn• 4 months ago

Vite 8 is pretty incredible. We saw around an 8x improvement (4m -> 30s) in our prod build, and it was nearly a drop-in replacement. Congrats (and thank you!) to the Vite team!

Griffinsauce2• 4 months ago

4 minutes?! How large is that app?

Not meant as a gotcha but I'm surprised because people always tout it as being so much faster than Next. (4m with Turbo would have to be a crazy huge app IME)

rk065• 4 months ago

most likely they are not running the prod build on latest mac. so it is slower.

dschu3• 4 months ago

Yeah, 4 mins is currently the avg. build time for our TanStack app dockerized. The turbo part takes 30 sec with Vite 7

FrostKiwi• 4 months ago

Same here (10s to 1s). The main reason for this is rolldown [1]. Already had it installed months ago, before it got merged into vite proper. Really awesome stuff.

[1] https://rolldown.rs/

bengale2• 4 months ago

We saw 12m -> 2m on one of our biggest projects. Incredible really.

christophilus5• 4 months ago

It blows my mind that there is a 12m build for a JavaScript application. How may lines of code is this app?

brandensilva• 4 months ago

Man the perf changes for this version are awesome. Thanks Vite.

pkilgore• 4 months ago

Congratulations!

hackernewsman71• 4 months ago

holy shit - Vite 8 - rhymes in french! Did they mention that somewhere?

soulchild77• 4 months ago

Awesome! Too bad Next.js will never profit from these incredible community efforts, because Vercel suffers from NIH.

rvcdbn• 4 months ago

maybe of interest: https://github.com/cloudflare/vinext

(haven't tried it myself)

vijaybritto2• 4 months ago

It's not a good piece of software. Breaks in many places

CalRobert2• 4 months ago

Got back in to react after a few years’ hiatus and I struggle to even understand what the point of Next is. Bizarrely the official docs even reference Next. Are people using react for non-SPA’s? Why?

codetantra2• 4 months ago

After Tanstack Start, Next.js seems even less intuitive. While it remains a viable option due to its established momentum, it feels quite alien to backend devs, esp with its unconventional defaults.

gnarlbar• 4 months ago

Not me, but I can imagine it happening.

JSX is a nice server side templating language. There a lot of people who aren't dependency conscious, and a lot of people who love react, and there is quite a bit of overlap in those two groups. I've used bun + preact_render_to_string for server side JSX templates before and it was nice. When I did it seemed that bun somewhat embraced react, and I could imagine react being the path of least resistance to server-side JSX there for some of the folks in the aforementioned groups.

flowerbreeze• 4 months ago

I'm being rather snarky here, but the main point of front-end JS UI frameworks is to exist and to survive in their environment. For this purpose they have evolved to form a parasymbiotic relationship with others in their environment, for example with influencers. The frameworks with the best influencers win out over older ones that do not have the novelty value anymore and fail to attract the best influencers.

drawfloat3• 4 months ago

Vercel has slowly taken over Facebook's position as being the employer of the main developers of React. There's a debate to be had over how much they 'control' it or not, but the fact create-next-app is the first recommended option on the official installation page now does show it's had an impact.

5 or so years ago, Next was a pretty solid option to quickly build up a non SPA, when combined with the static export function. It wasn't ideal, but it worked and came batteries included. Over time it's become more bloated, more complicated, and focused on features that benefit from Vercel's hosting – and static builds can't take advantage of them.

These newer features seem of limited benefit, to me, for even SPAs. Why is there still not a first class way of referencing API routes in the client code that provides typing? Once you reach even medium scale, it becomes a mess of inteprolated string paths and manually added shared response types.

pjmlp11• 4 months ago

The point is JavaScript developers rediscovering PHP, Spring MVC, ASP.NET MVC, Rails,.....

And to sell Vercel on top.

user342832• 4 months ago

Instead of going:

Fetch index.html -> Fetch JS bundle -> Evaluate -> Fetch /users/me

You do:

Fetch index.html (your page is rendered at this point) -> rehydrate with client side JS for interactivity in the background

It's a pretty smart solution I think, and many people are still sleeping on the whole SSR topic.

azangru3• 4 months ago

Are people using react for non-SPA’s?

Imagine a page that loads html during the first load, and then performs client-side routing during subsequent navigations. Is it an SPA? Is it not an SPA?

pjmlp11• 4 months ago

They have the enterprise partners that make Next.js the only officially supported SDK on their SaaS integrations.

See Sitecore Cloud, Sanity, Contentful,....

rk065• 4 months ago

Really the enterprise partner supports next, but not vanilla js sounds stupid? Honestly I expect them to prioritize nextjs and react given the popularity, but still be open to vanilla js.

I checked sitecore cloud to have special integration for nextjs and reactjs. But it also support vanilla js as well.

Are there really anyone who is exclusive to nextjs?

gherkinnn• 4 months ago

It's the Vercel way to first run broken previews for several years.

Next started with Turbopack alpha as a Webpack alternative in Next 13 (October 2022) and finally marked Turbopack as stable and default in Next 16 (October 2025). They also ran sketchy benchmarks against Vite back in 2022 [0].

Next's caching has a terrible history [1], it is demonstrably slow [2] (HN discussion [3]), RSCs had glaring security holes [4], the app router continues to confuse and relied on preview tech for years, and hosting Next outside of Vercel requires a special adapter [5].

Choosing Next.js is a liability.

0 - https://github.com/yyx990803/vite-vs-next-turbo-hmr/discussi...

1 - https://nextjs.org/blog/our-journey-with-caching

2 - https://martijnhols.nl/blog/how-much-traffic-can-a-pre-rende...

3 - https://news.ycombinator.com/item?id=43277148

4 - https://nextjs.org/blog/CVE-2025-66478

5 - https://opennext.js.org/

ssijak• 4 months ago

Next took a very bad turn and double downed on it. Coupled with years of terrible bugs its beyond repair for me unless they rewind a bunch of core changes they did.

There are several much better options right now. My favourite is Tanstack Start. No magice, great DX

littlecranky674• 4 months ago

Any suggestions to replace NextJS when you only use static export (no SSR)?

rk065• 4 months ago

Vercel owns nuxt and sveltekit, so they do benefit. only nextjs suffers from not being on vite.

verma_yatharth• 4 months ago

I tried it and I saw more than 6x improvement in speed. It's on the top. Awesome tool 1

pjmlp11• 4 months ago

Another rewrite in Rust.

What about finally stop using node.js for server side development?

vijaybritto2• 4 months ago

This is for tooling.

Node.js has been extraordinarily useful for building build tools. We're outgrowing it's capacity and rightfully moving to a compiled language. Also faster tooling is essential for establishing a high quality feedback loop for AI agents

pjmlp11• 4 months ago

Why go halfway, embrace compiled languages in the backend.

Fast all the way down, especially when coupled with REPL tooling.

CodeCompost• 4 months ago

Node as a compiler runtime or node as a runtime runtime?

pjmlp11• 4 months ago

Anything backend related.

maccard2• 4 months ago

I’m with you. It’s very telling when all of the tools are being rewritten and seeing orders of magnitudes of speed ups.

It just shows that people don’t value the actual performance of what they’re running.

mmusc• 4 months ago

isnt that what projects like bun are aiming to do?

nebezb• 4 months ago

Built-in tsconfig paths support

A great QoL change. One less place to duplicate (and potentially mistake) a config.

c-hendricks3• 4 months ago

This is great news, but people should also try using regular nodejs import aliases and see if they're viable for their project.

Timon3• 4 months ago

I keep trying the "native" solutions every so often, but every time I quickly hit some snag that makes me question why I'm not just using the solution that actually works. As an example, I just generated a new project using create-vite & added two subpath imports:

    {
        // ...
        "imports": {
            "#assets/*": "./src/assets/*",
            "#/*": "./src/*"
        },
        // ...
    }

The second one (#/*) is similar enough to what I usually use (@/*), and it's supported in Node since v25.4.0! Yet when I try to import the file at projectRoot/src/router/index.ts using:

    import router from "#/router/index"

VS Code shows an error: "Cannot find module '#/router/index' or its corresponding type declarations."

Now, imports from e.g. "#assets/main.css" work, so I could work around this issue - but this is what I keep experiencing: the native variant usually kinda works except for the most common use case, which is made unnecessarily awkward. For a long time this is what ESM used to feel like, and IMO it still does in places (e.g. directory imports not working is a shame).

karel-3d3• 4 months ago

Yesterday I stopped hating AI because it converted an old webpack project with impenetrable plugin settings to a single simple Vite config.

I still don't understand how people used to think scripts like this are the proper way to bundle an app.

https://github.com/facebook/create-react-app/blob/main/packa...

vite is great, is all I am saying

jjice2• 4 months ago

800 lines config to compile code that's later interpreted is wild. I get the general idea behind having a script instead of a static config, so you can do some runtime config (whether or not we should have runtime changes to config is a different conversation), but this is absurd.

I'm a big believer in fully reviewing all LLM generated code, but if I had to generate and review a webpack config like this, my eyes would gloss over...

karel-3d3• 4 months ago

No no no, the script on the link was BEFORE llms. That was how it used to be done before. That was the recommended facebook way.

The LLM generated vite config is 20 lines

ricardobeat• 4 months ago

People fought to replace the tools of the era with this. It had some advantages over time - ES6, a good plugin ecosystem, react adoption - but quickly it just became "the standard" which everyone is afraid to question.

I used to maintain a build workflow library [1] a lifetime ago; while our frontend build needs have evolved way beyond it, I can't avoid the feeling that we overengineered a little too much.

[1] https://github.com/ricardobeat/cake-flour

homebrewer• 4 months ago

Very pleased to see such performance improvements in the era of Electron shit and general contempt for users' computers. One of the projects I'm working on has been going for many years (since before React hooks were introduced), and I remember building it back in the day with tooling that was considered standard at the time (vanilla react-scripts, assembled around Webpack). It look maybe two minutes on a decent developer desktop, and old slow CI servers were even worse. Now Vite 8 builds it in about a second on comparable hardware. Another demonstration of how much resources we're collectively wasting.

vbezhenar• 4 months ago

It is especially weird because JavaScript was not supposed to be processed at all! This is all wrong if you ask me. Web development should strive to launch unchanged sources in the browser. TypeScript also was specifically designed so engine could strip types and execute result code. These build tools should not exist in the first place.

__alexs• 4 months ago

JavaScript was not supposed to a lot of things.

olmo23• 4 months ago

If you're already passing over the sources to strip the types, why would you also not do tree-shaking and minifications?

mexicocitinluez4• 4 months ago

It is especially weird because JavaScript was not supposed to be processed at all! This is all wrong if you ask me.

You're not actually suggesting that technology can't evolve are you? Especially one whose original design goals were to process basic forms and are now being used to build full-blown apps?

It's absolutely wild to me that with everything that has happened in the last 2 decades with regard to the web there are still people who refuse to accept that it's changed. We are building far bigger and more complex applications with JavaScript. What would you propose instead?

azangru3• 4 months ago

TypeScript also was specifically designed so engine could strip types and execute result code. These build tools should not exist in the first place.

Was it? Have you forgotten namespaces and enums?

tshaddox• 4 months ago

TypeScript also was specifically designed so engine could strip types and execute result code.

That's no less a build step than concating, bundling, minifying, etc. When people say "I'm against processing code before deploying it to a web site" but then also say "TypeScript is okay though" or "JSX is okay though," all they're really saying is "I like some build steps but not others." Which is fine! Just say that!

this_user• 4 months ago

Very pleased to see such performance improvements in the era of Electron shit and general contempt for users' computers.

Luckily, we have invented a completely new nightmare in the form of trying to graft machine-usable interfaces on top of AI models that were specifically designed to be used by humans.

itsTyrion• 4 months ago

the vite Homepage lags on both an A55 and s23fe regardless, which bears at least some irony

imfing• 4 months ago

Awesome! been using Vite since its early days. really excited to see how it's improving the JavaScript and TypeScript tooling landscape and how it continues to evolve

gdorsi• 4 months ago

Sweet, great job Vite team!

I wonder how much of the Rollup bundling magic has been ported to Rolldown.

One thing that always made this kind of switch to Rust has always been that Rollup has become so sophisticated that's hard to replace with something new.

shunia_huang• 4 months ago

Ah, wondering how long it will take Angular to replace it's sh*t building tool chain to fully vite compatible, hope it could happen before I change may career path or retire.

Klaster_1• 4 months ago

They recently put out a new roadmap item to adapt the compiler to modern tools: https://angular.dev/roadmap#developer-velocity . Given the great track record of recent Angular road map deliverables, I think they'll come up with something at least faster than what we have now. Angular already runs on Vite, and the fact that Vite 8 exposes AST level plugin endpoints are good signs. Not waiting 1 minute for unit test suite or `ng serve` cold start would be very welcome indeed.

moretti• 4 months ago

Thanks to the Vite team for building a faster, modern bundling solution on a fully open source stack that isn't tied to a specific framework...cough cough, Turbopack

throwaway2902• 4 months ago

Outsider question: why use Rollup when Esbuild exist? Is esbuild not enough for production builds?

rk065• 4 months ago

it is not. lack of plugin support is sufficient to block adoptions among other things.

throwaway2902• 4 months ago

but it has plugin support? what kind of plugins you mean?

abrztam• 4 months ago

also since typescript is being ported to go and rolldown is rust, they're stuck using IPC, so they miss out on native stuff like type awareness that a pure go toolchain would get for free

h4ch1• 4 months ago

I've been using rolldown-vite for the past 3-4 months with absolutely no issues on a very large monorepo with SvelteKit, multiple TS services and custom packages.

Just upgraded to 8 with some version bumping. Dev server time reduced to 1.5s from 8s and build reduced to 35s from 2m30. Really really impressed.

raydenvm• 4 months ago

Yeah, it makes you wonder how much computing power the industry has wasted over the years on tools that nobody questioned because "that's just how long builds take." We planned our work around it, joked about creating breaks, and built entire caching layers to work around it.

Kudos to the Vite maintainers!

jillesvangurp• 4 months ago

Build performance has been a pet topic for me for quite some time when I realized I was wasting so much times waiting for stuff to build 14 years ago. The problem is especially endemic in the Java world. But also in the backend world in general. I've seen people do integration tests where 99% of the time is spend creating and recreating the same database over and over again (some shitty ruby project more than a decade ago). That took something like 10 minutes.

With Kotlin/Spring Boot, compilation is annoyingly slow. That's what you get with modern languages and rich syntax. Apparently the Rust compiler isn't a speed daemon either. But tests are something that's under your control. Unit tests should be done in seconds/milliseconds. Integration tests are where you can make huge gains if you are a bit smart.

Most integration tests are not thread safe and make assumptions about running against an empty database. Which if you think about it, is exactly how no user except your first user will ever use your system.

The fix for this is 1) allow no cleanup between tests 2) randomize data so there are no test collisions between tests and 3) use multiple threads/processes to run your tests to 1 database that is provisioned before the tests and deleted after all tests.

I have a fast mac book pro that runs our hundreds of spring integration tests (proper end to end API tests with redis, db, elasticsearch and no fakes/stubs) in under 40 seconds. It kind of doubles as a robustness and performance test. It's fast enough that I have codex just trigger that on principle after every change it makes.

There's a bit more to it of course (e.g. polling rather than sleeping for assertions, using timeouts on things that are eventually happening, etc.). But once you have set this up once, you'll never want to deal with sequentially running integration tests again. Having to run those over and over again just sucks the joy out of life.

And with agentic coding tools having fast feedback loops is more critical than ever.

Sammi• 4 months ago

I've seen people do integration tests where 99% of the time is spend creating and recreating the same database over and over again (some shitty ruby project more than a decade ago). That took something like 10 minutes.

For anyone that doesn't know: With sqlite you can serialize the db to a buffer and create a "new" db from that buffer with just `new Datebase()`. Just run the migrations once on test initialization, serialize that migrated db and reuse it instantly for each test for amazing test isolation.

esafak• 4 months ago

Kotlin compiles fast; I don't have any problems with ktor. Spring Boot and Rust do not.

panstromek• 4 months ago

Most integration tests are not thread safe and make assumptions about running against an empty database. Which if you think about it, is exactly how no user except your first user will ever use your system.

Yea, cypress has this in their anti-patterns:

https://docs.cypress.io/app/core-concepts/best-practices#Usi...

Dangling state is useful for debugging when the test fails, you don't want to clean that up.

This has been super useful practice in my experience. I really like to be able to run tests regardless of my application state. It's faster and over time it helps you hit and fixup various issues that you only encounter after you fill the database with enough data.

charleslmunger• 4 months ago

With Kotlin/Spring Boot, compilation is annoyingly slow. That's what you get with modern languages and rich syntax.

This is because the kotlin compiler is not written in the way people write fast compilers. It has almost no backend to speak of (if you are targeting the jvm), and yet it can be slower at compilation than gcc and clang when optimizing.

Modern fast compilers follow a sort of emerging pattern where AST nodes are identified by integers, and stored in a standard traversal order in a flat array. This makes extremely efficient use of cache when performing repeated operations on the AST. The Carbon, Zig, and Jai compiler frontends are all written this way. The kotlin compiler is written in a more object oriented and functional style that involves a lot more pointer chasing and far less data-dense structures.

Then, if run on a non-graal environment, you also have to pay for the interpreter and JIT warmup, which for short-lived tasks represents nontrivial overhead.

But unlike header inclusion or templates, which are language level features that have major effects on compilation time, I don't think kotlin the language is inherently slow to compile.

Zopieux• 4 months ago

I wonder what will be the parallel hindsight about waste, but for matrix multiplications, in a few years.

_heimdall• 4 months ago

By then I understand that matrix multiplication will have cured cancer and invented unlimited free energy, so no hindsight of waste needed.

xxpor• 4 months ago

The economic incentives line up much better there. You charge for tokens -> cost is GPUs -> you work very hard to keep GPUs utilized 100% and get max tokens out of those cycles.

Compare this to essentially any modern business app, the product being sold has very little relationship with CPU cycles, or the CPU cycles are SO cheap relative to what you're getting paid, no one cares to optimize.

semiquaver2• 4 months ago

The waste of slow JS bundles is nothing compared to the cost of bloated interpreted runtimes or inefficient abstractions. Most production software is multiple orders of magnitude slower than it needs to be. Just look at all the electron apps that use multiple GB of ram doing nothing and are laggier than similar software written 40 years ago despite having access to an incredibly luxurious amount of resources from any sane historical perspective.

shimman6• 4 months ago

Something I realized while doing more political campaign work is how inefficient most self hosted solutions are. Things like plausible or umami (analytics) require at least 2 gigs of ram, postiz (scheduled social media planner) requires 2 gigs of ram, etc.

It all slowly adds up where you think a simple $10 VPS with 2 gigs of ram is enough but it's not, especially if you want a team of 10-30ish to work sporadically within the same box.

There can be a lot of major wins by rewriting these programs in more efficient languages like Go or Rust. It would make self hosting more maintainable and break away from the consulting class that often has worse solutions at way higher prices (for an example, one consulting group sells software similar to postiz but for $2k/month).

awongh• 4 months ago

I guess there's the distinction between capacity that could be taken up by other things, and free capacity that doesn't necessarily cost anything.

For a server built in the cloud those cycles could actually be taken up by other things, freeing the system and bringing costs down.

For a client computer running electron, as long as the user doesn't have so many electro apps open that their computer slows down noticeably, that inefficency might not matter that much.

Another aspect is that the devices get cheaper and faster so today's slow electron app might run fine on a system that is a few years away, and that capacity was never going to be taken up by anything else on the end user's device.

blackoil• 4 months ago

Why are electron apps memory intensive compared to other cross platform frameworks. Is it language, UI system or legacy?

spiderfarmer• 4 months ago

Imagine the amount of useful apps that would not have been made without Electron.

jjtheblunt3• 4 months ago

Most production software is multiple orders of magnitude slower than it needs to be.

at least 100x slower than it needs to be?

KronisLV• 4 months ago

Yeah, it makes you wonder how much computing power the industry has wasted over the years on tools that nobody questioned because "that's just how long builds take."

I feel the same way about tools like ESLint and Prettier as well after discovering Oxc https://oxc.rs/

flohofwoe• 4 months ago

No worries, projects will soon catch up by throwing more code at the build system.

punkbit• 4 months ago

Migrating straight away! Thank you!

Aldipower3• 4 months ago

As I am interested in long time maintainability (should still work in 10 years) with my projects I am just using esbuild directly. I am not interested in adjusting my projects, just because things changed under the hood in "wrappers" like Vite and I suddenly have a lot of work.

emadda• 4 months ago

esbuild has been very stable for my projects too.

I think it is the only tool in the JS ecosystem that has not broken after a few years.

christophilus5• 4 months ago

This is the way. Trivial to get live reloading working. HMR is overrated. I went with esbuild in my last project, and have no regrets. Also, used my own 100-line end-to-end typed RPC layer with Zod validation doing the heavy lifting. No codegen required for any part of the project other than generating types from Postgres. No regrets there, either. The only thing I would have changed in that project is I would have used Kysely instead of just raw porsager.

silverwind• 4 months ago

IIRC, esbuild is still lacking code splitting.

chearon• 4 months ago

esbuild still doesn’t support top-level await. And live reloading is way, way slower than HMR.

brillout3• 4 months ago

Vite+, Void Cloud, Void Framework... an epic battle between Vercel and Void is coming.

The PRC (aka server functions) demo [0] is particularly interesting — end-to-end type safety (from DB to UI) is a major milestone for JavaScript. We've been doing a lot of RPC design work in that space with Telefunc (tRPC alternative) [1] — it's a really hard topic, and we're looking forward to collaborating with the Void team. (Also looking forward to contributing as the creators of Vike [2].)

[0] https://www.youtube.com/watch?v=BX0Xv73kXNk (around the end of the first talk) [1]: https://telefunc.com (see the last PR) [2]: https://vike.dev

yurishimo4• 4 months ago

You say that, but isn't Vercel also a Void(0) investor in a roundabout way?

The big news regarding Void Cloud is that it all seems to be built on Cloudflare workers. The landing page is very light on info atm too. [0]

I am super excited that they are MIT open sourcing Vite+ however. In that realm, they are obviously targeting Bun as their main competition. Unfortunately for Bun, if they are forced to help Anthropic more than they can focus on OSS, they might lose their current (perceived?) advantage.

0: https://void.cloud/

brillout3• 4 months ago

Doesn't seem like it — see VoidZero investors [0].

Unfortunately for Bun, if they are forced to help Anthropic more than they can focus on OSS

Curious: is that speculation, or based on observation?

[0] https://voidzero.dev/about

chrisweekly• 4 months ago

Awesome news. Amid all the (real and perceived) js ecosystem churn, vite has been consistently excellent for dx and production. The unified rolldown bundler is only going to increase vite's appeal and widen the gap as the fastest, most pragmatic and flexible foundation for ts/js projects. Huge fan, speaking from deep experience (webdev since 1998).

vite_throwaway3• 4 months ago

I have a small React project using vite 7 and have the following in my config so that vite interprets ".js" files as JSX:

    // See https://github.com/vitejs/vite/discussions/14652
    esbuild: {
      loader: "jsx",
      include: /.*\.jsx?$/,
      exclude: [],
    },
    optimizeDeps: {
      esbuildOptions: {
        loader: {
          ".js": "jsx",
        },
      },
    },

Note the comment at the top. I had no idea how to come up with this config by checking the documentation pages of vite and its various related tools. Luckily I found the GitHub issue and someone else had come up with the right incantation.

Now this new vite uses new tools, and their documentation is still lacking. I spent half an hour trying to figure out how vite (and related tools that I had to navigate and try to piece a coherent view of: esbuild, oxc, rolldown, etc.) might be convinced, but gave up and stayed with vite 7.

Someone could respond with a working solution and it would help, sure, but these tools sure as hell have documentation issues.

spiros• 4 months ago

The solution here is working for me: https://github.com/vitejs/vite/discussions/21505

Though sometimes oxc complains about JSX in JS when running vite, but it still works fine.

vite_throwaway3• 4 months ago

Thanks, I will consider this workaround later on.

Another instance is the use of rollupOptions.output.manualChunks that now has to be rewritten, maybe that would be less frustrating to fathom.

iainmerrick• 4 months ago

Sorry if this comes across as overly facetious — I’m sure you have a reason for doing it that way! — but would it not be easier just to bow to convention and rename your .js files to .jsx?

vite_throwaway3• 4 months ago

Probably. It's just that I've always used .js for my projects (decades). Such a rename would likely result in configuration changes to the other tools I use, but indeed they are better documented. When faced with a multiplicity of conventions I pick one and stick to it; the tools are flexible enough to work with it I'm sure, the real issue is of discoverability.

ezfe• 4 months ago

I'm curious why you use `.js` files instead of `.jsx`? In my experience, using `jsx` files makes everything work better

upsuper• 4 months ago

I contributed this change in Vite 8:

Wasm SSR support: .wasm?init imports now work in SSR environments, expanding Vite's WebAssembly feature to server-side rendering.

While the process was relatively slow, I really appreciate the extra effort that the team have put on even this minor feature add. They not only guided me towards more compatible and idiomatic approach, but also added docs and helped keeping the code up to date before merging.

bovermyer• 4 months ago

This is a fun insight, thank you for sharing that!

I like Vite as a tool, but knowing that the Vite folks actually care about helping others learn and contribute is awesome.

repulsio• 4 months ago

Vite 8 has been a huge disappointment:

https://github.com/vitejs/vite/issues/21939

Build filesizes have doubled... No build speed gain is worth that...

I would take a slightly longer build time for half the filesize any day

Vite 8.0 Is Out

Related Stories