How to Install Neovim on Ubuntu (26.04, 24.04, 22.04)

This guide shows you how to install Neovim on Ubuntu using APT, PPAs, Snap, Flatpak, AppImage, pre-built tarballs, or a source build. If you pick the wrong method for your release, plugin requirements can break later, so this guide maps version differences first and then gives working install paths for Ubuntu 26.04 LTS, 24.04 LTS, and 22.04 LTS.

Neovim keeps Vim’s modal editing model and keybindings, then adds asynchronous jobs, a built-in terminal, and Lua-first configuration. Neovim includes an LSP client, but you still install language servers separately for each programming language.

Install Neovim on Ubuntu

Quick Start Install Neovim on Ubuntu

For the fastest path, install Neovim from Ubuntu’s default repository first, then verify the installed version:

sudo apt install neovim -y
nvim --version | head -n 1

Ubuntu 26.04: NVIM v0.11.6
Ubuntu 24.04: NVIM v0.9.5
Ubuntu 22.04: NVIM v0.6.1

If you need a newer build than your Ubuntu default, use the method comparison below and continue to the method-specific sections.

Default Neovim Versions by Ubuntu Release

Ubuntu 26.04 includes Neovim 0.11.x in the default repository, Ubuntu 24.04 includes 0.9.x, and Ubuntu 22.04 includes 0.6.x. If your plugin setup needs newer APIs, use one of the newer install paths below.

Ubuntu Release	Default Neovim Package	Support Status	Best For
Ubuntu 26.04 LTS	0.11.x	Current LTS (policy baseline)	Modern plugin compatibility from default repos
Ubuntu 24.04 LTS	0.9.x	Previous LTS	Stable systems that do not need 0.11+ features
Ubuntu 22.04 LTS	0.6.x	Older LTS	Long-lived hosts where stability outweighs new APIs

Compare Neovim Installation Paths on Ubuntu

Use this table to choose the install path that matches your Ubuntu release and update preference:

Method	Channel	Version Scope	Updates	Best For
Ubuntu Repository	Stable	22.04: 0.6.x, 24.04: 0.9.x, 26.04: 0.11.x	With APT system updates	Default, low-maintenance install
Neovim PPA (Stable)	Stable	0.7.x on 22.04, limited on 24.04, unavailable on 26.04	With APT updates	22.04 users who need newer than repo defaults
Neovim PPA (Unstable)	Nightly	22.04, 24.04, and 26.04 builds	With APT updates	Users needing bleeding-edge features
Snap	Stable / Edge	Current Snap channel build	Automatic via Snap	Simple updates with rollback support
Flatpak	Stable	Current Flathub stable build	Manual or automatic via Flatpak	Sandboxed install across distros
AppImage	Stable	Latest upstream release	Manual download	Portable, no package manager dependency
Pre-built Tarball	Stable	Latest upstream release	Manual download	Direct install under /opt
Build from Source	Stable branch or any commit	Any version/commit you select	Manual rebuild	Contributors and custom build workflows

Pick the Right Neovim Release Strategy on Ubuntu

Use the Ubuntu repository when the default version is enough for your workflow. If you need newer features like plugins that require Neovim 0.11+, use the unstable PPA, Flatpak, AppImage, tarball, or a source build.

For most desktop users, Snap or Flatpak gives the easiest path to recent builds. For servers or conservative hosts, APT from Ubuntu repositories is simpler to maintain. Use AppImage or tarball when you want to control exactly where Neovim lives without changing repository configuration.

This guide targets Ubuntu 26.04 LTS, 24.04 LTS, and 22.04 LTS. During verification, the unstable PPA published packages for all three releases, while the stable PPA provided useful updates mainly on 22.04, showed no newer candidate on 24.04, and did not publish a resolute Release file for 26.04. Snap, Flatpak, AppImage, tarball, and source methods work across all supported Ubuntu LTS releases.

Update Ubuntu Before You Install Neovim

