duat

Duat is a text editor meant to have as much modularity as possible, while keeping a sensible default configuration. It is written and configured in Rust, through the use of a configuration Rust crate, placed in ~/.config/duat/ (or wherever $XDG_CONFIG_HOME is set to).

When installing Duat, this crate will be automatically placed in that spot, and it will have a default example configuration.

When you first run Duat, and whenever you update the configuration, it will be compiled and reloaded automatically, so you can see the changes in almost real time. Initially, building Duat and its configuration crate might take a few minutes. And the first reload might also take a similar amount of time. But whenever you make new changes, the next reloads should take only about a second (for debug profile) and ~3 seconds (for release profile).

Note that this is an alpha project, so there may be some quirks and bugs. So if you have a problem, or something seems confusing, feel free to ask questions or raise an issue, that would be very welcome 🥰.

Getting started

To install Duat, I am assuming that you have cargo installed on your system, if you don’t, install it. Additionally, you’re going to need the nightly toolchain installed, since Duat requires many nightly features:

rustup install nightly

Also, in order to run duat, you should add ~/.cargo/bin/ to your $PATH variable. Alternatively, you can just add ~/.cargo/bin/duat, if you want to add just duat to the $PATH. Now, you can install duat:

cargo install duat

Although, since this is an alpha, I would recommend the git version, since that is kept much more up to date:

cargo install --git https://github.com/AhoyISki/duat --force --features git-deps

And if you want to nuke your config in order to get the newest default config crate, you can do the following:

rm -rf ~/.config/duat
cargo install --git https://github.com/AhoyISki/duat --force --features git-deps

Configuration

In the configuration file, there should be a setup_duat! macro, which takes in a function with no parameters.

This function is the setup for duat, and it can be empty, which is the equivalent of the default configuration for Duat.

Here’s an example configuration file, which makes use of the duat-kak crate, which is a plugin for Duat. This plugin, like all others, is included without the duat_ prefix, so in the config it is just kak.

setup_duat!(setup);
use duat::prelude::*;
use kak::Kak;
use match_pairs::MatchPairs;
use treesitter::TreeSitter;

fn setup() {
    plug!(TreeSitter, MatchPairs, Kak::new());
    map::<kak::Insert>("jk", "<Esc>");

    print::wrap_on_edge();

    hook::add::<LineNumbers<Ui>>(|pa, (line_nums, _)| {
        line_nums.align_right().align_main_left()
    });

    hook::remove("WindowWidgets");
    hook::add::<WindowCreated>(|pa, builder| {
        let upper_mode = mode_name(pa).map(pa, |m| match m.split_once('<') {
            Some((no_generics, _)) => no_generics.to_uppercase(),
            None => m.to_uppercase(),
        });
        let status_line = status!("[Mode]{upper_mode}{Spacer}{file_txt} {sels_txt} {main_txt}");

        builder.push(FooterWidgets::new(status_line));
    });

    hook::add::<ModeSwitched>(|_, (_, new)| match new {
        "Insert" => cursor::set_main(CursorShape::SteadyBar),
        _ => cursor::set_main(CursorShape::SteadyBlock),
    });

    form::set("Mode", Form::dark_magenta());
}

This configuration does the following things:

• plugs the Kak plugin, which changes the default mode, and the TreeSitter plugin, which adds syntax highlighting and is also used by the Kak plugin;
• Maps jk to esc in the Insert mode;
• Changes the wrapping;
• Changes the alignment of the LineNumbers Widget;
• Removes the hook group “WindowWidgets”;
• Pushes a custom status line (with a Spacer for 2 separate sides, and a reformatted mode_name), a command line, and a notifications widget to the bottom of the screen through a widget combo;
• Adds hooks for mode changes in Duat;
• Changes the style of the mode printed on the status line;

These are some of the ways you can configure Duat. You might notice some things that can be done with these simple options:

use duat::prelude::*;
hook::add::<File>(|_, (cfg, builder)| {
    builder.push(VertRule::cfg());
    builder.push(LineNumbers::cfg());
    builder.push(VertRule::cfg().on_the_right());
    builder.push(LineNumbers::cfg().on_the_right());
    cfg
});

Now, every file will open with two lines of numbers, one on each side. Would you ever want to do this? …No, not really, but it shows how configurable Duat can be.

