Perhaps like how the Kakoune text editor[0] (discussed a few days ago on HN [1]) uses tmux to manage panes (although that's C++ and just uses the Tmux client[2]).
[0]: http://kakoune.org/
[1]: https://news.ycombinator.com/item?id=13165919 (the article has a video of panes)
[2]: https://github.com/mawww/kakoune/blob/f7e2bfd76fc1629ffd4e16...
In Show HN: Libtmux – A tmux workspace manager in Pythonmawww
kakoune
C++2014–2026
mawww / kakoune
kakoune
mawww's experiment for a better code editor
62Distinct people
75Mentions
0Explicit recommenders
11.1KGitHub stars
What to know before exploring
What it is
mawww's experiment for a better code editor
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
No recommendation phrase was found in the indexed comments.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
No other repository is repeatedly linked in the same discussions.
This week on Hacker News
Nov 8–Nov 15 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/15/2026, 10:01:16 PM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year75 dated mentions
Observed mentions: 2014-02-24 00:54:18 UTC to 2026-10-28 18:40:09 UTC.
* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2014 | 2014-01-01 00:00:00 UTC | 2015-01-01 00:00:00 UTC | 2 | 1 | 1 |
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 11 | 2 | 9 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 13 | 1 | 12 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 8 | 0 | 8 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 5 | 0 | 5 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 5 | 1 | 4 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 6 | 0 | 6 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 11 | 1 | 10 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 6 | 0 | 6 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 3 | 1 | 2 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2026 (partial) | 2026-01-01 00:00:00 UTC | 2027-01-01 00:00:00 UTC | 2 | 0 | 2 |
From the project README
An excerpt from the repository, fetched Nov 13, 2026.
Read the project’s introduction
Kakoune
Table of Contents
TL;DR
Introduction
Features
Screenshots
Getting started
Building
Installing
Running
Basic Interaction
Selections
Normal Mode
Insert Mode
Movement
Appending
Using Counts
Disabling Hooks
Changes
Goto Commands
View commands
Marks
Jump list
Multi Selection
Object Selection
Commands
Basic Commands
Multiple commands
Configuration & Autoloading
Kakrc
Color Schemes
Options
Advanced topics
Faces
Registers
Macros
Search selection
Regex syntax
Exec and Eval
Insert mode completion
Escape to normal mode
Highlighters
Hooks
Key Mapping
Defining Commands and Aliases
FIFO Buffers
Credits
TL;DR
https://kakoune.org
Modal editor — Faster as in fewer keystrokes — Multiple selections — Orthogonal design
git clone https://github.com/mawww/kakoune.git
cd kakoune
make
./src/kak
See https://github.com/mawww/golf for Kakoune solutions to vimgolf challenges,
regularly beating the best Vim solution.
See the design document for more information on
Kakoune’s philosophy and design.
Introduction
Kakoune is a code editor that implements Vi’s "keystrokes as a text editing
language" model. As it is also a modal editor, it is somewhat similar to the
Vim editor (after which Kakoune was originally inspired).
Kakoune can operate in two modes: normal and insertion. In insertion mode,
keys are directly inserted into the current buffer. In normal mode, keys
are used to manipulate the current selection and to enter insertion mode.
Kakoune has a strong focus on interactivity. Most commands provide immediate
and incremental results, while being competitive with Vim in terms of keystroke count.
Kakoune works on selections, which are oriented, inclusive ranges of characters.
Selections have an anchor and a cursor. Most commands move both of
them except when extending selections, where the anchor character stays fixed
and the cursor moves around.
See https://vimeo.com/82711574
Join us on libera IRC #Kakoune
Features
Multiple selections as a central way of interacting
Powerful selection manipulation primitives
Select all regex matches in current selections
Keep selections containing/not containing a match for a given regex
Split current selections with a regex
Text objects (paragraph, sentence, nestable blocks)
Powerful text manipulation primitives
Align selections
Rotate selection contents
Case manipulation
Indentation
Piping each selection to external filter
Client-Server architecture
Multiple clients on the same editing session
Use tmux, zellij, kitty, wezterm or your X11/Wayland window manager to
manage splits/panes by spawning clients connected to the same session
Simple interaction with external programs
Automatic contextual help
Automatic as you type completion
Macros
Hooks
Syntax Highlighting
Supports multiple languages in the same buffer
Highlight a buffer differently in different windows
Screenshots
Figure 1. Kakoune in i3
Figure 2. Kakoune in tmux
Getting started
Building
Kakoune’s dependencies are:
A C++20 compliant compiler (GCC >= 10.3 or clang >= 11) along with its
associated C++ standard library (libstdc++ >= 10 or libc++)
To build, just type make in the root directory.
To generate man pages, type make man in the root directory.
Kakoune can be built on Linux, MacOS, and Cygwin. Due to Kakoune relying heavily
on being in a Unix-like environment, no native Windows version is planned.
Installing
In order to install kak on your system, rather than running it directly from
its source directory, type make install. You can specify the PREFIX and
DESTDIR if needed.
Tip
Homebrew (macOS) or Linuxbrew
brew install kakoune
Tip
MacPorts (macOS)
sudo port selfupdate
sudo port install kakoune
Tip
Fedora supported versions and Rawhide
dnf install kakoune
Tip
Fedora daily builds
Use the copr repository.
dnf copr enable jkonecny/kakoune
dnf install kakoune
Tip
RHEL/CentOS 8
Kakoune can be found in the EPEL8 repositories.
dnf install kakoune
Tip
Arch Linux
Kakoune is found in the repositories.
pacman -S kakoune
Tip
Gentoo
Kakoune is found in portage as
app-editors/kakoune.
emerge kakoune
Installation and Gentoo specific documentation is available.
Tip
Exherbo
cave resolve -x repository/mawww
cave resolve -x kakoune
Tip
openSUSE
Kakoune can be found in the repositories.
sudo zypper install kakoune
Tip
Ubuntu
Kakoune can be found in the Ubuntu repositories.
sudo apt install kakoune
If you want to compile from source on 20.04 or earlier, you must force the build to use GCC 10, which is not the default. Also, make sure you have .local/bin in your path so that kak is available after the installation.
git clone https://github.com/mawww/kakoune.git && cd kakoune/src
CXX=g++-10 make
make PREFIX=$HOME/.local install
Tip
Debian
Kakoune can be found in Debian 9 (Stretch) and later releases.
sudo apt install kakoune
Tip
FreeBSD
Kakoune is available in the official ports tree as
editors/kakoune.
A binary package is also available and can be installed with
pkg install kakoune
Tip
OpenBSD
Building on OpenBSD 6.7 amd64.
# pkg_add git gmake
# git clone https://github.com/mawww/kakoune
# cd kakoune
# export CXX=clang++
# gmake install
Kakoune is available in the 6.7-current port tree as
editors/kakoune
A binary package is also available for -current snapshot and can be installed with
# pkg_add kakoune
Running with support for plugins.
# pkg_add dash
$ export KAKOUNE_POSIX_SHELL=/usr/local/bin/dash
$ kak
Tip
Solus
Kakoune is available in the Solus stable repository.
It can be installed with
eopkg install kakoune
Tip
Void
Kakoune is available in the repositories.
It can be installed with
xbps-install -S kakoune
Tip
Term
Read the full README on GitHubWhat Hacker News says
13 sourcesIt's pretty hard to find a link[0] to actually getting kakoune on the home page. Usually that sort of link at the bottom is an email URI and I try to avoid clicking on those.
Based on the linked screenshot[1], perhaps the editor should be named "Clippy's Revenge"
[0] https://github.com/mawww/kakoune
[1] http://kakoune.org/img/screenshots/screenshot-tmux.gif
In Why Kakoune – The quest for a better code editorIt's a new caledonian word, see https://github.com/mawww/kakoune/blob/master/doc/manpages/fa...
In Why Kakoune – The quest for a better code editorFAQ on various things and what the name means:
https://github.com/mawww/kakoune/blob/master/doc/manpages/fa...
In Why Kakoune – The quest for a better code editorThe code statistics on github[1] show almost all C++, while vim is written in C. According to the author the project began as a reimplementation or merely a rewrite of vim then turned into a more ambitious reimagining of how to design a modal editor.
[1] https://github.com/mawww/kakoune
In Why Kakoune – The quest for a better code editorThey are just command that you could execute manually (using ':' like in vim). The difference is that all the commands in this file are executed at startup.
As I said, all the heavy lifting is done in scopes like
%sh{ ... }. This way you can actually use any language you want, and it's only the piping you have to do through kakoune commands.
Most common languages (like go) already have plugins to do some basic tasks like formatting.
If you're interested in the editor, I would rather recommend reading the readme of the project[1]. There is a lot to read, and you can start making plugins once you understand it.
[1] https://github.com/mawww/kakoune
In Why Kakoune – The quest for a better code editorSome answers as a user:
No scripting language, most of the heavy lifting done in plugin is through shell calls (asynchronously or not). Example here [1]. I personally think that it's kinda hard to grok to be honest.
Thanks to the client server architecture, it is possible to make an external UI[2].
There is no line wrapping currently. Don't know about long documents, but the editor in general is very efficient.
[1] https://github.com/mawww/kakoune/blob/master/rc/core/grep.ka...
[2] https://github.com/mawww/kakoune/blob/master/doc/json_ui.asc...
In Why Kakoune – The quest for a better code editorFrom the github repository: https://github.com/mawww/kakoune
reply
Vim inspired — Faster as in less keystrokes — Multiple selections — Orthogonal design
In Why Kakoune – The quest for a better code editorYou can find the editor source, and installation instructions on github: https://github.com/mawww/kakoune
In Why Kakoune – The quest for a better code editorI was sort of in your situation a while ago and wanted to learn vim, but was a bit put off by all the legacy that it carries (also spoiled by sublime's multiple cursors).
I then discovered kakoune[1] and liked its design. I started getting familiar with it and using it more and more, and I think its core is much more solid than vim/emacs. It definitely doesn't have the same community support and plugins but it's already quite feature rich.
[1] https://github.com/mawww/kakoune
In VimWiki – A personal wiki for VimI've found that reading the source code (or at least the general structure) of kakoune[1] really helped me understand editors. I think it's a very high quality c++ codebase for a relatively complex editor.
[1] https://github.com/mawww/kakoune
In Buttery Smooth EmacsPersonally, I find vim's modal editing to be very efficient. When starting from a clean slate, it doesn't really matter much -- but when changing/editing existing text/code, I find it feels much more natural. It also works well without using the mouse, which is important to me because of carpal tunnel syndrome (and also helps when working without a proper mouse, such as on laptops).
I've only toyed with emacs, but based on that, I don't think emacs' idea of keyboard "chords" is as good a fit as vi(m). With standard keybindings, it also puts a strain on my wrists.
Modal editing and the "edit language"[1] (verbs, nouns, modifiers (and motions), like dw=delete word, dd/dl=delete line, d$=delete from cursor to end-of-line, dG (delete to endo-of-file, where gg/G is motion for moving to top/bottom of file respectively), ciw()<ESC>P=change inner
Read the rest
word (cut word under cursor to buffer), add "()", escape out of insert mode, paste word between "()"). These look cryptic, but quickly starts to feel quite natural and intuitive.
My impression is that Emacs' Evil-mode has evolved quite a lot lately, and allows one to combine the best of both: a much better programming language (scheme dialect) for customization, with modal editing and vi(m) key bindings. But I've yet to play with it.
If you don't mind using the mouse, you might also want to look at ACME[2] - it's a bit more exotic, and unfortunately hasn't gotten as much support as VIM/Emacs.
The creator of Vim, Mjolnar, has a great video on "7 Habits For Effective Text Editing 2.0":
https://www.youtube.com/watch?v=p6K4iIMlouI
I think the idea is very powerful: aim for incremental improvement in your workflow. You don't have to use vim to do that, but you certainly can use vim for that. Another editor that might be worth a look if you're not already familiar with vim, is: https://github.com/mawww/kakoune
The main argument for Neovim/vim/Emacs over other "smaller" editors would be the plugin eco-system. I have a theory though, that beginners tend to start out with a lot of plugins, and then gradually trim down, as they realize the power that lies within the editor itself.
Still, for vim, you will probably want a plugin manager (well, maybe not now with vim 8 supporting that out of the box :-), and depending on what you're writing, some integration with a tag tools, like cscope, perhaps a search-tool like Ag/The silver searcher: https://github.com/rking/ag.vim#readme
As for plugin manager, I'm personally in the process of moving - I'd suggest looking at Vundle and/or vim-plug.
Finally, you can generally count on any unix-like system to have some form of vi(m) installed -- I'm not sure I really see that as such an important point, but does make it easier to edit stuff on a server with only ssh open to the world. But that stuff you're editing should probably be in a VCS, and use some kind of automated push to land on the server anyway! :-)
[1] http://yanpritzker.com/2011/12/16/learn-to-speak-vim-verbs-n...
"A Tour of the Acme Editor", by Russ Cox
[2] https://www.youtube.com/watch?v=dP1xVpMPn8M