Tilix gehört für mich seit vielen Jahren zu den Terminal-Programmen, die ich seit Jahren immer wieder installiere. Die frei aufteilbaren Terminalbereiche und die Möglichkeit, mehrere Shells gleichzeitig zu verwalten, haben meinen Arbeitsalltag deutlich erleichtert. Leider wird das Projekt inzwischen kaum noch gepflegt und basiert weiterhin auf GTK3 und VTE3.

Mit Rutile entsteht deshalb ein spannendes Projekt. Die Entwickler schreiben Tilix nicht einfach weiter, sondern entwickeln den Terminal-Emulator vollständig in Rust neu. Gleichzeitig bleibt das Bedienkonzept erhalten. Statt einer Neuerfindung soll eine moderne Umsetzung entstehen, die sich nahtlos in aktuelle GNOME-Systeme mit GTK4 und libadwaita einfügt.

Bewährtes Konzept auf moderner Basis

Viele Terminal-Emulatoren unterscheiden sich hauptsächlich durch ihr Erscheinungsbild oder kleinere Zusatzfunktionen. Rutile verfolgt dagegen einen anderen Ansatz. Ziel ist es, die Arbeitsweise von Tilix möglichst vollständig zu übernehmen und auf eine moderne technische Grundlage zu stellen. Bestehende Nutzer sollen sich sofort zurechtfinden.

Die Anwendung verwendet GTK4, libadwaita und VTE4 und profitiert dadurch von aktuellen Bibliotheken des GNOME-Desktops. Gleichzeitig setzen die Entwickler auf Rust als Programmiersprache. Das verspricht langfristig eine besser wartbare Codebasis und eröffnet die Möglichkeit, neue Funktionen auf einer modernen Architektur aufzubauen.

Flexible Terminalaufteilung

Die wichtigste Funktion übernimmt Rutile direkt von Tilix. Das Terminalfenster lässt sich rekursiv horizontal und vertikal aufteilen. Jeder Bereich kann anschließend erneut geteilt werden. Dadurch entstehen flexibel verschachtelte Arbeitsbereiche, ohne dass die Anwendung auf ein festes Raster oder eine bestimmte Fensteranordnung beschränkt ist.

Im Alltag bietet diese Arbeitsweise viele Vorteile. Links lassen sich beispielsweise Logdateien beobachten, während rechts gleichzeitig mehrere Server oder Container geöffnet sind. Zwischen den einzelnen Bereichen wechselt ihr bequem per Tastatur. Das spart Mausbewegungen und sorgt für einen flüssigen Arbeitsablauf bei komplexeren Aufgaben.

Andere Terminals wie Ghostty bieten diese Funktion ebenfalls, allerdings muss man sich dafür Tastenkombinationen merken. Alternativ kann man natürlich auch Terminal-Multiplexer wie tmux verwenden. Dort gilt jedoch dasselbe. Auch wenn es nicht viele Tastenkombinationen sind: Ich persönlich möchte dafür einfach Buttons haben.

Mehrere unabhängige Sitzungen

Neben den frei aufteilbaren Terminalbereichen unterstützt Rutile mehrere voneinander getrennte Sitzungen. Jede Sitzung besitzt ihre eigene Fensteraufteilung und ihren eigenen Arbeitskontext. Dadurch lassen sich unterschiedliche Projekte oder Aufgaben sauber voneinander trennen, ohne dafür mehrere Programmfenster öffnen zu müssen.

Zwischen den Sitzungen wechselt ihr entweder per Tastenkombination oder über eine Seitenleiste. Diese zeigt kleine Vorschaubilder der jeweiligen Arbeitsumgebung und bleibt standardmäßig ausgeblendet. Wer sie benötigt, blendet sie einfach über die Werkzeugleiste ein und behält so auch bei vielen geöffneten Sitzungen leichter den Überblick.

Synchronisierte Eingaben

Besonders praktisch finde ich die Funktion zur synchronisierten Eingabe. Aktiviert ihr sie, überträgt Rutile sämtliche Tastatureingaben gleichzeitig an mehrere Terminalbereiche einer Sitzung. Das spart Zeit, wenn identische Befehle auf mehreren Servern oder virtuellen Maschinen ausgeführt werden sollen.

Einzelne Terminalbereiche lassen sich jederzeit von der gemeinsamen Eingabe ausnehmen. Dadurch können einzelne Systeme gezielt abweichende Befehle erhalten, ohne die Synchronisierung komplett zu deaktivieren. Trotzdem empfiehlt sich etwas Vorsicht, denn fehlerhafte Befehle werden ansonsten ebenso gleichzeitig auf allen verbundenen Systemen ausgeführt.

