How to Install GoLand on Ubuntu 26.04, 24.04 and 22.04

GoLand makes sense when your Go work has outgrown a text editor: refactoring, debugging, tests, modules, and database tooling live in one JetBrains IDE. To install GoLand on Ubuntu, use the official JetBrains Snap for the simplest managed setup, the unverified Flathub package for a sandboxed desktop app, or the community APT wrapper on amd64 systems if you specifically want upgrades routed through APT.

Install GoLand on Ubuntu

Start with the method that matches how you want updates handled. Snap is published by JetBrains and uses classic confinement, Flatpak installs from Flathub with sandboxing but is not verified by JetBrains, and the APT repository is an unofficial wrapper that downloads the current JetBrains archive into /opt/goland while adding /usr/bin/goland and a desktop launcher.

Method	Channel	Update Behavior	Best For	Trade-offs
Snap	JetBrains on Snapcraft	Automatic Snap refreshes	Most Ubuntu desktop users who want the official managed package	Uses classic confinement; current stable builds are available for amd64 and arm64
Flatpak	Flathub, not JetBrains-verified	Manual or software-center Flatpak updates	Users who prefer Flathub packaging and desktop sandboxing	Unverified wrapper; current Flathub builds are available for x86_64 and aarch64
Community APT wrapper	Jonas Groeger repository	apt upgrade updates the wrapper, then the wrapper downloads JetBrains’ archive	amd64 users who specifically want APT to manage the launcher package	Community source; the repository currently advertises amd64 and i386 package indexes, not arm64

Use Snap unless you have a clear reason to choose another path. It is the official JetBrains package for a short Ubuntu command-line install and refreshes automatically. Use JetBrains Toolbox from the official download page if you manage several JetBrains IDEs, need rollback or specific-version controls, or hit Snap-specific IDE issues. Choose Flatpak for stronger sandboxing if you accept Flathub packaging, or the community APT wrapper only if APT-managed updates matter more than staying on an official packaging channel.

If your search goal is the official GoLand download, use JetBrains’ GoLand download page. JetBrains documents Toolbox, standalone Linux tar.gz archives, and Snap; this Ubuntu article keeps the manual tarball path as a handoff because Snap and Toolbox provide cleaner update ownership for most desktop installs.

Ubuntu 26.04 (Resolute Raccoon), 24.04 (Noble Numbat), and 22.04 (Jammy Jellyfish) can use the Snap and Flatpak commands below. JetBrains’ GoLand documentation currently lists Ubuntu 24.04 and 22.04 LTS in its Linux system requirements, so treat Ubuntu 26.04 runtime issues as an upstream-support edge case. GoLand does not have a separate free Community Edition; JetBrains provides a trial, EAP builds, and qualifying free or discounted license options.

Install GoLand via Snap (Recommended)

Snap is preinstalled on standard Ubuntu desktop images, and the Snapcraft listing identifies JetBrains as the verified publisher for the GoLand Snap. Installed Snap output may show the publisher as jetbrains**, where the asterisks mark the verified account. This method keeps the install short while still giving the IDE the file-system access it needs through classic confinement.

Verify Snap Availability

Confirm that Snap is available before installing GoLand. Standard Ubuntu desktop installations include it, but minimal systems, WSL environments, or containers may not.

snap version

Relevant output includes the Snap and snapd versions, plus the detected Ubuntu release:

snap          2.75.2
snapd         2.75.2
series        16
ubuntu        26.04
kernel        7.0.0-14-generic
architecture  amd64

If Snap is missing, install snapd first:

sudo apt update
sudo apt install snapd -y

These commands use sudo for package installation and system-wide app setup. If your account is not configured for administrator access yet, follow the Ubuntu guide to add a new user to sudoers before continuing.

Install GoLand

Install GoLand with --classic. Classic confinement lets GoLand access project directories, Go toolchains, Git, and terminal integrations that a development IDE normally needs.

sudo snap install goland --classic

The download is roughly 1 GB, so the install may take several minutes. The confirmation line should show the current stable version from JetBrains:

goland 2026.1.3 from jetbrains** installed

Verify Installation

Finally, confirm the installation by checking the installed Snap packages:

snap list goland

You should see output showing the installed version:

Name    Version   Rev   Tracking       Publisher   Notes
goland  2026.1.3  494   latest/stable  jetbrains**  classic

Snap refreshes GoLand automatically, so manual updates are rarely needed.

Install GoLand via Flatpak and Flathub

Flatpak provides stronger application sandboxing than Snap classic confinement, but Ubuntu does not install Flatpak by default. Use this method if you already prefer Flathub for desktop apps or want GoLand isolated from most host paths unless permissions allow access.

The Flathub listing states that its GoLand package is not verified by, affiliated with, or supported by JetBrains. Use Snap or JetBrains’ official download page when you need a JetBrains-published source.

Install Flatpak

If Flatpak is not already installed, add it and configure the Flathub remote. The dedicated Flatpak installation guide for Ubuntu covers desktop integration in more detail.

sudo apt update
sudo apt install flatpak -y
sudo flatpak remote-add --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo

Confirm that Flathub is now configured at system scope:

flatpak remotes --columns=name,url

flathub  https://dl.flathub.org/repo/

After adding Flathub for the first time, log out and back in, or restart the system, so desktop launchers and software-center integration can refresh cleanly.

Install GoLand from Flathub

Once Flatpak and Flathub are configured, install GoLand from Flathub:

sudo flatpak install flathub com.jetbrains.GoLand -y

Flatpak downloads GoLand plus the required runtime. On a fresh Flatpak setup, the total download can exceed 1 GB because the runtime is installed alongside the app.

Verify Installation

After installation, confirm Flatpak knows the GoLand app ID and branch:

flatpak info com.jetbrains.GoLand

On an x86_64 Ubuntu desktop, relevant output includes:

          ID: com.jetbrains.GoLand
         Ref: app/com.jetbrains.GoLand/x86_64/stable
      Branch: stable
     Version: 2026.1.3
     Runtime: org.freedesktop.Sdk/x86_64/25.08

The Flatpak app ID stays com.jetbrains.GoLand for launch, update, and removal commands.

Install GoLand via Community APT Repository

Jonas Groeger’s repository packages JetBrains IDE launchers for Debian and Ubuntu. For GoLand, the package is a small wrapper: APT installs the launcher files, then the package downloads JetBrains’ Linux archive and extracts it under /opt/goland.

This is a community-maintained repository, not an official JetBrains product. Use the Snap package or JetBrains’ official download page when you want a source published directly by JetBrains. Use Snap or Flatpak on arm64/aarch64 systems because this wrapper method is documented here only for amd64 Ubuntu desktops.

Verify Architecture Support

Check your Ubuntu architecture before adding the community APT source. Continue with this method only when the command prints amd64:

dpkg --print-architecture

amd64

Update Package Index

Refresh your package index before adding the repository:

sudo apt update

Install Prerequisites

Install the tools required to download the signing key, verify HTTPS certificates, and convert the key into APT’s binary keyring format:

sudo apt install curl ca-certificates gnupg -y

Here, curl fetches remote files, ca-certificates validates HTTPS connections, and gnupg provides the gpg command. For more download and header-check examples, see the curl command guide.

Import the Repository GPG Key

Download and convert the repository’s GPG signing key. The --yes flag lets the command overwrite an older copy during reruns instead of stopping at an interactive prompt.

curl -fsSL https://s3.eu-central-1.amazonaws.com/jetbrains-ppa/0xA6E8698A.pub.asc | sudo gpg --dearmor --yes -o /usr/share/keyrings/jetbrains-ppa-archive-keyring.gpg

The -fsSL flags make curl fail on HTTP errors, suppress the progress meter, show errors, and follow redirects. The gpg --dearmor step converts the ASCII-armored key into the binary format APT expects for a dedicated keyring.

Add the Repository

Create the repository source in DEB822 format. The printf output is piped through sudo tee because normal shell redirection cannot write to root-owned files with sudo.

printf '%s\n' \
'Types: deb' \
'URIs: http://jetbrains-ppa.s3-website.eu-central-1.amazonaws.com' \
'Suites: any' \
'Components: main' \
'Architectures: amd64' \
'Signed-By: /usr/share/keyrings/jetbrains-ppa-archive-keyring.gpg' \
| sudo tee /etc/apt/sources.list.d/jetbrains-ppa.sources > /dev/null

Check the saved source file before refreshing APT:

cat /etc/apt/sources.list.d/jetbrains-ppa.sources

Types: deb
URIs: http://jetbrains-ppa.s3-website.eu-central-1.amazonaws.com
Suites: any
Components: main
Architectures: amd64
Signed-By: /usr/share/keyrings/jetbrains-ppa-archive-keyring.gpg

Refresh Package Index

Update APT so it fetches the package list from the new source:

sudo apt update

Confirm that the repository provides the GoLand package:

apt-cache policy goland

Relevant output includes the current package candidate and the any/main repository source:

goland:
  Installed: (none)
  Candidate: 2026.1.3
  Version table:
     2026.1.3 500
        500 http://jetbrains-ppa.s3-website.eu-central-1.amazonaws.com any/main amd64 Packages

Install GoLand

Install the GoLand wrapper package:

sudo apt install goland -y

The APT package itself is tiny, but its maintainer scripts download the JetBrains tar.gz archive during installation. The current wrapper downloads goland-2026.1.3.tar.gz, then extracts it under /opt/goland. Expect roughly a 1.2 GB download and several gigabytes of installed files.

Launch GoLand

GoLand is a desktop IDE, so launching it requires a graphical session. After installation, start it from the application menu or use the terminal command that matches your install method.

Launch from Applications Menu

The application menu is the easiest launch path on a normal Ubuntu desktop:

• Click the Activities button (top-left corner) or press the Super key
• Type “GoLand” in the search bar
• Click the GoLand icon to launch the IDE

Launch from Terminal

Alternatively, you can start GoLand from the command line. The command differs based on your installation method:

Snap installation:

snap run goland

Flatpak installation:

flatpak run com.jetbrains.GoLand