Update your Ubuntu system before installing Neovim to ensure package compatibility and avoid dependency conflicts:

sudo apt update && sudo apt upgrade

Hit:1 http://archive.ubuntu.com/ubuntu noble InRelease
Reading package lists... Done
Building dependency tree... Done
Calculating upgrade... Done
All packages are up to date.

This guide uses sudo for commands that need elevated privileges. If your account does not have sudo access yet, follow our guide on adding a user to sudoers on Ubuntu, then return here.

This command refreshes your package list and installs any available system updates.

Install Neovim with APT (Ubuntu Repository or PPA)

Install Neovim from the Ubuntu Repository

The simplest method installs Neovim from the standard Ubuntu repository:

sudo apt install neovim

After installation completes, verify the installed version:

nvim --version

Ubuntu 26.04: NVIM v0.11.6
Ubuntu 24.04: NVIM v0.9.5
Ubuntu 22.04: NVIM v0.6.1

The version included in Ubuntu’s repository varies by release. Ubuntu 26.04 provides v0.11.x, Ubuntu 24.04 provides v0.9.x, and Ubuntu 22.04 provides v0.6.x. For newer features and recent updates, use the Neovim Team PPA instead.

Install Neovim from the Neovim Team PPA

The Neovim Team maintains two PPAs on Launchpad with different version support and update schedules. Understanding which PPA supports your Ubuntu release prevents installation errors.

Stable PPA (Best fit: Ubuntu 22.04)

The stable PPA currently provides a newer Neovim candidate on Ubuntu 22.04 (Jammy). On Ubuntu 24.04 (Noble), adding it may still leave the Ubuntu archive package as the candidate. On Ubuntu 26.04 (Resolute), apt update returns a missing Release-file error for this PPA.

Ubuntu 22.04 users can add the stable PPA with:

sudo add-apt-repository ppa:neovim-ppa/stable -y

Unstable PPA (Ubuntu 22.04, 24.04, and 26.04)

The unstable PPA publishes nightly builds for Ubuntu 22.04, 24.04, and 26.04. Use this PPA when you need features newer than the Ubuntu repository package.

sudo add-apt-repository ppa:neovim-ppa/unstable -y

After adding your chosen PPA, update the package index and install Neovim:

sudo apt update && sudo apt install neovim -y

Confirm the PPA version by checking the package policy:

apt-cache policy neovim

The output displays the installed version and confirms the source repository. Look for the PPA URL in the version table to confirm the package came from your chosen PPA rather than the Ubuntu repository:

neovim:
  Installed: 0.12.0~ubuntu1+git202601110810-d62bbe24cb-793e58f65d-e9f8804254~ubuntu24.04.1
  Candidate: 0.12.0~ubuntu1+git202601110810-d62bbe24cb-793e58f65d-e9f8804254~ubuntu24.04.1
  Version table:
 *** 0.12.0~ubuntu1+git202601110810-d62bbe24cb-793e58f65d-e9f8804254~ubuntu24.04.1 500
        500 https://ppa.launchpadcontent.net/neovim-ppa/unstable/ubuntu noble/main amd64 Packages
        100 /var/lib/dpkg/status
     0.9.5-6ubuntu2 500
        500 http://archive.ubuntu.com/ubuntu noble/universe amd64 Packages

If you are on Ubuntu 24.04 and apt-cache policy still shows the Ubuntu repository as the candidate after adding the stable PPA, switch to the unstable PPA. If you are on Ubuntu 26.04, remove the stable PPA because it does not publish a resolute Release file.

Install Neovim with Snap Packages on Ubuntu

Snap provides an alternative installation method for Neovim on Ubuntu. Your Ubuntu desktop should already have Snap installed unless you removed it.

Snap refreshes packages automatically, so this method works well if you want low-maintenance updates. Depending on maintainer cadence, the stable Snap channel may lag behind the latest GitHub release.

Prepare Snap Support