Vertraute Bedienung

Auch die Tastenkombinationen orientieren sich eng am Vorbild. Mit Strg+Umschalt+O und Strg+Umschalt+E teilt ihr das Fenster horizontal oder vertikal. Strg+Umschalt+W schließt den aktiven Bereich, während ihr mit den Pfeiltasten zwischen den einzelnen Terminalfenstern wechselt.

Neue Sitzungen öffnet ihr mit Strg+Umschalt+T. Zwischen vorhandenen Sitzungen wechselt ihr per Strg+Umschalt+Bild auf beziehungsweise Bild ab. Wer lieber mit der Maus arbeitet, erreicht dieselben Funktionen zusätzlich über die Werkzeugleiste oder das Kontextmenü der einzelnen Terminalbereiche.

Noch in einer frühen Entwicklungsphase

Rutile befindet sich derzeit noch am Anfang seiner Entwicklung. Die erste Version konzentriert sich bewusst auf die wichtigsten Funktionen. Features wie der Quake-Modus, das Speichern kompletter Sitzungen, Desktop-Benachrichtigungen oder die Nautilus-Integration sollen erst folgen, wenn die vorhandenen Funktionen zuverlässig arbeiten.

Diesen Ansatz halte ich für sinnvoll. Statt möglichst viele Funktionen früh bereitzustellen, konzentriert sich das Projekt zunächst auf einen stabilen Kern. Gerade bei Werkzeugen, die viele Anwender täglich nutzen, sind Zuverlässigkeit und ein konsistentes Bedienkonzept meist wichtiger als eine möglichst lange Funktionsliste.

Was aktuell wirklich fehlt, sind Übersetzungen – einige Dialoge erscheinen derzeit ausschließlich auf Französisch. Außerdem lassen sich die Terminalfarben noch nicht direkt in den Einstellungen anpassen. Das voreingestellte Farbschema macht Programme wie den Midnight Commander teilweise schwer lesbar. Allerdings ist die aktuelle Version von Rutile erst vor wenigen Tagen erschienen, sodass sich hier vermutlich bald etwas tun wird.

Installation

Unter Arch Linux steht Rutile sowohl als Quellpaket als auch als vorkompilierte Variante im AUR zur Verfügung. Für Debian, Ubuntu und Fedora bieten die Entwickler fertige DEB- beziehungsweise RPM-Pakete an. Zusätzlich lässt sich eine eigenständige Binärdatei herunterladen, sofern die benötigten GTK4-Komponenten bereits installiert sind. Alle Informationen zur Installation finden sich auf der GitHub-Seite des Projekts.

Wer Tilix seit Jahren nutzt und auf einen modernen GTK4-Unterbau wechseln möchte, sollte Rutile im Auge behalten. Noch fehlen einige Funktionen, doch der bisherige Entwicklungsstand macht einen sehr vielversprechenden Eindruck. Das Projekt verfolgt einen klaren Fokus und könnte sich zu einem würdigen Nachfolger für Tilix entwickeln.

Kitty is a popular terminal emulator that supports many modern features. Focused on power users, it offers a wide range of customization that other terminals often lack.

For example, it includes a functional image display protocol and smooth cursor animations.

I have shown Kitty tweaking in the past, and in the regards, I would like to discuss Kittens today.

Kittens are functional units that extend the features of the Kitty terminal or work as standalone programs. They have direct access to the running Kitty instance.

Kitty comes bundled with several of these kittens, written in Go, which we will explore in detail later. You even have the option to create your own custom Kittens in Python, if you find a specific need that hasn't been solved yet.

Some Cool Default Kittens

Themes

Let's start with the most popular tool first. If you use Kitty daily, you have likely come across this utility at some point.

Themes is a kitten that allows you to change your terminal color scheme interactively without editing any configuration files. Kitty includes a wide variety of preset themes that you can access by running a simple command:

kitten themes

In the overlay window, you can easily scroll through both dark and light themes to see a live preview. Once you find one you like, just press Enter and follow the prompts to set it as your preferred theme.

In my opinion, this is a feature I really miss when using Ghostty. While Ghostty has a similar interface, you still have to manually edit your configuration file to apply the theme name after you pick one.

Fonts

If you have found a new font and want to set it as your terminal choice, this kitten has you covered. You can launch the interactive interface directly in your terminal using a simple command:

kitten choose-fonts

This tool allows you to perform several actions within a single interface. You can select new fonts, preview how they look, and even fine-tune specific font faces.

The utility makes it much easier to manage your typography without guessing how a font will appear in your workspace. It handles the complex parts of the setup so you can focus on finding the perfect look.

Choose files

Choose files is a comprehensive file picker designed for Kitty and other GUI applications on your system. It functions similarly to fzf but is specifically optimized for finding and managing files.

This tool offers several powerful features, including the ability to select multiple files at once. It intelligently respects .gitignore rules in your git directories to keep your workflow clean.

To use it, run:

kitten choose-files

You can also select non-existent files to trigger a "save file" option or choose entire directories. In my opinion, this file picker will completely change the way you interact with files in your terminal.

Quick access terminal

If you remember Yakuake in KDE, you are already familiar with the concept of a drop down terminal for quick tasks. Kitty offers similar functionality through the Quick Access Terminal Kitten.

You can launch this feature at any time using a simple command in your terminal:

kitten quick-access-terminal

If you want to personalize the experience, you can customize the tool using a specific configuration file. Simply create or edit quick-access-terminal.conf inside your ~/.config/kitty/ directory to adjust its behavior.

GPU accelerated dock panel

The Panel kitten is something truly special. It creates a desktop panel for you that functions much like i3bar.

While some might feel this is a bit overpowered for a terminal application, the panel is quite interesting for minimal use cases. It even allows you to set tools like btop as your actual desktop wallpaper.

In my opinion, this is an incredible feature for anyone who loves a unique workspace. You heard that right, and here is a great example of how it looks in action.

A diff tool

The diff kitten is an excellent tool available directly within Kitty. It offers several advanced features like side-by-side comparisons, syntax highlighting, and even image diffs or recursive directory comparisons.

To use it, you simply pass the file names as shown in the command below:

kitten diff file1 file2

Other interesting Kittens

I use the terminal daily for standard update tasks and editing text files. If you are deeply involved in terminal usage, there are many kittens available for very niche use cases.

For example, the Broadcast kitten allows you to type text simultaneously across multiple Kitty windows. There are also SSH related kittens designed for editing files and even a specialized SSH supported clipboard.

In my opinion, these specific tools are essential for power users who manage remote servers regularly. Feel free to experiment with these options to make your terminal life significantly more productive.

Assign keybindings/alias for quick access

All these kittens can be bound to keyboard shortcuts or aliases so you don't have to manually run the command every time. This makes your workflow much faster by giving you instant access to your favorite actions.

I will show you how I mapped the kittens in my own configuration file. It is a straightforward process that keeps everything organized and easy to access.

The most important step is to make sure your chosen keys are uniquely assigned. You want to avoid any conflicts with existing terminal options or system-wide shortcuts.

In the below code, I mapped the F1 key to get the file chooser kitten in multiple file select mode.

map f1 kitten choose-files --mode=files

Adding the following line to your shell configuration file (~/.bashrc) to add an alias to the diff tool:

alias d="kitten diff"

Now, you can run:

d file1 file2

To get the difference between them.

Another example, let's map the F2 key to get a quick access terminal:

map f2 kitten quick-access-terminal

Wrapping up

So, we have seen how kittens can improve your terminal productivity. While most of these have separate alternatives like fzf for file selection or difftastic for diffs, integrating them directly into your terminal with a clean UI is commendable.

Kitty also offers a desktop-ui kitten that lets you integrate the file picker into all your GUI apps. Since this can cause issues with some applications and is something I use rarely, it remains out of scope for this guide.

In my opinion, the seamless integration of these tools makes Kitty feel much more cohesive than a standard terminal emulator.

Did you find any of these kittens useful enough to replace your existing tools?

It's been nearly five years since Alacritty made its debut and became a favorite of many power terminal users.

By power users, I mean people who configure Vi mode everywhere, even in graphical IDE.

Personally, I prefer Kitty and I have written some tutorials on Kitty. But whenever we share our Kitty articles, someone would mention Alacritty. And that kind of forced me to try Alacritty.

But this article is not about comparing Kitty and Alacritty. It's merely me sharing my experience and exploration of Alacritty.

What is Alacritty?

Alacritty is a modern terminal emulator designed with a strong focus on performance. It is a GPU-accelerated terminal that uses OpenGL technology to offload rendering tasks entirely to your graphics processor rather than relying heavily on the CPU. Out of the box, Alacritty comes with a decent set of defaults. Which seems to be true as you really don't need to do much to make this terminal work right away.

