# What is BiomeJS? A Complete Guide to the Rust-Powered Web Toolchain

> Discover BiomeJS, the Rust-powered web toolchain for formatting, linting, parsing, and LSP support. Enjoy high performance and Prettier compatibility.

- Repository: [Biome/biome](https://github.com/biomejs/biome)
- Tags: getting-started
- Published: 2026-06-19

---

**BiomeJS is a fast, unified toolchain written in Rust that combines code formatting, linting, parsing, and Language Server Protocol (LSP) support into a single high-performance tool, offering approximately 97% compatibility with Prettier and over 500 linting rules for web technologies.**

BiomeJS (commonly referred to as Biome) is an open-source project hosted in the `biomejs/biome` repository that aims to simplify JavaScript tooling by consolidating fragmented workflows into one cohesive solution. By leveraging Rust for performance-critical operations, BiomeJS eliminates the need to configure and maintain separate tools like Prettier, ESLint, and individual language servers. The project provides both a command-line interface and programmatic JavaScript APIs via WebAssembly bindings, making it accessible across Node.js environments and modern browsers.

## Core Components of BiomeJS

BiomeJS delivers four primary capabilities through a unified architecture designed to handle malformed code robustly while maintaining high performance.

### Formatter

The **formatter** provides ~97% compatibility with Prettier across JavaScript, TypeScript, JSX, JSON, CSS, and GraphQL. According to the `packages/@biomejs/biome/README.md`, this component handles complex formatting decisions while maintaining deterministic output. The formatter core resides in [`crates/biome_formatter/src/lib.rs`](https://github.com/biomejs/biome/blob/main/crates/biome_formatter/src/lib.rs), which implements the formatting algorithm for all supported languages through a shared engine.

### Linter

The **linter** enforces code quality through more than 500 rules drawn from ESLint, typescript-eslint, and other sources. Implemented in [`crates/biome_analyze/src/lib.rs`](https://github.com/biomejs/biome/blob/main/crates/biome_analyze/src/lib.rs), the linter provides detailed, contextual diagnostics with automatic fix application. The analysis engine supports robust error recovery, allowing it to lint code even when syntax errors are present.

### Parser and LSP

The **parser** infrastructure builds on a full-fidelity AST with robust error recovery capabilities. Language-specific parsers include [`crates/biome_js_parser/src/lib.rs`](https://github.com/biomejs/biome/blob/main/crates/biome_js_parser/src/lib.rs) for JavaScript/TypeScript/JSX, [`crates/biome_css_parser/src/lib.rs`](https://github.com/biomejs/biome/blob/main/crates/biome_css_parser/src/lib.rs) for CSS, and [`crates/biome_graphql_parser/src/lib.rs`](https://github.com/biomejs/biome/blob/main/crates/biome_graphql_parser/src/lib.rs) for GraphQL queries. The **Language Server Protocol (LSP)** implementation enables real-time editor integrations that function on malformed code as you type, providing immediate feedback during development.

## Architecture Overview

The BiomeJS repository is organized into Rust crates under `crates/` and JavaScript packages under `packages/`.

The core Rust architecture includes:

- `biome_formatter/` - Rust formatter engine
- `biome_analyze/` - Linter implementation and rule registry
- `biome_parser/` - Language-agnostic parser generator
- `biome_cli/` - Command-line front-end
- `biome_js_parser/`, `biome_css_parser/`, `biome_graphql_parser/` - Language-specific parsers

The JavaScript ecosystem bindings include:

- `@biomejs/biome/` - NPM package exposing the CLI
- `@biomejs/js-api/` - Node.js WebAssembly bindings
- `@biomejs/wasm-web/` - Browser WebAssembly bindings
- `@biomejs/plugin-api/` - Plugin extension points

## Using the BiomeJS CLI

The command-line interface defined in [`crates/biome_cli/src/main.rs`](https://github.com/biomejs/biome/blob/main/crates/biome_cli/src/main.rs) provides intuitive commands for code maintenance. You can execute BiomeJS via `npx` without installation:

```bash

# Format an entire project

npx @biomejs/biome format --write .

# Lint and automatically apply safe fixes

npx @biomejs/biome lint --write .

# Run both format and lint in one step

npx @biomejs/biome check --write .

# CI mode that fails on any issue

npx @biomejs/biome ci

```

The CLI parses configuration from [`biome.json`](https://github.com/biomejs/biome/blob/main/biome.json), with schema generation handled in [`xtask/codegen/src/generate_configuration.rs`](https://github.com/biomejs/biome/blob/main/xtask/codegen/src/generate_configuration.rs).

## JavaScript API Integration

BiomeJS exposes its Rust core through WebAssembly, enabling programmatic usage in both Node.js and browser environments.

### Node.js API

The `@biomejs/js-api` package defined in `packages/@biomejs/js-api/src/biome.ts` provides asynchronous methods for formatting and linting:

```javascript
import { Biome, Distribution } from "@biomejs/js-api";

async function formatAndLint(code) {
  const biome = await Biome.create({ distribution: Distribution.NODE });

  // Format code
  const formatted = await biome.formatContent({
    language: "js",
    sourceText: code,
  });

  // Lint the formatted code
  const lintResult = await biome.lintContent({
    language: "js",
    sourceText: formatted.code,
  });

  console.log("Formatted:", formatted.code);
  console.log("Diagnostics:", lintResult.diagnostics);
}

```

This API is tested in `packages/@biomejs/js-api/tests/formatContent.test.ts`.

### Browser WebAssembly API

For browser environments, BiomeJS loads from `packages/@biomejs/wasm-web/src/lib.rs`:

```html
<script type="module">
  import { Biome, Distribution } from "https://cdn.jsdelivr.net/npm/@biomejs/js-api/dist/web.js";

  async function run() {
    const biome = await Biome.create({ distribution: Distribution.WEB });
    const result = await biome.formatContent({
      language: "tsx",
      sourceText: "<div>Hello</div>",
    });
    console.log(result.code);
  }
  run();
</script>

```

The web build powers the online playground and supports the same formatting and linting capabilities as the Node.js version.

## Summary

- **BiomeJS** is a Rust-based toolchain combining formatting, linting, parsing, and LSP support for web languages.
- The **formatter** achieves ~97% Prettier compatibility across JavaScript, TypeScript, JSX, JSON, CSS, and GraphQL.
- The **linter** provides 500+ rules with automatic fixes and robust error recovery.
- **Architecture** separates concerns into Rust crates (`biome_formatter`, `biome_analyze`, `biome_*_parser`) and JavaScript packages (`@biomejs/js-api`, `@biomejs/wasm-web`).
- **Usage options** include CLI commands (`format`, `lint`, `check`, `ci`), Node.js APIs via WebAssembly, and browser integrations.
- **Key source files** include [`crates/biome_cli/src/main.rs`](https://github.com/biomejs/biome/blob/main/crates/biome_cli/src/main.rs) for CLI entry, [`crates/biome_formatter/src/lib.rs`](https://github.com/biomejs/biome/blob/main/crates/biome_formatter/src/lib.rs) for formatting logic, and [`crates/biome_analyze/src/lib.rs`](https://github.com/biomejs/biome/blob/main/crates/biome_analyze/src/lib.rs) for linting rules.

## Frequently Asked Questions

### What languages does BiomeJS support?

BiomeJS supports JavaScript, TypeScript, JSX, JSON, CSS, and GraphQL. Each language has a dedicated parser crate (e.g., [`crates/biome_js_parser/src/lib.rs`](https://github.com/biomejs/biome/blob/main/crates/biome_js_parser/src/lib.rs) for JavaScript/TypeScript, [`crates/biome_css_parser/src/lib.rs`](https://github.com/biomejs/biome/blob/main/crates/biome_css_parser/src/lib.rs) for CSS, and [`crates/biome_graphql_parser/src/lib.rs`](https://github.com/biomejs/biome/blob/main/crates/biome_graphql_parser/src/lib.rs) for GraphQL), all unified under a common formatting and analysis engine.

### How does BiomeJS compare to Prettier?

BiomeJS achieves approximately 97% compatibility with Prettier while offering significantly faster performance due to its Rust implementation. Unlike Prettier, BiomeJS also includes built-in linting capabilities with over 500 rules, eliminating the need to run separate formatting and linting tools.

### Can I use BiomeJS programmatically in my build tools?

Yes. BiomeJS exposes JavaScript APIs through the `@biomejs/js-api` package, which loads the Rust core via WebAssembly. You can create a `Biome` instance with `Biome.create({ distribution: Distribution.NODE })` and call methods like `formatContent()` and `lintContent()` to process code programmatically without spawning CLI processes.

### Is BiomeJS suitable for CI/CD pipelines?

Absolutely. The `npx @biomejs/biome ci` command is specifically designed for continuous integration environments, returning non-zero exit codes when issues are detected. This makes it ideal for pre-commit hooks and automated quality checks in CI/CD workflows.