Rust Meetup Amsterdam December 2024: RustRover and Biome

On Thursday 12 December 2024 I went to the December Rust meetup in Amsterdam, organised by RustNL and hosted at the JetBrains office. The room was empty when I arrived and full by the time the first speaker started. The evening had two talks about Rust developer tools from different angles: the IDE that helps you write Rust, and a JavaScript toolchain written in Rust. In between, the organisers announced RustWeek 2025.

The room at JetBrains before the meetup filled up.

Inside RustRover: solving your issues with lifetimes

The first talk was “Inside RustRover: Solving Your Issues with Lifetimes” by Vlad Beskrovnyi, Technical Lead in RustRover at JetBrains according to his title slide. RustRover is JetBrains’ IDE for Rust.

The opening slide. I’ve blurred the browser’s address bar.

Much of the talk was a live demo in the IDE, working through small programmes that the borrow checker rejects. The slides I photographed showed a move error (let foo = String::new(); followed by using foo after it had been moved) and a borrow error, where an immutable borrow is still used later. The clearest example was the classic one:

fn main() {
    let mut foo = vec![1, 2];
    let slice = &foo[..];   // immutable borrow occurs here
    foo.push(3);            // mutable borrow occurs here
    println!("{:?}", slice);
}

RustRover underlined foo.push(3) with the compiler’s message, “cannot borrow foo as mutable because it is also borrowed as immutable” (E0502), annotated the earlier line with “immutable borrow occurs here”, and offered a Navigate to cause action. That action takes you from where the error is reported to where the conflicting borrow starts. In a three-line example the two are next to each other. In real code, with the borrow taken in one function and used in another, that jump saves you a lot of reading.

The borrow checker’s E0502 error in RustRover, with the cause annotated inline.

RustWeek 2025 announced

Between the talks, RustWeek was announced from the stage, with the RustWeek site on screen: RustWeek “by RustNL”, 13–17 May 2025 in Utrecht. The Rust Foundation’s event listing describes it as a full week organised by Stichting Rust Nederland, including the first Rust project All Hands since 2019.

The RustWeek 2025 announcement.

Biome: toolchain of the web

The second talk was “Biome: Toolchain of the Web” by Arend van Beelen jr. The title slide carried “December 2024 Rust Meetup @ JetBrains” and links to biomejs.dev.

The Biome title slide.

The “What is Biome” slide described:

• a linter that replaces ESLint, Stylelint and many of their plugins;
• a formatter that is a drop-in replacement for Prettier;
• support for JavaScript/TypeScript, CSS, JSON/JSONC, GraphQL and GritQL;
• all of it written in Rust.

The Biome site today claims 97% compatibility with Prettier and says the architecture was inspired by rust-analyzer. That explains why the talk belonged at a Rust meetup.

Architecture: a workspace server and red-green trees

The Architecture slide had three points: a workspace client/server model, an optional daemon, and concrete syntax trees based on Rowan, the syntax tree library from rust-analyzer.

Biome’s architecture in three bullets.

The “Red Green Syntax Trees” slide explained the Rowan model, with a “Yo dawg” meme about layering a tree on top of your tree. The green tree is immutable, shares nodes and is built bottom-up. The red tree is constructed on demand, top-down. The point is that a formatter and a linter need a lossless tree that keeps every space and comment. The green tree gives you a cheap, shareable representation. The red tree adds parent pointers and offsets only for the parts you actually walk.

Plugins in GritQL

The Plugin support slide listed the use cases: lint rules, formatter customisation, codemods and language support. It weighed three implementation strategies, WASM, JavaScript and a DSL, and said the first focus was lint rules written in GritQL. The GritQL slide showed what that looks like, a pattern-matching rewrite language:

`$fn && $fn()` => `$fn?.()`

`function $name ($args) { $body }` as $func where {
    $func => `const $name = ($args) => { $body }`,
    $args <: contains `apple` => `mango`
}

The first rule turns fn && fn() into an optional call. The second rewrites function declarations into arrow functions and renames an argument along the way.

GritQL patterns as the first plugin format.

Multi-file analysis

The last technical section was about multi-file analysis and caching. The plan on the slide: move file-system traversal from the CLI and LSP into the workspace server, add new services (ProjectLayout, DependencyGraph, and, with question marks, GraphQlSchema and TsTypeInfo), and add file watching with Notify plus caching. A final slide covered workspace locking for the shared workspace.

The roadmap slide for multi-file analysis.

Six months later, that roadmap shipped. Biome v2, released on 17 June 2025, brought GritQL linter plugins, a file scanner that indexes the project for multi-file rules such as noImportCycles, and type-aware lint rules that don’t depend on the TypeScript compiler.

My take: Biome is a good example of why so much infrastructure tooling is moving to Rust. Startup time, a single static binary and predictable memory use matter a lot for a tool that runs on every keystroke in the editor and on every commit in CI. The daemon and workspace-server design is the same pattern language servers use, and it’s what makes multi-file analysis affordable.

Related

• Pixi: Building a Package Manager in Rust at RustNL Meetup
• Rust AI at Adyen: Building the Next-Gen Data Engine
• Rust Memory Safety Without Garbage Collection: How It Works
• Data Sovereignty and Rust: Robin Everaars at Rust AI