If you’ve uninstalled snapd from your system, reinstall it so the Snap daemon can manage packages:

sudo apt install snapd

Ensure the system-wide /snap mount point exists before Classic snaps attempt to bind to it. This script checks if /snap exists and creates a symbolic link to the actual snap directory if missing. If you want a refresher on symlink behavior, see our guide on creating symbolic links in Ubuntu.

if [ ! -e /snap ]; then
  sudo ln -s /var/lib/snapd/snap /snap
fi

The -e flag checks for file existence, and ln -s creates a symbolic link that points from /snap to where snapd stores packages.

Install the Snap core files to prevent conflicts and guarantee base runtimes are available:

sudo snap install core

Install the Neovim Snap

After the prerequisites finish, install Neovim with classic confinement so the editor can access your entire filesystem:

sudo snap install nvim --classic

After installation completes, confirm the Snap package:

snap list nvim

The output shows the installed version and confirms classic confinement:

Name  Version   Rev    Tracking       Publisher  Notes
nvim  v0.11.5   4611   latest/stable  neovim     classic

Snap will now refresh the package automatically in the background, reducing manual upkeep.

Install Neovim from Flatpak on Ubuntu

Flatpak provides another installation option with a sandboxed application environment that isolates Neovim from system libraries. Add the Flathub repository that hosts the Neovim package.

Flatpak is not pre-installed on Ubuntu. If you have not set it up yet, install it with sudo apt install flatpak and restart your session before continuing. For detailed setup including the Flathub repository, follow our Flatpak installation guide for Ubuntu.

Open the terminal and add the Flathub repository with this command:

sudo flatpak remote-add --if-not-exists --system flathub https://flathub.org/repo/flathub.flatpakrepo

Install Neovim system-wide with this Flatpak command:

sudo flatpak install --system flathub io.neovim.nvim -y

After installation completes, confirm the Flatpak package:

flatpak info --system --show-version io.neovim.nvim

The output confirms successful installation by printing the installed version:

0.11.6

To launch the Flatpak version, run flatpak run io.neovim.nvim from any terminal.

Install Neovim on Ubuntu with AppImage (Portable)

Alternatively, AppImage provides a portable, distribution-agnostic package that runs on most Linux systems without installation. This method works well for systems where you lack root access or need to run Neovim without affecting the system. The AppImage contains all dependencies and runs in isolation.

Download and Test the AppImage

Download the latest stable AppImage from the official Neovim releases. The commands below target x86_64; on ARM64, replace x86_64 with arm64 in the filename.

curl -LO https://github.com/neovim/neovim/releases/latest/download/nvim-linux-x86_64.appimage

Make the AppImage executable. The u+x syntax grants execute permission to the file owner (you) so the system can run it as a program:

chmod u+x nvim-linux-x86_64.appimage

Then launch the AppImage to confirm it runs correctly:

./nvim-linux-x86_64.appimage

If the AppImage fails to run at this stage (older systems or FUSE issues), extract the contents manually and run the binary directly. The --appimage-extract flag unpacks the AppImage into a squashfs-root directory, and AppRun is the actual executable inside:

./nvim-linux-x86_64.appimage --appimage-extract
./squashfs-root/AppRun --version

NVIM v0.11.6
Build type: Release

Enable System-wide Access to the AppImage

Once the AppImage passes basic testing, move it to a standard directory and create a consistent command path:

sudo mkdir -p /opt/nvim
sudo mv nvim-linux-x86_64.appimage /opt/nvim/nvim

Bash users can append the directory once and reload the shell. The script below adds a short PATH block with clearly labeled comments so you can remove it later without hunting through the file. The grep -q command searches quietly (no output), 2>/dev/null suppresses errors if the file doesn’t exist, and the ! negates the result so the command only runs when the block isn’t present:

if ! grep -q "NEOVIM_APPIMAGE_PATH" ~/.bashrc 2>/dev/null; then
  cat <<'EOF' >> ~/.bashrc
