# Vize: A Rust-Native Toolchain for Vue.js SFC Compilation, Linting, Formatting, and Type-Checking

> Vize is a Rust-native Vue.js toolchain that replaces the existing patchwork of JavaScript-based tools with a shared parser powering compilation, linting, type-checking, formatting, and editor tooling. It is in Real World Testing phase, not fully production-ready, and installs as a drop-in replacement for @vitejs/plugin-vue in Vite projects.

**ubugeeei-prod/vize** — Blazing fast Vue.js Toolchain. Compiler, Linter, Type Checker, Formatter, LSP, Story System, Editor Extensions. This already passed 10k+ test suites, includes real world E2E.

- Repository: https://github.com/ubugeeei-prod/vize
- Website: https://vizejs.dev
- Stars: 897 · Forks: 49
- Language: Rust
- License: MIT
- Published: 2026-08-08 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/ubugeeei-prod-vize

## What Vize Is and the Problem It Addresses

Vue.js projects typically combine several disconnected tools: @vitejs/plugin-vue for compilation, eslint-plugin-vue for linting, Prettier for formatting, and vue-tsc for type-checking. Each tool parses Vue single-file components independently, often with slight behavioral differences between parsers. A change to the Vue parser in one tool does not automatically update the others.

Vize addresses this by building a single Rust parser (vize_carton, the parser crate in Cargo.toml) that all toolchain components share. Compilation, linting, type-checking, and formatting run on the same parse output rather than each reimplementing SFC parsing.

The README states the toolchain includes: @vizejs/vite-plugin for Vite, @vizejs/nuxt for Nuxt, the vize package for project CLI scripts, oxlint-plugin-vize for Oxlint-based linting, and @vizejs/vite-plugin-musea for a component gallery (Musea is the story system). The repository also includes editors/ for VS Code integration and the LSP.

The project is in its Real World Testing phase. The README warns explicitly: 'Breaking changes and behavior that diverges from Vue are expected.' A stability guide and a production-readiness checklist are linked from the README for teams considering adoption.

## Drop-In Installation for Vite Projects

For a Vue 3 + Vite project, swapping the SFC compiler requires only one package change and one config line. Install the Vite plugin:

```bash
npm i -D @vizejs/vite-plugin
```

Then update vite.config.ts:

```ts
import vize from "@vizejs/vite-plugin";

export default defineConfig({
  plugins: [vize()],
});
```

This swaps SFC compilation only. Linting, formatting, and type-checking stay on existing tools unless added separately. The README describes this as the Drop-in scope and links to the Drop-in Scope documentation for what is and is not covered.

For Nuxt projects, use @vizejs/nuxt instead of wiring the Vite plugin directly. For a new setup on a freshly scaffolded Vue + Vite project:

```bash
npm create vue@latest my-app
cd my-app
npx vize init
```

The init command is idempotent: running it a second time adds no duplicate plugins, scripts, or dependencies. It accepts flags to add individual surfaces: --lint, --bundler, --fmt, --typecheck, --editor. A --dry-run flag previews the changes without applying them.

Migration from an existing Vite or Vite+ project uses the same init command, optionally with --dry-run first:

```bash
npx vize init --dry-run
npx vize init
```

## Benchmark Results and What They Measure

The README includes a benchmark table from BENCHMARK.md, run on a 32-vCPU machine (blacksmith-32vcpu-ubuntu-2404) on 2026-09-16, with 3 runs and 1 warmup. The versions used: Vize 0.424.11, tsgo 7.0.2, vue-tsc 6.0.3, Vue 3.6.0-beta.10, Node v24.14.0.

The benchmark results against existing tools on the same machine:

| Surface | Files | Existing tool | Existing | Vize | Speedup |
|---|---|---|---|---|---|
| SFC compile | 3,000 | @vue/compiler-sfc | 3.57s | 65.0ms | 54.8x |
| Lint | 3,000 | eslint-plugin-vue | 20.75s | 114.0ms | 182.0x |
| Format | 3,000 | Prettier | 29.72s | 351.4ms | 84.6x |
| Type check | 500 | vue-tsc | 6.75s | 1.37s | 4.9x |
| Vite build | 1,000 | @vitejs/plugin-vue | 1.66s | 889.2ms | 1.9x |
| Nuxt build | 250 | Nuxt compiler | 3.07s | 3.21s | 0.95x |

The README provides important caveats. The type-check comparison pits Vize (using native tsgo) against vue-tsc (using the JavaScript TypeScript compiler), so the ratio covers both the Vue layer and the TypeScript engine. The Nuxt build ratio is 0.95x, meaning Vize was slower than the reference in this run. The README states that diagnostic coverage differs between tools and that these ratios do not prove accuracy parity.

## Crate Structure and Repository Layout

