Come installare IntelliJ IDEA su Ubuntu 24.04, 22.04 e 20.04 LTS

Su Ubuntu LTS, IntelliJ IDEA si installa in modo pulito con tre approcci sensati: Snap, archivio tar.gz ufficiale e, quando serve standardizzare l’ambiente, toolbox o gestione manuale sotto /opt. La scelta non è estetica: cambia aggiornamenti, isolamento, integrazione col desktop e facilità di rollback. Se devi mettere in piedi una postazione da sviluppo in fretta, Snap è la via più corta; se vuoi controllo fine e niente vincoli del packaging, il tarball resta la soluzione più prevedibile.

Questa guida copre Ubuntu 24.04, 22.04 e 20.04 LTS con un taglio operativo: cosa verificare prima, come installare, come confermare che Java e il launcher siano a posto, e come rimuovere o aggiornare senza lasciare residui inutili. Dove ci sono differenze tra versioni, le segnalo. L’obiettivo è evitare l’errore classico: installare l’IDE e poi trovarsi con un runtime Java incoerente, un launcher non visibile nel menu o un aggiornamento che rompe il path dell’icona.

Scelta del metodo: Snap o tarball ufficiale

La decisione pratica è questa: se ti serve installazione rapida, aggiornamenti automatici e integrazione immediata con Ubuntu, usa Snap. Se vuoi una directory stabile, più controllo sugli upgrade e una struttura più adatta a macchine condivise o ambienti standardizzati, usa il pacchetto tar.gz ufficiale di JetBrains.

In entrambi i casi IntelliJ IDEA può usare il runtime incluso. Questo riduce la dipendenza dal Java di sistema e evita conflitti con versioni troppo vecchie o troppo nuove installate a livello OS. In pratica, per chi lavora su Ubuntu LTS, è spesso meglio non forzare una JVM di sistema se non hai un’esigenza precisa di compatibilità.

Verifiche preliminari su Ubuntu LTS

Prima di installare, conviene controllare due cose: spazio disco e architettura. IntelliJ IDEA non è leggero, e un ambiente con poco spazio sotto /home o /opt genera problemi fastidiosi dopo l’estrazione o durante i primi indicizzamenti.

Esegui questi controlli:

lsb_release -a
uname -m
df -h /
df -h /home

Atteso: Ubuntu 20.04, 22.04 o 24.04 su architettura x86_64 o amd64. Su ARM64 il discorso cambia: verifica sul sito JetBrains che il pacchetto scelto sia quello corretto per il tuo hardware. Se il sistema è quasi pieno, libera spazio prima di iniziare; un’IDE che si installa ma poi non riesce a creare cache o indici è solo mezza installazione.

Installazione rapida con Snap

Snap è il metodo più semplice su Ubuntu perché non richiede dipendenze esterne e lascia a snapd la gestione del ciclo di vita. Su 22.04 e 24.04 è normalmente già presente; su 20.04 di solito lo è, ma conviene verificarlo.

snap version
sudo snap install intellij-idea-community --classic

Per la versione Ultimate, il comando è:

sudo snap install intellij-idea-ultimate --classic

Il flag --classic è necessario perché l’IDE deve accedere liberamente al filesystem del progetto, ai tool esterni, al terminale e alle configurazioni dell’utente. Senza, l’esperienza sarebbe troppo limitata per un uso reale.

Dopo l’installazione, verifica che il comando sia disponibile e che il pacchetto risulti installato:

snap list | grep -E 'intellij-idea-(community|ultimate)'
which intellij-idea-community 2>/dev/null || true

Su alcune installazioni il launcher viene esposto tramite menu grafico e non tramite un binario immediatamente intuitivo nel PATH. È normale: l’avvio dal menu resta il modo più pulito per la prima esecuzione. Se vuoi usare il terminale, spesso conviene aprire l’app una volta e poi creare un alias o un collegamento più comodo.

Installazione con tarball ufficiale in /opt

Il tarball ufficiale è il metodo che preferisco quando devo controllare esattamente dove finisce il software e come viene aggiornato. Non dipende da Snap, non introduce confinamenti e si presta bene a installazioni ripetibili. La contropartita è che l’aggiornamento lo gestisci tu.

