How to Install Kotlin on Ubuntu 26.04, 24.04 and 22.04

Kotlin’s command-line compiler is useful when you need to test JVM code, run a small script, or verify a build workflow without opening a full IDE. To install Kotlin on Ubuntu Linux with a current stable compiler, use SDKMAN for a per-user JVM toolchain, JetBrains’ GitHub release archive, the JetBrains-published Snap package, or Homebrew if you already manage developer tools with brew.

Ubuntu’s repository package exists, but Ubuntu 26.04, 24.04, and 22.04 still carry an old 1.3.x branch, so treat it as a legacy option rather than the default path for modern Kotlin development. SDKMAN works well when one user owns the toolchain, while the manual workflow resolves the latest stable GitHub release, refuses beta and release-candidate tags, verifies the official checksum, and installs the compiler under /opt/kotlin.

Install Kotlin on Ubuntu

Choose a Kotlin Installation Method on Ubuntu

Choose the method that matches how you want Kotlin updated and where you want the compiler stored. SDKMAN keeps Kotlin in your home directory and can switch project toolchains, the manual GitHub release method gives checksum-verified system-wide control, and Snap or Homebrew trade some control for package-manager convenience. The Ubuntu repository package stays available for legacy 1.3.x needs, not current compiler features.

Method	Source or Channel	Update Behavior	Best For	Trade-offs
SDKMAN	SDKMAN Kotlin candidate	sdk upgrade kotlin	Per-user JVM toolchains and project version switching	Requires SDKMAN in the user account and does not install a system-wide compiler
Manual GitHub release	GitHub stable release	Run update-kotlin-compiler	Current compiler with checksum verification	Requires a manual helper because APT does not own the files
Snap	Snapcraft latest/stable	Automatic Snap refreshes, or manual snap refresh	Simple JetBrains-published package on Ubuntu systems with Snap	Uses classic confinement and the Snap runtime layout
Ubuntu repository package	Ubuntu universe component	Normal APT upgrades	Legacy projects that specifically need Ubuntu’s packaged 1.3.x compiler	Very old compiler branch, with Java warnings possible on newer JDKs
Homebrew	Homebrew formula	brew upgrade kotlin	Systems where Homebrew already manages developer tools	Dependencies and updates live outside APT under the Homebrew prefix

For most Ubuntu development shells, choose SDKMAN when you already use JVM tools such as Java, Gradle, or Maven. Use the manual release method when you need a checksum-verified system-wide compiler, Snap when you want the quickest package-store path, APT only when a legacy 1.3.x compiler is acceptable, and Homebrew when brew already owns your developer tools.

Pick one method unless you deliberately want more than one Kotlin compiler. These methods can coexist, but your shell runs whichever kotlinc appears first on PATH. Check the active compiler with command -v kotlinc before troubleshooting version mismatches.

If SDKMAN is not installed yet, follow the Install SDKMAN on Ubuntu workflow first, then return to the SDKMAN install section. If you need command-line download background before using the manual method, review the curl command examples. If you plan to use Homebrew but have not installed it yet, start with the Homebrew on Ubuntu setup guide.

Update Ubuntu Before Installing Kotlin

Refresh the package index before any APT-backed step. This gives Ubuntu current dependency metadata for Java, curl, snapd, and archive tools; if SDKMAN and Java already work in the current shell, you can continue directly to the SDKMAN method.

sudo apt update

Most commands require sudo privileges. If your account cannot run sudo, configure an administrative user first with the Ubuntu sudoers workflow.

Install Kotlin with SDKMAN on Ubuntu

Use this method when SDKMAN is already installed in your user account. SDKMAN stores Kotlin under ~/.sdkman/candidates/kotlin, so it avoids replacing Ubuntu packages and works well when different projects need different JVM tools.

Load SDKMAN into the current terminal, install Java through SDKMAN only if no Java runtime is available, then install Kotlin from the current SDKMAN catalog.

source "$HOME/.sdkman/bin/sdkman-init.sh"
if ! command -v java >/dev/null 2>&1; then
  sdk install java
fi
sdk install kotlin
source "$HOME/.sdkman/bin/sdkman-init.sh"

