← Back to blog
AiAbout 6 min read

A Rust Rebuild of IntelliJ That Opens a 770-File Project in 0.9 Seconds

Published Nov 13, 2026
A Rust Rebuild of IntelliJ That Opens a 770-File Project in 0.9 Seconds

OpenIDEA has a thesis you can read in one line: the IDE you know, rebuilt in Rust.

The claim underneath is that IntelliJ's way of working, meaning the keymap, the tool windows, the search-everywhere habit, is worth keeping, and the JVM underneath it is not. So somebody rebuilt the whole thing on a Rust core, shipped builds for macOS, Windows and Linux, and published a benchmark table with six rows.

The table

Opening freqtrade, a Python repository of roughly 770 files, with warm caches, median of five runs, measured on Windows 11, a 32-core AMD chip and 62 GB of RAM:

| | OpenIDEA | IntelliJ IDEA 2026.2.3 | |---|---|---| | Window with the project | 0.9 s | 3.1 s | | Ready (CPU settled) | 1.1 s | 13.2 s | | Memory (USS, all processes) | 169 MB | 2011 MB | | CPU time until ready | 2.4 s | 47.9 s | | Idle CPU | 4% of a core | 7% of a core | | Quit | 0.3 s | 5.9 s |

The memory number is the one that will get screenshotted. Two gigabytes against 169 megabytes is not a tuning difference, it is a different architecture arriving at a different address. The CPU time until ready, 47.9 seconds against 2.4, tells the same story from the other side: one of these spends most of a minute doing analysis before you can type, and the other does not.

Then the footnote, which is worth more than the table: IDEA analyses Python more deeply, so "ready" does not mean the same work on both sides. Both were measured from the outside, the same way, and the repository ships perf/compare so you can run it on your own machine and projects.

That is the correct way to publish a benchmark and the correct way to undercut it in the same document. A reader who trusts the numbers now knows exactly where not to trust them.

What is actually in the box

Editor, code insight, debugger, Git, terminal, database client, HTTP client, for more than 60 languages. Builds for all three desktop platforms. Apache 2.0.

Plugins are the part worth slowing down for. They run as sandboxed WebAssembly components, and the plugin surface covers actions, completion, quick fixes, tool windows, custom editors, themes, file icons and languages. Themes, icon themes and languages need no code at all, which is how a new language can ship as a data file rather than a compiled extension.

There is a CLI for scaffolding, openidea-plugin new, and a set of official plugins in the repository. The plugin API is explicitly labelled a preview, which is the right word for a project this young. An IDE's plugin ecosystem is the moat that took JetBrains two decades to dig, and a preview API is a long way from a moat.

Why a Rust IDE is suddenly plausible

This kind of project used to be a fantasy for a specific reason: an IDE is not one program, it is a compiler front end, an incremental index, a language server, a debugger protocol, a build system and a text editor that all have to agree about the same file at the same time. The JVM was a reasonable place to put that, because the JVM had garbage collection, threads and two decades of libraries.

Three things changed. Rust's ecosystem caught up on the pieces that matter, incremental parsing and tree-sitter-style analysis being the big ones. The LSP protocol standardized the boundary between editor and language intelligence, so a new IDE no longer has to write its own analysis for every language. And the local LLM tooling wave pushed a lot of people to build editors and terminals and file trees in Rust, which means there is now a generation of developers who have shipped a text buffer in anger.

The keymap decision is the interesting one. Rebuilding IntelliJ's keymap means targeting the people most locked in, which is either the smartest or the most quixotic choice available. Those users have twenty years of muscle memory and a plugin stack they cannot replace. They are also the users most likely to notice a 13-second difference, because they open projects all day.

What the numbers do not cover

Startup and memory are the easy metrics, and they are also the ones a competitor can lose badly while still being the better tool.

Deep analysis is where an IDE earns its keep: refactoring across a codebase, finding usages through dynamic dispatch, understanding a framework's implicit wiring, debugging a thread dump. IntelliJ is enormous partly because that work is enormous. The footnote in OpenIDEA's table says as much, and the honest read is that a 770-file Python project is a friendly test case, not a hostile one.

Warm caches are the other caveat. Cold-start numbers on a fresh clone, with a machine that is not already holding the file tree in RAM, will look different. Every editor vendor reports warm numbers because they flatter everyone.

Then there is the unglamorous part: a new IDE does not have the plugins you actually use. No database tooling you already paid for, no framework-specific support, no vendor integrations. Migrating means leaving things behind, and the migration cost is not in the table.

The unglamorous parts

An IDE is mostly small interactions repeated ten thousand times, and that is where a rebuild either earns trust or loses it. Cursor behavior across a wrapped line, the exact feel of incremental search, whether the file tree updates when a branch changes underneath you, whether a rename applies to files the index has not opened yet. None of that appears in a startup benchmark. All of it decides whether you keep using the thing after a week.

The cross-platform claim is also doing quiet work. Native builds for macOS, Windows and Linux mean the same binary family rather than an Electron shell wrapping the same web view everywhere, which is the architecture most new editors chose. Whether that translates into consistent behavior on three platforms is a question only users can answer, and the repository's own performance numbers are Windows-specific with a warm cache.

Who this is for right now

If your daily work is opening a monorepo on a laptop with 16 GB of RAM and waiting, OpenIDEA is aimed directly at you. The 169 MB number is not a curiosity, it is a laptop that stays responsive while a browser is open.

If your daily work is a Java or Kotlin codebase with a decade of IntelliJ plugins, this is not for you yet, and the project says as much. The footer notes it is unaffiliated with JetBrains and that the trademark belongs to someone else.

If you write language tooling, the WebAssembly plugin model is the part to study. Sandboxed extensions with no JVM in the loop is a design that solves a security problem and a distribution problem at the same time, and it is the sort of thing that could outlive the IDE itself.

The repository is at 8.9k stars, which is a lot for a tool that most people cannot switch to yet. That gap between interest and adoption is the real story. Developers are shopping for proof that the old IDE's weight was a choice, more than for a replacement.

Related articles