Scarica il pacchetto dal sito JetBrains scegliendo la release Community o Ultimate. Poi estrailo in /opt o in una directory dedicata. Esempio:

cd /tmp
wget -O ideaIU.tar.gz https://download.jetbrains.com/idea/ideaIU-*.tar.gz
sudo mkdir -p /opt/jetbrains
sudo tar -xzf ideaIU.tar.gz -C /opt/jetbrains
sudo mv /opt/jetbrains/idea-IU-* /opt/jetbrains/intellij-idea

Se preferisci la Community, cambia il nome del file e della cartella di conseguenza. Il punto non è il nome esatto, ma mantenere un path stabile, per esempio /opt/jetbrains/intellij-idea. In questo modo gli aggiornamenti futuri possono avvenire sostituendo la directory con una nuova release e aggiornando il symlink, senza cambiare i riferimenti nel desktop launcher.

Per lanciare l’IDE dalla shell puoi usare lo script incluso:

/opt/jetbrains/intellij-idea/bin/idea.sh

La prima esecuzione può richiedere qualche secondo in più perché IntelliJ crea cache, plugin metadata e configurazioni utente. Se la finestra non compare subito, non significa che sia bloccato: controlla l’uso CPU e il processo Java prima di intervenire.

Creare un launcher desktop stabile

Con il tarball, il passaggio che molti saltano è il launcher desktop. Senza, finisci a cercare lo script ogni volta o a dipendere dal terminale. La soluzione corretta è generare un file .desktop nel profilo utente o a livello sistema.

Esempio per il singolo utente:

mkdir -p ~/.local/share/applications
cat > ~/.local/share/applications/intellij-idea.desktop <<'EOF'
[Desktop Entry]
Version=1.0
Type=Application
Name=IntelliJ IDEA
Exec=/opt/jetbrains/intellij-idea/bin/idea.sh
Icon=/opt/jetbrains/intellij-idea/bin/idea.png
Terminal=false
Categories=Development;IDE;
StartupWMClass=jetbrains-idea
EOF
chmod +x ~/.local/share/applications/intellij-idea.desktop

Dopo averlo creato, verifica che il file sia leggibile dal desktop environment e che l’icona punti a un file esistente:

test -f ~/.local/share/applications/intellij-idea.desktop && echo OK
ls -l /opt/jetbrains/intellij-idea/bin/idea.png

Se l’icona non compare, il problema di solito non è l’IDE ma il path nel launcher o la cache del desktop environment. In quel caso ricarica la sessione grafica o aggiorna la cache delle applicazioni, senza toccare l’installazione principale.

Java: usare quello incluso o quello di sistema

IntelliJ IDEA include il proprio runtime e nella maggior parte dei casi è la scelta giusta. È il modo più semplice per evitare incompatibilità tra versioni di OpenJDK installate sul sistema e requisiti dell’IDE. Se però devi uniformarti a una policy aziendale o testare plugin che dipendono da una specifica JVM, allora ha senso controllare le alternative.

Per vedere quali Java sono presenti sul sistema:

update-alternatives --list java 2>/dev/null || true
java -version 2>/dev/null || true

Su Ubuntu 24.04 la JVM di sistema può essere più recente, ma questo non significa che sia la scelta migliore per l’IDE. Il runtime incluso da JetBrains di solito riduce i problemi operativi. Se vuoi forzare un Java esterno, fallo solo dopo aver verificato che il plugin o il progetto lo richiedano davvero.

Aggiornamento e rollback senza sorprese

Con Snap, l’aggiornamento è automatico e gestito dal sistema. Se vuoi forzarlo o controllarlo, puoi usare:

sudo snap refresh intellij-idea-community
snap info intellij-idea-community

Con il tarball, l’update è manuale ma prevedibile: scarichi la nuova release, la estrai in una directory nuova e poi aggiorni il symlink o il launcher. Esempio di approccio semplice:

sudo mv /opt/jetbrains/intellij-idea /opt/jetbrains/intellij-idea.old
sudo tar -xzf ideaIU-new.tar.gz -C /opt/jetbrains
sudo mv /opt/jetbrains/idea-IU-* /opt/jetbrains/intellij-idea

