Get AI summaries of any video or article — Sign up free
I did not expect this... thumbnail

I did not expect this...

Theo - t3․gg·
5 min read

Based on Theo - t3․gg's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

V+ is now released as an open-source (MIT) alpha, shifting from previously closed-source paid distribution to a unified toolchain centered on Vit.

Briefing

Vit Plus—an open-source, MIT-licensed alpha of the previously closed-source “V+” toolchain—lands as a unified workflow for modern web development centered on Vit. The pitch is straightforward: collapse the scattered pieces of project management (package/dependency handling, environment setup, testing, scaffolding, bundling, linting, formatting) into one cohesive tool so teams stop juggling fast-changing configs and CLIs. That matters because the ecosystem is already converging around Vit and its “Void Zero” ecosystem, and V+ aims to make the rest of the toolchain feel equally centralized.

The most compelling part is the live migration and performance check. The setup experience includes node version management via an NVM/FNM-style workflow, plus fast code quality commands. In practice, VP check scans and auto-fixes formatting issues across ~15,000 lines in about 332 milliseconds, with formatting and linting reported in the few-hundred-millisecond range (and bun run lint around 0.19 seconds user time). The workflow also introduces V+ “agents” configuration via agent MD files, pre-commit hooks for lint/type/format, and a VP env/doctor flow to wire node version control into shells and editor environments.

Migrating an existing project reveals both the promise and the friction. The migration flow can switch package managers (bun to PNPM) and update scripts, but it exposes gaps: bun support is explicitly rejected during migration, and some orchestration behavior around scripts becomes confusing—especially when custom dev commands are hijacked or when VP rundev doesn’t honor existing package.json script precedence the way bun users expect. A separate issue appears with TanStack Start compatibility: the project initially breaks due to mismatched TanStack package versions, and the fix ends up being a dependency/version alignment plus a clean reinstall rather than a single “run this command” solution.

Despite those rough edges, the build-time results are encouraging. A TanStack Start app that previously built in roughly 28 seconds drops to about 22 seconds after the migration, with the caveat that PNPM installs can be slower and that cloud/deployment overhead still exists. Under the hood, V+ introduces V Tasks, a Rust-based task runner that fingerprints dependency-aware execution, splits multi-command scripts into cached subtasks, and provides a PNPM-like interface via VP run.

The overall verdict is mixed: V+ feels like a serious attempt to centralize the developer experience and reduce decision fatigue, and the speed numbers are real. But alpha-stage roughness shows up in agent MD bloat, missing bun support, script/namespace quirks, and framework edge cases—enough that the narrator doesn’t yet plan to use V+ for all projects. Still, with V+ now open-source and actively iterating, the direction toward one toolchain for the full stack (paired with Void’s broader deployment ambitions) is framed as genuinely exciting, even if not ready to replace established workflows today.

Cornell Notes

Vit Plus (V+) is an open-source, MIT-licensed alpha toolchain built around Vit that aims to unify the messy parts of web development: node/environment management, dependency and workspace handling, linting/formatting, testing, scaffolding, and bundling. A live first-time setup shows very fast lint/format checks (hundreds of milliseconds) and node version pinning that can simplify team and Docker/agent workflows. Migrating an existing TanStack Start project demonstrates both the upside and the pain: bun-to-PNPM migration is supported only in one direction (bun is rejected), script orchestration can behave unexpectedly, and TanStack version mismatches can break runtime until dependencies are aligned and installs are cleaned. Build times improved in the test (about 28s down to ~22s), suggesting the Rust-based task runner and caching can pay off—if alpha edge cases are handled.

What does V+ try to unify, and why is that a big deal for teams already using Vit?

V+ positions itself as a single “unified tool chain” around Vit Zero’s ecosystem, bundling together tasks that are usually spread across multiple tools: package/dependency management, environment and node version handling, testing, scaffolding, packing/bundling, plus linting and formatting. The practical value is reducing the constant churn of configs and CLIs—especially as more frameworks and tooling converge on Vit and its ecosystem.

How does V+ handle node versions, and what did the first run suggest about team workflows?

V+ includes an NVM/FNM-style node management layer. The transcript shows enabling it immediately, then using commands like vpenv doctor (to ensure the tool is first in PATH) and vpenv pin (to create a project-level node version pinned to the latest). The key implication is easier multi-version setups across a team and in agentic/Docker-like environments, without manually juggling separate node managers.

What were the reported speed results for code quality tasks?