When SDKMAN asks whether to make Java or Kotlin the default version, press Enter to accept unless you only want that candidate active in the current shell. Reloading SDKMAN after the install makes the new kotlinc path available in the same terminal before you verify it.

sdk current kotlin
case "$(command -v kotlinc)" in
  "$HOME"/.sdkman/*) echo "sdkman-kotlin-active" ;;
  *) command -v kotlinc ;;
esac
kotlinc -version 2>&1 | sed -n '1p'

Current default kotlin version 2.3.21
sdkman-kotlin-active
info: kotlinc-jvm 2.3.21 (JRE 25.0.3+9-LTS)

The JRE version can differ when SDKMAN uses a different Java candidate or when your shell falls back to Ubuntu’s system Java. The important checks are that sdk current kotlin reports a Kotlin version and the active kotlinc path comes from ~/.sdkman.

Install Kotlin Manually from GitHub Releases

The manual method follows JetBrains’ command-line compiler distribution but adds repeatable version resolution, checksum verification, and a stable PATH entry. Use this method when you want the newest stable Kotlin compiler without relying on Ubuntu’s older repository package.

Install Manual Method Prerequisites

Install curl, certificate support, unzip, and Ubuntu’s default headless JDK. Kotlin targets the JVM, so the compiler and the compiled examples need Java available.

sudo apt install curl ca-certificates unzip default-jdk-headless

Confirm that Java is available before downloading Kotlin.

java -version 2>&1 | sed -n '1p'

openjdk version "25.0.3-ea" 2026-04-21

The Java version shown depends on your Ubuntu release and enabled repositories. If you need a specific JDK branch for a project, set it deliberately instead of relying on the default package.

Resolve the Latest Stable Kotlin Release

Resolve the latest stable Kotlin tag through GitHub’s release redirect. The checks allow normal version tags such as v2.3.21 and stop if the resolved version looks like a beta, milestone, or release candidate.

KOTLIN_TAG=$(curl -fsSIL -o /dev/null -w '%{url_effective}' https://github.com/JetBrains/kotlin/releases/latest | sed -E 's#.*/tag/##')

case "$KOTLIN_TAG" in
  v[0-9]*) ;;
  *) echo "Could not resolve a Kotlin release tag."; exit 1 ;;
esac

KOTLIN_VERSION=${KOTLIN_TAG#v}

case "$KOTLIN_VERSION" in
  ''|*-Alpha*|*-alpha*|*-Beta*|*-beta*|*-RC*|*-rc*|*-M*|*-m*|*-Dev*|*-dev*) echo "Refusing prerelease Kotlin tag: $KOTLIN_VERSION"; exit 1 ;;
esac

printf 'Latest stable Kotlin: %s\n' "$KOTLIN_VERSION"

Latest stable Kotlin: 2.3.21

Run the download and extraction commands in the same terminal session so $KOTLIN_VERSION stays available.

Download and Verify the Kotlin Compiler

Download the compiler ZIP and its official SHA256 checksum from the same release. The checksum file published by JetBrains contains the hash only, so the command formats it with the local archive name before running sha256sum -c.

cd /tmp
ARCHIVE="kotlin-compiler-${KOTLIN_VERSION}.zip"
BASE_URL="https://github.com/JetBrains/kotlin/releases/download/v${KOTLIN_VERSION}"

curl -fsSL "${BASE_URL}/${ARCHIVE}" -o "$ARCHIVE"
curl -fsSL "${BASE_URL}/${ARCHIVE}.sha256" -o "${ARCHIVE}.sha256"
printf '%s  %s\n' "$(cat "${ARCHIVE}.sha256")" "$ARCHIVE" | sha256sum -c -

kotlin-compiler-2.3.21.zip: OK

Extract Kotlin and Add It to PATH

Install Kotlin under a versioned directory in /opt, then point /opt/kotlin at the active compiler. The guard stops if /opt/kotlin already exists as a real directory, which avoids accidentally nesting the symlink inside another installation.

if [ -e /opt/kotlin ] && [ ! -L /opt/kotlin ]; then
  echo "/opt/kotlin exists and is not a symlink. Move it before continuing."
  exit 1
fi