Exploring Alacritty

Alacritty comes with several 'cool features' that will elevate your terminal workflow. These are Vi mode, scrollback buffer search, regex hints and multi-window approach.

Scrollback navigation with keyboard

Alacritty features a built-in Vi mode, which you can easily access using the keyboard shortcut Ctrl + Shift + Space.

Once you are in this mode, you can move around your scrollback buffer using standard Vi navigation keys. This means you don't need to reach for your mouse at all just to scroll through your text, keeping your hands exactly where they belong on the keyboard.

Text selection

The Vi mode can do several types of selection and copy text entirely with keyboard shortcuts.

When you are in Vi mode, pressing Alt + v enables semantic selection, which is the one I use most often. Semantic selection is a smart feature that lets you select distinct words or semantic blocks of text based on specific characters acting as boundaries.

If you want to perform a standard manual selection, simply press v to start selecting from the cursor, then move the cursor in any direction to select your text.

Now, instead of lowercase v, if you press Shift + v, a line selection mode is enabled, allowing you to quickly select entire lines of text at once.

Searching inside terminal

When you have a lot of output in your terminal scrollback and need to track something down, Alacritty has built-in search functions. You can press Ctrl + Shift + F to start a forward search.

Or Ctrl + Shift + B to initiate a backward search.

Once you type your query, you can press Enter to jump between the matches sequentially.

Alternatively, if you are already inside the Vi mode, you can simply press / and type your search term directly.

I personally use the Vi mode search because it gives me extra flexibility. It allows me to semantic-select/line-select the entire matched term even when only a partial match is found.

Moving between brackets

A feature I love while reading configuration files is bracket matching. I usually print the file to the terminal and jump straight into Vi mode.

Once there, you can place your cursor on top of any bracket and press %. This will instantly jump your cursor to the matching opening or closing bracket.

At times, this is much more handy than opening the file up in a separate text editor. Especially when I am using it with the Zellij terminal multiplexer.

Configuring Alacritty

Alacritty does not need any user configuration to work properly and access its important features, as it comes right out of the box with some highly sensible defaults.

Still, there are plenty of areas that we can customize to tweak it to perfection. Here, I will take you through some of the options that I personally changed in my Alacritty setup.

I have also shared these config changes on our GitHub repo for your ease.

Splitting the configuration

Creating a single configuration file for all your features seems easy at first. However, if a tool supports multiple configuration files and imports, it is always a better practice to divide the config into relevant, modular parts.

Doing this will give you a much easier editing experience later when you need to tweak specific behaviors.

For Alacritty, all configuration files should be located in the ~/.config/alacritty/ directory. The directory structure in my system looks like this:

├── alacritty.toml
├── keybindings
│   └── keybindings.toml
└── themes
    ├── ansi.toml
    ├── catppuccin-mocha.toml
    ├── cocoa-dark.toml
    ├── cream-light.toml
    ├── dracula.toml
    ├── dusk-dark.toml
    ├── fog-light.toml

You can see that I have split the configuration files into separate items for:

• Main config: alacritty.toml
• Keybindings: keybindings/keybindings.toml
• Themes: themes <name>.toml

Now, once you have all your configuration files split up, you need to import the other configs into your main file alacritty.toml so that Alacritty can actually read them.

Open up your alacritty.toml file in a text editor and add the import lines to the top of your file using the import array under the [general] section:

[general]
import = [
  "~/.config/alacritty/keybindings/keybindings.toml",
  "~/.config/alacritty/themes/lavender-fields-light.toml"
]

Change the font

To change font in Alacritty, in the config file, add the following lines:

[font]
size = 12

[font.normal]
family = "JetBrains Mono"
style = "Regular"

[font.bold]
family = "JetBrains Mono"
style = "Bold"

[font.italic]
family = "JetBrains Mono"
style = "Italic"

[font.bold_italic]
family = "JetBrains Mono"
style = "Bold Italic"

The above configuration is self-explanatory. Of course, any font you want to appear in your terminal must actually be installed on your system first.

To find the exact name of the font you want to use, you can either open up a font-manager GUI application, or query your system via the command line using fc-list and filtering for your desired font family:

fc-list | grep "jetbrains"

Set scrollback history

We have already seen some great features relating to scrollback navigation, selection, and searching. To make these features truly efficient, you need a comparatively large scrollback buffer so you don't lose your terminal history too quickly.

