Overview

Vue is a free, open-source JavaScript framework for building user interfaces. It builds on standard HTML, CSS and JavaScript and adds a declarative, component-based programming model: you describe what the interface should look like for a given state, and Vue keeps the DOM in step as that state changes. The two ideas at its centre are declarative rendering — templates that extend HTML with expressions bound to JavaScript state — and reactivity, where Vue tracks which pieces of state an interface actually reads and updates only those parts when they change.

Evan You created Vue in 2013 after working at Google on AngularJS projects, and announced it publicly in February 2014 as a lighter way to get the parts of Angular he valued without the rest of the framework. It has been developed in the open ever since, and the current repository carries more than 54,000 stars on GitHub. Vue 2 stopped receiving fixes on 31 December 2023; Vue 3 has been the default since February 2022, and the latest stable release is 3.5.45, published on 5 November 2026.

Key Features

• Reactivity — a Proxy-based system records which state each render, computed property or watcher depends on, and re-runs only what is affected. Computed values are cached and invalidated precisely, so derived data does not recompute on every keystroke.
• Single-File Components — a .vue file holds a component’s script, template and scoped styles together. The compiler turns it into a plain JavaScript module, so a component is one file to read, move and review rather than three that must be kept in sync.
• Composition API — ref, computed, watch and lifecycle hooks can be grouped by feature inside script setup blocks, and any slice of logic can be extracted into a reusable composable function. The Options API remains fully supported for teams that prefer an object of data, methods and computed.
• Compiled templates — templates are compiled ahead of time rather than interpreted at runtime. The compiler hoists static content out of the render function and annotates dynamic bindings with patch flags, so the runtime knows exactly which nodes may need work.
• Built-in building blocks — Transition and TransitionGroup for animations, Teleport for rendering a subtree elsewhere in the document, Suspense for coordinating async setup, and KeepAlive for caching component instances.
• Server-side rendering and hydration — the same components render to HTML on the server through @vue/server-renderer and hydrate in the browser. Async components can pick their own hydration strategy, so a below-the-fold widget can wait until it becomes visible.
• Tooling that fits the language — the official Vue Language Tools extension provides type checking, completion and refactors inside templates and script setup blocks, including TypeScript, and Vue DevTools inspects the component tree, props, events, Pinia stores and router state in the browser.
• A small, documented core — routing, state management, build tooling and testing are separate packages with official support: Vue Router, Pinia, Vite, Vitest and the VitePress static-site generator, all under the same MIT licence.

Why Use Vue?

The practical argument is the size of the step you have to take to start. Vue can be dropped onto an existing server-rendered page as a single script tag and used to make one form interactive, and the same framework scales to a full single-page application with routing, stores and a build step — the core knowledge does not change between those two ends. That is what the project means by a progressive framework: adoption is incremental, and nothing has to be rewritten to move up a level.

The second argument is that Vue is unusually readable to people who arrive knowing HTML. A template is markup with bindings in it, directives read like attributes (v-if, v-for, v-model), and styles can be scoped to the component that owns them. Teams that hand projects between front-end and back-end developers tend to cite this; the learning curve is short without the framework becoming a toy, because the Composition API and the TypeScript support are there when the application grows complicated.

It is also a framework that stays out of the way of the rest of the stack. There is no mandated router, no mandated state library and no file-system routing convention baked into the core: you can use Vue Router and Pinia, or a different approach, or none at all, and the framework still works.

Use Cases

• Interactive components on an existing site — a search box, a filterable table or a multi-step form, mounted onto the markup a CMS or server framework already renders.
• Single-page applications — dashboards and internal tools where the interface holds a lot of state and should not reload between views; Vue Router and Pinia cover the navigation and store layers.
• Server-rendered and static sites — Nuxt builds on Vue for SSR, SSG and hybrid rendering, and VitePress uses Vue components inside Markdown documentation sites.
• Web Components — a Vue component can be compiled to a standard custom element and embedded in a page built with something else, which makes it a practical choice for design systems shared across teams.
• Teaching — the guide is progressive itself, and a working counter is a dozen lines, which makes Vue a common first framework in courses and bootcamps.

Getting Started

The fastest route is the command-line scaffold: npm create vue@latest asks a short set of questions (TypeScript, router, Pinia, testing) and writes a Vite project with those pieces wired together. npm install followed by npm run dev starts a development server with hot module replacement, and npm run build produces static assets for any web server. A playground at playground.vuejs.org runs the same compiler in the browser if you only want to try a component.

The only prerequisite is Node.js for the build-tool route — the toolchain runs on Linux, macOS and Windows — or nothing at all if you use the standalone script build. For server-rendered projects, Nuxt is the batteries-included option; for a plain SPA, Vite plus Vue Router is the usual minimum.

What Changed in 3.5 — and What Is Coming in 3.6

Vue 3.5, released on 1 September 2024, refactored the reactivity system for lower memory use — the project measured a 56% reduction — without behaviour changes, and made tracking on large deeply reactive arrays up to ten times faster in some cases. Reactive props destructure became stable, so const { count = 0 } = defineProps() works with JavaScript’s own default syntax and stays reactive. The release also added useId() for hydration-safe generated IDs, useTemplateRef(), deferred Teleport, onWatcherCleanup(), and per-component lazy hydration strategies for async components. The 3.5.x line has continued with bug-fix releases through 3.5.45.

The 3.6 line is in release candidate: 3.6.0-rc.14 was tagged on 30 October 2026, and the minor branch carries new compiler-vapor and runtime-vapor packages. Vapor mode is the project’s second rendering strategy — a compiler that emits direct DOM operations instead of virtual-DOM diffing — and it is the main reason to watch 3.6 rather than install it today. Existing applications are not required to adopt it.

How It Compares

React is the closest comparison and the biggest ecosystem. Both are component frameworks with declarative rendering, but React re-renders a component function and reconciles the result, while Vue tracks dependencies and updates the specific bindings that read changed state; React’s JSX is JavaScript all the way down, and Vue’s templates are compiled markup that many developers find quicker to scan. Svelte takes the compile-away idea furthest, compiling components into JavaScript that updates the DOM directly, at the cost of a smaller ecosystem and different debugging habits. Angular is a complete, opinionated platform with dependency injection, a CLI and RxJS at its centre — a better fit for large organisations that want one prescribed architecture, and a heavier start for a small interface. Vue’s position is between React’s flexibility and Angular’s completeness: a small core with official, optional companions.

Learn and Get Help

The official guide at vuejs.org is written as a progressive course, from a single counter to SSR and performance, and it is published in several languages. The interactive tutorial walks through a small application in the browser, the examples page shows the same component written with the Options API and the Composition API, and the API reference is complete enough to use without leaving the site. Beyond the docs: the Vue Mastery and Vue School video courses, weekly news in the Vue.js Weekly newsletter, the vuejs tag on Stack Overflow, the community forum and Discord, and the RFC repository where new features are designed in public. Bugs and feature requests belong in the vuejs/core issue tracker, and the roadmap discussion lives in vuejs/roadmap.