sudo rm -rf "/opt/kotlin-${KOTLIN_VERSION}"
sudo install -d -m 0755 "/opt/kotlin-${KOTLIN_VERSION}"
sudo unzip -q "$ARCHIVE" -d "/opt/kotlin-${KOTLIN_VERSION}"
sudo ln -sfn "/opt/kotlin-${KOTLIN_VERSION}/kotlinc" /opt/kotlin
printf '%s\n' "export PATH=/opt/kotlin/bin:\$PATH" | sudo tee /etc/profile.d/kotlin.sh >/dev/null
. /etc/profile.d/kotlin.sh
hash -r

Verify that your shell finds the manual compiler first.

command -v kotlinc
kotlinc -version
kotlin -version

/opt/kotlin/bin/kotlinc
info: kotlinc-jvm 2.3.21 (JRE 25.0.3-ea+7-Ubuntu-2)
Kotlin version 2.3.21-release-298 (JRE 25.0.3-ea+7-Ubuntu-2)

Remove the downloaded ZIP files after the compiler passes the version check.

rm -f "/tmp/${ARCHIVE}" "/tmp/${ARCHIVE}.sha256"

Create the Kotlin Manual Update Helper

Manual installations need an update workflow because SDKMAN, APT, Snap, and Homebrew do not own the files in /opt/kotlin. Create a small root-owned helper that repeats the same stable-release and checksum checks.

sudo tee /usr/local/bin/update-kotlin-compiler >/dev/null <<'EOF'
#!/usr/bin/env bash
set -euo pipefail

if [ "$(id -u)" -ne 0 ]; then
  echo "Run this helper with sudo: sudo update-kotlin-compiler" >&2
  exit 1
fi

for cmd in curl sed unzip sha256sum mktemp; do
  if ! command -v "$cmd" >/dev/null 2>&1; then
    echo "Missing required command: $cmd" >&2
    exit 1
  fi
done

KOTLIN_TAG=$(curl -fsSIL -o /dev/null -w '%{url_effective}' https://github.com/JetBrains/kotlin/releases/latest | sed -E 's#.*/tag/##')
case "$KOTLIN_TAG" in
  v[0-9]*) ;;
  *) echo "Could not resolve a Kotlin release tag." >&2; exit 1 ;;
esac

KOTLIN_VERSION=${KOTLIN_TAG#v}
case "$KOTLIN_VERSION" in
  ''|*-Alpha*|*-alpha*|*-Beta*|*-beta*|*-RC*|*-rc*|*-M*|*-m*|*-Dev*|*-dev*) echo "Refusing prerelease Kotlin tag: $KOTLIN_VERSION" >&2; exit 1 ;;
esac

INSTALL_DIR="/opt/kotlin-${KOTLIN_VERSION}"
LINK_DIR="/opt/kotlin"

if [ -e "$LINK_DIR" ] && [ ! -L "$LINK_DIR" ]; then
  echo "$LINK_DIR exists and is not a symlink. Move it before continuing." >&2
  exit 1
fi

if [ -x "${INSTALL_DIR}/kotlinc/bin/kotlinc" ] && [ "$(readlink -f "$LINK_DIR" 2>/dev/null || true)" = "${INSTALL_DIR}/kotlinc" ]; then
  echo "Kotlin ${KOTLIN_VERSION} is already installed at ${LINK_DIR}."
  "${LINK_DIR}/bin/kotlinc" -version
  exit 0
fi

WORK_DIR=$(mktemp -d)
TMP_DIR="/opt/.kotlin-${KOTLIN_VERSION}.tmp.$$"

cleanup() {
  rm -rf "$WORK_DIR" "$TMP_DIR"
}
trap cleanup EXIT

ARCHIVE="kotlin-compiler-${KOTLIN_VERSION}.zip"
BASE_URL="https://github.com/JetBrains/kotlin/releases/download/v${KOTLIN_VERSION}"

cd "$WORK_DIR"
curl -fsSL "${BASE_URL}/${ARCHIVE}" -o "$ARCHIVE"
curl -fsSL "${BASE_URL}/${ARCHIVE}.sha256" -o "${ARCHIVE}.sha256"
printf '%s  %s\n' "$(cat "${ARCHIVE}.sha256")" "$ARCHIVE" | sha256sum -c -

rm -rf "$TMP_DIR"
mkdir -p "$TMP_DIR"
unzip -q "$ARCHIVE" -d "$TMP_DIR"

