Skip to content
Tutorials Center
My learning

Topics

Lesson 69 of 87 ยท Performance, Security and Ecosystem

The Vue Ecosystem

A guided map of the Vue ecosystem: Vite, Vue Router, Pinia, Vitest, VueUse, UI libraries like Vuetify and Quasar, Nuxt, Vapor mode and how to choose tools.

Vue's core is deliberately small. Reactivity, components, templates and the Composition API fit in one package, and everything else comes from a surrounding ecosystem: official libraries that the Vue team maintains, tools that make building and testing pleasant, and community packages for almost every need. You have now used the core for dozens of lessons. This final tour of the advanced section shows what surrounds it, so that when a project needs routing, state, tests, a design system or server rendering, you know the usual answer and why.

A word of caution first. Ecosystems change fast, and any list of libraries ages. Learn the categories and the questions to ask, and treat the specific names as today's good starting points. Check each project's own documentation for current versions and recommendations.

flowchart TD
  C["Vue core<br/>reactivity, components, templates"]
  C --> O["Official libraries<br/>Vue Router, Pinia"]
  C --> T["Tooling<br/>Vite, Vitest, Vue DevTools, Vue language tools"]
  O --> F["Frameworks<br/>Nuxt, Quasar, VitePress"]
  T --> F
  C --> U["UI and utilities<br/>VueUse, Vuetify, PrimeVue, Element Plus"]

Most of the ecosystem hangs off the core in layers: official libraries and tooling first, then frameworks, UI kits and utility collections.

Build tools and project setup

Vite is the standard build tool and dev server for Vue. It serves your source as native ES modules during development, so startup is instant, and it uses a bundler for the optimized production build (the one you analyzed in Build and Load Performance). create-vue, started with npm create vue@latest, scaffolds a Vite project and asks whether to add TypeScript, a router, Pinia, a test runner and linting. You saw this in Ways to Use Vue.

Almost everything else in this lesson plugs into Vite. Vue itself is just one Vite plugin (@vitejs/plugin-vue) that compiles your single-file components.

Official libraries

  • Vue Router is the official client-side router: nested routes, dynamic segments, navigation guards, lazy routes (see Vue Router Basics and Vue Router Advanced Features).
  • Pinia is the official state management library, the recommended successor to Vuex (which is in maintenance mode). It has stores with state, getters and actions, DevTools support and good TypeScript inference, as shown in Pinia.

Neither library is required. A small app can share state with a plain reactive module (see Building a Simple Store) and may not need a router at all. Add each when its absence starts to hurt.

Developer tools

  • Vue DevTools is a browser extension and also a Vite plugin. It lets you inspect the component tree, props, state, Pinia stores, router and performance timeline, and it is the first thing to reach for when debugging (see Debugging Vue).
  • The Vue language tools ("Vue - Official" extension for VS Code and compatible editors) give completion, error checking and type information inside .vue files. vue-tsc runs the same type checking on the command line and in CI.
  • ESLint with eslint-plugin-vue catches Vue-specific mistakes, and Prettier formats code (see Code Quality and Style).

Testing tools

  • Vitest is a fast test runner that shares Vite's configuration, so your tests see the same aliases and plugins as the app.
  • Vue Test Utils is the official library for mounting components and asserting on output, events and props.
  • Testing Library for Vue focuses on testing like a user: finding things by role and text.
  • Playwright or Cypress drive a real browser for end-to-end tests.

See Testing Vue Apps for how these fit together.

VueUse: a toolbox of composables

VueUse is a large collection of ready-made composables built on the Composition API: useMouse, useLocalStorage, useDebounceFn, useEventListener, useDark, useIntersectionObserver, useFetch and many more. They follow the conventions from Composables: inputs can be refs, outputs are refs, and listeners are cleaned up automatically when the component unmounts.

Before you reach for a library, it helps to know how little is inside one of these helpers. The demo defines three small composables in the style of VueUse and uses them together: a toggle, a debounced copy of a value, and a window event listener with automatic cleanup. These are hand-written stand-ins, not the real package, which is more complete and handles many more cases.

Mini VueUse: three composables

Type quickly into the search box: the "Typed" line follows every keystroke, while the "Debounced" line only updates 300 ms after you stop. That is exactly what you want for search-as-you-type, because it avoids sending a request on every key. The key counter also keeps counting presses, since the window listener is registered in onMounted and removed in onBeforeUnmount.

UI component libraries

Building buttons, dialogs, data tables and date pickers that work well and are accessible is a lot of work. A UI library gives you a tested set:

Library Style and strengths
Vuetify Material Design components, very complete, theming and a data table
Quasar A framework as much as a library: Material-style components plus builds for SPA, SSR, PWA, mobile (Capacitor) and desktop (Electron)
PrimeVue Large set of enterprise components, themeable, with unstyled mode
Element Plus Popular for admin interfaces and dashboards
Naive UI and Ant Design Vue Complete kits with their own design language
Nuxt UI Components for Nuxt (and plain Vue) built on Tailwind CSS
shadcn-vue and Reka UI Accessible unstyled building blocks (shadcn-vue copies component code into your project, Reka UI was previously called Radix Vue)