# NEOVIM_APPIMAGE_PATH_START
if [[ ":$PATH:" != *":/opt/nvim:"* ]]; then
  export PATH="$PATH:/opt/nvim"
fi
# NEOVIM_APPIMAGE_PATH_END
EOF
fi
source ~/.bashrc

The # NEOVIM_APPIMAGE_PATH_START/END markers keep the export grouped for easy removal, and the source command reloads your shell configuration immediately so the new PATH takes effect without logging out.

Zsh users should add the same export to ~/.zshrc and reload the configuration:

if ! grep -q "NEOVIM_APPIMAGE_PATH" ~/.zshrc 2>/dev/null; then
  cat <<'EOF' >> ~/.zshrc
# NEOVIM_APPIMAGE_PATH_START
if [[ ":$PATH:" != *":/opt/nvim:"* ]]; then
  export PATH="$PATH:/opt/nvim"
fi
# NEOVIM_APPIMAGE_PATH_END
EOF
fi
source ~/.zshrc

After reloading your shell, running nvim launches the AppImage from any directory.

AppImage packages may not work on Linux distributions older than 4 years. If you encounter compatibility issues, use one of the package manager methods instead.

Install Neovim on Ubuntu from a Pre-built Tarball

Alternatively, pre-built tarballs offer a manual installation method that gives you control over the installation location without requiring package managers. This approach works when you need specific versions or want to isolate Neovim from system package management.

Download and Extract the Tarball

Begin by downloading the latest stable release tarball for your architecture using curl:

curl -LO https://github.com/neovim/neovim/releases/latest/download/nvim-linux-x86_64.tar.gz

Remove any existing installation to avoid conflicts:

sudo rm -rf /opt/nvim-linux-x86_64

Then extract the tarball to /opt. The -C /opt flag changes to that directory before extracting, -x extracts files, -z decompresses gzip archives, and -f specifies the filename:

sudo tar -C /opt -xzf nvim-linux-x86_64.tar.gz

Add the Tarball Build to PATH

Add Neovim to your PATH by editing the shell configuration file only once. Bash users can run:

if ! grep -q "NEOVIM_TARBALL_PATH" ~/.bashrc 2>/dev/null; then
  cat <<'EOF' >> ~/.bashrc
# NEOVIM_TARBALL_PATH_START
if [[ ":$PATH:" != *":/opt/nvim-linux-x86_64/bin:"* ]]; then
  export PATH="$PATH:/opt/nvim-linux-x86_64/bin"
fi
# NEOVIM_TARBALL_PATH_END
EOF
fi
source ~/.bashrc

The # NEOVIM_TARBALL_PATH_START/END markers collect this export so you can delete the entire block automatically during cleanup.

Zsh users should add the same export to ~/.zshrc:

if ! grep -q "NEOVIM_TARBALL_PATH" ~/.zshrc 2>/dev/null; then
  cat <<'EOF' >> ~/.zshrc
# NEOVIM_TARBALL_PATH_START
if [[ ":$PATH:" != *":/opt/nvim-linux-x86_64/bin:"* ]]; then
  export PATH="$PATH:/opt/nvim-linux-x86_64/bin"
fi
# NEOVIM_TARBALL_PATH_END
EOF
fi
source ~/.zshrc

Verify the installation:

nvim --version

The output confirms the installed version:

NVIM v0.11.6
Build type: Release
LuaJIT 2.1.1741730670

For ARM64 systems, replace nvim-linux-x86_64.tar.gz with nvim-linux-arm64.tar.gz in the download command.

Build Neovim from Source on Ubuntu

For maximum control, building from source gives you complete command over compilation options, allows testing development versions, and enables custom configurations for specific needs. This method requires build tools and is primarily for developers or users needing unreleased features.

Install Build Prerequisites

Beforehand, install the required development tools and libraries. The build process requires CMake for configuration management:

sudo apt install ninja-build gettext cmake unzip curl build-essential git -y

Clone and Build Neovim

