Neovide

Discord Chat On Matrix Discussions

Neovide Discord Chat On Matrix Discussions

This is a simple, no-nonsense, cross-platform graphical user interface for Neovim (an aggressively refactored and updated Vim editor). Where possible there are some graphical improvements, but functionally it should act like the terminal UI.

If you're looking for the Neovide source code, that can be found here. To search within the docs, you can simply press s or click the magnifying glass icon in the top left to bring up the search bar.

Installing through a package manager or building from source? no problem!

Want to see a list of all the available features? here you go!

Looking to configure your neovide? we've got you covered!

Screenshot of Neovide

Screenshot of Neovide running on Windows

Features

This should be a standard, fully-featured Neovim GUI. Beyond that there are some visual niceties listed below :)

Ligatures

Supports ligatures and font shaping.

Ligatures

Animated Cursor

Cursor animates into position with a smear effect to improve tracking of cursor position.

Animated Cursor

Smooth Scrolling

Scroll operations on buffers in neovim will be animated smoothly pixel wise rather than line by line at a time.

Note: multigrid must be enabled for this to work.

Smooth Scrolling

Animated Windows

Windows animate into position when they are moved making it easier to see how layout changes happen.

Note: multigrid must be enabled for this to work.

Animated Windows

Blurred Floating Windows

The backgrounds of floating windows are blurred improving the visual separation between foreground and background from built in window transparency.

Note: multigrid must be enabled for this to work.

Blurred Floating Windows

Emoji Support

Font fallback supports rendering of emoji not contained in the configured font.

Emojis

WSL Support

Neovide supports displaying a full gui window from inside wsl via the --wsl command argument. Communication is passed via standard io into the wsl copy of neovim providing identical experience similar to Visual Studio Code's Remote Editing.

Remote TCP Support

Neovide supports connecting to a remote instance of Neovim over a TCP socket via the --remote-tcp command argument. This would allow you to run Neovim on a remote machine and use the GUI on your local machine, connecting over the network.

Launch Neovim as a TCP server (on port 6666) by running:

nvim --headless --listen localhost:6666

And then connect to it using:

/path/to/neovide --remote-tcp=localhost:6666

By specifying to listen on localhost, you only allow connections from your local computer. If you are actually doing this over a network you will want to use SSH port forwarding for security, and then connect as before.

ssh -L 6666:localhost:6666 ip.of.other.machine nvim --headless --listen localhost:6666

Finally, if you would like to leave the neovim server running, close the neovide application window instead of issuing a :q command.

Some Nonsense ;)

To learn how to configure the following, head on over to the configuration section!

Railgun

Railgun

Torpedo

Torpedo

Pixiedust

Pixiedust

Sonic Boom

Sonicboom

Ripple

Ripple

Wireframe

Wireframe

Installation

Note: Neovide requires neovim version 0.6 or greater. See previous releases such as 0.5.0 if your distro is too slow with updating or you need to rely on older neovim versions.

Building instructions are somewhat limited at the moment. All the libraries Neovide uses are cross platform and should have support for Windows, Mac, and Linux. The rendering is based on OpenGL, so a good GPU driver will be necessary, the default drivers provided by virtual machines might not be enough. On Windows this should be enabled by default if you have a relatively recent system.

Binaries

Installing should be as simple as downloading the binary, making sure the nvim executable with version 0.6 or greater is on your PATH environment variable, and running it. Everything should be self contained.

The binaries are to be found on the release page.

Windows

Scoop

Scoop has Neovide in the extras bucket. Ensure you have the extras bucket, and install:

$ scoop bucket list
main
extras

$ scoop install neovide

Windows Source

  1. Install the latest version of Rust. I recommend https://rustup.rs/

  2. Install CMake. I use chocolatey: choco install cmake --installargs '"ADD_CMAKE_TO_PATH=System"' -y

  3. Install LLVM. I use chocolatey: choco install llvm -y

  4. Ensure graphics libraries are up to date.

  5. Build and install Neovide:

    cargo install --git https://github.com/neovide/neovide.git
    

    The resulting binary can be found inside of ~/.cargo/bin afterwards (99% of the time).

