← Torna al blog
Aicirca 6 min di lettura

Una riscrittura di IntelliJ in Rust che apre un progetto da 770 file in 0.9 s

Pubblicato 13 nov 2026
Una riscrittura di IntelliJ in Rust che apre un progetto da 770 file in 0.9 s

OpenIDEA ha una tesi che si legge in una riga: l'IDE che conosci, rifatto in Rust.

La rivendicazione sotto è più concreta. Il modo di lavorare di IntelliJ, cioè la keymap, le finestre degli strumenti, l'abitudine di cercare ovunque, vale la pena tenerlo, la JVM che ci sta sotto no. Così qualcuno ha ricostruito tutto su un nucleo Rust, ha pubblicato build per macOS, Windows e Linux e ha messo fuori una tabella di benchmark da sei righe.

La tabella

Apertura di `freqtrade`, un repo Python da circa 770 file, cache calde, mediana di cinque esecuzioni, misurato su Windows 11, un AMD da 32 core e 62 GB di RAM:

| | OpenIDEA | IntelliJ IDEA 2026.2.3 | |---|---|---| | Finestra con il progetto | 0.9 s | 3.1 s | | Pronto (CPU assestata) | 1.1 s | 13.2 s | | Memoria (USS, tutti i processi) | 169 MB | 2011 MB | | Tempo CPU fino a pronto | 2.4 s | 47.9 s | | CPU in idle | 4% di un core | 7% di un core | | Chiusura | 0.3 s | 5.9 s |

Il numero sulla memoria è quello che finirà negli screenshot. Due gigabyte contro 169 megabyte, nessun tuning colma quel divario, sono due architetture che atterrano a indirizzi diversi. Il tempo CPU fino a pronto racconta la stessa cosa dall'altro lato: 47.9 s contro 2.4 s, uno passa quasi un minuto ad analizzare prima che tu possa scrivere, l'altro no.

Poi la nota in fondo, che vale più della tabella: IDEA analizza Python più a fondo, quindi "pronto" non significa lo stesso lavoro sui due lati. Entrambi sono stati misurati dall'esterno, allo stesso modo, e il repo include `perf/compare` così puoi farlo girare sulla tua macchina e sui tuoi progetti.

È il modo giusto di pubblicare un benchmark, e il modo giusto di smontarlo nello stesso documento. Chi crede ai numeri adesso sa esattamente dove non crederci.

Cosa c'è davvero dentro

Editor, code insight, debugger, Git, terminale, client di database, client HTTP, per più di 60 linguaggi. Build per tutte e tre le piattaforme desktop. Apache 2.0.

La parte per cui vale la pena rallentare sono i plugin. Girano come componenti WebAssembly in sandbox, e la superficie copre azioni, completamento, quick fix, finestre degli strumenti, editor personalizzati, temi, icone dei file e linguaggi. Temi, temi di icone e linguaggi non richiedono codice, ed è così che un linguaggio nuovo può uscire come file di dati invece che come estensione compilata.

C'è una CLI per lo scaffolding, `openidea-plugin new`, e una serie di plugin ufficiali nel repo. L'API dei plugin è etichettata esplicitamente come preview, e per un progetto così giovane è la parola giusta. L'ecosistema di plugin di un IDE è il fossato che JetBrains ha scavato in vent'anni, e un'API in preview è ancora lontana da un fossato.

Perché un IDE in Rust è diventato all'improvviso plausibile

Questo tipo di progetto era fantasia, per una ragione precisa. Un IDE non è un programma, è un front end di compilatore, un indice incrementale, un language server, un protocollo di debug, un sistema di build e un editor di testo che devono mettersi d'accordo sullo stesso file nello stesso momento. La JVM era un posto ragionevole dove mettere tutto questo, perché aveva garbage collection, thread e vent'anni di librerie.

