跪拜 Guibai
← Back to the summary

Vue 2026: Core Rewritten, API Frozen, and Upgrading Is Nearly Free

2026 Vue Ecosystem Analysis: The Underlying Layer Was Rewritten, Yet Upgrading Costs Almost Nothing

First, look at a contrast: As of 2026-11-20, Vue 3.6 is still in RC (v3.6.0-rc.15), but the reactivity core, the SFC compilation mode, and the build bundler have all been swapped out. And your business code doesn't need a single line changed.

This sentence is not rhetoric. The 3.6 reactivity rewrite is enabled by default for everyone, Vapor is opt-in per component, and the bundler replacement in Vite 8 is transparent to application code. The path the Vue team is taking in 2026 is clear: cram all the aggressive changes into the compiler, runtime, and toolchain internals, so that upgrading existing projects costs almost zero.

But "zero-cost upgrade" does not equal "zero-risk upgrade." The real pitfalls are in two places: overestimating Vapor's immediate benefits, and misreading the performance numbers floating around online. This article breaks the ecosystem into a layered map, pairs it with a set of locally reproducible benchmark data, and ends with a sequenced upgrade path.

1. A Full Picture First: Three Layers Changed, One Layer Untouched

Layer 2025 2026 (as of November) Does Application Code Need Changes?
Rendering Virtual DOM + diff/patch New Vapor Mode, compile-time generation of imperative DOM directives No; enable per component with vapor
Reactivity @vue/reactivity (Set-based dependency tracking) Rewritten on alien-signals, bidirectional linked list + push-pull No; effective on upgrade
Build esbuild (dev) + Rollup (build) Vite 8 uses Rolldown as a single bundler Mostly no; watch plugin compatibility
Meta-framework Nuxt 4.x Nuxt 4.6, supports Vapor interop; Nuxt 3 is EOL Depends on version
State Pinia 2/3 Pinia 3 + Pinia Colada (server state) New projects should use Colada
API Composition API + Options API Unchanged No

In one sentence: Performance first, API stable. This is also the key to understanding all Vue news in 2026 — don't wait for some new syntax; pay attention to the benefit windows and boundaries brought by the underlying replacements.

2. Version Status: Production Is Still on 3.5

First, lay out the timeline to avoid being led astray by headlines like "3.6 is coming" (data checked as of 2026-11-20):

Date Version Notes
2025-07-12 3.6.0-alpha.1 Vapor Mode first appears
2026-03-12 Vite 8.0 Rolldown becomes the only bundler
2026-05-07 Rolldown 1.0 API locked, usable independently of Vite
2026-07-18 3.6.0-rc.1 Enters RC, Vapor features complete
2026-07-31 Nuxt 3 EOL Officially ends lifecycle after extended support
2026-09-28 Vite+ 1.0 Unified vp command, MIT
2026-10-05 Nuxt 4.6 Supports Vapor interop mode
2026-11-05 v3.5.45 Latest patch on the current stable line
2026-11-12 v3.6.0-rc.15 Latest on the current RC line, 90% of changes in Vapor

The conclusion is direct: the default choice for production remains 3.5.x; 3.6 will wait for the stable release. The API may still be tweaked during RC. All 3.6 code in this article is based on rc.15; re-verify with the official Release Notes before shipping.

There's also a long-term signal easily overlooked: Vue 4.0 has been announced to start development at Vue & Vite Conf 2026, with the goal of stabilizing 3.6's experimental features without introducing breaking API changes. Evan You's reason is interesting — model training data has already solidified Vue 3's API patterns, and keeping the framework stable helps with the reliability of AI-generated code. For teams, this means the investment in this round of upgrades won't be wasted by Vue 4.

3. Rendering Layer: Vapor Moves Diff from Runtime to Compile Time

The difference between the traditional path and the Vapor path can be summed up in two lines:

Traditional: Template → render function → VNode tree → diff → patch → real DOM
Vapor: Template → compile-time analysis → point-to-point DOM update directives → real DOM

Vapor analyzes each dynamic expression in the template at compile time and maps it directly to the corresponding DOM node. At runtime, no VNode is generated and no diff is done. This path is the same idea as the compile-time optimizations in Solid and Svelte 5.

