How to install the Kakoune code editor on Linux – Addictive Tips Guide

If you’ve ever looked at your terminal and thought, “I want Vim vibes, but with fewer ritual sacrifices,”
you’re in the right place. Kakoune (often called “kak”) is a fast, selection-first, modal code editor
that feels familiar to Vim usersbut it has its own personality, and it’s the kind that’s weirdly easy to get hooked on.

This guide walks you through installing Kakoune on the most popular Linux distributions (Ubuntu/Debian, Fedora, Arch,
openSUSE, Nix/NixOS), plus a universal Snap option and a “give me the latest” build-from-source method. Along the way,
we’ll cover verification steps, common hiccups, and a beginner-friendly first-run setup so you don’t install it and then
immediately close the terminal like it just made eye contact.

What is Kakoune, and why do people get obsessed with it?

Kakoune is a modal editor inspired by the Vi family, but it takes a different approach:
it’s selection-first. In practical terms, you often select text first and then act on it,
instead of moving a cursor and hoping you’re on the exact right character. It also supports
multiple selections (think multi-cursor editing, but purpose-built), and it’s designed to be
interactivehelpful completions, contextual prompts, and a workflow that encourages you to stay in the editor instead of
bouncing between tools.

Another big reason it feels “addictive”: Kakoune has a client-server architecture. You can attach
multiple clients to the same editing session, which plays nicely with terminal multiplexers (like tmux) or a tiling window
manager. Once you get used to that “one session, many views” workflow, it’s hard to go back.

Before you install: pick your Kakoune “diet”

There are three main ways to install Kakoune on Linux. The best one depends on whether you want convenience, the newest
version, or something portable across distributions.

• Distribution package manager (APT, DNF, Pacman, Zypper, etc.): easiest and usually safest. The tradeoff:
  some distro repos may lag behind the newest upstream release.
• Snap: simple cross-distro install, often reasonably up to date. Requires snapd and uses “classic”
  confinement.
• Build from source: best for the latest release (or if your distro package is older than your favorite meme).
  Requires a C++20 compiler and build tools.

If you’re on Ubuntu and you notice your repo version is behind upstream, don’t panicthis is common for some packages.
Your options are: live with it, use Snap, or build from source.

Install Kakoune using your distro’s package manager

This is the “just let me edit files today” path. Use your distro’s package manager and you’ll get a working Kakoune
integrated with your system.

Ubuntu / Debian (APT)

Update package lists, then install:

Tip: If you specifically need the newest upstream features and your distro package is older, consider the Snap method
or build from source. For many people, the repo version is totally fine for day-to-day editing.

Fedora (DNF) and RHEL-family

Install from Fedora’s repos:

Want something newer than the standard repo? Some users choose “daily builds” via COPR. This is optional and more advanced
because third-party repos can carry different trust and update policies than official distro repos. If you do use COPR,
prefer well-known maintainers and read the project page before enabling anything.

Arch Linux (Pacman)

Install from the official repositories:

If you want the bleeding-edge development version, Arch users often install a “-git” package from the AUR (for example,
kakoune-git). Many people use an AUR helper (like yay or paru), but that’s optionaluse the method you’re comfortable with,
and remember that AUR packages are community-maintained.

openSUSE (Zypper)

Try installing directly from the repos:

If your enabled repositories don’t include Kakoune (or you want a specific build), openSUSE also offers packages via the
Open Build Service. One common approach is adding a repository and installing from there:

Nix / NixOS

If you use Nix, you can install Kakoune from nixpkgs:

Nix users often go further and declare Kakoune in system or home configuration, but the command above is the fastest way to
get it installed and working.

Other popular distros (quick commands)

Kakoune is packaged in many ecosystems. Here are a few “grab-and-go” commands you might see:

• Gentoo: emerge kakoune
• Void Linux: xbps-install -S kakoune
• Termux (Android terminal environment): pkg install kakoune

Install Kakoune via Snap (cross-distro option)

Snap is a convenient middle ground when you want a simple install that’s not tied to your distro’s package timeline.
On Ubuntu, it’s often a one-liner:

On some distros (like Fedora), you’ll install snapd first, then enable classic snap support. The exact steps can vary by
distro, but a common Fedora approach looks like this:

Note: “classic” confinement means the snap isn’t strictly sandboxed the way some snaps are. That’s normal for development
tools that need broad filesystem access, but it’s good to know what you’re installing.

Build and install Kakoune from source (best for the latest release)

If you want the newest upstream versionor your distro package is older than your coffeeyou can build Kakoune from source.
The official build process is intentionally simple: it’s essentially make and then make install.

What you’ll need

• A C++20-compliant compiler (for example, modern GCC or Clang) and a matching standard library.
• make and basic build tooling.
• Terminal UI dependencies (commonly ncurses), depending on how your distro packages build requirements.
• Optional: asciidoc (or related tools) if you want to generate man pages.

Clone, build, and install

This approach installs Kakoune system-wide (requires sudo). It’s clean and straightforward on most distros:

Want a user-local install (no sudo, and easy to remove later)? Install to ~/.local with a PREFIX:

After a local install, make sure $HOME/.local/bin is in your PATH. If it isn’t, your terminal may act like
Kakoune doesn’t exist (which is rude, honestly).

Ubuntu-specific footnote: On older Ubuntu releases (like 20.04 and earlier), you may need to explicitly use a newer compiler
than the default to meet C++20 requirements. One documented pattern is setting CXX before building:

Verify the install (and avoid the “did it work?” spiral)

Once installed, confirm Kakoune launches:

If Kakoune opens, congratsyou’ve succeeded. If you want a quick look at command-line flags, try:

You can also open a specific file directly:

First run basics: enough to feel productive in 5 minutes

Kakoune is modal, so you’ll spend most of your time in “normal mode” and jump into “insert mode” when you actually want
to type text.

• Insert text: press i to enter insert mode (you’ll then type like a normal editor).
• Return to normal mode: press Esc.
• Run a command: press : in normal mode, then type a command (like saving or quitting).

Yes, it sounds familiar if you’ve used Vim, but Kakoune’s “selection-first” approach will feel different in your hands.
Give yourself a day before judging it. Your muscle memory might throw a tiny tantrum at first.

Create a simple config file

Kakoune loads user configuration from ~/.config/kak/kakrc (or the XDG config path if you’ve customized it).
You can start with a tiny, friendly config.

Example minimal kakrc ideas (keep it simple at first):

The editor ships with runtime scripts (syntax highlighting, filetype helpers, and more). If you build from source and
only run the binary without installing, you may miss runtime integrationso prefer make install over
“run it from the build folder forever.”

Troubleshooting: common installation problems (and quick fixes)

“kak: command not found”

This usually means one of two things:

• Kakoune isn’t installed (double-check your package manager output).
• Kakoune is installed somewhere not in your PATHcommon with user-local installs.

If you installed to ~/.local, ensure ~/.local/bin is in your PATH. You can test quickly:

If you don’t see ~/.local/bin, add it in your shell profile (for example, in ~/.bashrc or
~/.zshrc):

“My distro version is old”

That’s not unusualstable distributions often prioritize stability over the newest features. If you want a newer build:

• Use Snap for an easy cross-distro install.
• Build from source for the newest upstream release.
• On Fedora, consider COPR daily builds (optional and advanced).
• On Arch, consider an AUR -git package (community-maintained).

“Syntax highlighting looks off” or “runtime files missing”

Make sure you installed Kakoune properly (especially if you built from source). A full install includes runtime scripts
that power highlighting and filetype behavior. If you built it, run make install (or a PREFIX-based install)
rather than only executing the compiled binary in-place.

Experience notes: what it’s like installing and living with Kakoune

Installing Kakoune is usually the easy partthe “experience” begins the moment you open it and realize your hands are about
to learn a slightly different dialect of the modal-editor language. Here are the most common real-world experiences people
report after installing Kakoune on Linux, plus some practical advice to make the transition smooth.

First: the selection-first mindset is the main “aha!” moment. If you’re coming from Vim, your brain is
trained to move a cursor precisely and then run an action. Kakoune nudges you to select text as you move, and then apply
operations to that selection. At first, this can feel like your cursor is suddenly carrying a highlighter marker around
and coloring everything you pass. That’s not a bugit’s the point. Once it clicks, editing becomes more “visual” and
intentional. You stop wondering “am I on the right character?” because your selection shows you what you’re acting on.

Second: multiple selections are where Kakoune earns its keep. Many users install Kakoune out of curiosity, then stay because
editing repeated patterns is dramatically faster when you can create several selections and apply changes in one shot. In
day-to-day work, this looks like quickly adjusting several variable names, changing multiple function calls, or fixing a
repeated formatting issue without reaching for an external search-and-replace tool. The “addictive” feeling comes from the
moment you do a multi-edit that would have been tedious elsewhereand it works in seconds.

Third: your installation method can shape your long-term happiness. If you installed from your distro repository and you’re
on a stable distribution, you may eventually read about a feature or improvement that isn’t in your packaged version yet.
That’s when many people switch to Snap or build from source. The source build route appeals to the “I want the latest, and I
don’t mind compiling” crowd. The Snap route appeals to the “I want updates without thinking too hard” crowd. Neither is
morally superior (this is a text editor, not a personality test), but choosing the right method prevents future frustration.

Fourth: terminal workflow matters. Kakoune plays nicely with terminal multiplexers and tiling window managers because of its
client-server architecture. In practice, users often start an editing session, then attach another client in a different
pane or terminal to view another file in the same session context. This feels powerful once you get used to it, especially
if you like having logs on one side, code on the other, and a third terminal for running tests. The installation itself
doesn’t force you into this workflow, but Kakoune’s design quietly encourages it.

Fifth: the most common early “gotcha” is configuration expectations. New users sometimes expect a full IDE experience out of
the box. Kakoune ships with helpful defaults and runtime scripts, but it’s still an editor: you’ll likely add language
servers, formatting tools, and custom hooks over time. The good news is that you don’t need to do that on day one. A realistic
path is: install Kakoune, learn the movement/selection basics, then gradually add quality-of-life improvements. Many people
report that once they stop trying to configure everything immediately, Kakoune becomes much more enjoyable.

Finally: the “I can’t quit now” stage is real. Once you’ve installed Kakoune and used it for a week, you may notice your
tolerance for slow, repetitive editing drops dramatically. You’ll start reaching for multiple selections as a reflex. You’ll
prefer workflows where your editor stays responsive and your hands stay on the keyboard. And yesyou may catch yourself
recommending Kakoune to friends with the same intensity people reserve for a new TV series. That’s normal. Welcome to the
club. We have selections.

Conclusion

Kakoune is one of those tools that feels simple to install, then surprisingly deep to master. If you want the easiest setup,
install it from your distro’s package manager. If you want something portable across distros, use Snap. If you want the newest
upstream version, build from source with a modern C++20 compiler and install it properly so runtime scripts work as intended.

Once it’s installed, spend a little time getting comfortable with selection-first editing and basic mode switching. The payoff
is real: faster edits, fewer keystrokes, and a workflow that makes multi-change tasks feel almost unfair (in the fun way).

SEO tags