Create a dedicated source directory and clone the Neovim repository using Git. Keeping the source in $HOME/src/neovim makes future updates straightforward since you can return to this directory to pull changes and rebuild:

mkdir -p ~/src
git clone https://github.com/neovim/neovim.git ~/src/neovim
cd ~/src/neovim

Check out the stable branch for the latest stable release. The git checkout command switches your working directory to the specified branch, giving you tested stable code instead of development versions:

git checkout stable

Build Neovim with release optimizations. The CMAKE_BUILD_TYPE=Release flag enables compiler optimizations that produce faster binaries by removing debugging symbols and applying performance tuning:

make CMAKE_BUILD_TYPE=Release

Install Neovim system-wide to /usr/local:

sudo make install

Alternatively, install to a custom location under your home directory to avoid requiring root privileges and simplify removal. The CMAKE_INSTALL_PREFIX flag tells the build system where to install files (default is /usr/local), and $HOME expands to your home directory path:

rm -rf build/
make CMAKE_BUILD_TYPE=Release CMAKE_EXTRA_FLAGS="-DCMAKE_INSTALL_PREFIX=$HOME/neovim"
make install

The rm -rf build/ command removes the previous build directory to ensure a clean build with the new installation prefix.

Bash users can add the new directory to their PATH with:

if ! grep -q "NEOVIM_SOURCE_PATH" ~/.bashrc 2>/dev/null; then
  cat <<'EOF' >> ~/.bashrc
# NEOVIM_SOURCE_PATH_START
if [[ ":$PATH:" != *":$HOME/neovim/bin:"* ]]; then
  export PATH="$HOME/neovim/bin:$PATH"
fi
# NEOVIM_SOURCE_PATH_END
EOF
fi
source ~/.bashrc

The source-path comment markers help you remove the entire block in one step if you later uninstall this custom build.

Zsh users should mirror the change inside ~/.zshrc:

if ! grep -q "NEOVIM_SOURCE_PATH" ~/.zshrc 2>/dev/null; then
  cat <<'EOF' >> ~/.zshrc
# NEOVIM_SOURCE_PATH_START
if [[ ":$PATH:" != *":$HOME/neovim/bin:"* ]]; then
  export PATH="$HOME/neovim/bin:$PATH"
fi
# NEOVIM_SOURCE_PATH_END
EOF
fi
source ~/.zshrc

Verify the installation shows the built version:

nvim --version

The output displays the version and build information:

NVIM v0.11.6
Build type: Release
LuaJIT 2.1.1741730670
Compilation: /usr/bin/cc -O3 -DNDEBUG

Building from the master branch provides development features but may contain bugs. Production systems should use the stable branch or tagged releases.

Launch Neovim on Ubuntu via CLI or GUI

Launch Neovim using commands specific to your installation method.

Launch Neovim from APT or PPA Installation

If you installed Neovim using the Ubuntu repository or PPA, launch it with the standard command:

nvim

If you prefer typing neovim, create an alias in your shell configuration. This script works identically to the PATH modification commands shown earlier, checking if the alias exists before adding it to prevent duplicates (swap ~/.bashrc with ~/.zshrc when needed):

if ! grep -q "alias neovim='nvim'" ~/.bashrc 2>/dev/null; then
  echo "alias neovim='nvim'" >> ~/.bashrc
fi
source ~/.bashrc

Launch Neovim from Snap Installation

Snap installations use the snap-provided command:

nvim

Launch Neovim from Flatpak Installation

Flatpak installations launch through the application ID:

flatpak run io.neovim.nvim

Launch Neovim from AppImage, Tarball, or Source Installation

In these cases, AppImage, tarball, or source installations where you added the binary to your PATH launch with the standard command:

nvim

If you prefer to skip the PATH export, launch Neovim from the binary path that matches your installation.

AppImage builds live at /opt/nvim/nvim after you relocate the file:

/opt/nvim/nvim