Mac

Homebrew

Neovide is available as Cask in Homebrew. It can be installed from the command line:

brew install --cask neovide

Mac Source

  1. Install the latest version of Rust. Using homebrew: brew install rustup-init

  2. Configure rust by running rustup-init

  3. Install CMake. Using homebrew: brew install cmake

  4. git clone https://github.com/neovide/neovide

  5. cd neovide

  6. cargo install --path .

    The resulting binary is to be found under ~/.cargo/bin. In case you want a nice application bundle:

  7. cargo install cargo-bundle

  8. cargo bundle --release

  9. Copy ./target/release/bundle/osx/neovide.app to ~/Applications and enjoy.

Linux

Arch Linux

Stable releases are packaged in the community repository.

pacman -S neovide

To run a development version you can build from the VCS package in the AUR. This can be built and installed using an AUR helper or by hand in the usual way. To build from a non-default branch you can edit the PKGBUILD and add #branch-name to the end of the source URL.

Snap

Neovide is also available in the Snap Store. You can install it using the command below.

snap install neovide

Get it from the Snap Store

Linux Source

  1. Install necessary dependencies (adjust for your preferred package manager, probably most of this stuff is already installed, just try building and see)

    • Ubuntu/Debian

      sudo apt install -y curl \
          gnupg ca-certificates git \
          gcc-multilib g++-multilib cmake libssl-dev pkg-config \
          libfreetype6-dev libasound2-dev libexpat1-dev libxcb-composite0-dev \
          libbz2-dev libsndio-dev freeglut3-dev libxmu-dev libxi-dev libfontconfig1-dev \
          libxcursor-dev
      
    • Fedora

      sudo dnf install fontconfig-devel freetype-devel libX11-xcb libX11-devel libstdc++-static libstdc++-devel
      sudo dnf groupinstall "Development Tools" "Development Libraries"
      
  2. Install Rust

    curl --proto '=https' --tlsv1.2 -sSf "https://sh.rustup.rs" | sh
    
  3. Fetch and build

    cargo install --git https://github.com/neovide/neovide
    

    The resulting binary can be found inside of ~/.cargo/bin afterwards, you might want to add this to your PATH environment variable.

Configuration

Global Vim Settings

Neovide supports settings via global variables with a neovide prefix. They enable configuring many parts of the editor and support dynamically changing them at runtime.

init.vim helpers

Hello, is this Neovide?

Not really a configuration option, but g:neovide only exists and is set to v:true if this Neovim is in Neovide. It's not set else. Useful for configuring things only for Neovide in your init.vim:

if exists("g:neovide")
    " Put anything you want to happen only in Neovide here
endif

Display

Font

set guifont=Fira\ Code\ Nerd\ Font:h14

Controls the font used by Neovide. Only setting which is actually controlled through an option, and as such it's also documented in :h guifont. But to sum it up and also add Neovide's extension:

  • The basic format is Primary\ Font,Fallback\ Font\ 1,Fallback\ Font\ 2:option1:option2:option3, while you can have as many fallback fonts as you want (even 0) and as many options as you want (also even 0).
  • Fonts
    • are separated with , (commas).
    • can contain spaces by either escaping them or using _ (underscores).
  • Options
    • apply to all fonts at once.
    • are separated from the fonts and themselves through : (colons).
    • can be one of the following:
      • hX — Sets the font size to X points, while X can be any (even floating-point) number.
      • b — Sets the font bold.
      • i — Sets the font italic.
      • #e-X (available since 0.10.2) — Sets edge pixels to be drawn opaquely or with partial transparency, while X is a type of edging:
        • antialias (default)
        • subpixelantialias
        • alias
      • #h-X (available since 0.10.2) - Sets level of glyph outline adjustment, while X is a type of hinting:
        • full (default)
        • normal
        • slight
        • none
  • Some examples:
    • Hack,Noto_Color_Emoji:h12:b — Hack at size 12 in bold, with Noto Color Emoji as fallback should Hack fail to contain any glyph.
    • Roboto_Mono_Light:h10 — Roboto Mono Light at size 10.
    • Hack:h14:i:#e-subpixelantialias:#h-none

