Issue tracking can be found at ~reykjalin/kakoune-mode.
WARNING: This VSCode extension is still under heavy development and should only be considered ready for testing. It is not ready for real use.
Kakoune mode allows you to use the text editor Kakoune as the text editing driver instead of VSCode. This extension runs an instance of Kakoune in the background, passess all inputs to Kakoune and only uses VSCode to display the text file. While in insert mode VSCode does take care of insertion, but everything VSCode does is echoed to Kakoune. Once you exit insert mode, the VSCode view is synced back up with Kakoune.
Because Kakoune is used in the background, user defined functions should work. As an example, custom keybindings — e.g. a custom keybinding to exit insert mode — will work by simply modifying the
All other custom configuration should work, at least in theory. Plugins might not work, depending on what kind of functionality they provide.
I've been trying to find a good code editor for day to day use and haven't really been able to find one. VSCode provides the best overall experience, but I want a modal editor so I need to rely on extensions. Currently I use the Vim extension for VSCode to simulate Vim, but I like the Kakoune way of doing things so much better. Since there's no proper Kakoune mode plugin I decided I might as well just work on it myself!
The Reason tooling is also much better. The F# tooling for VSCode can feel a bit slow, often taking ~1sec to think for auto-completions and types, and you need to compile manually (or use a watcher) while developing. The Reason tooling is relatively fast, auto-completions come in instantly, and the toolchain is fast enough to recompile automatically after every save, which is an immense productivity boost.
My reason for looking into these 2 frameworks is that I wanted to use a functional language for features such as pattern matching, currying, and pipes (
-> in Reason).
Type safety is also a big consideration, although you do get that with TypeScript, just not to the same extent.
any make the type system more complicated than I'd like it to be.
There are some downsides to this, particularly in the form of glue code.
The best example is probably
src/VSCode.re where I've mapped the part of the VSCode API I use to Reason types.
Most of this code still looks like Reason, which was not the case with F#.
kak needs to be available in your
You can find installation instructions for Kakoune in the GitHub repository.
You'll need to have
npm install npm run build