Tarball extractions place the binary inside /opt/nvim-linux-x86_64/bin:

/opt/nvim-linux-x86_64/bin/nvim

Source installations default to /usr/local/bin/nvim:

/usr/local/bin/nvim

If you used the custom install prefix example, run the binary from your home directory:

$HOME/neovim/bin/nvim

Launch Neovim from Desktop GUI

Alternatively, desktop users can locate the Neovim application icon by navigating to Activities > Show Applications > Neovim. Add Neovim to your favorites for quick access.

Update and Remove Neovim on Ubuntu

Update Neovim

To stay current, keep Neovim updated by checking for new releases regularly. While some installation methods provide automatic updates, manual checks ensure you have the latest features and security fixes. Use the appropriate command for your installation method:

Update Neovim Installed via APT

For APT installations (Ubuntu repository or PPA), update only the Neovim package:

sudo apt update && sudo apt install --only-upgrade neovim -y

Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
neovim is already the newest version.

Update Neovim Installed via Flatpak

Flatpak installations update all Flatpak applications system-wide:

sudo flatpak update --system io.neovim.nvim

Update Neovim Installed via Snap

Snap installations refresh all snap packages:

sudo snap refresh nvim

Update Neovim Installed via AppImage

AppImage installations require manual updates. Download the latest version and replace the existing file. The mv command moves and renames the new AppImage to overwrite the old one in /opt/nvim/nvim:

curl -LO https://github.com/neovim/neovim/releases/latest/download/nvim-linux-x86_64.appimage
chmod u+x nvim-linux-x86_64.appimage
sudo mv nvim-linux-x86_64.appimage /opt/nvim/nvim

Update Neovim Installed via Pre-built Tarball

Tarball installations download the latest release and extract it to replace the existing version:

curl -LO https://github.com/neovim/neovim/releases/latest/download/nvim-linux-x86_64.tar.gz
sudo rm -rf /opt/nvim-linux-x86_64
sudo tar -C /opt -xzf nvim-linux-x86_64.tar.gz

Update Neovim Built from Source

Source builds require manual updates when new versions release. Navigate to your Neovim source directory, pull the latest changes, and rebuild. If you followed this guide, the source lives in ~/src/neovim:

cd ~/src/neovim
git fetch --tags
git checkout stable
git pull
rm -rf build/
make CMAKE_BUILD_TYPE=Release
sudo make install

If you installed to a custom location ($HOME/neovim), use the same prefix during rebuild:

cd ~/src/neovim
git fetch --tags
git checkout stable
git pull
rm -rf build/
make CMAKE_BUILD_TYPE=Release CMAKE_EXTRA_FLAGS="-DCMAKE_INSTALL_PREFIX=$HOME/neovim"
make install

Automate Source Updates with a Script

Users who compile from source often forget the exact rebuild steps months later. The following script automates the update process by checking for new releases, comparing versions, and rebuilding only when necessary. Create the script in your source directory:

cat <<'EOF' > ~/src/neovim/update-neovim.sh
#!/bin/bash
# Neovim Source Update Script
# Updates Neovim from the stable branch and rebuilds if needed

set -e

NVIM_SRC="$HOME/src/neovim"
INSTALL_PREFIX="/usr/local"  # Change to $HOME/neovim for user install

# Check prerequisites
if [ ! -d "$NVIM_SRC" ]; then
    echo "Error: Neovim source directory not found at $NVIM_SRC"
    exit 1
fi

cd "$NVIM_SRC"

# Get current installed version
CURRENT_VERSION=$(nvim --version 2>/dev/null | head -1 | awk '{print $2}' || echo "none")

# Fetch latest changes
echo "Fetching latest changes..."
git fetch --tags
git checkout stable
git pull

# Get new version from git
NEW_VERSION=$(git describe --tags --abbrev=0 2>/dev/null || echo "unknown")

if [ "$CURRENT_VERSION" = "$NEW_VERSION" ]; then
    echo "Already up to date: $CURRENT_VERSION"
    exit 0