In your main Alacritty configuration file, you can set this by adding the following lines:

[scrolling]
history = 10000

I would suggest caution when increasing this value much beyond 10000. Because this scrollback history is stored directly in your RAM, a massive scrollback buffer can negatively affect your system performance.

Especially when you accidentally dump a massive log file or print exceptionally long files directly to the terminal.

Change the shell

Most Linux distributions come with Bash as the default shell, and sometimes you may want to use an alternative shell like Zsh.

You don't actually need to change your entire system-wide default shell just for this. You can simply change the shell executed inside Alacritty itself.

To do this, add the following lines to your main alacritty.toml file:

[terminal]
shell = "/usr/bin/zsh"

To know the shell location, use:

which zsh

Opacity and blur

Alacritty allows you to change the terminal window opacity across all desktop environments, and it even lets you add a native blur effect if you are running a KDE Plasma Wayland session.

To configure this, add the following lines under the [window] section of your configuration:

opacity = 1.0
blur = true  # enable this for KDE Plasma to get blur

Keybindings

The best way to manage custom shortcuts is by adding them via a separate keybindings.toml file and importing it into your main configuration, as we looked at earlier.

In this file, you can define keybindings using the following syntax:

[[keyboard.bindings]]
key = "C"
mods = "Control|Shift"
mode = "Vi"
action = "ClearSelection"

Here, [[keyboard.bindings]] defines the section. For every new keybinding you want to map, a separate [[keyboard.bindings]] section must be used.

Inside this section, you have a few core parameters to customize:

• key: The main key used to perform the action (e.g., A, B, 2, 3, |, /).
• mods: The modifier keys required for the shortcut. You can use keys like Control, Shift, Alt, or Super. To combine multiple modifiers, separate them with a pipe symbol (|)—for example, Control|Shift triggers on a Ctrl + Shift action.
• mode: Defines a specific terminal state (such as Vi mode) that must actively be running for this shortcut to take effect.
• action: The actual command or event you want to perform. You can find a complete action reference list directly in the official documentation.

Mouse bindings

With Alacritty, you can customize how various mouse buttons behave inside your terminal. The general syntax looks like this:

[[mouse.bindings]]
mouse = "Forward"
action = "ToggleViMode"

[[mouse.bindings]]
mouse = "Back"
action = "CreateNewWindow"

Just like keyboard configurations, the [[mouse.bindings]] headers must be separate sections for each distinct mouse shortcut. Inside each section, you define:

• mouse: The specific mouse button you want to map. Options include Right, Left, Middle, Forward, Back, WheelUp, and WheelDown.
• action: The command you want to perform. This uses the exact same action references as the keyboard bindings.

For instance, I have an 8-button mouse, so I added the Forward button to quickly toggle into Vi mode, and the Back button to instantaneously open a fresh Alacritty window.

Color schemes

Alacritty allows you to completely alter the appearance of your terminal using custom color configurations.

Out of the box, it expects you to modify the hex color values for various display elements manually. If you don't want to build a palette from scratch, you can visit our GitHub repository to grab several preset color schemes for Alacritty.

Once you find a theme you like, you can drop it into your ~/.config/alacritty/themes/ directory, import it into your main config, or tweak the individual color blocks within that file to customize the look entirely to your liking.

Installing Alacritty

Alacritty is available in the default repositories of most popular distributions. If you are using Ubuntu, install it using the apt package manager:

sudo apt install alacritty

Fedora users can install it using the DNF package manager:

sudo dnf install alacritty

For Arch Linux users, install Alacritty from the extra repository using the command:

sudo pacman -S alacritty

Wrapping Up

One thing to note is that, as far as I know, Alacritty does not support viewing images natively from the terminal, though there is some Sixel image support development floating around.

Personally, I don't care much about image support because I am not working on images from the terminal anyway. But if that is an absolute requirement for your workflow, you may feel a bit disappointed.

There are exciting new terminal emulators like Ghostty and Ptyxis these days, and I have given them a try for a while. Now, I have been using Alacritty for the past couple of months as my main terminal, paired with Zellij multiplexer. I like this setup. It may make me forget Kitty, who knows.

What's your take on Alacritty? Do you use it as your main terminal emulator? If not, which one is your favorite? Do mention it in the comments below!