if [ ! -x "${TMP_DIR}/kotlinc/bin/kotlinc" ]; then
  echo "Downloaded archive did not contain kotlinc/bin/kotlinc." >&2
  exit 1
fi

rm -rf "$INSTALL_DIR"
mv "$TMP_DIR" "$INSTALL_DIR"
ln -sfn "${INSTALL_DIR}/kotlinc" "$LINK_DIR"
printf '%s\n' "export PATH=/opt/kotlin/bin:\$PATH" > /etc/profile.d/kotlin.sh
chmod 0644 /etc/profile.d/kotlin.sh

echo "Kotlin ${KOTLIN_VERSION} installed at ${LINK_DIR}."
"${LINK_DIR}/bin/kotlinc" -version
EOF

sudo chmod 0755 /usr/local/bin/update-kotlin-compiler
command -v update-kotlin-compiler

/usr/local/bin/update-kotlin-compiler

Run the helper when you want to check for a newer stable Kotlin compiler.

sudo update-kotlin-compiler

Kotlin 2.3.21 is already installed at /opt/kotlin.
info: kotlinc-jvm 2.3.21 (JRE 25.0.3-ea+7-Ubuntu-2)

Install Kotlin with Snap on Ubuntu

The Kotlin Snap is maintained by JetBrains, tracks the current stable compiler, and uses classic confinement. This method is convenient on standard Ubuntu desktop and server systems where Snap is already available.

If snap is missing on a minimal or customized system, install snapd first.

sudo apt install snapd

Install the Kotlin Snap with classic confinement, then confirm the installed revision.

sudo snap install --classic kotlin
snap list kotlin

kotlin 2.3.21 from jetbrains** installed
Name    Version  Rev  Tracking       Publisher    Notes
kotlin  2.3.21   97   latest/stable  jetbrains**  classic

Verify the command path and compiler version. Snap exposes the standard kotlinc and kotlin commands under /snap/bin.

command -v kotlinc
kotlinc -version
kotlin -version

/snap/bin/kotlinc
info: kotlinc-jvm 2.3.21 (JRE 1.8.0_292-8u292-b10-0ubuntu1~16.04.1-b10)
Kotlin version 2.3.21-release-298 (JRE 1.8.0_292-8u292-b10-0ubuntu1~16.04.1-b10)

If a minimal system only installed snapd in the previous step and the path check does not find /snap/bin/kotlinc, open a new login shell or run the compiler directly as /snap/bin/kotlinc. Snap adds /snap/bin through profile scripts, so the current session can lag behind the package install.

Install Kotlin from Ubuntu’s Repository Package

Ubuntu’s repository package is useful when you want the distro-managed package and an older compiler is acceptable. It comes from the universe component on current Ubuntu releases, so minimal or customized systems may need the Ubuntu Universe setup guide before APT can locate it.

apt-cache policy kotlin | sed -n '1,3p'

kotlin:
  Installed: (none)
  Candidate: 1.3.31+ds1-3ubuntu1

Install the package only when that 1.3.x branch fits your project. Modern Kotlin code should use SDKMAN, the manual release, Snap, or Homebrew instead.

sudo apt install kotlin

Confirm that APT installed the compiler under /usr/bin.

command -v kotlinc
command -v kotlin
kotlinc -version
kotlin -version

/usr/bin/kotlinc
/usr/bin/kotlin
info: kotlinc-jvm 1.3-SNAPSHOT (JRE 25.0.3-ea+7-Ubuntu-2)
Kotlin version 1.3.31 (JRE 25.0.3-ea+7-Ubuntu-2)

On newer Java runtimes, the legacy compiler can print deprecation or restricted-access warnings before or after the version line. Those warnings do not necessarily mean the package failed, but they are another reason to prefer a current Kotlin compiler for new projects.

Install Kotlin with Homebrew on Ubuntu

Homebrew is a reasonable Kotlin option when brew already manages your developer toolchain. Avoid adding Homebrew just for Kotlin unless you also want its separate package prefix and update model.

brew update
brew install kotlin
brew list --versions kotlin

A successful Homebrew install prints a kotlin version line from the formula. Homebrew currently builds the formula from JetBrains’ stable compiler ZIP and depends on its own openjdk package.