3.1 Three Ways to Enable (Compile-tested on [email protected])

<!-- ① Per-component enable: add the vapor attribute; template and setup logic don't change -->
<script setup vapor>
import { ref } from 'vue'
const count = ref(0)
</script>

<template>
  <button @click="count++">count: {{ count }}</button>
</template>
// ② Hybrid mode: the main path for existing projects, must register the interop plugin
import { createApp, vaporInteropPlugin } from 'vue'
import App from './App.vue'

createApp(App).use(vaporInteropPlugin).mount('#app')
// ③ Full Vapor app: new projects or standalone sub-apps; vDOM runtime can be fully tree-shaken
import { createVaporApp } from 'vue'
import App from './App.vue'

createVaporApp(App).mount('#app')

Standard props, events, and slots work across Vapor / vDOM boundaries, and the two component types can be mixed in the same component tree.

3.2 Practical Test: What the Compiled Output Looks Like

I set up a minimal project locally to verify, using Node 22.22.2 / vue 3.6.0-rc.15 / vite 8.3.8 / @vitejs/plugin-vue 6.0.11. After npm run build, the Vapor component in the unminified output is compiled to this (excerpt):

const n0 = t0();
renderEffect(() => setText(x0, "count: " + toDisplayString(count.value)));

t0() clones the static template, and renderEffect directly calls setText when count changes — no render function generates VNode, no diff, no patch. Removing the vapor attribute and rebuilding, the same component returns to the createVNode path and no longer has the t0() template factory. This shows more clearly than any architecture diagram what "bypassing the virtual DOM" actually bypasses.

To reproduce, you only need three files and one vite.config.js; the core code is the three snippets above.

3.3 Practical Test: Production Size Across Three Modes, and a Counterintuitive Conclusion

For the same minimal demo (1 button + 1 ref, no third-party dependencies), default esbuild minification, single JS chunk with full runtime:

Build Mode Raw Output gzip vs Baseline
Hybrid mode (Vapor component + vDOM component + interop) 125.39 kB 45.9 kB +0.5 kB
Pure vDOM control (remove vapor attribute) 124.14 kB 45.4 kB Baseline
Full Vapor (createVaporApp) 48.30 kB 18.0 kB about −60%

Two notable points:

  1. Full Vapor does compress the runtime, gzip drops from about 45.9 kB to 18.0 kB, because the vDOM runtime is entirely tree-shaken.
  2. Hybrid mode is slightly larger than pure vDOM. Including both runtimes and the interop plugin costs you.

This explains the official recommendation: "new small applications should go full Vapor, existing applications should only try 1-2 performance-sensitive pages," rather than migrating everything. Vapor's benefit is cleanest in full Vapor applications; in hybrid mode, you trade local rendering performance for an extra runtime in your bundle.

Note on methodology: This is a relative comparison of a minimal demo, not a real business bundle size. No built-in components, no UI library; the number of components and features used will change the difference. The numbers are only meant to illustrate the mechanism that "hybrid mode has extra runtime cost" — don't treat them as performance promises.

3.4 Unsupported List (Common Pitfall Area)

Vapor does not support anything that depends on VNode or the component public instance proxy. Officially listed:

Unsupported Notes
Options API Only Composition API + <script setup>
getCurrentInstance() Returns null
app.config.globalProperties Global property injection unavailable
@vue:xxx lifecycle events Element-level lifecycle hooks unavailable
v-memo Cache directive relying on vDOM
$el / $props and other instance proxies Not available on template refs
Custom directives Must migrate to Vapor-specific functional interface
Suspense Officially stated as the only exception for functional equivalence

Additionally, since RC.2 event delegation is opt-in (explicitly declared when needed, and the old compilerOptions.eventDelegation config is removed). Another hidden pitfall: using slots.default?.() as a "probe" to check whether a slot exists in Vapor can trigger side effects — let template rendering handle it, don't call it in the script.

4. Reactivity Layer: The Only Change That "Takes Effect on Upgrade"

3.6 rewrites @vue/reactivity on top of alien-signals, using a push-pull two-phase approach:

