Vue Tooling Map

Published 2026-03-26 Author ubugeeei

One reason Vize is easy to misunderstand is that it overlaps with several tools people already know, but not always at the same layer.

Some of these projects are official. Some are framework-agnostic. Some are editor-first. Some are compiler-first. Some are mainly about type checking. Some are trying to become a full toolchain.

So the most useful question is not "which one is better?" It is: what problem is each tool actually trying to solve?

The Short Version

Here is the fastest way to position them:

If you keep that table in your head, most of the confusion goes away.

Vize

Vize is best understood as an unofficial, full Vue toolchain in Rust.

Its ambition is broad:

• compile Vue SFCs

• lint Vue-specific patterns

• format Vue files

• type-check Vue templates and script bindings

• power an LSP

• provide a component gallery

• expose Vue-aware tooling to AI workflows

That breadth is what makes Vize different from most of the projects in this comparison. It is not just an editor integration, not just a type checker, and not just a bundler plugin. It is trying to be a coherent Vue-native toolchain with one architectural center.

That is also why the recent type-check direction matters. Vize is not only trying to "make vue-tsc faster." The current direction is to keep Vue-aware virtual file generation, diagnostics mapping, and editor-facing type information inside vize_canon, with native project sessions powered by corsa-bind.

How Vize Is Approaching tsgo

A recent note, corsa-bind: The Idea of Language Processor Orchestration, argues that the interesting part is not only faster execution but to "change the shape of work, not the compiler."

That framing is very close to how Vize is approaching tsgo.

Vize is not trying to turn tsgo into the whole product story, and it is not treating it as a one-shot CLI that gets rerun for every feature. The direction is closer to treating TypeScript processing as a reusable native service inside a broader Vue toolchain:

• vize check materializes a Vue-aware virtual TypeScript project, opens a Corsa project session, and requests diagnostics in batch.

• vize_maestro can keep a Corsa bridge around for hover, completion, definition, references, and rename when native type checking is enabled.

• vize_patina uses lazy native Corsa sessions for type-aware lint rules, probing only the types it needs instead of rebuilding everything in a JavaScript-hosted stack.

• vize_canon keeps ownership of Vue-specific virtual file generation and source mapping, while corsa-bind and tsgo answer the TypeScript-side questions.

So Vize's tsgo story is not just "swap vue-tsc for a faster binary." It is closer to building a Vue-native control layer around a resident TypeScript processor, then reusing that layer across batch checks, editor features, and type-aware linting.

Vize vs Vue Language Tools

The official Vue Language Tools project is the production-ready Vue editor and type-checking stack. It includes:

• the Vue (Official) VS Code extension

• vue-tsc

• @vue/language-server

• @vue/language-core

That stack is fundamentally about language tooling: editor support, type checking, virtual code generation, and integrations that make Vue feel first-class in IDEs.

Vize overlaps with that world because Vize also has a type checker and an LSP. But Vize is trying to cover more ground:

• Vize includes its own compiler ambitions

• Vize includes linting and formatting ambitions

• Vize includes product surfaces like Musea and MCP tooling

• Vize is Rust-first rather than TypeScript-first

So the simplest distinction is:

• Vue Language Tools is the official editor and type-check foundation for Vue

• Vize is an unofficial attempt to unify much more of the Vue toolchain under one Rust architecture

If your priority is production-ready editor support today, the official Vue stack is the baseline. If your interest is a broader, experimental, Rust-native Vue toolchain, that is where Vize starts to make sense.

Vize vs Golar

Golar is not really "another Vue toolchain" in the same sense.

Golar describes itself as an embedded language framework based on typescript-go. For Vue specifically, it reuses the official @vue/language-core machinery and focuses on making extension-based languages like .vue, .astro, and .svelte work with tsgo.

That means Golar's center of gravity is:

• CLI type checking

• declaration emitting

• tsgo integration for embedded languages

• plugin infrastructure for virtual code generation

Vize is different in two important ways:

1. Scope

Golar is primarily a type-checking and virtual-code story around typescript-go. Vize is trying to own a much larger slice of the Vue toolchain: compiler, linter, formatter, type checker, LSP, gallery, and more.

2. Ownership of the Vue layer

Golar deliberately reuses official Vue tooling for Vue code generation. Vize is trying to build more of the Vue-specific stack itself in Rust.

