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

Neovim is a modernized fork of Vim that extends the classic text editor with asynchronous plugins, a built-in terminal emulator, and Lua scripting capabilities. Unlike traditional Vim, Neovim delivers non-blocking operations that keep the editor responsive during heavy plugin activity, built-in LSP (Language Server Protocol) support for IDE-like features without external dependencies, and first-class Lua integration for faster, more maintainable configuration. The editor preserves Vim’s modal editing and keybindings while modernizing the plugin ecosystem and improving performance.

This guide covers installing Neovim on Ubuntu through the default APT repository, the Neovim Team PPA for latest releases, universal packages (Snap, Flatpak, AppImage), pre-built tarballs, and building from source. APT (Advanced Package Tool) is Ubuntu’s package manager, while a PPA (Personal Package Archive) is a community-hosted repository that delivers faster upstream releases. Snap and Flatpak are sandboxed package formats with their own stores, and AppImage bundles the program into a portable executable you can run from anywhere. You’ll learn how to choose the right installation method, launch Neovim, manage updates, and remove it when needed.

Choose Your Neovim Installation Method

Compare Neovim Installation Paths

Ubuntu offers multiple Neovim installation paths that balance stability, update frequency, and isolation. Understanding the differences helps you choose the method that matches your development needs and update preferences.

Method	Channel	Version	Updates	Best For
Ubuntu Repository	Stable	0.6.x–0.11.x (varies by release)	With system updates	Production systems prioritizing stability
Neovim PPA (Stable)	Stable	0.7.x (Ubuntu 22.04 only)	With apt upgrade	Ubuntu 22.04 users needing newer stable builds
Neovim PPA (Unstable)	Nightly	Development builds	With apt upgrade	Plugin developers, testing new features
Snap	Stable	Latest stable	Automatic	Users wanting automatic updates with rollback
Flatpak	Stable	Latest stable	Manual or automatic	Multi-distro users, sandboxed environments
AppImage	Stable	Latest stable	Manual download	Portable use, systems without root access
Pre-built Tarball	Stable	Latest stable	Manual download	Full control over installation location
Build from Source	Any branch	Any commit	Manual rebuild	Custom builds, contributing to Neovim

Pick the Right Release Strategy

Ubuntu’s default repository prioritizes stability over freshness, so versions lag behind upstream releases by months or years. The Neovim Team maintains two PPAs: the stable PPA provides newer builds than Ubuntu’s repository but only publishes packages for Ubuntu 22.04, while the unstable PPA offers nightly development builds for 22.04, 24.04, and 26.04. Snap and Flatpak deliver the latest stable releases with automatic updates in sandboxed environments, trading slightly slower startup times and more disk usage for isolation from system libraries. AppImage and pre-built tarballs work well for portable installations or systems where you lack root access. Building from source provides maximum control for developers who need custom compilation options or want to test unreleased features.

For most users on Ubuntu 24.04 or 26.04, Snap or Flatpak provides the best balance of current versions and easy updates. Ubuntu 22.04 users who want newer stable releases can use the stable PPA (version 0.7.x) or universal packages. Production systems should favor the default repository for maximum stability, while plugin developers benefit from the unstable PPA’s early access to API changes.

This guide supports Ubuntu 26.04 LTS, 24.04 LTS, and 22.04 LTS. The stable PPA only publishes Neovim packages for Ubuntu 22.04, while the unstable PPA supports all three LTS releases. Snap, Flatpak, AppImage, tarball, and source methods work across all Ubuntu versions.

Update Ubuntu Before Installing Neovim

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

sudo apt update && sudo apt upgrade

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

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 (Ubuntu 22.04 only)

The stable PPA provides tested releases but only publishes packages for Ubuntu 22.04 (Jammy). Ubuntu 24.04 and 26.04 users should skip this PPA and use the unstable PPA or alternative methods instead.

Ubuntu 22.04 users can add the stable PPA:

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

Unstable PPA (Ubuntu 22.04, 24.04, and 26.04)

The unstable PPA provides nightly development builds and supports all current Ubuntu LTS releases. Despite the name, these builds are functional for daily use, though they may occasionally include bugs from active development.

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

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+git202601150810-abc123-stable~ubuntu24.04.1
  Candidate: 0.12.0~ubuntu1+git202601150810-abc123-stable~ubuntu24.04.1
  Version table:
 *** 0.12.0~ubuntu1+git202601150810-abc123-stable~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 added the stable PPA on Ubuntu 24.04 or 26.04 and apt-cache policy shows the Ubuntu repository version instead of a PPA version, the stable PPA does not have packages for your release. Remove the stable PPA with sudo add-apt-repository --remove ppa:neovim-ppa/stable -y and use the unstable PPA or another installation method.