APT installation:

goland

On first launch, GoLand asks you to accept the license agreement, sign in or start the available trial, and optionally import settings from a previous JetBrains IDE.

Update GoLand

The update path depends on how you installed GoLand.

Update Snap Installation

Snap refreshes GoLand automatically in the background. To check immediately for a newer build, run:

sudo snap refresh goland

Update Flatpak Installation

For Flatpak installations, refresh the app from Flathub:

sudo flatpak update com.jetbrains.GoLand -y

Update APT Installation

When using the community APT repository, update the wrapper package through APT. A new wrapper version can download the matching JetBrains archive during the upgrade.

sudo apt update
sudo apt install --only-upgrade goland

In this command, the --only-upgrade flag updates GoLand only if an update is available, without installing it if missing.

Troubleshoot Common Issues

Use these checks for common GoLand setup issues after installation.

GoLand Cannot Find Go SDK

GoLand does not install the Go toolchain by itself. If the IDE shows “No SDK” warnings, install Go first and then point GoLand at the detected SDK path.

For Ubuntu’s package-managed Go toolchain, install golang-go:

sudo apt install golang-go -y

For a fuller method comparison, including upstream Go releases, see the guide to install Go on Ubuntu. After installing Go, print the SDK root path:

go env GOROOT

Open GoLand, then use File, Settings, Go, GOROOT and select the path printed by go env GOROOT.

For Flatpak installations, host paths appear inside the sandbox under /var/run/host. If go env GOROOT prints a path such as /usr/lib/go-1.xx, the Flatpak-visible path is /var/run/host/usr/lib/go-1.xx. Use the exact versioned path printed by your system.

APT Reports Conflicting Signed-By Values

If APT reports conflicting Signed-By values for the JetBrains PPA source, you likely have an older .list or differently named .sources file already configured. Keep only one JetBrains PPA source file, then refresh APT again.

sudo rm -f /etc/apt/sources.list.d/jetbrains.list /etc/apt/sources.list.d/jetbrains.sources /etc/apt/sources.list.d/jetbrains-ppa.list
sudo apt update

Flatpak GoLand Cannot Access Project Directories

Flatpak limits which host paths GoLand can see. If your projects live outside the normal home-directory paths exposed to the sandbox, add a per-user filesystem override for the project location.

flatpak override --user --filesystem=/path/to/projects com.jetbrains.GoLand

This command intentionally uses --user because the extra project-directory access belongs to your desktop account, even when the app itself was installed system-wide.

Fonts Appear Blurry or Incorrect

JetBrains IDEs render best with matching developer fonts installed. If text appears blurry or poorly spaced, install JetBrains Mono and Fira Code:

sudo apt install fonts-jetbrains-mono fonts-firacode -y

Once installed, restart GoLand and select your preferred font from File, Settings, Editor, Font.

On minimal Ubuntu systems, missing font packages usually mean the needed repository component is disabled. The Ubuntu guide to enable Universe and Multiverse repositories covers the repository setup.

Remove GoLand

Use the removal command that matches the installation method you chose.

Remove Snap Installation

To remove the Snap package, run:

sudo snap remove --purge goland

The --purge flag removes GoLand without keeping Snap’s automatic recovery snapshot. If you intentionally want that snapshot, omit --purge and run sudo snap saved afterward to confirm what Snap retained.

Remove Flatpak Installation

For Flatpak, remove the GoLand app from the same system scope used during installation:

If you added a per-user Flatpak filesystem override, reset it before removing the app:

flatpak override --user --reset com.jetbrains.GoLand

sudo flatpak uninstall com.jetbrains.GoLand -y

Then remove unused Flatpak runtimes if no other installed app needs them:

sudo flatpak uninstall --unused -y

Remove APT Installation

To uninstall the community APT wrapper and remove the extracted IDE under /opt/goland, run:

sudo apt remove goland -y

If you no longer need the Jonas Groeger repository, remove the source file and dedicated keyring, then refresh APT:

sudo rm -f /etc/apt/sources.list.d/jetbrains-ppa.sources
sudo rm -f /usr/share/keyrings/jetbrains-ppa-archive-keyring.gpg
sudo apt update

Remove User Configuration Data

The following commands permanently delete GoLand settings, project configurations, plugins, and cached data. Skip this step, or back up the directories first, if you plan to reinstall GoLand later and keep your settings.

JetBrains stores GoLand user data in your home directory. For Snap and APT installations, remove the standard JetBrains directories plus the Snap profile if it exists:

rm -rf ~/.config/JetBrains/GoLand*
rm -rf ~/.local/share/JetBrains/GoLand*
rm -rf ~/.cache/JetBrains/GoLand*
rm -rf ~/snap/goland

For Flatpak installations, sandboxed user data is stored separately:

rm -rf ~/.var/app/com.jetbrains.GoLand

Conclusion

GoLand is ready on Ubuntu through the official Snap, the unverified Flathub package, or the amd64 community APT wrapper, with launch and cleanup paths matched to each method. Install the Go SDK next if the IDE cannot find one, then use GoLand for module-aware editing, debugging, tests, and project refactoring.