El Poblador is a fully playable Settlers of Catan clone that runs entirely in your terminal. Written in Go by developer vicho, El Poblador is a compete rendition of the iconic competitive board game, which is all about resources, trading, building settlements and blocking your opponents. All of Catan’s core mechanics are accounted for, albeit free of the tactile joy of handling and placing tiny wooden blocks in the real game. It’s a game designed for 3-4 players, so you’ll want to huddle around a laptop or on a PC to play it. You use arrow keys to navigate the […]

You're reading Play Catan in your terminal with El Poblador, a TUI clone, a blog post from OMG! Ubuntu. Do not reproduce elsewhere without permission.

The Ghostty terminal is now packaged in the Ubuntu 26.04 LTS repositories – meaning for those on the new long-term support release, it’s only an apt install away. Ghostty is a fast, open-source terminal emulator for macOS and Linux (Windows support is seemingly trapped between planes), made by Mitchell Hashimoto. It’s picked up millions of users since its launch in December 2024, and has been available on Ubuntu via a community-maintained PPA, DEB and Snap packages for a while. This is its first appearance in the Ubuntu repos proper. What makes Ghostty different? “Ghostty is a fast, feature-rich, and cross-platform […]

You're reading Ghostty finally lands in the Ubuntu repos, a blog post from OMG! Ubuntu. Do not reproduce elsewhere without permission.

Microsoft hat mit Edit einen neuen, quelloffenen Texteditor für die Kommandozeile vorgestellt. Das unter der MIT-Lizenz veröffentlichte Projekt ist nicht nur für Windows, sondern auch für Linux verfügbar. Zudem nicht nur für PCs, sondern auch für die ARM64-Architektur, wie sie auf dem Raspberry Pi genutzt wird. Der Editor richtet sich an Nutzer, die ein einfaches, schnelles Werkzeug für das Bearbeiten von Textdateien im Terminal suchen. Microsofts Edit reiht sich irgendwo zwischen Nano, Micro oder Kilo ein.

Kompakter Editor für den Terminaleinsatz

Edit ist ein schlanker Editor mit Text User Interface (TUI), der insbesondere auf Portabilität und geringe Abhängigkeiten ausgelegt ist. Die Software setzt auf eine eigene TUI-Bibliothek, die laut Projektentwickler besser zu einer geplanten Plugin-Schnittstelle auf Basis einer C-ABI passt. Außerdem wurde Wert auf UTF-8-Unterstützung, kompakte Dateigröße, VT-kompatible Ausgabe (für bessere SSH-Kompatibilität) und statische Kompilierung gelegt. So lässt sich das Programm ohne Abhängigkeiten ausführen.

Der Editor wurde in Rust geschrieben, nachdem erste Prototypen in C, C++ und Zig entstanden waren. Die Entscheidung für Rust fiel, weil die Sprache innerhalb Microsofts bereits offiziell unterstützt wird und sich gut für systemnahe Programmierung eignet. Der Editor ist natürlich für Windows-Admins interessant, weil man sich seit Windows 10/Windows Server 2019 via SSH auch auf Windows-Kisten einloggen kann. Für administrative Aufgaben braucht es dann auch einen effektiven Editor.

Veröffentlichung auf GitHub

Der Quellcode sowie vorkompilierte Binaries sind auf GitHub unter github.com/microsoft/edit verfügbar. Für Linux steht ein statisch gelinktes Binary bereit, das ohne weitere Abhängigkeiten ausgeführt werden kann:

$ wget https://github.com/microsoft/edit/releases/download/v1.0.0/edit-1.0.0-x86_64-linux-gnu.xz
$ unxz edit-1.0.0-x86_64-linux-gnu.xz
$ chmod +x edit-1.0.0-x86_64-linux-gnu
$ ./edit-1.0.0-x86_64-linux-gnu

Im Arch User Repository (AUR) stehen mehrere inoffizielle Pakete zur Verfügung, unter anderem edit, ms-edit, ms-edit-bin und microsoft-edit. Ich möchte hier keine Empfehlung ausgeben, mit Sicherheit wird hier in den nächsten Tagen ein wenig aufgeräumt. Dazu kommen Kochrezepte mit der Endung -git, die das Programm aus dem Quellcode bauen.

$ yay -Ss microsoft edit
aur/edit 1.0.0-1 (+0 0.00) 
    A simple editor for simple needs (Microsoft Edit)
aur/ms-edit 1.0.0-1 (+1 1.00) 
    A simple editor for simple needs (Microsoft Edit)
aur/ms-edit-git 1.0.0.r1.ge8d40f6-1 (+2 1.98) 
    A simple editor for simple needs (Microsoft Edit)
