# Vuesion 5: the last open-source generation of a Vue and Nuxt boilerplate

> Vuesion 5 is a full-stack Vue and Nuxt boilerplate with a design system, auth, Prisma and 250+ example tests. Its README states it will receive no new features or ongoing maintenance, so the decision is about adopting a frozen foundation, not a growing one.

**vuesion/vuesion** — Vuesion is a boilerplate that empowers product teams to build faster with modern best practices across engineering and design. It features a full-stack framework, comprehensive design system, robust testing, and seamless internationalization. 

- Repository: https://github.com/vuesion/vuesion
- Website: https://www.vuesion.dev/blog/why-vuesion-is-no-longer-open-source
- Stars: 2,871 · Forks: 385
- Language: Vue
- License: MIT
- Published: 2026-09-28 · Updated: 2026-09-28 · Language: en
- Canonical page: https://hysenlabs.com/projects/vuesion-vuesion

## What Vuesion 5 assembles, and the team it was assembled for

Vuesion 5 is a boilerplate, not a library. You clone it, keep the parts you need, and delete the rest. The README describes it as a Vue and Nuxt boilerplate that provides a foundation for building production applications, and the repository layout backs that up: `src/`, `prisma/`, `cypress/`, `i18n/`, `_templates/`, `.storybook/`, plus `nuxt.config.ts`, `vite.config.mts` and a `Dockerfile` at the root.

The target audience is a product team that would otherwise spend its first weeks wiring the same pieces together: server-side rendering, a component library, authentication, database access, internationalization, end-to-end tests, and a Storybook instance for designers. The README lists 35+ design-system components, a Figma UIKit, SEO support, an authentication module, a PWA module, and code generators for components, pages, RESTful APIs and Pinia stores. That is a wide surface. A solo developer building a small marketing site will find most of it dead weight.

## Nuxt renders, Prisma persists, Hygen generates

The architecture is a standard Nuxt 3 application with opinions layered on top. Nuxt handles rendering, and the README states the boilerplate supports server-side rendering, single-page-app mode or statically generated HTML. Vite is the build tool, TypeScript is the default language, and Pinia holds client state.

Data access runs through Prisma. The `prisma/` directory sits at the top level, and the scripts in `package.json` cover the whole migration lifecycle: `db:migrate`, `db:migrate-deploy`, `db:push`, `db:reset`, `db:seed` and `db:generate-client`. A seed script exists at `./prisma/seed.ts`. Authentication comes from the `nuxt-auth` module, which needs a secret and an origin; the Dockerfile shows both as environment variables, `NUXT_AUTH_SECRET` and `AUTH_ORIGIN`.

Scaffolding is handled by Hygen. The `_templates/` directory and `.hygen.js` drive commands such as `npm run new:component`, `new:page`, `new:store`, `new:rest-api` and `new:form`. This is the part that most distinguishes Vuesion from a plain Nuxt starter: the project assumes you will keep generating new modules in its shape, not just consume the ones shipped.

## Installing Vuesion 5 and generating your first store

The README does not print a numbered install sequence, but the repository files give one. Dependencies are installed with npm, and the dev server runs through `nuxi`. Note that `dev` sets `NODE_ICU_DATA` to the bundled `full-icu` package, which matters for internationalization formatting.

```bash
npm install
npm run dev
```

Nuxt serves the app on its default development port. Before any database-backed page works, Prisma needs a PostgreSQL connection string in `DATABASE_URL`. The Dockerfile example uses this shape:

```bash
DATABASE_URL='postgresql://postgres:postgres@localhost:5432/vuesion?schema=public'
```

With that variable set, apply the schema and seed it:

```bash
npm run db:migrate
npm run db:seed
```

The first command runs `prisma migrate dev` and the second runs the seed script through `ts-node`. If you only want the schema pushed without a migration history, `npm run db:push` does that instead.

For a first real use, generate a Pinia store rather than editing files by hand:

```bash
npm run new:store
```

Hygen prompts for a name and writes the store into `src/`. The same pattern applies to `npm run new:component`, `npm run new:page` and `npm run new:rest-api`. To check the design system in isolation, run Storybook on port 6006:

```bash
npm run storybook:dev
```

## The README says this repository is finished

The most important line in the README is not a feature. It states that the repository will remain available as an open-source reference under the MIT license but will no longer receive new features or ongoing maintenance, and that active development continues in a commercial product. The last push to the default branch was on 2026-08-18, and the most recent release listed is v5.4.0 from 2025-06-09.