Install Neovim with Snap Packages

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

However, Snap is less popular than Flatpak across Linux distributions even though it comes from Canonical (Ubuntu’s developers) and integrates tightly with Ubuntu systems. Update frequency depends on the package maintainer, though Snap’s automatic update mechanism keeps applications current without manual intervention.

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 [ ! -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.4   4113   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 flathub https://flathub.org/repo/flathub.flatpakrepo

Install Neovim system-wide with this Flatpak command:

sudo flatpak install flathub io.neovim.nvim

After installation completes, confirm the Flatpak package:

flatpak list | grep -i neovim

The output confirms successful installation by displaying the application ID and version:

Neovim    io.neovim.nvim    0.11.5    stable    flathub    system

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

Run Neovim via 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 -L flag follows redirects (GitHub redirects to the actual file), and -O saves the file with its original name:

curl -LO https://github.com/neovim/neovim/releases/latest/download/nvim.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.appimage

Then launch the AppImage to confirm it runs correctly:

./nvim.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.appimage --appimage-extract
./squashfs-root/AppRun --version

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.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 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-linux64.tar.gz

Remove any existing installation to avoid conflicts:

sudo rm -rf /opt/nvim-linux64

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-linux64.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-linux64/bin:"* ]]; then
  export PATH="$PATH:/opt/nvim-linux64/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-linux64/bin:"* ]]; then
  export PATH="$PATH:/opt/nvim-linux64/bin"
fi
# NEOVIM_TARBALL_PATH_END
EOF
fi
source ~/.zshrc

Verify the installation:

nvim --version

The output confirms the installed version:

NVIM v0.11.5
Build type: Release
LuaJIT 2.1.1741730670

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

Build Neovim from Source

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

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.5
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 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-linux64/bin:

/opt/nvim-linux64/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

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 the package list and upgrade packages:

sudo apt update && sudo apt upgrade

Update Neovim Installed via Flatpak

Flatpak installations update all Flatpak applications system-wide:

sudo flatpak update

Update Neovim Installed via Snap

Snap installations refresh all snap packages:

sudo snap refresh

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.appimage
chmod u+x nvim.appimage
sudo mv nvim.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-linux64.tar.gz
sudo rm -rf /opt/nvim-linux64
sudo tar -C /opt -xzf nvim-linux64.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

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.

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.

Remove Neovim Installed via APT

For APT installations, uninstall Neovim with this command:

sudo apt remove neovim

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

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

Remove Neovim Installed via Flatpak

Flatpak installations uninstall Neovim and its data:

sudo flatpak remove --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-linux64

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:

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

AppImage Fails with FUSE Error

When running the AppImage, if you see an error mentioning FUSE, your system lacks the required FUSE library. On Ubuntu 22.04, install it with:

sudo apt install libfuse2

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

sudo apt install libfuse2t64

After installation, rerun the nvim.appimage command.

nvim Command Not Found After Tarball or Source Install

If your terminal cannot find the nvim command after tarball or source installation, verify your PATH includes the installation directory. Check the current PATH:

echo $PATH

The output should include your installation path (e.g., $HOME/neovim/bin for tarball or /usr/local/bin for source). If missing, reload your shell configuration:

source ~/.bashrc

Alternatively, open a new terminal session to apply the updated PATH settings.

Stable PPA Shows No New Version

The stable PPA only publishes Neovim packages for Ubuntu 22.04. If you added the stable PPA on Ubuntu 24.04 or 26.04 and apt-cache policy neovim still shows the Ubuntu repository version, remove the stable PPA and switch to the unstable PPA instead:

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

Ubuntu 26.04 users may find the unstable PPA less necessary since the default repository already provides Neovim v0.11.x. For the absolute latest stable release on any Ubuntu version, Snap, Flatpak, AppImage, or tarball installations provide consistent access to upstream releases.

Conclusion

Neovim delivers a modernized Vim experience with asynchronous plugins, Lua scripting, and a built-in terminal emulator. Ubuntu users can choose from multiple installation paths: the default repository for tested stability, Snap or Flatpak for the latest releases with automatic updates, AppImage and tarballs for portable deployments, the unstable PPA for development builds, and source compilation for maximum control. Match your installation method to your update preferences and version requirements to maintain an effective terminal-based development environment.