There is also a practical execution-layer difference starting to show up. Golar is closely identified with typescript-go integration for embedded languages. Vize's current native type-check path is being shaped around vize_canon plus corsa-bind, which makes the question less "how do we reuse the official stack with a faster TS engine?" and more "how much of the Vue toolchain can live inside one native architecture?"

So Golar is closer to "make tsgo work well for embedded languages," while Vize is closer to "build a native Vue toolchain end-to-end."

Vize vs Verter

Verter is probably the closest philosophical neighbor in this list.

Like Vize, Verter is aiming high. Its public vision is a hybrid Rust + TypeScript Vue compiler, LSP, build tool, linter, and broader toolchain. That puts it in the same general family as Vize: ambitious, full-stack, and willing to rethink the Vue toolchain instead of only patching one layer.

This is where the differences become more about product shape and architecture than category:

• Verter presents itself as a strict-first Vue language and compiler toolchain with a strong VS Code and TS provider story.

• Vize presents itself as an unofficial high-performance Vue toolchain with a unified CLI, Vite integration, Musea, and a stronger "one parser / one AST / one toolchain" narrative.

There is also a difference in emphasis:

• Verter highlights typed TSX generation, Type Provider backends such as TSGO / tsserver, and a broad built-in lint rule catalog.

• Vize highlights a unified Rust-native toolchain across compile, lint, format, type-check, editor tooling, component gallery, and AI integration, while explicitly positioning itself as complementary to ecosystem tools like Vite+ and Oxlint.

So I would not describe Verter as "the same thing with a different name." It is better thought of as another serious answer to the question: what would a next-generation Vue toolchain look like if we started again?

Vize vs Vite+

Vite+ sits at a different layer.

Vite+ is a unified entry point for web development more broadly. Its job is to manage runtime setup, package management, development, checking, testing, build, packing, and monorepo task execution in one workflow. It pulls together Vite, Vitest, Oxlint, Oxfmt, Rolldown, tsdown, and related tooling.

That makes Vite+:

• framework-agnostic

• workflow-oriented

• broader than Vue

Vize is different because it is Vue-specific.

Vite+ does not try to become a Vue compiler or a Vue template linter. It gives you a unified web toolchain entry point. Vize can plug into that world. In fact, this repository already uses Vite+ for workspace orchestration.

So this is not really a competition:

• Vite+ = the general web toolchain shell

• Vize = the Vue-specific engine that can live inside that shell

Vize vs Oxlint

Oxlint is also at a different layer.

Oxlint is the high-performance JavaScript and TypeScript linter from the Oxc ecosystem. It is excellent at general JS/TS rules, and increasingly type-aware workflows, but by itself it is not meant to replace all Vue template-aware diagnostics.

That is where Vize Patina comes in.

Patina focuses on Vue-specific linting concerns such as:

• template directives

• SFC structure

• component conventions

• accessibility checks in Vue templates

So the difference is straightforward:

• Oxlint handles general-purpose JS/TS linting

• Vize / Patina handles Vue-specific linting

The new oxlint-plugin-vize alpha exists precisely because these two are complementary rather than redundant.

So Where Does Vize Sit?

Vize sits in the overlap between several categories, but it is not reducible to any one of them.

It is:

• broader than official Vue language tooling

• broader than tsgo acceleration projects like Golar

• closest in ambition to alternative full-stack efforts like Verter

• complementary to general workflow tools like Vite+

• complementary to general JS/TS linters like Oxlint

If I had to compress it into one sentence:

Vize is an unofficial Rust-native attempt to unify much more of the Vue toolchain than the official language tools cover, while still cooperating with broader ecosystem tools rather than replacing them.

Which One Should You Reach For?

That depends on what you want:

• Choose Vue Language Tools if you want the official, production-ready editor and type-check stack for Vue today.

• Look at Golar if your main interest is typescript-go-based type checking for embedded languages while reusing official language tooling.

• Look at Verter if you want another ambitious full-stack Vue toolchain with a strong strict typing and LSP story.

• Use Vite+ if you want a unified general-purpose workflow entry point for web development.

• Use Oxlint if your need is high-performance JavaScript and TypeScript linting.

• Use Vize if what excites you is the possibility of a broader Rust-native Vue toolchain that tries to make compiler, linting, formatting, type checking, editor tooling, gallery tooling, and AI tooling feel like one system.

That is the real difference.