aur/ms-edit-bin 1.0.0-1 (+3 2.99) 
    A simple editor for simple needs (Microsoft Edit)
aur/microsoft-edit-git 1.0.0.r1.ge8d40f6-2 (+1 1.00) 
    Modern version of the MS-DOS Editor with a modern UI and keybindings similar to VS Code
aur/microsoft-edit 1.0.0-2 (+2 1.99) 
    Modern version of the MS-DOS Editor with a modern UI and keybindings similar to VS Code

Entwicklung aus Eigeninitiative

Der Editor entstand im Rahmen eines internen Microsoft-Projekts, wurde jedoch größtenteils in der Freizeit des Entwicklers umgesetzt. In einem ausführlichen Kommentar auf Hacker News beschreibt der Autor Hintergründe zur Entstehung, den Technologiestack sowie die Beweggründe für die Eigenentwicklung anstelle der Verwendung bestehender TUI-Editoren. Einen neuen Editor für Linux-User zu schaffen, stand allerdings nicht auf dem Zettel. /s

Ziel sei es unter anderem gewesen, ein möglichst kleines Binary mit guter Unicode-Unterstützung bereitzustellen, das systemnah arbeitet und sich auch für automatisierte Systemumgebungen oder Remote-Shells eignet. Ob sich Edit langfristig gegen etablierte Editoren behaupten kann, bleibt abzuwarten. Der Fokus auf Minimalismus, Portabilität und UTF-8-Kompatibilität dürfte insbesondere in reduzierten oder serverseitigen Umgebungen relevant sein.

We’re seeing something of a terminal emulator renaissance of late, with developers eager to reimagine, rethink, and rewire the humble console to leverage modern hardware, GPU acceleration, containerised workflows, and (in some cases) AI/LLMs. Ghostty, a new open-source and cross-platform terminal application created by Mitchell Hashimoto (co-founder of HashiCorp) is the latest to join the fray. Hashimoto’s says he “set out to build a terminal emulator that was fast, feature-rich, and had a platform-native GUI while still being cross-platform.” The first public release materialised over Christmas, rather like a festive Dickensian spook seeking to give us a glimpse into the […]

You're reading Ghostty: New Open Source Terminal That’s Spookily Good, a blog post from OMG! Ubuntu. Do not reproduce elsewhere without permission.

Ich bin gerade in der Situation, dass ich meinen Arbeitsplatz ein wenig umgestalten möchte. Die Monitoren sollen nicht mehr nur einfach auf dem Schreibtisch stehen, sondern auf einem Gestell an den Tisch geklemmt werden — Ergo: mehr Platz auf dem Tisch. Nun gilt es dabei ein paar Dinge zu beachten. Etwa die Frage, wie schwer meine Monitore eigentlich sind. Da ich keine Lust habe alles abzubauen und die Geräte auf die Waage zu stellen, wäre es recht nett zu wissen, vor was für Geräten ich da eigentlich täglich sitze. Da Information könnte ich sicherlich aus alten Rechnungen herauskramen, doch das geht sicherlich auch ein wenig cleverer.

Das Logo des Herstellers glitzert mir auf der Frontseite des Gehäuses entgegen, doch weitere Informationen zum Gerät finden sich dort nicht. Und auch auf der Rückseite gibt es keine weiteren Details. Ein Schildchen mit der Typenbezeichnung gab es in der Regel bei den guten alten Röhrenmonitoren, doch bei meinen aktuellen Dell-Flatscreens findet sich dort nichts mehr. Auch die Monitor-Einstellungen der Gnome-Desktopumgebung lässt den Nutzer im Stich. Die zeigen nur dann Informationen zum Typ des Monitors an, wenn zwei Displays angeschlossen sind. Mehr als den Hersteller und die Bildschirmdiagonale erfährt man jedoch nicht.

Gnome geizt mit Informationen

Wenn die grafischen Tools so sparsam mit Informationen sind, dann hilft doch sicherlich das Terminal. Tools zur Anzeige von Hardware-Informationen gibt es unter Linux ja wie Sand am Meer, da müsste doch was dabei sein. Das Go-To-Werkzeug für diese Aufgabe wäre hier Inxi, das sich bei vielen Distributionen aus den Paketquellen installieren lässt (etwa via pacman -S inxi bei Arch Linux oder apt install inxi bei Ubuntu, Debian und Derivaten). Das Kommando inxi -F spuckt dann sämtliche Details zum System aus, aber auch hier Pustekuchen: keine Details zu den angeschlossenen Monitoren.

