tsv is a set of performance-focused language tools for the Web. Today it ships formatters and parsers for TypeScript/JS, CSS, and Svelte, including a vscode/openvsx extension. JSON and HTML are planned, maybe linting after. The readme has a loose roadmap - https://github.com/fuzdev/tsv

tsv's benchmarks show how the Web's newer native tools have some performance left on the table. Formatting TypeScript, tsv is more than twice as fast as oxfmt, and is smaller and uses less memory - https://tsv.fuz.dev/docs/benchmarks

From the site:

- formatting TypeScript, tsv is ~2.2x faster than Oxfmt (native), ~36x faster than Prettier (native Rust vs Prettier's JS; ~26x as wasm), and ~7.6x faster than Biome (wasm)

- formatting Svelte, tsv is ~79x faster than Prettier (~55x as wasm) and ~10x faster than Biome (wasm)

- formatting CSS, tsv is ~3.6x faster than Oxfmt (native), ~111x faster than Prettier (~78x as wasm), and ~12x faster than Biome (wasm)

tsv is focused on the Web and Svelte, and doesn't support other nonstandard languages like JSX/TSX and SCSS. This limits possible adoption, but it keeps the tool slim and simple, and there are plenty of other tools that offer a generic language platform - tsv isn't trying to compete with them. Part of my motivation was being tired of slow tools and Svelte's second-class status in this next generation.

Before starting the project, I had tried to build on Oxc and Biome, and ran into some discouraging edges. On the benchmarks' language support section, you'll see Oxc doesn't export its CSS parser (recently added, a fork of Raffia - https://github.com/g-plane/raffia), and Biome doesn't export its parsers. Also oxfmt doesn't ship wasm to the browser yet, and tsv's smaller footprint is useful there (Biome is 46.9 MB to tsv's 2.7).

Parser conformance is as good or better than Oxc, Biome, and swc, except negative parser cases (errors), which are unfinished. https://tsv.fuz.dev/docs/conformance

The codebase turns 1 year old at the end of the month. It's my first serious AI-generated project, built with Claude Code. I learned Rust in 2015, built some toys including an arcade action prototype, and followed its development over the years, but this is my first project since. tsv wouldn't exist without LLMs - it requires far too much labor for a side project.

tsv leans heavily on Prettier, but doesn't copy it. This is why this production release took almost a year, despite the silly fast coding part. I made some different stylistic choices, more for Svelte than TypeScript, and fixed numerous quirks and bugs and documented them. tsv also takes advantage of Svelte 5's whitespace rules, which further diverged from HTML to trim leading whitespace in tags, fixing longstanding formatting warts - https://svelte.dev/docs/svelte/v5-migration-guide#Whitespace...

The formatter takes no style config, and instead is hardcoded to Prettier's style with Svelte's config. Supporting Prettier's config would force significant costs on tsv with a JS runtime, so instead I'm keeping the formatters non-configurable instead of making all users pay those costs. Part of these costs can be see in the CLI benchmark (which is a fork of Oxc's official bench-formatter) - when tsv's binary is used directly instead of via Node, the single-repo CLI benchmark runs tsv 1.7x faster using less than half the memory.

Next I'm exploring rearchitecting to Zig-inspired data-oriented parsing - https://mitchellh.com/zig/parser - which should get tsv closer to Yuku's speed, measured on the site.

The vscode extension is `fuzdev.tsv-format` - https://marketplace.visualstudio.com/items?itemName=fuzdev.t... - and Open VSX - https://open-vsx.org/extension/fuzdev/tsv-format

Repo: https://github.com/fuzdev/tsv

Show HN: tsv has fast formatters and parsers for Svelte, TypeScript/JS, CSS