fi

echo "Updating from $CURRENT_VERSION to $NEW_VERSION..."

# Clean and rebuild
rm -rf build/
echo "Building Neovim..."
make CMAKE_BUILD_TYPE=Release

# Install (adjust for custom prefix)
if [ "$INSTALL_PREFIX" = "/usr/local" ]; then
    echo "Installing to /usr/local (requires sudo)..."
    sudo make install
else
    echo "Installing to $INSTALL_PREFIX..."
    make CMAKE_EXTRA_FLAGS="-DCMAKE_INSTALL_PREFIX=$INSTALL_PREFIX" install
fi

echo "Update complete: $(nvim --version | head -1)"
EOF
chmod +x ~/src/neovim/update-neovim.sh

Run the script whenever you want to check for updates:

~/src/neovim/update-neovim.sh

Fetching latest changes...
Already up to date: v0.11.6

The script compares your installed version against the latest stable tag, skipping the rebuild if versions match. Edit the INSTALL_PREFIX variable inside the script if you used a custom installation location. Run this script manually when needed instead of scheduling unattended cron updates.

Remove Neovim

When you no longer need Neovim, uninstall it using the method that matches your original installation. These steps remove the application and clean up leftover files.

Review every rm -rf path before pressing Enter. These commands permanently delete directories and cannot be undone.

Remove Neovim Installed via APT

For APT installations, uninstall Neovim with this command:

sudo apt remove --purge neovim -y

Remove orphaned dependencies that were installed alongside Neovim. This cleans up libraries like LuaJIT, x11 utilities, and Python bindings that are no longer needed:

sudo apt autoremove -y

If you installed Neovim using one of the PPAs, remove them with these commands:

Remove Neovim Stable PPA:

sudo add-apt-repository --remove ppa:neovim-ppa/stable -y

Remove Neovim Unstable PPA:

sudo add-apt-repository --remove ppa:neovim-ppa/unstable -y

Refresh APT metadata and confirm only Ubuntu repository entries remain:

sudo apt update && apt-cache policy neovim

neovim:
  Installed: (none)
  Candidate: 0.9.5-6ubuntu2
  Version table:
     0.9.5-6ubuntu2 500
        500 http://archive.ubuntu.com/ubuntu noble/universe amd64 Packages

Remove Neovim Installed via Flatpak

Flatpak installations uninstall Neovim and its data:

sudo flatpak remove --system --delete-data io.neovim.nvim -y

Remove Neovim Installed via Snap

Snap installations remove Neovim with this command:

sudo snap remove nvim

Remove Neovim Installed via AppImage

For AppImage builds, remove the AppImage file and clean up PATH modifications:

sudo rm -rf /opt/nvim

Remove the PATH block you added earlier. Run the command that matches your shell configuration file:

if [ -f ~/.bashrc ]; then
  sed -i '/# NEOVIM_APPIMAGE_PATH_START/,/# NEOVIM_APPIMAGE_PATH_END/d' ~/.bashrc
fi

if [ -f ~/.zshrc ]; then
  sed -i '/# NEOVIM_APPIMAGE_PATH_START/,/# NEOVIM_APPIMAGE_PATH_END/d' ~/.zshrc
fi

Remove Neovim Installed via Pre-built Tarball

Tarball installations remove the extracted directory and clean up PATH modifications:

sudo rm -rf /opt/nvim-linux-x86_64

Remove the PATH block using the following commands for the shell files you edited:

if [ -f ~/.bashrc ]; then
  sed -i '/# NEOVIM_TARBALL_PATH_START/,/# NEOVIM_TARBALL_PATH_END/d' ~/.bashrc
fi

if [ -f ~/.zshrc ]; then
  sed -i '/# NEOVIM_TARBALL_PATH_START/,/# NEOVIM_TARBALL_PATH_END/d' ~/.zshrc
fi

Remove Neovim Built from Source