Scale

let g:neovide_scale_factor = 1.0

Available since 0.10.2.

In addition to setting the font itself, this setting allows to change the scale without changing the whole font definition. Very useful for presentations. See the FAQ section about this for a nice recipe to bind this to a hotkey.

Background Color (Currently macOS only)

" g:neovide_transparency should be 0 if you want to unify transparency of content and title bar.
let g:neovide_transparency = 0.0
let g:transparency = 0.8
let g:neovide_background_color = '#0f1117'.printf('%x', float2nr(255 * g:transparency))

Available since 0.10.

BackgroundColor

Setting g:neovide_background_color to a value that can be parsed by csscolorparser-rs will set the color of the whole window to that value.

Note that g:neovide_transparency should be 0 if you want to unify transparency of content and title bar.

Floating Blur Amount

let g:neovide_floating_blur_amount_x = 2.0
let g:neovide_floating_blur_amount_y = 2.0

Available since 0.9.

Setting g:neovide_floating_blur_amount_x and g:neovide_floating_blur_amount_y controls the blur radius on the respective axis for floating windows.

Transparency

let g:neovide_transparency = 0.8

Transparency

Setting g:neovide_transparency to a value between 0.0 and 1.0 will set the opacity of the window to that value.

Scroll Animation Length

let g:neovide_scroll_animation_length = 0.3

Sets how long the scroll animation takes to complete, measured in seconds.

Hiding the mouse when typing

let g:neovide_hide_mouse_when_typing = v:false

By setting this to v:true, the mouse will be hidden as soon as you start typing. This setting only affects the mouse if it is currently within the bounds of the neovide window. Moving the mouse makes it visible again.

Underline automatic scaling

let g:neovide_underline_automatic_scaling = v:false

Available since 0.10.

Setting g:neovide_underline_automatic_scaling to a boolean value determines whether automatic scaling of text underlines (including undercurl, underdash, etc.) is enabled. Noticeable for font sizes above 15.

Note: This is currently glitchy, and leads to some underlines being clipped by the line of text below.

Functionality

Refresh Rate

let g:neovide_refresh_rate = 60

Setting g:neovide_refresh_rate to a positive integer will set the refresh rate of the app. This is limited by the refresh rate of your physical hardware, but can be lowered to increase battery life.

Also do note that Neovide's frame pacing is far from optimal at the moment, so better hardware might not mean better FPS.

Idle Refresh Rate

let g:neovide_refresh_rate_idle = 5

Available since 0.10.

Setting g:neovide_refresh_rate_idle to a positive integer will set the refresh rate of the app when it is not in focus.

This might not have an effect on every platform (e.g. Wayland).

No Idle

let g:neovide_no_idle = v:true

Setting g:neovide_no_idle to a boolean value will force neovide to redraw all the time. This can be a quick hack if animations appear to stop too early.

Confirm Quit

let g:neovide_confirm_quit = v:true

If set to true, quitting while having unsaved changes will require confirmation. Enabled by default.

Fullscreen

let g:neovide_fullscreen = v:true

Setting g:neovide_fullscreen to a boolean value will set whether the app should take up the entire screen. This uses the so called "windowed fullscreen" mode that is sometimes used in games which want quick window switching.

Remember Previous Window Size

let g:neovide_remember_window_size = v:true

Setting g:neovide_remember_window_size to a boolean value will determine whether the window size from the previous session or the default size will be used on startup. The commandline option --geometry will take priority over this value.