The workspace Cargo.toml (version 0.429.1) lists 34 crates. Named crates include vize_carton (the parser), vize_armature, vize_croquis, vize_atelier_core, vize_atelier_dom, vize_atelier_vapor, vize_atelier_ssr, vize_atelier_sfc, vize_atelier_jsx, vize_vitrine, vize_canon, vize_patina, vize_glyph, vize_musea, vize_maestro, vize_curator, vize_davinci, vize_l0 through vize_l4, vize_fresco, vize_marquette, vize_doctor, vize_extension_contract, vize_extension_host, vize_resident, and vize_dialect_moonbit. The last crate suggests work on MoonBit language dialect support.

The npm/ directory holds the JavaScript packages (@vizejs/vite-plugin, @vizejs/nuxt, and others). The editors/ directory holds VS Code extension code. The tools/benchmarks directory contains the benchmark harness crates. The pnpm-workspace.yaml and pnpm-lock.yaml manage the JavaScript workspace with pnpm 12.1.0.

Recent releases show frequent patch cycles: v0.428.1 on 2026-09-26, v0.429.0 on 2026-09-27, and v0.429.1 on 2026-09-27. The last push to the repository was on 2026-09-25.

## Limitations and When to Stay on Existing Tools

Vize is Chromium-only is not applicable here, but the project has its own scope limits. The Real World Testing label means that divergence from Vue's reference behavior is expected and will be fixed as test beds surface regressions. Teams that cannot afford unexpected SFC compilation behavior in production should wait for a stable release.

The type-checking improvement (4.9x over vue-tsc) comes from using the native tsgo engine rather than the JavaScript TypeScript compiler. tsgo is also a pre-release tool, and the benchmark version (7.0.2) is distinct from the stable TypeScript release line. Teams that need guaranteed diagnostic parity with the standard TypeScript compiler should continue using vue-tsc until the tsgo compatibility story is clearer.

Custom @vitejs/plugin-vue options and unusual Vite configurations are not automatically rewritten by vize init. The README states that vize init may not handle these correctly, meaning projects with custom plugin-vue option objects will need manual migration steps.

An alternative to Vize is the existing tool combination: @vitejs/plugin-vue for compilation, eslint-plugin-vue for linting, Prettier for formatting, and vue-tsc for type-checking. This combination is mature, widely documented, and has stable diagnostic behavior. Its weakness is the disconnected parser per tool and the performance cost of JavaScript-based compilation, which Vize addresses with its shared Rust core.

## License, Credits, and Maintenance

Vize is MIT-licensed. The workspace version as of the most recent release is 0.429.1, and the Rust toolchain minimum version is 1.95.0. The last push was on 2026-09-25, with releases v0.428.1, v0.429.0, and v0.429.1 published on 2026-09-26 and 2026-09-27.

The README credits several projects as inspiration: Volar.js, vuejs/language-tools, eslint-plugin-vue, eslint-plugin-vuejs-accessibility, Lightning CSS, and Storybook. These are the existing JavaScript-based Vue tooling projects that Vize is designed to replace or complement.

The GOVERNANCE.md, SUPPORT.md, SECURITY.md, and CONTRIBUTING.md files indicate a structured governance approach for an open-source project. The repository has a homepage at vizejs.dev with a playground and documentation. The README asks for real-world Vue projects as test beds and invites fix requests and pull requests.

## Conclusion

Vize is worth evaluating for Vue 3 projects on Vite where lint times, format times, or SFC compilation speed are a practical problem. The drop-in path is genuinely low-risk for trying the compiler: replace one npm package and change one config line. The Real World Testing label is honest: the project has reached 10,000-plus test suites and ships frequent patch releases, but breaking changes should be expected and the production-readiness checklist at the GitHub repository should be reviewed before deploying Vize in a CI pipeline or a production build. The type-checking improvement over vue-tsc is real but uses a different underlying engine (native tsgo vs the JavaScript TypeScript compiler), which means the diagnostic coverage may differ.

## FAQ

### How do I add Vize to an existing Vue 3 + Vite project?

Install @vizejs/vite-plugin with npm i -D @vizejs/vite-plugin, then replace the import of @vitejs/plugin-vue in vite.config.ts with import vize from "@vizejs/vite-plugin" and use vize() as the plugin. This swaps SFC compilation only. For linting, formatting, and type-checking, run npx vize init and select the surfaces you want.

### Is Vize production-ready?

No, not yet. The README labels the project as Real World Testing phase and states explicitly that breaking changes and behavior that diverges from Vue are expected. A production-readiness checklist is available in the repository for teams evaluating adoption. The project has passed 10,000-plus test suites but has not declared a stable release.

### How does Vize compare to vue-tsc for type checking?

The benchmark shows Vize at 4.9x faster than vue-tsc on 500 files, but the README notes that this comparison covers both the Vue layer and the TypeScript engine, because Vize uses native tsgo while vue-tsc uses the JavaScript TypeScript compiler. Diagnostic coverage differs between the two tools, and the ratios do not prove accuracy parity.

## Sources

- [Official documentation](https://vizejs.dev)
- [Official README](https://github.com/ubugeeei-prod/vize#readme)
- [Project repository](https://github.com/ubugeeei-prod/vize)
- [Release notes](https://github.com/ubugeeei-prod/vize/releases)

---

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