Confirm that your shell resolves Homebrew’s Kotlin compiler. Homebrew installs formula dependencies in its own prefix, so the JRE path in version output can differ from Ubuntu’s default JDK.

command -v kotlinc
kotlinc -version

The path should point inside the Homebrew prefix, usually /home/linuxbrew/.linuxbrew/bin, when Homebrew is ahead of older Kotlin installs on PATH.

Compile and Run Kotlin on Ubuntu

After installation, compile a small Kotlin file into a runnable JAR. The sample prints the Kotlin compiler version and the JVM version so you can see which runtime is being used.

mkdir -p ~/kotlin-demo
cd ~/kotlin-demo

cat > hello.kt <<'EOF'
fun main() {
    println("Hello, Kotlin on Ubuntu!")
    println("Kotlin version: ${KotlinVersion.CURRENT}")
    println("JVM version: ${System.getProperty("java.version")}")
}
EOF

kotlinc hello.kt -include-runtime -d hello.jar
kotlin -classpath hello.jar HelloKt

Hello, Kotlin on Ubuntu!
Kotlin version: 2.3.21
JVM version: 25.0.3-ea

The generated main class is HelloKt because the file is named hello.kt. The Kotlin and JVM versions can differ by method; APT users will see the older 1.3.x compiler, the Snap package uses its bundled runtime, SDKMAN uses the active Java candidate or system Java on PATH, and the manual and Homebrew methods use the Java runtime available to their launchers.

Kotlin can also run scripts directly with kotlinc -script, which is useful for quick automation or compiler checks.

cat > hello.kts <<'EOF'
val os = System.getProperty("os.name")
val arch = System.getProperty("os.arch")
println("Kotlin script on $os ($arch)")
EOF

kotlinc -script hello.kts

Kotlin script on Linux (amd64)

JetBrains documents more compiler options in the official Kotlin command-line compiler documentation. For larger JVM projects, pair Kotlin with a build tool such as Apache Maven on Ubuntu.

Manage Kotlin Updates on Ubuntu

The update command depends on the installation method. Use only the command set that matches the method you installed.

Update Kotlin Installed with APT

APT updates the Ubuntu repository package with the rest of your system. This keeps the distro-managed 1.3.x package patched when Ubuntu publishes package updates, but it does not move the compiler to JetBrains’ current release line.

sudo apt update
sudo apt --only-upgrade install kotlin
kotlinc -version

Update Kotlin Installed with SDKMAN

SDKMAN refreshes its candidate metadata separately from APT. Update the catalog, upgrade the installed Kotlin candidate when SDKMAN offers a newer version, then confirm the active version.

source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk update
sdk upgrade kotlin
sdk current kotlin

Update a Manual Kotlin Installation

Run the helper to check GitHub’s latest stable release, verify the checksum, and repoint /opt/kotlin when a newer compiler is available.

sudo update-kotlin-compiler
. /etc/profile.d/kotlin.sh
kotlinc -version

Update Kotlin Installed with Snap

Snap refreshes packages automatically, but you can request a refresh and then verify the installed channel.

sudo snap refresh kotlin
snap list kotlin

Update Kotlin Installed with Homebrew

Use Homebrew’s normal update and upgrade flow when Kotlin was installed from the Homebrew formula.

brew update
brew upgrade kotlin
brew list --versions kotlin

Troubleshoot Kotlin on Ubuntu

Fix SDKMAN Kotlin Not Found or Wrong Compiler

If Kotlin was installed with SDKMAN but your shell still finds another compiler, reload SDKMAN and check the active Kotlin selection. This usually happens when the current terminal was opened before SDKMAN updated the shell path.