Profiler

let g:neovide_profiler = v:false

Setting this to v:true enables the profiler, which shows a frametime graph in the upper left corner.

Input Settings

Use Logo Key

let g:neovide_input_use_logo = v:false  " v:true on macOS

Setting g:neovide_input_use_logo to a boolean value will change how logo key (also known as super key, command key or windows key) is handled, allowing all key combinations containing logo to be forwarded to neovim. On MacOS, this defaults to true (so that e.g. cmd+v works for pasting with respective setup of init.vim), and to false for other platforms (that typically use e.g. ctrl+v for pasting).

macOS Alt is Meta

let g:neovide_input_macos_alt_is_meta = v:false

Available since 0.10.

Interprets Alt + whatever actually as <M-whatever>, instead of sending the actual special character to Neovim.

Touch Deadzone

let g:neovide_touch_deadzone = 6.0

Setting g:neovide_touch_deadzone to a value equal or higher than 0.0 will set how many pixels the finger must move away from the start position when tapping on the screen for the touch to be interpreted as a scroll gesture.

If the finger stayed in that area once lifted or the drag timeout happened, however, the touch will be interpreted as tap gesture and the cursor will move there.

A value lower than 0.0 will cause this feature to be disabled and all touch events will be interpreted as scroll gesture.

Touch Drag Timeout

let g:neovide_touch_drag_timeout = 0.17

Setting g:neovide_touch_drag_timeout will affect how many seconds the cursor has to stay inside g:neovide_touch_deadzone in order to begin "dragging"

Once started, the finger can be moved to another position in order to form a visual selection. If this happens too often accidentally to you, set this to a higher value like 0.3 or 0.7.

Cursor Settings

Animation Length

Short Cursor Animation Length     Long Cursor Animation Length

let g:neovide_cursor_animation_length=0.13

Setting g:neovide_cursor_animation_length determines the time it takes for the cursor to complete it's animation in seconds. Set to 0 to disable.

Animation Trail Size

Short Cursor Trail Length     Long Cursor Trail Length

let g:neovide_cursor_trail_size = 0.8

Setting g:neovide_cursor_trail_size determines how much the trail of the cursor lags behind the front edge.

Antialiasing

let g:neovide_cursor_antialiasing = v:true

Enables or disables antialiasing of the cursor quad. Disabling may fix some cursor visual issues.

Unfocused Outline Width

let g:neovide_cursor_unfocused_outline_width = 0.125

Specify cursor outline width in ems. You probably want this to be a positive value less than 0.5. If the value is <=0 then the cursor will be invisible. This setting takes effect when the editor window is unfocused, at which time a block cursor will be rendered as an outline instead of as a full rectangle.

Cursor Particles

There are a number of vfx modes you can enable which produce particles behind the cursor. These are enabled by setting g:neovide_cursor_vfx_mode to one of the following constants.

None at all

let g:neovide_cursor_vfx_mode = ""

The default, no particles at all.

Railgun

Railgun
let g:neovide_cursor_vfx_mode = "railgun"

Torpedo

Torpedo
let g:neovide_cursor_vfx_mode = "torpedo"

Pixiedust

Pixiedust
let g:neovide_cursor_vfx_mode = "pixiedust"

Sonic Boom

Sonicboom
let g:neovide_cursor_vfx_mode = "sonicboom"

Ripple

Ripple
let g:neovide_cursor_vfx_mode = "ripple"

Wireframe

Wireframe
let g:neovide_cursor_vfx_mode = "wireframe"

Particle Settings

Options for configuring the particle generation and behavior.

Particle Opacity

let g:neovide_cursor_vfx_opacity = 200.0

Sets the transparency of the generated particles.

Particle Lifetime

let g:neovide_cursor_vfx_particle_lifetime = 1.2

Sets the amount of time the generated particles should survive.

Particle Density

let g:neovide_cursor_vfx_particle_density = 7.0

Sets the number of generated particles.