VP check is described as extremely fast: it scanned and auto-fixed formatting issues across a ~15,000-line codebase in about 332 milliseconds. The transcript also gives separate timing-style numbers: formatting around 341 ms and linting around 247 ms, with bun run lint taking roughly 0.19 seconds user time. The takeaway is that V+’s Rust-based tooling and caching/parallelism are delivering near-instant feedback in this test.

Where did migration go wrong, and what does that reveal about alpha maturity?

Several friction points appear: bun is explicitly unsupported during migration (even though many early adopters use bun), script behavior can be confusing (custom dev commands and script precedence aren’t always respected), and TanStack Start compatibility breaks when dependency versions don’t align. The fix required identifying the likely root cause (workspace-pinned TanStack versions plus the bun→PNPM change) and then cleaning/reconciling installs rather than relying on a single migration command.

What is V Tasks, and how does it relate to caching and faster builds?

V Tasks is described as a Rust-based task runner shipped with V+ that fingerprints dependency-aware execution. It runs tasks in the correct order based on the package.json dependency graph and explicit depends declarations, splits multi-command scripts into cached subtasks, and skips work when inputs haven’t changed. The transcript’s example: generating icons can be cached so subsequent runs skip regeneration unless source files or relevant environment variables change.

Did build times improve after migrating, and what numbers were cited?

Yes, in the tested TanStack Start app. The build time reportedly went from about 28 seconds down to roughly 22 seconds after migration. The transcript notes this isn’t necessarily a pure “V+ makes builds faster” story because PNPM installs can be slower and deployment overhead still exists, but the net build improvement was still described as meaningful.

Review Questions

  1. Which parts of the typical web-dev toolchain does V+ attempt to consolidate, and which pain points does that consolidation target?
  2. What specific alpha-stage issues surfaced during migration (package manager support, script orchestration, framework compatibility), and how were they resolved?
  3. How does V Tasks’ dependency fingerprinting and subtask caching work in principle, and why would that reduce repeated build or generation time?

Key Points

  1. 1

    V+ is now released as an open-source (MIT) alpha, shifting from previously closed-source paid distribution to a unified toolchain centered on Vit.

  2. 2

    The workflow emphasizes consolidation: node/environment management, dependency handling, linting/formatting, testing, scaffolding, and bundling under one set of commands.

  3. 3

    Node version pinning is handled via vpenv-style commands (doctor/pin), aiming to simplify multi-version setups for teams and agentic/Docker environments.

  4. 4

    VP check and related lint/format operations are reported to run in the hundreds of milliseconds on a ~15,000-line codebase, suggesting strong performance characteristics.

  5. 5

    Migration can break real projects: bun is not supported in the migration path, script precedence/orchestration can be confusing, and TanStack Start compatibility depends on aligning workspace-pinned package versions.

  6. 6

    V Tasks introduces dependency-aware execution with caching and a PNPM-like interface via VP run, including examples like skipping icon regeneration when inputs haven’t changed.

  7. 7

    In a TanStack Start build test, build time dropped from ~28 seconds to ~22 seconds after migration, though install and deployment factors still affect end-to-end timing.

Highlights

V+’s VP check reportedly fixed formatting issues across ~15,000 lines in about 332 milliseconds—fast enough to feel “instant” for iterative development.
The migration experience exposed alpha gaps: bun support is rejected during migration, and script orchestration can override or ignore existing package.json script expectations.
TanStack Start initially failed after migration due to dependency/version mismatches; the resolution leaned on aligning pinned versions and cleaning installs rather than a single command fix.
V Tasks is positioned as a Rust-based, dependency-fingerprinted task runner that caches subtasks and can skip work like icon generation when inputs haven’t changed.
A real build test showed a net improvement (roughly 28s → ~22s), suggesting the caching/task-runner approach can translate into measurable speed gains.

Topics

  • Vit Plus Alpha
  • Unified Toolchain
  • Node Version Pinning
  • VP Check Performance
  • TanStack Start Migration
  • V Tasks Caching

Mentioned

  • Vit
  • V+
  • MIT
  • NVM
  • FNM
  • VP
  • TSC
  • TS
  • MD
  • CI
  • VP check
  • VP dev
  • VP build
  • VP preview
  • VP config
  • VP env
  • vpenv
  • PATH
  • ESLint
  • Oxlint
  • T3
  • GPT
  • Codex
  • UI
  • CI badges
  • PNPM
  • bun
  • npx
  • VS Code
  • CLI
  • Docker
  • Rust