source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk current kotlin
case "$(command -v kotlinc)" in
  "$HOME"/.sdkman/*) echo "sdkman-kotlin-active" ;;
  *) command -v kotlinc ;;
esac

Current default kotlin version 2.3.21
sdkman-kotlin-active

If source "$HOME/.sdkman/bin/sdkman-init.sh" fails, SDKMAN is not installed or its files were removed. Reinstall it with the SDKMAN setup guide for Ubuntu, then run sdk install kotlin again.

Fix kotlinc Command Not Found After Manual Install

If the manual compiler exists but your shell cannot find it, reload the profile script and clear the shell’s command cache.

test -x /opt/kotlin/bin/kotlinc && echo kotlin-binary-present
. /etc/profile.d/kotlin.sh
hash -r
command -v kotlinc

kotlin-binary-present
/opt/kotlin/bin/kotlinc

Open a new terminal after changing files in /etc/profile.d if your current shell still does not load the updated PATH.

Fix Java Runtime Missing Errors

The manual compiler depends on a working Java runtime. Check for Java and reinstall Ubuntu’s default headless JDK if the command is missing.

command -v java || echo java-not-found

java-not-found

sudo apt install default-jdk-headless
java -version 2>&1 | sed -n '1p'

For systems with multiple JDK branches, set the intended runtime consistently. The Java environment path workflow for Ubuntu covers persistent Java path configuration.

Fix the Old APT Kotlin Package Taking Priority

If apt install kotlin gives you an old compiler, confirm the candidate version from Ubuntu’s repositories. On current Ubuntu releases, the repository candidate remains a 1.3.x package.

apt-cache policy kotlin | sed -n '1,3p'

kotlin:
  Installed: (none)
  Candidate: 1.3.31+ds1-3ubuntu1

Remove the old APT package before using the SDKMAN, manual, Snap, or Homebrew method if it is taking priority in your PATH.

sudo apt remove kotlin
hash -r
if command -v kotlinc >/dev/null 2>&1; then
  command -v kotlinc
  kotlinc -version 2>&1 | sed -n '1p'
else
  echo kotlinc-not-found
fi

Remove Kotlin from Ubuntu

Remove Kotlin with the command set that matches your installation method. Mixing removal commands can leave one method active while another one is removed.

Remove Kotlin Installed with APT

sudo apt remove kotlin
hash -r
command -v kotlinc || echo kotlinc-not-found

kotlinc-not-found

Preview unused dependencies afterward and remove them only if no other Java tools need them.

sudo apt autoremove --dry-run

If the preview only lists packages you no longer need, rerun the command without --dry-run.

sudo apt autoremove

Remove Kotlin Installed with SDKMAN

SDKMAN removes one candidate version at a time. Check the active version, then replace 2.3.21 with the Kotlin version shown by your shell. The --force option is required when that version is also the current default.

source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk current kotlin
sdk uninstall kotlin 2.3.21 --force

removed kotlin 2.3.21.

The next cleanup command deletes every SDKMAN-managed Kotlin version under ~/.sdkman/candidates/kotlin. Use it only when you want to remove all Kotlin versions managed by SDKMAN for the current user.

rm -rf "$HOME/.sdkman/candidates/kotlin"
hash -r
command -v kotlinc || echo kotlinc-not-found

kotlinc-not-found

Remove a Manual Kotlin Installation

These removal commands delete Kotlin directories under /opt, the profile script, and the manual update helper. Review the paths before running them on a system with custom Kotlin files under /opt.

sudo rm -rf /opt/kotlin /opt/kotlin-[0-9]*
sudo rm -f /etc/profile.d/kotlin.sh
sudo rm -f /usr/local/bin/update-kotlin-compiler
hash -r
command -v kotlinc || echo kotlinc-not-found

kotlinc-not-found

Remove Kotlin Installed with Snap

sudo snap remove --purge kotlin
snap list kotlin 2>/dev/null || echo "kotlin snap is not installed"

kotlin snap is not installed

Remove Kotlin Installed with Homebrew

brew uninstall kotlin
brew autoremove
brew list --versions kotlin || echo "kotlin formula is not installed"

kotlin formula is not installed

If you created the sample project in your home directory and no longer need it, remove only that sample directory.

This cleanup command deletes ~/kotlin-demo. Skip it if you reused that directory for real Kotlin code.

rm -rf ~/kotlin-demo

Conclusion

Kotlin is ready on Ubuntu once the compiler path, Java runtime, and update method all match the installation source you chose. Use SDKMAN for per-user JVM toolchains, the manual GitHub release flow for checksum-verified stable releases, Snap for automatic refreshes, APT only for the legacy Ubuntu package, or Homebrew when brew already owns your developer tools. For Android work, continue with Android Studio on Ubuntu.