Sono cambiate tre cose. L'ecosistema Rust ha recuperato sui pezzi che contano, con il parsing incrementale e le analisi in stile tree-sitter in testa. Il protocollo LSP ha standardizzato il confine tra editor e intelligenza del linguaggio, così un IDE nuovo non deve più scrivere la propria analisi per ogni linguaggio. E l'ondata di strumenti LLM locali ha spinto molta gente a scrivere editor, terminali e alberi di file in Rust, il che significa che c'è una generazione di sviluppatori che ha consegnato davvero un text buffer.

La decisione sulla keymap è quella interessante. Rifare la keymap di IntelliJ significa puntare sulle persone più bloccate, ed è la scelta più intelligente o la più donchisciottesca disponibile. Quegli utenti hanno vent'anni di memoria muscolare e uno stack di plugin che non possono sostituire. Sono anche quelli che notano più facilmente una differenza di 13 secondi, perché aprono progetti tutto il giorno.

Cosa i numeri non coprono

Avvio e memoria sono le metriche facili, e sono anche quelle su cui un concorrente può perdere malissimo restando lo strumento migliore.

L'analisi profonda è dove un IDE si guadagna lo stipendio: refactoring su tutto un repository, trovare gli usi attraverso il dispatch dinamico, capire il cablaggio implicito di un framework, fare debug di un thread dump. IntelliJ è enorme anche perché quel lavoro è enorme. La nota nella tabella di OpenIDEA dice più o meno questo, e la lettura onesta è che un progetto Python da 770 file è un caso di test amichevole, non ostile.

Le cache calde sono l'altra avvertenza. I numeri a freddo su un clone appena fatto, su una macchina che non tiene ancora l'albero dei file in RAM, saranno diversi. Ogni produttore di editor riporta numeri caldi perché fanno bella figura con tutti.

Resta la parte poco glamour: un IDE nuovo non ha i plugin che usi davvero. Niente strumenti per database già pagati, niente supporto specifico per framework, niente integrazioni dei fornitori. Migrare significa lasciare cose indietro, e quel costo non è nella tabella.

Le parti poco glamour

Un IDE è per lo più piccole interazioni ripetute diecimila volte, ed è lì che una riscrittura guadagna o perde fiducia. Il comportamento del cursore su una riga mandata a capo, la sensazione esatta della ricerca incrementale, se l'albero dei file si aggiorna quando un branch cambia sotto, se un rename arriva anche ai file che l'indice non ha ancora aperto. Niente di tutto questo compare in un benchmark di avvio. Tutto questo decide se usi ancora la cosa dopo una settimana.

Anche la promessa multipiattaforma lavora in silenzio. Build native per macOS, Windows e Linux significano la stessa famiglia di binari invece di un guscio Electron che impacchetta la stessa web view ovunque, l'architettura che ha scelto la maggior parte dei nuovi editor. Se questo si traduca in un comportamento coerente su tre piattaforme lo possono dire solo gli utenti, e i numeri di prestazione del repo sono specifici per Windows, con cache calda.

A chi serve adesso

Se il tuo lavoro quotidiano è aprire un monorepo su un portatile con 16 GB di RAM e aspettare, OpenIDEA punta dritto a te. Il numero di 169 MB non è una curiosità: un portatile che resta reattivo con un browser aperto.

Se il tuo lavoro quotidiano è una base di codice Java o Kotlin con dieci anni di plugin IntelliJ, questo non fa ancora per te, e il progetto lo dice. Il footer precisa che non è affiliato a JetBrains e che il marchio è di qualcun altro.

Se scrivi strumenti per linguaggi, il modello di plugin WebAssembly è la parte da studiare. Estensioni in sandbox senza JVM nel giro è un progetto che risolve insieme un problema di sicurezza e un problema di distribuzione, ed è il genere di cosa che potrebbe sopravvivere all'IDE stesso.

Il repo è a 8.9k stars, che è molto per uno strumento su cui la maggior parte della gente non può ancora spostarsi. Quel divario tra interesse e adozione è la storia vera. Gli sviluppatori stanno cercando la prova che il peso del vecchio IDE fosse una scelta, più che un sostituto.

Articoli correlati