Particle Speed

let g:neovide_cursor_vfx_particle_speed = 10.0

Sets the speed of particle movement.

Particle Phase

let g:neovide_cursor_vfx_particle_phase = 1.5

Only for the railgun vfx mode.

Sets the mass movement of particles, or how individual each one acts. The higher the value, the less particles rotate in accordance to each other, the lower, the more line-wise all particles become.

Particle Curl

let g:neovide_cursor_vfx_particle_curl = 1.0

Only for the railgun vfx mode.

Sets the velocity rotation speed of particles. The higher, the less particles actually move and look more "nervous", the lower, the more it looks like a collapsing sine wave.

Command Line Reference

Neovide supports a few command line arguments for effecting things which couldn't be set using normal vim variables.

$ in front of a word refers to it being an "environment variable" which is checked for, some settings only require it to be set in some way, some settings also use the contents.

Information

Version

--version or -V

Prints the current version of neovide.

Help

--help or -h

Prints details about neovide. This will be a help page eventually.

Functionality

Frame

--frame or $NEOVIDE_FRAME

Can be set to:

  • full: The default, all decorations.
  • none: No decorations at all. NOTE: Window cannot be moved nor resized after this.
  • (macOS only) transparent: Transparent decorations including a transparent bar.
  • (macOS only) buttonless: All decorations, but without quit, minimize or fullscreen buttons.

Geometry

--geometry=<width>x<height>

Sets the initial neovide window size in characters.

Log File

--log

Enables the log file for debugging purposes. This will write a file next to the executable containing trace events which may help debug an issue.

Maximized

--maximized or $NEOVIDE_MAXIMIZED

Maximize the window on startup, while still having decorations and the status bar of your OS visible.

This is not the same as g:neovide_fullscreen, which runs Neovide in "exclusive fullscreen", covering up the entire screen.

Multigrid

--multigrid or $NEOVIDE_MULTIGRID

This enables neovim's multigrid functionality which will also enable floating window blurred backgrounds and window animations. For now this is disabled due to some mouse input bugs upstream (neovim/neovim/pull/12667, neovim/neovim/issues/15075) and some floating window transparency issues.

No Fork

--nofork

By default, neovide detaches itself from the terminal. Instead of spawning a child process and leaking it, be "blocking" and have the shell directly as parent process.

No Idle

--noidle or $NEOVIDE_NO_IDLE

Instead of skipping some frames in order to match g:neovide_refresh_rate, render every possible one.

No sRGB

--nosrgb or $NEOVIDE_NO_SRGB

Don't request sRGB on the window. Swapping sometimes fixes startup issues.

No Tabs

--notabs

By default, Neovide opens files given directly to Neovide (not NeoVim through --!) in multiple tabs to avoid confusing new users. The option disables that and makes multiple given files to normal buffers.

Note: Even if files are opened in tabs, they're buffers anyways. It's just about them being visible or not.

No VSync

--novsync

Available since 0.10.2.

By default, Neovide requests to use VSync on the created window. This option disables this behavior.

Remote TCP

--remote-tcp <remote_tcp>

What IP and port to use when connecting to neovim.

WSL

--wsl

Runs neovim from inside wsl rather than as a normal executable.

Neovim Binary

--neovim-bin or $NEOVIM_BIN

Sets where to find neovim's executable. If unset, neovide will try to find nvim on the PATH environment variable instead. If you're running a Unix-alike, be sure that binary has the executable permission bit set.

Wayland / X11

--wayland-app-id <wayland_app_id> or $NEOVIDE_APP_ID
--x11-wm-class-instance <x11_wm_class_instance> or $NEOVIDE_WM_CLASS_INSTANCE
--x11-wm-class <x11_wm_class> or $NEOVIDE_WM_CLASS

On Linux/Unix, this alters the identification of the window to either X11 or the more modern Wayland, depending on what you are running on.

Editing w/ External Tools