Rollback: se la nuova versione non parte o rompe plugin importanti, rimetti il vecchio path al posto del nuovo. È il vantaggio di avere una directory stabile e una copia precedente ancora disponibile. Prima di cancellare la versione vecchia, prova almeno un avvio e verifica i plugin critici.

Problemi tipici su Ubuntu 20.04, 22.04 e 24.04

Il problema più comune non è l’installazione in sé, ma l’ambiente circostante. Su Ubuntu 20.04 puoi incontrare librerie e componenti desktop più vecchi; su 22.04 e 24.04, invece, i problemi più frequenti sono legati a Wayland, scaling HiDPI, font e integrazione con il file chooser.

Se l’IDE non si apre o mostra una finestra vuota, controlla il log utente. Il percorso tipico è nella home dell’utente sotto la configurazione di JetBrains. Una verifica rapida:

find ~/.cache ~/.config -maxdepth 3 -iname '*idea*' 2>/dev/null | head
ls -lah ~/.cache/JetBrains 2>/dev/null || true

Se sospetti un problema grafico, avvia l’IDE da terminale e guarda gli errori immediati. Spesso il messaggio utile è già nel primo avvio, prima che il launcher mascheri il problema.

Se il problema è il consumo di memoria, non aumentare subito la RAM assegnata a caso. Prima osserva il comportamento reale: indicizzazione iniziale, progetto enorme, plugin pesanti o repository con molte dipendenze. La metrica utile qui è il tempo di avvio e la saturazione CPU/RAM nei primi minuti, non un’impressione a occhio.

Integrazione con progetti Java, PHP, Python e frontend

IntelliJ IDEA non serve solo per Java. Su Ubuntu LTS viene usato spesso anche per stack misti: backend Java, script Python, frontend Node, progetti PHP con plugin dedicati. Il punto da tenere fermo è che l’IDE non sostituisce i runtime del progetto: li orchestra. Quindi, dopo l’installazione, conviene sempre verificare toolchain e SDK.

Per Java, controlla il JDK configurato nel progetto. Per Node, Python o PHP, usa gli interpreter del sistema o quelli gestiti dal progetto, ma non mescolare percorsi a caso. Un controllo base lato shell è utile per confermare che il tool esista e risponda correttamente:

javac -version 2>/dev/null || true
node -v 2>/dev/null || true
python3 --version
php -v 2>/dev/null || true

Se uno di questi comandi non risponde, il problema non è IntelliJ IDEA ma l’ambiente di sviluppo del sistema. In quel caso installa il runtime richiesto con i pacchetti Ubuntu o con un gestore versione dedicato, poi riconfigura l’IDE.

Rimozione pulita e residui da controllare

La disinstallazione dipende dal metodo usato. Con Snap basta rimuovere il pacchetto:

sudo snap remove intellij-idea-community

Con il tarball, elimina la directory applicativa e il launcher utente se lo hai creato:

sudo rm -rf /opt/jetbrains/intellij-idea
rm -f ~/.local/share/applications/intellij-idea.desktop

Attenzione a non cancellare per errore cache e configurazioni personali se vuoi conservare impostazioni, keymap o plugin. I dati utente di IntelliJ stanno nel profilo dell’utente, non nella directory dell’applicazione. Se vuoi un reset completo, allora sì, ma va fatto consapevolmente e con backup prima di toccare ~/.config e ~/.cache.

Scelta consigliata in pratica

Per una workstation personale su Ubuntu 24.04 o 22.04, Snap è la scelta più rapida e con meno manutenzione. Per una macchina da lavoro dove vuoi un controllo più preciso su versioni, path e rollback, il tarball in /opt è più robusto. Su Ubuntu 20.04, entrambi i metodi funzionano, ma il tarball può risultare più prevedibile se vuoi isolarti da eventuali particolarità del sistema grafico o dei repository.

In ogni caso, il criterio corretto non è “quale metodo è migliore in assoluto”, ma “quale riduce gli errori operativi nel tuo contesto”. Se devi installare l’IDE su più postazioni, standardizza un solo metodo e documenta il path del launcher, il metodo di update e il punto di rollback. È lì che si risparmia tempo, non nel clic iniziale di installazione.