---
title: "Why I Switched to Vite+"
description: "Sharing my personal experience with Vite+ and why I finally decided to make the switch."
canonical_url: "https://www.bencodezen.io/blog/why-i-switched-to-vite-plus"
---

> Index of every page on this site: [llms.txt](https://www.bencodezen.io/llms.txt)

When I first heard about [Vite+](https://viteplus.dev/), it was at VueConf US when [Evan](https://x.com/evanyou) gave his keynote talk. It was pitched as a "unified toolchain," but without the ability to try it out on a project, I could only earmark it as something to keep an eye on.

Fast forward a few months and [Vite+ 1.0 was finally released](https://voidzero.dev/posts/announcing-vite-plus-1-0). The marketing claims on what it was capable of certainly sounded promising. And while new tooling can be fun to play with on side projects, the real question I needed to answer was: "Is it actually worth adopting as my primary toolchain?"

## Before Vite+

Up until this point, every project I've worked on starts with the same series of decisions around its tooling:

1. Which package manager? npm? yarn? pnpm?
2. Which bundler? Webpack? Parcel? Vite?
3. How do I manage Node runtime versions? nvm? fnm? volta?
4. What linter and formatters should be configured? Prettier? ESLint? both?
5. What other conventions should we add? lint-staged?

While templates (like [Vitesse](https://github.com/antfu-collective/vitesse)) and generators (like [`create-vue (CLI)`](https://github.com/vuejs/create-vue)) do a great job at getting you up and running, it can often be a headache to modify the existing toolchain. Linters, formatters, and build pipelines often have strong opinions about how they should work, and the wiring between them can be quite fragile. Though I wish it weren't true, I've lost more time than I care to admit on wrestling with a configuration bug when I could have been working on the actual project instead.

In an ideal world, these conventions should already be set up for you when you start, regardless of your framework preference. And when you need to modify something, it should feel more like toggling a setting on or off rather than having to rewire the internal plumbing of your application.

## So, what exactly is Vite+?

Given how a lot of products are named, I wouldn't blame you if your first guess is that Vite+ is a paid version of Vite that comes with premium features for a low cost of $9.99 a month. Thankfully, you can put away your credit card and rejoice because that's not the case at all!

Instead, I like to think of it as:

> Vite + Performant Tooling + Best Practices

Let's break that down.

### 1. Vite

If you haven't hopped on the Vite train yet, it is the dev server and bundler that serve as the new standard for modern frontend development. Known for its speed, Vite provides a dev server with near-instant Hot Module Replacement (HMR), and as of Vite 8, you can bundle your code with highly optimized static assets through Rolldown.

### 2. Performant Tooling

For those new to the Vite ecosystem, VoidZero (the team behind Vite) set out to reimagine what existing tooling could look like if built by compiled languages (like Rust or Go) to give developers access to performance that would otherwise difficult to achieve using JavaScript alone.

As a result, Vite+ bundles all of the following tools in a single CLI package:

- **Linting:** Oxlint, with ESLint-compatible options
- **Formatter:** Oxfmt, with Prettier-compatible options
- **Test runner:** Vitest
- **Library builds:** tsdown
- **Task running:** Vite Task with caching
- **Runtime:** `vp env`, which manages your Node and package manager versions

### 3. Best Practices

As anyone who has been in the industry for a while can tell you, tooling trends will come and go, but good software engineering practices have largely stayed the same. What's changed is the developer experience around them.

Here are three of my favorite best practices that are built into Vite+:

1. **One source of truth for configuration.** Instead of having multiple dot files (e.g., lint, format, test, commit) scattered across your project, Vite+ centralizes everything into a single `vite.config.ts`.
2. **Enforce conventions at commit time.** `vp hooks` installs the git hook, and the `staged` block in the config defines what runs on staged files. As a result, developers can work however they want locally, but when it's time to commit the code, Vite+ will ensure that everything is formatted and linted correctly so no one ever has to ask for a file to be updated because it used tabs instead of spaces.
3. **Pin your runtime so everyone builds on the same Node version.** `vp env` reads the Node version and package manager your project already declares and resolves both of them for you.

Here's an example of the `staged` block on the project I was working on. In this rule, content folders are still formatted and linted, but never auto-fixed, because autofix can change what a code sample means in the exercise.

```ts
// vite.config.ts
export default defineConfig({
  staged: {
    '*.{ts,vue,md,json}': (files) => {
      // Content folders hold code samples where an autofix
      // can change meaning, so they're checked but never fixed.
      const code = files.filter((f) => /\.(ts|vue)$/.test(f))
      const content = code.filter((f) => /\/(exercises|lessons)\//.test(f))
      const app = code.filter((f) => !content.includes(f))
      return [
        `vp check --fix --no-lint ${files.join(' ')}`,
        // With no files to pass, a command would check the whole repo.
        ...(app.length ? [`vp check --fix --no-fmt ${app.join(' ')}`] : []),
        ...(content.length ? [`vp check --no-fmt ${content.join(' ')}`] : []),
      ]
    },
  },
})
```

To sum it up, Vite+ provides a streamlined experience to manage your toolchain with a single `vp` command:

<figure>

![Eight tools on the left, each with its own config, funnel into a single vp command, which fans out into vp dev and build, vp env, vp lint, vp fmt, vp check, vp hooks and staged, vp test, and vp run.](https://www.bencodezen.io/images/blog/2026/11/vite-plus-toolchain-map.svg)<figcaption ariaHidden="true">

Eight tools on the left, each with its own config, funnel into a single vp command, which fans out into vp dev and build, vp env, vp lint, vp fmt, vp check, vp hooks and staged, vp test, and vp run.

</figcaption>
</figure>

## Why did I decide to switch?

After working on different projects using Vite+ on some and not others, it boiled down to three primary reasons:

1. **Speed.** The performance gains have honestly allowed me to maintain better flow state when working on things since I am not waiting on processes to run for long periods of time.
2. **Open source.** I'll address this more in the section below, but contrary to what it may sound like, Vite+ allows you to choose what's best for your team.
3. **Streamlined developer experience.** As someone who works in the field, I have a special appreciation for people who are able to take something incredibly complicated and make it accessible to others.

### Is it really that fast?

The reason we build tools is to provide us feedback on whether something is working or not. The faster the feedback, the more you are able to experiment and try things out without feeling a huge sunk-cost bias on each attempt. So, of course the question at hand is: how fast is it really?

Rather than quote [VoidZero's benchmarks](https://viteplus.dev/guide/why#fast-and-scalable-by-default), I thought it would be best to measure it on a project of mine: a Vue 3 app + Node tooling sitting on a strictly typed codebase. In total, it contained ~1,400 `.ts` and `.vue` files and ~97,000 lines of code.

When I compared the Vite+ version with a non-Vite+ version (that used ESLint 9 with `typescript-eslint`, Prettier 3, `tsc` and standalone Vitest), these are the numbers I saw on my Apple M1 Max.*

<figure>

![Format, lint and type-check on the same 97k-line repo: 26.4 seconds with Prettier, ESLint and tsc; 4.5 seconds with vp check. vue-tsc takes the same 5.7 seconds either way.](https://www.bencodezen.io/images/blog/2026/11/vite-plus-check-timings.svg)<figcaption ariaHidden="true">

Format, lint and type-check on the same 97k-line repo: 26.4 seconds with Prettier, ESLint and tsc; 4.5 seconds with vp check. vue-tsc takes the same 5.7 seconds either way.

</figcaption>
</figure>

* *All numbers are a median of three runs after a warm-up*

As far as key things to take away, formatting, linting and type-checking on the whole repo went from **26.4 seconds to 4.5 seconds** with `vp check`, which is about 5.9x faster. And while my 5.9x gain may not sound huge to some, when you consider that this check is run before every commit and push, the gains from a workflow perspective are massive.

Here's the full breakdown for anyone who's curious:

<table>
<thead>
  <tr>
    <th>
      What
    </th>
    
    <th>
      Before
    </th>
    
    <th align="right">
      Before (s)
    </th>
    
    <th>
      After
    </th>
    
    <th align="right">
      After (s)
    </th>
    
    <th align="right">
      Ratio
    </th>
  </tr>
</thead>

<tbody>
  <tr>
    <td>
      Format + lint + type-check
    </td>
    
    <td>
      <code>
        prettier --check . ; eslint . ; tsc --noEmit
      </code>
    </td>
    
    <td align="right">
      26.4
    </td>
    
    <td>
      <code>
        vp check
      </code>
    </td>
    
    <td align="right">
      4.5
    </td>
    
    <td align="right">
      5.9x
    </td>
  </tr>
  
  <tr>
    <td>
      Same, plus <code>
        .vue
      </code>
      
       type-check
    </td>
    
    <td>
      + <code>
        vue-tsc --noEmit
      </code>
    </td>
    
    <td align="right">
      31.9
    </td>
    
    <td>
      <code>
        vp check
      </code>
      
       + <code>
        vue-tsc
      </code>
    </td>
    
    <td align="right">
      10.2
    </td>
    
    <td align="right">
      3.1x
    </td>
  </tr>
  
  <tr>
    <td>
      Lint, type-aware, same rule list
    </td>
    
    <td>
      <code>
        eslint .
      </code>
    </td>
    
    <td align="right">
      13.6
    </td>
    
    <td>
      <code>
        vp lint
      </code>
    </td>
    
    <td align="right">
      1.8
    </td>
    
    <td align="right">
      7.7x
    </td>
  </tr>
  
  <tr>
    <td>
      Format check
    </td>
    
    <td>
      <code>
        prettier --check .
      </code>
    </td>
    
    <td align="right">
      9.7
    </td>
    
    <td>
      <code>
        vp fmt --check
      </code>
    </td>
    
    <td align="right">
      2.6
    </td>
    
    <td align="right">
      3.7x
    </td>
  </tr>
  
  <tr>
    <td>
      Type-check, <code>
        .ts
      </code>
      
       only
    </td>
    
    <td>
      <code>
        tsc --noEmit
      </code>
    </td>
    
    <td align="right">
      4.0
    </td>
    
    <td>
      <code>
        vp check --no-fmt --no-lint
      </code>
    </td>
    
    <td align="right">
      1.7
    </td>
    
    <td align="right">
      2.4x
    </td>
  </tr>
  
  <tr>
    <td>
      Type-check <code>
        .vue
      </code>
    </td>
    
    <td>
      <code>
        vue-tsc --noEmit
      </code>
    </td>
    
    <td align="right">
      5.7
    </td>
    
    <td>
      same tool
    </td>
    
    <td align="right">
      5.8
    </td>
    
    <td align="right">
      1.0x
    </td>
  </tr>
  
  <tr>
    <td>
      Tests (77 files, 709 tests)
    </td>
    
    <td>
      <code>
        vitest run
      </code>
    </td>
    
    <td align="right">
      7.9
    </td>
    
    <td>
      <code>
        vp test
      </code>
    </td>
    
    <td align="right">
      7.8
    </td>
    
    <td align="right">
      1.0x
    </td>
  </tr>
</tbody>
</table>

### Wait, isn't Vite+ just vendor lock-in?

Though it may sound like Vite+ is trying to swallow your entire toolchain under a single package that you can never escape from, the reality is that there are plenty of off-ramps in the event something in the toolchain doesn't work well for your team:

- **It's all open source.** Vite+, Vite, Rolldown, Oxc, and Vitest are all MIT licensed and work on their own without the `vp` CLI experience.
- **Everything is configurable.** The standards adopted by the team are progressive enhancements to already existing standards used by the community. For example, `oxlint` and `oxfmt` are largely compatible with their predecessors `ESLint` and `Prettier`.
- **Everything is optional.** While I mentioned many benefits like a runtime manager, you can always opt out of any tools that don't work for you or your team.

So, at the end of the day, the centralization of tooling exists for streamlining the developer experience rather than locking you in.

## So, is Vite+ perfect for everything?

While it would be nice to claim that Vite+ can solve the problems of every codebase, no tool is right for everything. For example, if your project contains other languages like Python, Ruby or Go, odds are good that you'll need additional tooling beyond Vite+ to make sure everything works as intended.

## Verdict: Give it a try and experience it for yourself

With all that said and done, while Vite+ has become a solid addition to my toolbox and will drive many of the apps I build, the best way to decide if it's a good fit for you and your team is to try it yourself.

To learn more, be sure to check out the official [Getting Started with Vite+ Guide](https://viteplus.dev/guide/). And if you get a chance to measure your own performance gains, I'd love to hear what kind of numbers you're seeing and whether it's helped improve your workflow!

## Sitemap

See the full [sitemap](https://www.bencodezen.io/sitemap.md) for all pages.