You can use Neovide in other programs as editor, this page aims to document some quirks. Support for that, however, is only possible as far as reasonably debuggable.

Note: We do not endorse nor disrecommend usage of all programs listed here. All usage happens on your own responsibility.

jrnl

In your configuration file:

editor: "neovide --nofork"

...as jrnl saves & removes the temporary file as soon as the main process exits, which happens before startup by forking.

Troubleshooting

  • Should Neovide happen not to start at all, check the following:

    • if you're using zsh ~/.zshenv, ~/.zprofile and ~/.zlogin, or whatever the equivalent for your shell is if anything emits output during shell startup, since Neovide uses your shell to find nvim. You can instead use ~/.zshrc.

    • whether you can reproduce this by running from the latest git main commit. This can be done by running from source or just grabbing the binary from the Actions tab on GitHub.

  • Neovide requires that a font be set in init.vim otherwise errors might be encountered. This can be fixed by adding set guifont=Your\ Font\ Name:h15 in init.vim file. Reference issue #527.

  • If you installed neovim via Apple Silicon (M1)-based brew, you have to add the brew prefix to $PATH to run Neovide.app in GUI. Please see the homebrew documentation. Reference issue #1242

Linux

  • If you recieve errors complaining about DRI3 settings, please reference issue #44.

Frequently Asked Questions

Commonly asked questions, or just explanations/elaborations on stuff.

How To Enable Scrolling Animations and Transparency?

First, enable multigrid, it's not enabled by default.

Then, scrolling animations should work, for transparency see the section below.

How To Enable Floating And Popupmenu Transparency?

Those are controlled through the winblend and pumblend options. See their help pages for more, but for short: Both options can be values between 0 (opaque) and 100 (fully transparent), inclusively on both ends. winblend controls the background for floating windows, pumblend the one for the popup menu.

How Can I Dynamically Change The Scale At Runtime?

Neovide offers the setting g:neovide_scale_factor, which is multiplied with the OS scale factor and the font size. So using this could look like

let g:neovide_scale_factor=1.0
function! ChangeScaleFactor(delta)
    let g:neovide_scale_factor = g:neovide_scale_factor * a:delta
endfunction
nnoremap <expr><C-=> ChangeScaleFactor(1.25)
nnoremap <expr><C--> ChangeScaleFactor(1/1.25)

Credits to BHatGuy here.

How can I Dynamically Change The Transparency At Runtime? (macOS)

" Set transparency and background color (title bar color)
let g:neovide_transparency=0.0
let g:neovide_transparency_point=0.8
let g:neovide_background_color = '#0f1117'.printf('%x', float2nr(255 * g:neovide_transparency_point))

" Add keybinds to change transparency
function! ChangeTransparency(delta)
  let g:neovide_transparency_point = g:neovide_transparency_point + a:delta
  let g:neovide_background_color = '#0f1117'.printf('%x', float2nr(255 * g:neovide_transparency_point))