Duat also comes with a fully fledged text creation system, which significantly eases the creation of widgets:

let text = txt!("[my_form]Waow it's my form![]not anymore 😢").build();

In this example, I’m using the “my_form” form in order to style the text, while [] reverts back to the “default” form. Double [[ and ]] escape the [ and ], just like in println!. The status! macro works similarly.

Duat also has a simple command system, that lets you add commands with arguments supported by Rust’s type system. As an example, this command will change the numbering of a LineNumbers widget, switching between absolute and relative numbering.

Troubleshooting

These issues asume that you are working with the --git-deps version of duat

The configuration fails to compile/recompile

Try running this in ~/.config/duat:

cargo clean && cargo update && cargo build --release

This could solve inconsistencies in the API, given that it could change without the plugins being aware of those changes.

It still fails to compile!

In this case, you should open an issue with the error message that cargo build --release sent you.

It’s segfaulting sometimes when I reload

For now, since duat is using dlopen, it’s unfortunatelly just going to happen from time to time. It should work correctly if you reopen though.

This should be a problem of the past with #9, however.

It’s still segfaulting as I reopen!

This is an indication that your installed version of duat became incompatible with that of your config. Rerun the installation process, no need to remove ~/.config/duat.

It’s still segfaulting!

In that case open an issue

Default plugins

When you install duat, the default config crate will come with some preinstalled plugins:

• duat-kak is a plugin that changes the default mode of Duat to one inspired by Kakoune’s “Normal”, also bringing with it various other modes from Kakoune.
• duat-catppuccin is a just a simple colorscheme plugin, it adds the four flavors from the catppuccin colorscheme. You can pick between the four of them, you can apply its colors to other Forms and you can allow or disallow the colorscheme to set the background color.
• duat-treesitter brings tree-sitter to Duat in the form of syntax highlighting and indentation calculation, which can be used by Modes (such as those from duat-kak) in order to give better feedback when editing files.

You can, of course, unplug these by not calling plug!, or you could remove them entirely by taking them out of the Cargo.toml’s dependencies section.

Features

Duat provides a lot of features, trying to be as configurable as possible, here are some of the things that Duat is capable of:

• Completely custom modes, with full Vim style remapping
• Completely custom widgets, with user created modes
• Arbitrary concealment of text, and arbitrary ghost text
• Custom hooks, whose activation is up to the creator
• Custom commands, with customizable parameters supported by Rust’s robust type system
• Multi UI adaptability, although for now, only a terminal UI has been made
• And many others still being planned

Additionally, by choosing Rust as its configuration language, Duat also gains the following features:

• Complete type safety
• A very functional programming language, with lots of native features
• Cargo is the plugin manager

Roadmap

These are the goals that have been accomplished or are on their way:

• Implement basic visual functionality (printing, scrolling, etc);
• Implement wrapping;
• Implement editing;
• Create a kak mode;
• Implement the use of multiple cursors;
• Implement a history system;
• Implement colors;
• Implement widgets and designated areas;
• Make all of these things easy to use on a public interface;
• Create a number line and a separator line;
• Create a status line;
• File switching;
• Create a command creation interface and a command line;
• Add the ability to frame areas;
• Implement concealment;
• Implement hot reloading of configuration;
• Create a “normal editing” mode;
• Add the ability to create hooks;
• Create a more generalized plugin system;
• Implement incremental Regex searching;
• Implement tree-sitter;
• Add floating widgets, not tied to the session layout;
• Implement autocompletion lists;
• Create an LSP plugin;
• Create a vim mode;

︙

• Create an Iced frontend;

NOTE: These are not set in stone, and may be done out of order.

Why should I use this?

I don’t know what your personal reasoning would be, but in my case, I really like Kakoune’s editing model, but was frustrated with the lack of some features, like folding, multiple file editing, the general barebonesness of the configuration, etc.

I know that Neovim has all of these features, and Helix supposedly tries to solve some of these issues. But I don’t really like either of their editing styles to be honest.

And so I thought, why not make my own text editor?

I thought, why not make a text editor that is as modular as possible, while still having a sensible default configuration? That I could modify however I wanted, and with a language that I love?

That’s why I decided to create Duat.

Why the name

idk, cool sounding word that I got from Spelunky 2.

Also, just wanted to say that no AI was used in this project, cuz I don’t like it.