Pick by design fit and ownership. A styled kit such as Vuetify saves the most time if you accept its look. Headless libraries give behavior and accessibility but leave styling to you, which suits a custom design system (see Styling Strategies). Check three things before committing: keyboard and screen reader support, bundle impact (can you import components one by one?), and whether the kit works with your server rendering setup.

Frameworks built on Vue

  • Nuxt for server rendering, static sites and full-stack apps, as covered in Nuxt Overview.
  • Quasar for apps that must ship as a website, a PWA and native shells from one codebase.
  • VitePress for documentation sites: Markdown in, a fast static site out, with Vue components allowed inside the Markdown. The Vue documentation itself is built with it.

Other common categories

Many needs have a well-known Vue-friendly answer: vue-i18n for translations, VeeValidate or FormKit for forms and validation, TanStack Query for Vue for server-state caching (instead of hand-written fetching code), unhead for page titles and meta tags, Vue Chart wrappers or ECharts for charts, Storybook for documenting components. For all of them, a plain composable or a small component may be enough. Use a library when the problem is bigger than it looks, such as dates, accessibility, drag and drop or rich text.

Vapor mode and the future

Vue normally renders through a virtual DOM: components return vnodes, and Vue compares old and new trees. Vapor mode is an alternative compilation strategy that the Vue team has been developing. Templates compile to direct, fine-grained DOM operations without the virtual DOM, which means smaller bundles and faster updates. It is opt-in, works with the same Composition API and <script setup> syntax you already know, and you can mix it with normal components. At the time of writing it is still maturing and not the default, so check the official release notes before you build on it. The takeaway for learners: the code you write today stays valid, and the performance gains arrive underneath it.

A note on the past: Vue 2 reached end of life on December 31, 2023. If you meet a Vue 2 project (Options API, Vuex, new Vue()), the Vue 3 migration guide and its compatibility build are the way forward, and this tutorial's Options API lesson will help you read the old code.

How to choose tools

The best stack is the smallest one that solves your actual problems. A few questions help:

  1. Do I have the problem yet? Do not add Pinia to a three-component app or SSR to a dashboard behind a login.
  2. Is it maintained? Look at release history, open issues, and whether it supports the current Vue version.
  3. Does it fit my constraints? TypeScript support, SSR compatibility, bundle size, license, accessibility.
  4. How hard is it to leave? A library behind a small wrapper of your own is easier to replace than one used everywhere.
  5. What does the community use? Popular tools have more answers, tutorials and examples, which is a real productivity benefit.

The next demo turns a few of those questions into a rough recommender. It is a simplification for practice, not an authority, but it shows the mindset: your requirements decide the tools, not the other way around.

A rough stack chooser

Tick "Public pages must rank in search results" and the first suggestion changes from a plain SPA to Nuxt. Tick "I also need mobile or desktop apps" as well and Quasar replaces it. The extra libraries appear only when the matching need is ticked, which is the habit to keep.

Where to go from here

You have the core concepts, the tooling and a map of the surrounding world. The best next steps are practical: build the projects at the end of this tutorial, read the source of a small composable in VueUse, and explore the official documentation of the libraries you chose. Learning the ecosystem is easier when each tool solves a problem you actually have.

Check your understanding

Quick check ยท 5 questions

of 5 answered You scored / 5 ยท perfect!

  1. 1. Which tool is the standard build tool and dev server for Vue projects?

    Vite serves the app during development and builds the production bundle. Pinia manages state, and VitePress is a documentation site generator.
  2. 2. What is the recommended official state management library for new Vue 3 projects?

    Pinia is the official recommendation and the successor of Vuex, which is in maintenance mode. Vue Router handles routing and VueUse is a composable collection.
  3. 3. What is a good reason to choose a headless UI library over a fully styled one?

    Headless libraries provide behavior such as focus handling and keyboard support, and leave all styling to you, which suits a custom design system.
  4. 4. What does Vapor mode change?

    Vapor mode is an opt-in compilation strategy that skips the virtual DOM. The component code you write stays the same.
  5. 5. Which question comes first when you consider adding a library?

    Tools should answer real needs. Adding state, routing or SSR before you need them only adds complexity.

Summary

  • Vue's core is small. Vite builds, Vue Router routes and Pinia manages shared state, and Vue DevTools and the Vue language tools support development.
  • Vitest, Vue Test Utils and Playwright or Cypress cover unit, component and end-to-end tests.
  • VueUse provides many ready-made composables; a hand-written one such as a debounce is only a few lines.
  • UI kits (Vuetify, Quasar, PrimeVue, Element Plus) and headless libraries (Reka UI, shadcn-vue) trade speed against design control.
  • Nuxt, Quasar and VitePress are frameworks built on Vue for specific kinds of projects.
  • Vapor mode is an opt-in, virtual-DOM-free compilation strategy still maturing; Vue 2 is end of life.
  • Choose the smallest toolset that solves problems you actually have, and prefer maintained, replaceable tools.

Next, put everything together in the first project: Project: Todo App.