endfunction
noremap <expr><D-]> ChangeTransparency(0.01)
noremap <expr><D-[> ChangeTransparency(-0.01)

Neovide Is Not Picking Up Some Shell-configured Information

...aka nvm use doesn't work, aka anything configured in ~/.bashrc/~/.zshrc is ignored by Neovide.

Neovide doesn't start the embedded neovim instance in a login shell, so your shell doesn't read its resource file (~/.bashrc/~/.zshrc/whatever the equivalent for your shell is). But depending on your shell there are other options for doing so, for example for zsh you can just put your relevant content into ~/.zprofile or ~/.zlogin.

The Terminal Displays Fallback Colors/:terminal Does Not Show My Colors

Your colorscheme has to define g:terminal_color_0 through g:terminal_color_15 in order to have any effect on the terminal. Just setting any random highlights which have Term in name won't help.

Some colorschemes think of this, some don't. Search in the documentation of yours, if it's your own, add it, and if you can't seem to find anything, open an issue in the colorscheme's repo.

Maintainer Cookbook

General notes about collaborating/doing maintenance work on Neovide.

How to keep your sanity

  • Don't think you need to solve, participate in or even notice everything happening.

    Work on such a project where most things are already done and the things left aren't that fun anymore can be very gruesome, even if that might not be directly noticeable. Just do whatever is fun, feels doable and is inspiring you. This is not a full-time job, it's not even a job at all. You're not required to answer if you don't feel like doing so or would be forcing yourself.

    In short: Do whatever you seriously want.

  • Always assume the best. There's no reason to be rude.

    Communication is hard. Even if it might seem like someone seriously didn't take any look at the docs before opening the issue, it's very possible that they did and found it not to be matching their case, misinterpreted what's written, or weren't sure if they were looking at the right section. What might feel obvious to you could feel obscure to another person.

    Re-state the essential docs contents, link to the relevant section and ask how it could be worded better/could be found better.

  • Ask for more information if you require so. Some investigation can be done by the user.

    If some case requires some special environmental information which isn't given in the original report, ask for it. Or if you aren't sure what you're looking for, state what you believe is the case and add some potentially useful queries. It's also completely okay to state afterwards that you still don't have a clue.

    Neovide is a frontend for an arcane text editor, it's very possible that the person reporting the issue has some Rust or general programming knowledge and could help with debugging/tracing down the original cause for an issue. Some people state so if they want to do that (usually by "I'd be happy for any pointers or hints" or "I'm interested in contributing"), but this is more art than science. Even if the original reporter can't seem to solve the issue, someone else interested in contributing might lurk around and find exactly those pointers.

How to release

Preparing

  • Head over to the releases page and hit the Draft a new release button.

  • Keep the resulting page somewhere safe open, you'll need to work with it the next half an hour and GitHub doesn't automatically save its contents.

  • Create a new tag with an appropiate version number.

    We're not fully following SemVer here, but as of 0.10.1 larger changes should be an increase in the MINOR part, while fixups should be an increase in the PATCH part.

  • Hit the Generate release notes button.

  • Reformat to be similar to previous releases

    • Rename the What's Changed section to Changes
    • Rewrite each line in the Changes section to reflect what this change means for the end user, linking to the relevant PR/commit
    • Group all bug fix PRs/commits under a point named Bug fixes
    • Have each line reflect what platform it applies to if not irrelevant
  • Hit the Save draft button

You can make several rounds of preparing such releases through editing the current draft over time, to make sure every contributor is mentioned and every change is included.

Actually releasing

  • Announce a short period of time where last changes to be done or fixup work can flow in (can be anything you imagine, though 24 hours to one week might be enough depending on the blocker)
  • Wait for that period to pass
  • Have a last look over the draft to make sure every new contributor and change has been mentioned

Now here's where the order becomes important:

  • Make sure the working directory is clean

  • Run cargo update and cargo build, make sure both succeed

  • Create a commit named Run cargo update or similar

  • Bump the version to match the tag name everywhere

    • Cargo.toml
    • snap/snapcraft.yaml
    • website/docs/*.md and update Unreleased yet to Available since $tag (where $tag is the tag name)
  • Run cargo build and make sure it succeeds, remember to git add Cargo.lock to make sure releases stay reproducable (#1628, #1482)

  • Create a commit called Bump version to $tag

  • Push and wait for CI to complete (will take around 25 minutes)

  • Run cargo build --frozen

In the meantime, you can look through the previous commits to see if you missed anything.

  • From the Bump version to $tag commit, download all the artifacts
  • Unzip neovide-linux.tar.gz.zip to get neovide.tar.gz
  • Head to the release draft, edit it and upload the produced artifacts (using the unzipped neovide.tar.gz for Linux)
  • Hit Publish release
  • profit

Phew. Now, announce the new release anywhere you think is appropiate (like Reddit, Discord, whatever) and go create a PR in nixpkgs.