Dependency storage is changed from Set to a bidirectional linked list, nodes are removed directly, stale dependency cleanup is faster, and allocation is lower; combined with more aggressive batching, baseline memory usage is about −14% (source: "The State of Vue in 2026", marked as baseline data).

The significance: you don't need to enable Vapor — just upgrade to 3.6, and ordinary vDOM components also get the benefits of the new core. But it's also the only change that "you didn't actively turn on, but it's globally effective" — complex watch / effect chains may see dependency timing changes. So the official recommendation is: first upgrade to 3.6 alone without enabling Vapor, run a round of regression tests, then consider piloting Vapor. Don't do the two things together, or you won't be able to tell which layer caused a problem.

5. Build Layer: Vite 8 Merges Two Bundlers into One

Before Vite 8 (2026-03-12), dev used esbuild, build used Rollup, and the two semantics inevitably differed; Vite 8 makes Rust-written Rolldown the only bundler for all environments. Official claims are up to 10–30x build speedup on large codebases; user feedback from preview/beta includes Linear 46s → 6s, Beehiiv build time reduced by 64%, Mercedes-Benz.io 38% faster (cited from "The State of Vue in 2026", all officially published user feedback, not general benchmarks).

Other things worth noting: Vite Devtools integration, native resolve.tsconfigPaths, WebAssembly SSR, built-in emitDecoratorMetadata. The cost is installation size about +15MB vs Vite 7 (lightningcss ~10MB + Rolldown binary ~5MB), so CI images and caches need to reserve space.

There are also two toolchain items: Vite+ 1.0 (2026-09-28) uses a single vp command to cover dev, build, test, lint, format, and monorepo tasks; vp check runs formatting, lint, and type-checking in one pass. VoidZero joined Cloudflare in June 2026 and publicly committed that Vite, Vitest, Rolldown, Oxc, and Vite+ remain open source under MIT. For people making technology choices, the concern "will the Rust-ified toolchain be commercially absorbed" now has a clear public answer.

6. Upper Ecosystem: All Small Steps, No Disruptive Upgrades

Project 2026 Status Significance for Tool Selection
Nuxt 4.6 (Oct) supports Vapor interop, latest v4.6.4; 4.5 already switched to Vite 8 and introduced SSR streaming; Nuxt 3 is EOL Still the first choice for SSR/SSG/API routes; most of Nuxt 5's capabilities are opt-in in 4.6
Nitro v3 beta Prerequisite for Nuxt 5
Pinia v3 stable, completely drops Vue 2 support Official and only recommended client state solution
Pinia Colada First stable release in early 2026 Fills the server state gap: caching, request deduplication, background revalidation, optimistic updates, role similar to TanStack Query
Vue Router Native View Transition API support Page transition animations no longer need manual hacks
Language tools Official Vue Language Tools open issues dropped from 300+ to <30 (Evan You, State of Vue 2026) Editor experience significantly improved

One change in state management worth calling out separately: the State of Vue.js Report 2025 shows over 80% of respondents use Pinia, but Vuex still has a 38.4% existing usage share. Pinia 3 dropping Vue 2 support is itself a signal — the community migration is basically complete. For new projects doing API integration, you can design Pinia (client state) and Pinia Colada (server state) separately, and stop letting a store handle all request caching logic.

7. Let Data Speak: Four Ways to Measure, Don't Mix Them Up

This is where I find second-hand articles most likely to mislead. Usage rate, satisfaction, download count, website share — they measure different things:

Metric Vue React Source & Window
Usage rate (State of JS 2025) 52% 85% 13,002 responses, published 2026-02-03, self-selected JS developers, values are biased high
Satisfaction / positive ratings (same) 84% 72% Same; Svelte 86%, Solid 89%, Angular 48%
Usage rate (Stack Overflow 2026) 17.2% 41.5% n=10,281, all developers "used deeply in the past year"
npm weekly downloads 24.8M 252.2M npm API, 2026-11-05~11; includes CI installs and transitive dependencies
Website share (W3Techs) 0.6% 6.1% 2026-11-13, only public sites that can be detected

A few rules for reading data:

Also be careful with performance numbers. The widely circulated demo at Frontend Nation 2026 (10,000-grid update: 3.5 ~16ms / 3.6 without Vapor ~10ms / Vapor ~0.2ms, memory 3-10 times less) is a pre-release build demo; numbers like "97% rendering improvement" or "first-load JS reduced by 2/3" come from extreme synthetic scenarios in third-party reviews. The official positioning is just one phrase: "on par with Solid and Svelte 5." In real business, bottlenecks are usually network requests, unnecessary re-renders, bundle size, layout thrashing, and long lists without virtualization — framework-level rendering differences are often far smaller than the difference between good and bad architecture.

8. Practical: A Sequenced Upgrade Path

Based on the boundaries above, I recommend this order for existing Vue 3 projects, with each step independently reversible:

Step 1: Upgrade the build layer first — highest benefit, lowest risk

npm install -D vite@^8 @vitejs/plugin-vue@^6
npm run build

Verify three things: build time, output size, and whether existing Vite/Rollup plugins are compatible. Rolldown focuses on plugin compatibility, but custom plugins still need real testing. Also confirm the CI image can accommodate the +15MB install size.

Step 2: Wait for 3.6 stable, upgrade but don't enable Vapor

npm install vue@^3.6

Don't add any vapor attributes; behavior is the same as 3.5, and you get alien-signals' reactivity benefits for free. Focus regression testing on complex watcher / effect chains, since this is the only globally effective change that may alter timing.

Step 3: Pick 1-2 pages that actually have performance bottlenecks to pilot Vapor

<script setup vapor>
// Only add vapor to this high-frequency update component
</script>

Register vaporInteropPlugin in the vDOM app entry, and compare before/after with the Performance panel. If there's no measurable benefit, remove it. Don't use new technology just for the sake of it.

New projects are a different story: Vue 3.5 stable + Vite 8 + Pinia 3 + Pinia Colada is the most solid combination right now; if you need SSR/SSG, go with Nuxt 4.6; for small and performance-sensitive apps, after 3.6 stable you can use createVaporApp entirely, provided you accept constraints like "no Options API" and "some third-party UI libraries need interop plugins."

9. Pitfall Quick Reference Table

Pitfall Symptom Avoidance
Adding vapor directly to an Options API project Compile error / abnormal behavior Migrate to <script setup> first, then pilot per component
Missing interop plugin registration in hybrid mode Vapor component renders abnormally, slots fail createApp(App).use(vaporInteropPlugin)
Using getCurrentInstance() / $el / v-memo Returns null or doesn't work Check the unsupported list and refactor
Using slots.default?.() as an existence probe Triggers unexpected side effects Let template rendering handle it
Reusing custom directives directly Runtime error Migrate to the Vapor functional directive interface
Upgrading 3.6 and piloting Vapor at the same time Can't locate which layer has a problem Split into two steps, run regression for each
Directly citing "97% improvement" No noticeable effect in production Measure on your own performance-sensitive pages
Keeping the old compilerOptions.eventDelegation Config invalid since RC.2 Remove the config; when delegation is needed, declare it explicitly
Ignoring Vite 8 size increase node_modules / images get larger Reserve about 15MB, evaluate CI cache

10. When Vue Is Not the Optimal Choice

An ecosystem analysis that only talks about benefits is not worth much. Let's honestly list the boundaries:

Summary

  1. The main story of Vue in 2026 is "performance first, API stable": the rendering (Vapor, opt-in), reactivity (alien-signals, globally effective), and build (Rolldown / Vite 8) layers have been replaced, with almost no changes to the application layer. Vue 4.0 also explicitly promises no breaking API changes, so the investment in this round of upgrades is safe.
  2. The real decision point is how to adopt Vapor: a full Vapor app measures about 18 kB gzip (vDOM runtime is tree-shaken), while hybrid mode is about 0.5 kB larger than pure vDOM. So existing projects should pilot on specific pages, new small apps should go full Vapor — don't migrate everything.
  3. Only two things to do now: upgrade to Vite 8 to get build benefits, and after 3.6 stable, first upgrade alone and run regression. Measure performance numbers on your own pages; don't cite synthetic benchmarks.

What patch version of 3.5 is your team currently on? Have you already piloted Vapor on any page, and how much does the measured benefit differ from the official claim? Share real data in the comments.

References