That changes what you are evaluating. A frozen boilerplate is not automatically a bad choice, because you fork it and own it either way. But you inherit every future Nuxt, Vite, Prisma and dependency upgrade yourself, and the project's own upgrade path now runs toward a paid product rather than back into this repository. If your team has no capacity for framework migrations, this is the wrong tool. The README also points readers to vuesion.dev for the maintained version, so anyone who wants ongoing fixes should look there instead of at this code.

A second limitation is scope. The README advertises 250+ example tests and a 35+ component design system, which is a lot of code to read before you can confidently delete what you do not want. Trimming an opinionated boilerplate takes real time, and the generators assume you keep the structure intact.

## Vuesion 5 against a bare Nuxt starter

The honest alternative is `nuxi init`, the official Nuxt scaffolding command, followed by adding modules as you need them. The difference is one of sequencing. A bare Nuxt project starts empty and you choose authentication, a database layer, a component library, i18n and Storybook individually, which means more decisions but no inherited code to remove.

Vuesion 5 makes those decisions for you in advance. You get Prisma instead of a free choice of ORM, `nuxt-auth` instead of a hand-rolled session layer, and a specific design system instead of Tailwind or Vuetify. The trade is speed at the start against flexibility later. Because the repository is frozen, the second half of that trade gets worse over time: the modules Vuesion picked will keep moving, and this code will not follow them. If your project has a two-year horizon and a small team, the bare starter plus a handful of modules is the lower-risk path.

## Licence, maintenance and what a fork actually costs

Vuesion 5 is MIT licensed, and the README repeats that the code remains available under the MIT license. MIT permits commercial use, modification and redistribution, so forking the repository into a private product is within the terms. This is not legal advice; check the `LICENSE` file and your own counsel for anything binding.

The practical cost is not the licence, it is the upgrade treadmill. Because no new features or ongoing maintenance are promised here, every security advisory in Nuxt, Vite, Prisma or the auth module lands on your team. The repository does ship tooling that helps: `npm run lint` runs ESLint with `--fix` and a `tsc --noEmit` type check, `npm test` runs Vitest with coverage, and `npm run e2e` runs Cypress headless. Those commands give you a regression net when you start bumping versions. The `Dockerfile` also assumes a specific build order, including copying a prebuilt `storybook-static` directory into `src/public/storybook` before the Nuxt build, so any change to that pipeline is yours to maintain as well.

## Conclusion

Adopt Vuesion 5 if you want a broad Vue 3 and Nuxt starting point with a design system, Storybook, Prisma and a large example test suite, and you are willing to own upgrades yourself. Do not adopt it if you need a maintained dependency, because the README states the repository will receive no new features or ongoing maintenance and points to a commercial successor. Verify first that `npm install`, `npm run build` and `npm run db:migrate` succeed against your Node and PostgreSQL versions, and check whether Nuxt 3 still fits your runtime plans.

## FAQ

### Is Vuesion 5 still maintained?

The README states that the repository will no longer receive new features or ongoing maintenance and that it remains available as an open-source reference under the MIT license. Active development continues in the commercial product at vuesion.dev. The last push to the default branch was on 2026-08-18.

### What database does Vuesion 5 use?

It uses Prisma, with a `prisma/` directory at the top level and scripts such as `db:migrate`, `db:seed` and `db:push` in package.json. The Dockerfile example passes a PostgreSQL connection string through the `DATABASE_URL` environment variable.

### How do I generate a new component or store in Vuesion 5?

The project uses Hygen templates in `_templates/`, exposed as npm scripts. Running `npm run new:component`, `npm run new:store`, `npm run new:page`, `npm run new:rest-api` or `npm run new:form` scaffolds the corresponding files.

### Which rendering modes does Vuesion 5 support?

The README states that it supports server-side rendering, single-page-app mode and statically generated HTML through Nuxt. The choice is made in the Nuxt configuration rather than in application code.

## Sources

- [License: MIT](https://github.com/vuesion/vuesion/blob/main/LICENSE)
- [Project website](https://www.vuesion.dev/blog/why-vuesion-is-no-longer-open-source)
- [README](https://github.com/vuesion/vuesion/blob/main/README.md)
- [Releases](https://github.com/vuesion/vuesion/releases)
- [vuesion/vuesion on GitHub](https://github.com/vuesion/vuesion)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/vuesion-vuesion