After adding a newer Neovim, the regular nvim command can still open the older copy. I was curious how to try the new version without retiring the editor already in place.
A read-only lookup lets you see what will open before changing anything, keeping your current editor as a fallback. The first check is command -v nvim.
Check which Neovim command your shell will open
If no alias or function shadows nvim, the shell searches PATH from left to right and launches the first matching executable.
command -v nvim
type -a nvim
command -v shows the command your shell resolves, while type -a lists the matching aliases, functions, and executables. If the name resolves to a file, put that file’s bin directory first in PATH only when it is the build you want to open.
Choose a Neovim installation source
Neovim is a terminal text editor based on Vim, with its own executable and user configuration, and the official Neovim install page lists distribution packages and upstream downloads.
| Route | Use it when | Where it lives | Who updates it |
|---|---|---|---|
| Distribution package | You want the repository version and package-manager lifecycle | System package paths | Your Linux distribution |
| Upstream tar archive | You need the upstream build in a separate directory | A directory you own | You replace the extracted directory |
| AppImage | You want one file to run without a system package | A file you own | You replace the AppImage file |
Choose the package when its version meets your needs. The Ubuntu 24.04 Noble package page lists Neovim 0.9.5, while upstream stable is 0.12.5, so an upstream download fits a plugin that requires a newer version.
Check the architecture before choosing an upstream build
The upstream archive and AppImage have separate x86_64 and arm64 builds, so check uname before choosing one. This prevents downloading an executable built for another CPU.
uname -m
| uname result | Asset suffix |
|---|---|
| x86_64 | x86_64 |
| aarch64 or arm64 | arm64 |
- A distribution package selects the matching architecture for you.
- For another CPU type, use your distribution package unless Neovim publishes a matching upstream asset.
An upstream archive also needs a directory you can write to and a PATH entry that points to its bin directory. Keep it separate from a package-managed copy so you can tell which one the shell launches.
Install Neovim from a package or upstream release
Use a distribution package when its repository version fits your needs, because the package manager resolves dependencies and owns future upgrades.
1. Install the distribution package
The package manager installs a package named neovim, then makes the executable available as nvim.
| Distribution | Install command |
|---|---|
| Ubuntu or Debian | sudo apt install neovim |
| Fedora | sudo dnf install neovim |
| Arch Linux | sudo pacman -S neovim |
The package version follows your distribution release, not Neovim’s upstream release schedule. Arch users can follow the Pacman package synchronization and upgrade commands when they need to refresh packages and upgrade Neovim together.
2. Install the upstream tar archive
The tar archive keeps Neovim’s executable and runtime files together, so extract the complete directory instead of copying only the binary. This command maps x86_64 or ARM Linux to the official asset name and stores the files under your home directory.
case "$(uname -m)" in
x86_64) asset=x86_64 ;;
aarch64|arm64) asset=arm64 ;;
*) printf 'Unsupported architecture: %s\n' "$(uname -m)" >&2; exit 1 ;;
esac
curl -fLO "https://github.com/neovim/neovim/releases/latest/download/nvim-linux-${asset}.tar.gz"
mkdir -p "$HOME/.local/opt"
tar -xzf "nvim-linux-${asset}.tar.gz" -C "$HOME/.local/opt"
export PATH="$HOME/.local/opt/nvim-linux-${asset}/bin:$PATH"
nvim --version
That case statement maps uname’s result to the x86_64 or arm64 suffix, so curl fetches the matching archive and tar extracts its executable and runtime files under .local/opt. The curl download options reject failed HTTP responses, and the tar extraction options choose its destination.
I ran both upstream arm64 formats and each reported NVIM v0.12.5. The Release line distinguishes this build from a distribution package, which can carry another version.
For a persistent PATH change, add the matching directory to ~/.bashrc for Bash or ~/.zshrc for Zsh, replacing the asset variable with x86_64 or arm64. Open a new terminal after saving the file, then use the apt package listing command before moving an Ubuntu-managed copy behind an upstream build.
3. Try the upstream AppImage
An AppImage is a single executable file, so you can run it without extracting a directory or installing a system package. Use the asset name for the architecture you found above.
case "$(uname -m)" in
x86_64) asset=x86_64 ;;
aarch64|arm64) asset=arm64 ;;
*) printf 'Unsupported architecture: %s\n' "$(uname -m)" >&2; exit 1 ;;
esac
curl -fLO "https://github.com/neovim/neovim/releases/latest/download/nvim-linux-${asset}.appimage"
chmod u+x "nvim-linux-${asset}.appimage"
mkdir -p "$HOME/.local/bin"
mv -i "nvim-linux-${asset}.appimage" "$HOME/.local/bin/nvim"
export PATH="$HOME/.local/bin:$PATH"
command -v nvim
nvim --version
mv -i asks before replacing an existing nvim file in that directory. The command then adds your user-owned bin directory to PATH and prints the executable and version. To keep nvim available in later terminals, add this export to your Bash or Zsh startup file.
export PATH="$HOME/.local/bin:$PATH"
The AppImage installation guide covers desktop integration.
Fix a wrong version or missing nvim command
When the wrong build starts, use the earlier command lookup before reinstalling. Bash searches PATH from left to right, so an earlier package or manual copy can hide the one you meant to run.
| Symptom | What to check |
|---|---|
| The shell cannot find nvim | Add the installed bin directory to PATH or install the package named neovim. |
| An older version starts | Check every nvim match and the order of PATH entries. |
| The AppImage reports a FUSE error | Extract the image and run its AppRun file from the extracted directory. |
| The binary reports a GLIBC version error | Use a package built for your distribution or a supported upstream asset. |
Neovim’s upstream instructions provide an extraction route when FUSE is unavailable. Run it in the directory containing the downloaded AppImage, then launch the extracted AppRun executable.
./nvim-linux-arm64.appimage --appimage-extract
./squashfs-root/AppRun --version
For an x86_64 download, replace arm64 with x86_64 and run the commands from the directory containing that file. Extraction avoids the mount step but does not make a binary compatible with an older glibc.
Removing the archive or AppImage leaves your Neovim user configuration in its separate XDG directory.
Keep one Neovim installation ahead in PATH
Let one install source own updates. If you keep both a distribution package and an upstream copy, put the one you intend to use first in PATH and confirm its version before configuring plugins.
nvim --clean
Neovim opens without loading your usual configuration, which gives you a clean starting point. The Vim-family save and quit commands work here too.
Neovim installation questions
Neovim’s executable and user configuration live in separate locations, so removing the editor does not automatically remove your settings.
Does installing Neovim replace Vim?
No. Neovim uses the nvim executable and keeps its user configuration separate from Vim’s executable and configuration.
Which Linux install gives me the current stable Neovim release?
The upstream tar archive or AppImage follows Neovim’s stable release. A distribution package follows the version in that distribution’s repository, so check the result with nvim –version.
Can I run the Neovim AppImage without FUSE?
Yes. Run the AppImage with –appimage-extract, then start the extracted squashfs-root/AppRun file. This avoids the mount step but does not fix an incompatible glibc version.
Will removing Neovim delete my configuration?
The user configuration is stored separately under XDG_CONFIG_HOME/nvim, normally ~/.config/nvim. Removing an upstream archive or AppImage does not remove that directory, but check your distribution’s package-removal behavior before purging configuration files.