For source installations to /usr/local, use the CMake uninstall target from the source directory. The --build build/ flag specifies the build directory, and --target uninstall runs the uninstall rules defined by the build system:

cd ~/src/neovim
sudo cmake --build build/ --target uninstall

Alternatively, manually remove the installation artifacts. The binary lives in /usr/local/bin/nvim, and support files (runtime files, documentation, syntax definitions) reside in /usr/local/share/nvim/:

sudo rm /usr/local/bin/nvim
sudo rm -r /usr/local/share/nvim/

If you installed to a custom location ($HOME/neovim), remove that directory and delete the PATH block:

rm -rf ~/neovim

if [ -f ~/.bashrc ]; then
  sed -i '/# NEOVIM_SOURCE_PATH_START/,/# NEOVIM_SOURCE_PATH_END/d' ~/.bashrc
fi
if [ -f ~/.zshrc ]; then
  sed -i '/# NEOVIM_SOURCE_PATH_START/,/# NEOVIM_SOURCE_PATH_END/d' ~/.zshrc
fi

Optionally, remove the source directory if you no longer need it for future updates:

rm -rf ~/src/neovim

The sed commands above erase the exact comment block you added earlier, ensuring your shell configuration stays tidy.

Remove Neovim User Configuration Files

Uninstalling Neovim does not remove your personal configuration files and plugin data. Remove these directories for a complete cleanup:

These commands permanently delete your Neovim configuration, installed plugins, and state history. Back up these directories first if you might restore your setup later.

rm -rf ~/.config/nvim
rm -rf ~/.local/share/nvim
rm -rf ~/.local/state/nvim

The ~/.config/nvim directory stores your init.lua or init.vim configuration file and plugin settings. The ~/.local/share/nvim directory contains plugin installations, shada (shared data) files, and swap files. The ~/.local/state/nvim directory holds undo history and session data. Back up these directories before deletion if you plan to reinstall Neovim later.

Troubleshoot Common Neovim Issues on Ubuntu

AppImage Fails with FUSE Error

If AppImage launch fails with a FUSE error, install the required compatibility package for your Ubuntu release.

dlopen(): error loading libfuse.so.2
AppImages require FUSE to run.

sudo apt install libfuse2

On Ubuntu 24.04 and 26.04, the package name includes a transition suffix:

sudo apt install libfuse2t64

After installing the package, verify AppImage launch again:

./nvim-linux-x86_64.appimage --version | head -n 1

NVIM v0.11.6

nvim Command Not Found After Tarball or Source Install

If your terminal cannot find nvim after tarball or source installation, first confirm the error and then check whether your shell PATH contains the Neovim binary directory.

bash: nvim: command not found

command -v nvim
echo "$PATH"

If command -v nvim returns nothing, reload the shell file where you added the PATH block:

source ~/.bashrc

Open a new terminal and rerun command -v nvim. It should return a full binary path such as /opt/nvim-linux-x86_64/bin/nvim or /usr/local/bin/nvim.

Stable PPA Does Not Provide a Newer Candidate

If apt-cache policy neovim still points to the Ubuntu archive after adding the stable PPA, your release is not getting a newer stable-PPA build. During validation, Ubuntu 24.04 kept the Ubuntu archive candidate and Ubuntu 26.04 lacked a stable-PPA Release file.

sudo add-apt-repository --remove ppa:neovim-ppa/stable -y
sudo add-apt-repository ppa:neovim-ppa/unstable -y
sudo apt update && sudo apt install neovim -y

For the newest stable release instead of nightly builds, use Snap, Flatpak, AppImage, or the pre-built tarball method.

Frequently Asked Questions About Installing Neovim on Ubuntu

Conclusion

To install Neovim on Ubuntu, choose the simplest method that still meets your version requirement. Use Ubuntu repositories when stability matters most, switch to unstable PPA or universal packages when plugins require newer Neovim APIs, and use AppImage, tarball, or source builds only when you need explicit path or build control.