Details zum Monitor über das Terminal

Um mir eine weitere Suche unter den zahlreichen Tools zu ersparen, greife ich nun gleich auf das „richtige“ Werkzeug zurück. Details zum Displayserver liefert das Kommandozeilenwerkzeug Xrandr. Tools wie Inxi machen in der Regel nichts anderes, also solche Kommandos auszuführen und die Ausgabe optisch aufgewertet anzuzeigen. Über xrandr -q --verbose bekommt man also zahlreiche Details zu den unterstützten Auflösungen und Wiederholraten, doch der Name und Typ des Monitors fehlt immer noch. Aber nicht ganz: Die Daten sind im Feld EDID oder Extended Display Identification Data codiert.

Wer diese Daten nun jetzt nicht von Hand decodieren möchte, muss sich ein wenig unter die Arme greifen lassen. Das bei Stack Overflow gepostete Skript beispielsweise braucht keine weiteren Helferlein, um die EDID zu dekodieren. Ihr speichert folgenden Code einfach als monitor.sh ab und macht die Skriptdatei via chmod +x monitor.sh ausführbar. Aus dem Terminal heraus aufgerufen, zeigt das Skript dann die angeschlossenen Monitore inklusive den Namen des Herstellers und der Typenbezeichnung an. Technische Details zu Auflösungen oder Wiederholraten fehlen, doch die lassen sich ja auch an zahlreichen anderen Stellen ermitteln.

#!/bin/bash
while read -r output hex conn; do
    [[ -z "$conn" ]] && conn=${output%%-*}
    echo "# $output $conn   $(xxd -r -p <<< "$hex")"
done < <(xrandr --prop | awk '
    !/^[ \t]/ {
        if (output && hex) print output, hex, conn
        output=$1
        hex=""
    }
    /ConnectorType:/ {conn=$2}
    /[:.]/ && h {
        sub(/.*000000fc00/, "", hex)
        hex = substr(hex, 0, 26) "0a"
        sub(/0a.*/, "", hex)
        h=0
    }
    h {sub(/[ \t]+/, ""); hex = hex $0}
    /EDID.*:/ {h=1}
    END {if (output && hex) print output, hex, conn}
    ' | sort
)

$ ./monitor.sh 
# DP1-8 DP1   DELL U2515H
# HDMI1 HDMI1   DELL P2213

Alternativ holt ihr euch das Paket edid-decode auf den Rechner. Bei Ubuntu/Debian oder Linux Mint direkt über die offiziellen Paketquellen (via apt install edid-decode), bei Arch Linux oder Manjaro lediglich über das AUR (etwa mit einem AUR-Helper via yay -S edid-decode-git). Hier genügt dann der folgende Einzeiler, der allerdings nicht mit dem proprietären Nvidia-Treiber funktioniert. Hier bekommt ihr dann allerdings nicht nur den Hersteller und den Monitortyp angezeigt, sondern auch gleich die Seriennummer der Geräte — falls ihr an diesen Interesse haben solltet.

$ for file in $(ls -1 /sys/class/drm/*/edid); do text=$(tr -d 0 <"$file"); if [ -n "$text" ]; then edid-decode "$file" | grep -e Manufacturer: -e Product; sleep 0.0001; fi done
  Vendor & Product Identification:
    Manufacturer: DEL
    Display Product Serial Number: '9X2VY55I0J0L'
    Display Product Name: 'DELL U2515H'
  Vendor & Product Identification:
    Manufacturer: DEL
    Display Product Serial Number: 'Y57VF31AAT3M'
    Display Product Name: 'DELL P2213'

Letztendlich wäre es natürlich schneller gewesen die alten Rechnungen herauszusuchen, oder vielleicht auch mal einen Blick über den Tellerrand zu KDE zu werfen. Im Gegensatz zu den Einstellungen von Gnome zeigen die Systemeinstellungen von KDE nämlich gleich die Bildschirmkennungen mit an. Wie immer ist Gnome ein wenig arg spartanisch und geizig mit Funktionen und Details. In meinen Augen dürften die System-Settings von Gnome ruhig auch die Bezeichnungen ausgeben. Nötig sind sie in der Regel nicht, doch ab und an können sie doch auch praktisch sein.

theme.sh is a script to easily change the terminal theme. It comes with more than 400 themes, an optional interactive theme picker, and it's terminal agnostic.