kevin/neovim
1
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2024-12-19 02:34:59 -07:00
Code Issues Packages Projects Releases Wiki Activity

docs: add installation and build guides from wiki to repo

Browse Source
This commit is contained in:
dundargoc 2023-12-12 16:42:02 +01:00 committed by dundargoc
parent c8223007d0
commit fbd0f6658f
4 changed files with 913 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

484
BUILD.md Normal file
View File

@ -0,0 +1,484 @@
- **IMPORTANT**: Before upgrading to a new version, **always check for [breaking changes](https://neovim.io/doc/user/news.html#news-breaking).**
## Quick start
1. Install [build prerequisites](#build-prerequisites) on your system
2. `git clone https://github.com/neovim/neovim`
3. `cd neovim && make CMAKE_BUILD_TYPE=RelWithDebInfo`
- If you want the **stable release**, also run `git checkout stable`.
- If you want to install to a custom location, set `CMAKE_INSTALL_PREFIX`. See also [Installing Neovim](https://github.com/neovim/neovim/wiki/Installing-Neovim#install-from-source).
- On BSD, use `gmake` instead of `make`.
- To build on Windows, see the [Building on Windows](#building-on-windows) section. _MSVC (Visual Studio) is recommended._
4. `sudo make install`
- Default install location is `/usr/local`
- On Debian/Ubuntu, instead of installing files directly with `sudo make install`, you can run `cd build && cpack -G DEB && sudo dpkg -i nvim-linux64.deb` to build DEB-package and install it. This should help ensuring the clean removal of installed files.
**Notes**:
- From the repository's root directory, running `make` will download and build all the needed dependencies and put the `nvim` executable in `build/bin`.
- Third-party dependencies (libuv, LuaJIT, etc.) are downloaded automatically to `.deps/`. See the [FAQ](FAQ#build-issues) if you have issues.
- After building, you can run the `nvim` executable without installing it by running `VIMRUNTIME=runtime ./build/bin/nvim`.
- If you plan to develop Neovim, install [Ninja](https://ninja-build.org/) for faster builds. It will automatically be used.
- Install [ccache](https://ccache.dev/) for faster rebuilds of Neovim. It's used by default. To disable it, use `CCACHE_DISABLE=true make`.
## Running tests
See [test/README.md](https://github.com/neovim/neovim/blob/master/test/README.md).
## Building
First make sure you installed the [build prerequisites](#build-prerequisites). Now that you have the dependencies, you can try other build targets explained below.
The _build type_ determines the level of used compiler optimizations and debug information:
- `Release`: Full compiler optimizations and no debug information. Expect the best performance from this build type. Often used by package maintainers.
- `Debug`: Full debug information; few optimizations. Use this for development to get meaningful output from debuggers like GDB or LLDB. This is the default if `CMAKE_BUILD_TYPE` is not specified.
- `RelWithDebInfo` ("Release With Debug Info"): Enables many optimizations and adds enough debug info so that when Neovim ever crashes, you can still get a backtrace.
So, for a release build, just use:
```
make CMAKE_BUILD_TYPE=Release
```
(Do not add a `-j` flag if `ninja` is installed! The build will be in parallel automatically.)
Afterwards, the `nvim` executable can be found in `build/bin`. To verify the build type after compilation, run:
```sh
./build/bin/nvim --version | grep ^Build
```
To install the executable to a certain location, use:
```
make CMAKE_INSTALL_PREFIX=$HOME/local/nvim install
```
CMake, our main build system, caches a lot of things in `build/CMakeCache.txt`. If you ever want to change `CMAKE_BUILD_TYPE` or `CMAKE_INSTALL_PREFIX`, run `rm -rf build` first. This is also required when rebuilding after a Git commit adds or removes files (including from `runtime`) — when in doubt, run `make distclean` (which is basically a shortcut for `rm -rf build .deps`).
By default (`USE_BUNDLED=1`), Neovim downloads and statically links its needed dependencies. In order to be able to use a debugger on these libraries, you might want to compile them with debug information as well:
<!-- THIS CAUSES SCREEN INTERFERENCE
```
make distclean
VERBOSE=1 DEBUG=1 make deps
```
-->
```
make distclean
make deps
```
## Building on Windows
### Windows / MSVC
**MSVC (Visual Studio) is the recommended way to build on Windows.** These steps were confirmed as of 2023.
1. Install [Visual Studio](https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community) (2017 or later) with the _Desktop development with C++_ workload.
- On 32-bit Windows, you will need [this workaround](https://developercommunity.visualstudio.com/content/problem/212989/ninja-binary-format.html).
2. Open the Neovim project folder.
- Visual Studio should detect the cmake files and automatically start building...
3. Choose the `nvim.exe (bin\nvim.exe)` target and hit F5.
- If the build fails, it may be because Visual Studio started the build with `x64-{Debug,Release}` before you switched the configuration to `x86-Release`.
- Right-click _CMakeLists.txt → Delete Cache_.
- Right-click _CMakeLists.txt → Generate Cache_.
- If you see an "access violation" from `ntdll`, you can ignore it and continue.
4. If you set an error like `msgpackc.dll not found`, try the `nvim.exe (Install)` target. Then switch back to `nvim.exe (bin\nvim.exe)`.
### Windows / MSVC PowerShell
To build from the command line (i.e. invoke the `cmake` commands yourself),
1. Ensure you have the Visual Studio environment variables, using any of the following:
- Using the [Visual Studio Developer Command Prompt or Visual Studio Developer PowerShell](https://learn.microsoft.com/en-us/visualstudio/ide/reference/command-prompt-powershell?view=vs-2022)
- Invoking `Import-VisualStudioVars` in PowerShell from [this PowerShell module](https://github.com/Pscx/Pscx)
- Invoking `VsDevCmd.bat` in Command Prompt
```
VsDevCmd.bat -arch=x64
```
This is to make sure that `luarocks` finds the Visual Studio installation, and doesn't fall back to MinGW with errors like:
```
'mingw32-gcc' is not recognized as an internal or external command
```
2. From the "Developer PowerShell" or "Developer Command Prompt":
```
cmake -S cmake.deps -B .deps -G Ninja -D CMAKE_BUILD_TYPE=Release
cmake --build .deps --config Release
cmake -B build -G Ninja -D CMAKE_BUILD_TYPE=Release
cmake --build build --config Release
```
- Omit `--config Release` if you want a debug build.
- Omit `-G Ninja` to use the "Visual Studio" generator.
### Windows / CLion
1. Install [CLion](https://www.jetbrains.com/clion/).
2. Open the Neovim project in CLion.
3. Select _Build → Build All in 'Release'_.
### Windows / Cygwin
Install all dependencies the normal way, then build Neovim the normal way for a random CMake application (i.e. do not use the `Makefile` that automatically downloads and builds "bundled" dependencies).
The `cygport` repo contains Cygport files (e.g. `APKBUILD`, `PKGBUILD`) for all the dependencies not available in the Cygwin distribution, and describes any special commands or arguments needed to build. The Cygport definitions also try to describe the required dependencies for each one. Unless custom commands are provided, Cygport just calls `autogen`/`cmake`, `make`, `make install`, etc. in a clean and consistent way.
https://github.com/cascent/neovim-cygwin was built on Cygwin 2.9.0. Newer `libuv` should require slightly less patching. Some SSP stuff changed in Cygwin 2.10.0, so that might change things too when building Neovim.
### Windows / MSYS2 / MinGW
1. From the MSYS2 shell, install these packages:
```
pacman -S \
mingw-w64-x86_64-{gcc,cmake,make,ninja,diffutils}
```
2. From the Windows Command Prompt (`cmd.exe`), set up the `PATH` and build.
```cmd
set PATH=c:\msys64\mingw64\bin;c:\msys64\usr\bin;%PATH%
```
3. You have two options:
- Build using `cmake` and `Ninja` generator:
```cmd
mkdir .deps
cd .deps
cmake -G Ninja ..\cmake.deps\
ninja
cd ..
mkdir build
cd build
cmake -G Ninja -D CMAKE_BUILD_TYPE=RelWithDebInfo ..
ninja
ninja install
```
If you cannot install neovim with `ninja install` due to permission restriction, you can install neovim in a directory you have write access to.
```cmd
mkdir build
cd build
cmake -G Ninja -D CMAKE_INSTALL_PREFIX=C:\nvim -D CMAKE_BUILD_TYPE=RelWithDebInfo ..
ninja
ninja install
```
- Or, alternatively, you can use `mingw32-make`:
```cmd
mingw32-make deps
mingw32-make CMAKE_BUILD_TYPE=RelWithDebInfo
:: Or you can do the previous command specifying a custom prefix
:: (Default is C:\Program Files (x86)\nvim)
:: mingw32-make CMAKE_BUILD_TYPE=RelWithDebInfo CMAKE_INSTALL_PREFIX=C:\nvim
mingw32-make install
```
## Localization
### Localization build
A normal build will create `.mo` files in `build/src/nvim/po`.
* If you see `msgfmt: command not found`, you need to install [`gettext`](http://en.wikipedia.org/wiki/Gettext). On most systems, the package is just called `gettext`.
### Localization check
To check the translations for `$LANG`, run `make -C build check-po-$LANG`. Examples:
```
cmake --build build --target check-po-de
cmake --build build --target check-po-pt_BR
```
- `check-po-$LANG` generates a detailed report in `./build/src/nvim/po/check-${LANG}.log`. (The report is generated by `nvim`, not by `msgfmt`.)
### Localization update
To update the `src/nvim/po/$LANG.po` file with the latest strings, run the following:
```
cmake --build build --target update-po-$LANG
```
- **Note**: Run `src/nvim/po/cleanup.vim` after updating.
## Compiler options
To see the chain of includes, use the `-H` option ([#918](https://github.com/neovim/neovim/issues/918)):
```sh
echo '#include "./src/nvim/buffer.h"' | \
> clang -I.deps/usr/include -Isrc -std=c99 -P -E -H - 2>&1 >/dev/null | \
> grep -v /usr/
```
- `grep -v /usr/` is used to filter out system header files.
- `-save-temps` can be added as well to see expanded macros or commented assembly.
## Xcode and MSVC project files
CMake has a `-G` option for exporting to multiple [project file formats](http://www.cmake.org/cmake/help/v2.8.8/cmake.html#section_Generators), such as Xcode and Visual Studio.
For example, to use Xcode's static analysis GUI ([#167](https://github.com/neovim/neovim/issues/167#issuecomment-36136018)), you need to generate an Xcode project file from the Neovim Makefile (where `neovim/` is the top-level Neovim source code directory containing the main `Makefile`):
```
cmake -G Xcode neovim
```
The resulting project file can then be opened in Xcode.
## Custom Makefile
You can customize the build process locally by creating a `local.mk`, which is referenced at the top of the main `Makefile`. It's listed in `.gitignore`, so it can be used across branches. **A new target in `local.mk` overrides the default make-target.**
Here's a sample `local.mk` which adds a target to force a rebuild but *does not* override the default-target:
```make
all:
rebuild:
rm -rf build
make
```
## Third-party dependencies
Reference the [Debian package](https://packages.debian.org/sid/source/neovim) (or alternatively, the [Homebrew formula](https://github.com/Homebrew/homebrew-core/blob/master/Formula/neovim.rb)) for the precise list of dependencies/versions.
To build the bundled dependencies using CMake:
```sh
mkdir .deps
cd .deps
cmake ../cmake.deps
make
```
By default the libraries and headers are placed in `.deps/usr`. Now you can build Neovim:
```sh
mkdir build
cd build
cmake ..
make
```
### How to build without "bundled" dependencies
1. Manually install the dependencies:
- libuv libluv libtermkey luajit lua-lpeg lua-mpack msgpack-c tree-sitter unibilium
2. Do the "CMake dance": create a `build` directory, switch to it, and run CMake:
```sh
mkdir build
cd build
cmake ..
```
If all the dependencies are not available in the package, you can use only some of the bundled dependencies as follows (example of using `ninja`):
```sh
mkdir .deps
cd .deps
cmake ../cmake.deps/ -DUSE_BUNDLED=OFF -DUSE_BUNDLED_LIBVTERM=ON -DUSE_BUNDLED_TS=ON
ninja
cd ..
mkdir build
cd build
cmake ..
```
3. Run `make`, `ninja`, or whatever build tool you [told CMake to generate](#xcode-and-msvc-project-files).
- Using `ninja` is strongly recommended.
#### Debian 10 (Buster) example:
```sh
sudo apt install luajit libluajit-5.1-dev lua-mpack lua-lpeg libunibilium-dev libmsgpack-dev libtermkey-dev
mkdir .deps
cd .deps
cmake ../cmake.deps/ -DUSE_BUNDLED=OFF -DUSE_BUNDLED_LIBUV=ON -DUSE_BUNDLED_LUV=ON -DUSE_BUNDLED_LIBVTERM=ON -DUSE_BUNDLED_TS=ON -G Ninja
ninja
cd ..
mkdir build
cd build
cmake ..
ninja
```
#### Example of using a Makefile
- Example of using a package with all dependencies:
```
make USE_BUNDLED=OFF
```
- Example of using a package with some dependencies:
```
make BUNDLED_CMAKE_FLAG="-DUSE_BUNDLED=OFF -DUSE_BUNDLED_LUV=ON -DUSE_BUNDLED_TS=ON -DUSE_BUNDLED_LIBVTERM=ON -DUSE_BUNDLED_LIBUV=ON"
```
## Build prerequisites
General requirements (see [#1469](https://github.com/neovim/neovim/issues/1469#issuecomment-63058312)):
- Clang or GCC version 4.9+
- CMake version 3.10+, built with TLS/SSL support
- Optional: Get the latest CMake from an [installer](https://github.com/Kitware/CMake/releases) or the [Python package](https://pypi.org/project/cmake/) (`pip install cmake`)
Platform-specific requirements are listed below.
### Ubuntu / Debian
```sh
sudo apt-get install ninja-build gettext cmake unzip curl
```
### CentOS / RHEL / Fedora
```
sudo dnf -y install ninja-build cmake gcc make unzip gettext curl
```
### openSUSE
```
sudo zypper install ninja cmake gcc-c++ gettext-tools curl
```
### Arch Linux
```
sudo pacman -S base-devel cmake unzip ninja curl
```
### Alpine Linux
```
apk add build-base cmake coreutils curl unzip gettext-tiny-dev
```
### Void Linux
```
xbps-install base-devel cmake curl git
```
### NixOS / Nix
Starting from NixOS 18.03, the Neovim binary resides in the `neovim-unwrapped` Nix package (the `neovim` package being just a wrapper to setup runtime options like Ruby/Python support):
```sh
cd path/to/neovim/src
```
Drop into `nix-shell` to pull in the Neovim dependencies:
```
nix-shell '<nixpkgs>' -A neovim-unwrapped
```
Configure and build:
```sh
rm -rf build && cmakeConfigurePhase
buildPhase
```
Tests are not available by default, because of some unfixed failures. You can enable them via adding this package in your overlay:
```
neovim-dev = (super.pkgs.neovim-unwrapped.override {
doCheck=true;
}).overrideAttrs(oa:{
cmakeBuildType="debug";
nativeBuildInputs = oa.nativeBuildInputs ++ [ self.pkgs.valgrind ];
shellHook = ''
export NVIM_PYTHON_LOG_LEVEL=DEBUG
export NVIM_LOG_FILE=/tmp/log
export VALGRIND_LOG="$PWD/valgrind.log"
'';
});
```
and replacing `neovim-unwrapped` with `neovim-dev`:
```
nix-shell '<nixpkgs>' -A neovim-dev
```
Neovim contains a Nix flake in the `contrib` folder, with 3 packages:
- `neovim` to run the nightly
- `neovim-debug` to run the package with debug symbols
- `neovim-developer` to get all the tools to develop on `neovim`
Thus you can run Neovim nightly with `nix run github:neovim/neovim?dir=contrib`.
Similarly to develop on Neovim: `nix develop github:neovim/neovim?dir=contrib#neovim-developer`.
### FreeBSD
```
sudo pkg install cmake gmake sha unzip wget gettext curl
```
If you get an error regarding a `sha256sum` mismatch, where the actual SHA-256 hash is `e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855`, then this is your issue (that's the `sha256sum` of an empty file).
### OpenBSD
```sh
doas pkg_add gmake cmake unzip curl gettext-tools
```
Build can sometimes fail when using the top level `Makefile`, apparently due to some third-party component (see [#2445-comment](https://github.com/neovim/neovim/issues/2445#issuecomment-108124236)). The following instructions use CMake:
```sh
mkdir .deps
cd .deps
cmake ../cmake.deps/
gmake
cd ..
mkdir build
cd build
cmake ..
gmake
```
### macOS
#### macOS / Homebrew
1. Install Xcode Command Line Tools: `xcode-select --install`
2. Install [Homebrew](http://brew.sh)
3. Install Neovim build dependencies:
```
brew install ninja cmake gettext curl
```
- **Note**: If you see Wget certificate errors (for older macOS versions less than 10.10):
```sh
brew install curl-ca-bundle
echo CA_CERTIFICATE=$(brew --prefix curl-ca-bundle)/share/ca-bundle.crt >> ~/.wgetrc
```
- **Note**: If you see `'stdio.h' file not found`, try the following:
```
open /Library/Developer/CommandLineTools/Packages/macOS_SDK_headers_for_macOS_10.14.pkg
```
#### macOS / MacPorts
1. Install Xcode Command Line Tools: `xcode-select --install`
2. Install [MacPorts](http://www.macports.org)
3. Install Neovim build dependencies:
```
sudo port install ninja cmake gettext
```
- **Note**: If you see Wget certificate errors (for older macOS versions less than 10.10):
```sh
sudo port install curl-ca-bundle
echo CA_CERTIFICATE=/opt/local/share/curl/curl-ca-bundle.crt >> ~/.wgetrc
```
- **Note**: If you see `'stdio.h' file not found`, try the following:
```
open /Library/Developer/CommandLineTools/Packages/macOS_SDK_headers_for_macOS_10.14.pkg
```
#### Building for older macOS versions
From a newer macOS version, to build for older macOS versions, you will have to set the macOS deployment target:
```
make CMAKE_BUILD_TYPE=Release MACOSX_DEPLOYMENT_TARGET=10.13 DEPS_CMAKE_FLAGS="-DCMAKE_CXX_COMPILER=$(xcrun -find c++)"
```
Note that the C++ compiler is explicitly set so that it can be found when the deployment target is set.

425
INSTALL.md Normal file
View File

@ -0,0 +1,425 @@
You can install Neovim from [download](#install-from-download), [package](#install-from-package), or [source](#install-from-source) in just a few seconds.
---
- To start Neovim, run `nvim` (not `neovim`).
- [Discover plugins](Related-projects#plugins).
- Before upgrading to a new version, **check [Breaking Changes](https://neovim.io/doc/user/news.html#news-breaking).**
- For config (vimrc) see [the FAQ](https://github.com/neovim/neovim/wiki/FAQ#where-should-i-put-my-config-vimrc).
---
Install from download
=====================
Downloads are available on the [Releases](https://github.com/neovim/neovim/releases) page.
* Latest [stable release](https://github.com/neovim/neovim/releases/latest)
* [macOS](https://github.com/neovim/neovim/releases/latest/download/nvim-macos.tar.gz)
* [Linux](https://github.com/neovim/neovim/releases/latest/download/nvim-linux64.tar.gz)
* [Windows](https://github.com/neovim/neovim/releases/latest/download/nvim-win64.msi)
* Latest [development prerelease](https://github.com/neovim/neovim/releases/nightly)
Install from package
====================
Packages are listed below. (You can also [build Neovim from source](#install-from-source).)
## Windows
Windows 8+ is required. Windows 7 or older is not supported.
### [Winget](https://docs.microsoft.com/en-us/windows/package-manager/winget/)
- **Release:** `winget install Neovim.Neovim`
### [Chocolatey](https://chocolatey.org)
- **Release (v0.7):** `choco install neovim` (use -y for automatically skipping confirmation messages)
- **Development (pre-release):** `choco install neovim --pre`
### [Scoop](https://scoop.sh/)
```
scoop bucket add main
scoop install neovim
```
- **Release:** `scoop install neovim`
Several Neovim GUIs are available from scoop (extras): [scoop.sh/#/apps?q=neovim](https://scoop.sh/#/apps?q=neovim)
### Pre-built archives
0. If you are missing `VCRUNTIME140.dll`, install the [Visual Studio 2015 C++ redistributable](https://support.microsoft.com/en-us/kb/2977003) (choose x86_64 or x86 depending on your system).
1. Choose a package (**nvim-winXX.zip**) from the [releases page](https://github.com/neovim/neovim/releases).
2. Unzip the package. Any location is fine, administrator privileges are _not_ required.
- `$VIMRUNTIME` will be set to that location automatically.
3. Double-click `nvim-qt.exe`.
**Optional** steps:
- Add the `bin` folder (e.g. `C:\Program Files\nvim\bin`) to your PATH.
- This makes it easy to run `nvim` and `nvim-qt` from anywhere.
- If `:set spell` does not work, create the `C:/Users/foo/AppData/Local/nvim/site/spell` folder.
You can then copy your spell files over (for English, located
[here](https://github.com/vim/vim/blob/master/runtime/spell/en.utf-8.spl) and
[here](https://github.com/vim/vim/blob/master/runtime/spell/en.utf-8.sug));
- For Python plugins you need the `pynvim` module. "Virtual envs" are recommended. After activating the virtual env do `pip install pynvim` (in *both*). Edit your `init.vim` so that it contains the path to the env's Python executable:
```vim
let g:python3_host_prog='C:/Users/foo/Envs/neovim3/Scripts/python.exe'
```
- Run `:checkhealth` and read `:help provider-python`.
- **init.vim ("vimrc"):** If you already have Vim installed you can copy `%userprofile%\_vimrc` to `%userprofile%\AppData\Local\nvim\init.vim` to use your Vim config with Neovim.
## macOS / OS X
### Pre-built archives
The [Releases](https://github.com/neovim/neovim/releases) page provides pre-built binaries for macOS 10.15+.
curl -LO https://github.com/neovim/neovim/releases/download/nightly/nvim-macos.tar.gz
tar xzf nvim-macos.tar.gz
./nvim-macos/bin/nvim
### [Homebrew](https://brew.sh) on macOS or Linux
brew install neovim
### [MacPorts](https://www.macports.org/)
sudo port selfupdate
sudo port install neovim
## Linux
### AppImage ("universal" Linux package)
The [Releases](https://github.com/neovim/neovim/releases) page provides an [AppImage](https://appimage.org) that runs on most Linux systems. No installation is needed, just download `nvim.appimage` and run it. (It might not work if your Linux distribution is more than 4 years old.)
curl -LO https://github.com/neovim/neovim/releases/latest/download/nvim.appimage
chmod u+x nvim.appimage
./nvim.appimage
If the `./nvim.appimage` command fails, try:
```sh
./nvim.appimage --appimage-extract
./squashfs-root/AppRun --version
# Optional: exposing nvim globally.
sudo mv squashfs-root /
sudo ln -s /squashfs-root/AppRun /usr/bin/nvim
nvim
```
### Arch Linux
Neovim can be installed from the community repository:
sudo pacman -S neovim
Alternatively, Neovim can be also installed using the PKGBUILD [`neovim-git`](https://aur.archlinux.org/packages/neovim-git), available on the [AUR](https://wiki.archlinux.org/index.php/Arch_User_Repository).
Alternatively, Neovim Nightly builds can be also installed using the PKGBUILD [`neovim-nightly-bin`](https://aur.archlinux.org/packages/neovim-nightly-bin), available on the [AUR](https://wiki.archlinux.org/index.php/Arch_User_Repository).
The Python module is available from the community repository:
sudo pacman -S python-pynvim
Ruby modules (currently only supported in `neovim-git`) are available from the AUR as [`ruby-neovim`](https://aur.archlinux.org/packages/ruby-neovim).
### CentOS 8 / RHEL 8
Neovim is available through [EPEL (Extra Packages for Enterprise Linux)](https://fedoraproject.org/wiki/EPEL)
yum install -y https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm
yum install -y neovim python3-neovim
### Clear Linux OS
Neovim is available through the [neovim bundle](https://github.com/clearlinux/clr-bundles/blob/master/bundles/neovim)
sudo swupd bundle-add neovim
Python (`:python`) support is available if the [python-basic bundle](https://github.com/clearlinux/clr-bundles/blob/master/bundles/python-basic) is installed.
sudo swupd bundle-add python-basic
### Debian
Neovim is in [Debian](https://packages.debian.org/search?keywords=neovim).
sudo apt-get install neovim
Python (`:python`) support is installable via the package manager on Debian unstable.
sudo apt-get install python3-neovim
If installing via appimage, the following commands may be helpful in updating default paths:
# CUSTOM_NVIM_PATH=/usr/local/bin/nvim.appimage
# Set the above with the correct path, then run the rest of the commands:
set -u
sudo update-alternatives --install /usr/bin/ex ex "${CUSTOM_NVIM_PATH}" 110
sudo update-alternatives --install /usr/bin/vi vi "${CUSTOM_NVIM_PATH}" 110
sudo update-alternatives --install /usr/bin/view view "${CUSTOM_NVIM_PATH}" 110
sudo update-alternatives --install /usr/bin/vim vim "${CUSTOM_NVIM_PATH}" 110
sudo update-alternatives --install /usr/bin/vimdiff vimdiff "${CUSTOM_NVIM_PATH}" 110
### Exherbo Linux
Exhereses for scm and released versions are currently available in repository `::medvid`. Python client (with GTK+ GUI included) and Qt5 GUI are also available as suggestions:
cave resolve app-editors/neovim --take dev-python/neovim-python --take app-editors/neovim-qt
### Fedora
Neovim is in [Fedora](https://src.fedoraproject.org/rpms/neovim) starting with Fedora 25:
sudo dnf install -y neovim python3-neovim
You can also get nightly builds of git master from the [Copr automated build system](https://copr.fedoraproject.org/coprs/agriffis/neovim-nightly/):
dnf copr enable agriffis/neovim-nightly
dnf install -y neovim python3-neovim
See the [blog post](https://arongriffis.com/2019/03/02/neovim-nightly-builds) for information on how these are built.
### Flatpak
You can find Neovim on [Flathub](https://flathub.org/apps/details/io.neovim.nvim). Providing you have Flatpak [set up](https://flatpak.org/setup/):
flatpak install flathub io.neovim.nvim
flatpak run io.neovim.nvim
You can add `/var/lib/flatpak/exports/bin` (or `~/.local/share/flatpak/exports/bin` if you used `--user`) to the `$PATH` and run it with `io.neovim.nvim`.
Note that Flatpak'ed Neovim will look for `init.vim` in `~/.var/app/io.neovim.nvim/config/nvim` instead of `~/.config/nvim`.
### Gentoo Linux
An ebuild is available in Gentoo's official portage repository:
emerge -a app-editors/neovim
### GNU Guix
Neovim can be installed with:
guix install neovim
### GoboLinux
Neovim can be installed with:
sudo -H Compile NeoVim
### Nix / NixOS
Neovim can be installed with:
nix-env -iA nixpkgs.neovim
Or alternatively, if you use flakes:
nix profile install nixpkgs#neovim
### Mageia 7
urpmi neovim
To install the Python modules:
urpmi python3-pynvim
### makedeb Package Repository (MPR)
Neovim is available inside the [MPR](https://mpr.makedeb.org/packages/neovim). You can install it with:
git clone https://mpr.makedeb.org/neovim
cd neovim/
makedeb -si
### OpenSUSE
Neovim can be installed with:
sudo zypper in neovim
To install the Python modules:
sudo zypper in python-neovim python3-neovim
### PLD Linux
Neovim is in [PLD Linux](https://github.com/pld-linux/neovim):
poldek -u neovim
poldek -u python-neovim python3-neovim
poldek -u python-neovim-gui python3-neovim-gui
### Slackware
See [neovim on SlackBuilds](https://slackbuilds.org/apps/neovim/).
For instructions on how to install the Python modules, see [`:help provider-python`].
### Source Mage
Neovim can be installed using the Sorcery package manager:
cast neovim
### Solus
Neovim can be installed using the default package manager in Solus (eopkg):
sudo eopkg install neovim
### Snap
Neovim nightly and stable are available on the [snap store](https://snapcraft.io/nvim).
**Stable Builds**
```sh
sudo snap install --beta nvim --classic
```
**Nightly Builds**
```sh
sudo snap install --edge nvim --classic
```
### Ubuntu
As in Debian, Neovim is in [Ubuntu](https://packages.ubuntu.com/search?keywords=neovim).
sudo apt install neovim
Python (`:python`) support seems to be automatically installed
sudo apt install python3-neovim
Neovim has been added to a "Personal Package Archive" (PPA). This allows you to install it with `apt-get`. Follow the links to the PPAs to see which versions of Ubuntu are currently available via the PPA. Choose **stable** or **unstable**:
- [https://launchpad.net/~neovim-ppa/+archive/ubuntu/**stable**](https://launchpad.net/~neovim-ppa/+archive/ubuntu/stable)
- [https://launchpad.net/~neovim-ppa/+archive/ubuntu/**unstable**](https://launchpad.net/~neovim-ppa/+archive/ubuntu/unstable)
**Important:** The Neovim team does not maintain the PPA packages. For problems or questions about the PPA specifically contact https://launchpad.net/~neovim-ppa.
To be able to use **add-apt-repository** you may need to install software-properties-common:
sudo apt-get install software-properties-common
If you're using an older version Ubuntu you must use:
sudo apt-get install python-software-properties
Run the following commands:
sudo add-apt-repository ppa:neovim-ppa/stable
sudo apt-get update
sudo apt-get install neovim
Prerequisites for the Python modules:
sudo apt-get install python-dev python-pip python3-dev python3-pip
If you're using an older version Ubuntu you must use:
sudo apt-get install python-dev python-pip python3-dev
sudo apt-get install python3-setuptools
sudo easy_install3 pip
For instructions to install the Python modules, see [`:help provider-python`].
If you want to use Neovim for some (or all) of the editor alternatives, use the following commands:
sudo update-alternatives --install /usr/bin/vi vi /usr/bin/nvim 60
sudo update-alternatives --config vi
sudo update-alternatives --install /usr/bin/vim vim /usr/bin/nvim 60
sudo update-alternatives --config vim
sudo update-alternatives --install /usr/bin/editor editor /usr/bin/nvim 60
sudo update-alternatives --config editor
Note, however, that special interfaces, like `view` for `nvim -R`, are not supported. (See [#1646](https://github.com/neovim/neovim/issues/1646) and [#2008](https://github.com/neovim/neovim/pull/2008).)
### Void-Linux
Neovim can be installed using the xbps package manager
sudo xbps-install -S neovim
### Alpine Linux
Neovim can be installed using the apk package manager
sudo apk add neovim
## BSD
### FreeBSD
Neovim can be installed using [`pkg(8)`](https://www.freebsd.org/cgi/man.cgi?query=pkg&sektion=8&n=1):
pkg install neovim
or [from the ports tree](https://www.freshports.org/editors/neovim/):
cd /usr/ports/editors/neovim/ && make install clean
To install the pynvim Python modules using [`pkg(8)`](https://www.freebsd.org/cgi/man.cgi?query=pkg&sektion=8&n=1) run:
pkg install py36-pynvim
### OpenBSD
Neovim can be installed using [`pkg_add(1)`](https://man.openbsd.org/pkg_add):
pkg_add neovim
or [from the ports tree](https://cvsweb.openbsd.org/cgi-bin/cvsweb/ports/editors/neovim/):
cd /usr/ports/editors/neovim/ && make install
## Android
[Termux](https://github.com/termux/termux-app) offers a Neovim package.
Install from source
===================
If a package is not provided for your platform, you can build Neovim from source. See [BUILD.md](./BUILD.md) for details. If you have the [prerequisites](./BUILD.md#build-prerequisites) then building is easy:
make CMAKE_BUILD_TYPE=Release
sudo make install
For Unix-like systems this installs Neovim to `/usr/local`, while for Windows to `C:\Program Files`. Note, however, that this can complicate uninstallation. The following example avoids this by isolating an installation under `$HOME/neovim`:
rm -r build/ # clear the CMake cache
make CMAKE_EXTRA_FLAGS="-DCMAKE_INSTALL_PREFIX=$HOME/neovim"
make install
export PATH="$HOME/neovim/bin:$PATH"
## Uninstall
There is a CMake target to _uninstall_ after `make install`:
```sh
sudo cmake --build build/ --target uninstall
```
Alternatively, just delete the `CMAKE_INSTALL_PREFIX` artifacts:
```sh
sudo rm /usr/local/bin/nvim
sudo rm -r /usr/local/share/nvim/
```
[`:help provider-python`]: https://neovim.io/doc/user/provider.html#provider-python

6
README.md
View File

@ -16,7 +16,7 @@ Neovim is a project that seeks to aggressively refactor [Vim](https://www.vim.or
- Simplify maintenance and encourage [contributions](CONTRIBUTING.md)
- Split the work between multiple developers
- Enable [advanced UIs] without modifications to the core
- Maximize [extensibility](https://github.com/neovim/neovim/wiki/Plugin-UI-architecture)
- Maximize [extensibility](https://github.com/neovim/neovim/wiki/Remote-UI-architecture)
See the [Introduction](https://github.com/neovim/neovim/wiki/Introduction) wiki page and [Roadmap]
for more information.
@ -47,7 +47,7 @@ Pre-built packages for Windows, macOS, and Linux are found on the
Install from source
-------------------
See the [Building Neovim](https://github.com/neovim/neovim/wiki/Building-Neovim) wiki page and [supported platforms](https://neovim.io/doc/user/support.html#supported-platforms) for details.
See [BUILD.md](./BUILD.md) and [supported platforms](https://neovim.io/doc/user/support.html#supported-platforms) for details.
The build is CMake-based, but a Makefile is provided as a convenience.
After installing the dependencies, run the following command.
@ -113,7 +113,7 @@ Apache 2.0 license, except for contributions copied from Vim (identified by the
[nvim-news]: https://neovim.io/doc/user/news.html
[Roadmap]: https://neovim.io/roadmap/
[advanced UIs]: https://github.com/neovim/neovim/wiki/Related-projects#gui
[Managed packages]: https://github.com/neovim/neovim/wiki/Installing-Neovim#install-from-package
[Managed packages]: ./INSTALL.md#install-from-package
[Debian]: https://packages.debian.org/testing/neovim
[Ubuntu]: https://packages.ubuntu.com/search?keywords=neovim
[Fedora]: https://packages.fedoraproject.org/pkgs/neovim/neovim/

2
runtime/lua/nvim/health.lua
View File

@ -17,7 +17,7 @@ local shell_error = function()
return vim.v.shell_error ~= 0
end
local suggest_faq = 'https://github.com/neovim/neovim/wiki/Building-Neovim#optimized-builds'
local suggest_faq = 'https://github.com/neovim/neovim/blob/docs/install/BUILD.md#building'
local function check_runtime()
health.start('Runtime')