Whether you're a developer, system administrator, or simply someone who spends a lot of time in the terminal, juggling multiple terminal sessions can be messy and frustrating.

A terminal multiplexer helps you keep everything organized, letting you manage several sessions from a single interface while making your workflow much more efficient.

While tmux and GNU Screen are the names most Linux users are familiar with, there are many more similar terminal multiplexer tools available. As someone who like to explore new tools, I spent some time and came up with this list for you.

Zellij

Zellij describes itself as a terminal workspace rather than just a multiplexer, with an emphasis on delivering a polished experience from the moment you launch it.

It aims to provide sensible defaults while still leaving plenty of room for customization.

One of the things that sets Zellij apart is its focus on usability. Built-in layouts, a plugin system, and collaborative sessions are all part of the experience, but the project's philosophy is that you shouldn't have to trade simplicity for advanced functionality.

This makes it approachable for newcomers while still offering enough flexibility for users who want to tailor their workspace.

While this is not a ranking list, Zellij is the first one on this list because I have used it on a daily basis for the past several months.

TUIOS

While most terminal multiplexers focus on helping you manage terminal sessions, TUIOS takes that idea a step further by presenting itself as a terminal window manager.

TUIOS tries to bring concepts you'd expect from a tiling window manager, such as workspaces, automatic tiling, and window management, into your existing terminal.

The workflow is centered around a modal interface inspired by Vim, letting you switch between managing windows and interacting with terminal applications.

Alongside features like a command palette and workspace organization, TUIOS also supports automation through tape files, making it suitable for users who want to build repeatable terminal workflows instead of just juggling multiple shells.

Wezterm

You probably know WezTerm as a feature-rich terminal emulator. But there's more to it than meets the eye.

WezTerm includes a built-in multiplexer, allowing you to create and manage persistent sessions without relying on a separate tool.

It integrates multiplexing directly into the terminal and supports local domains. While it lets you connect to remote domains over SSH and other tmux like features, this requires you to spend some time configuring.

Kitty + Abduco

If you're already using Kitty as your terminal emulator, you don't necessarily have to switch to a traditional multiplexer. Pairing it with abduco gives you a lightweight way to keep terminal sessions running in the background while letting Kitty handle everything on the frontend.

It's a simple combination that sticks to the Unix philosophy of using small tools that do one job well.

The primary job of abduco is to detach and reattach terminal sessions, leaving the rest to your terminal emulator.

Kitty complements this nicely with features like tabs, splits, and a polished interface, giving you a workflow that feels familiar while still providing session persistence.

tmate

Rather than reinventing the multiplexer experience, tmate builds on tmux and adds secure session sharing, making it easy to collaborate, troubleshoot problems, or provide remote assistance without asking someone to install extra software.

The biggest addition is the ability to generate a connection string that others can use to join your session.

By default, these shared sessions are relayed through tmate's public servers, although you can host your own relay if you prefer to keep everything under your control. If you never need to share your terminal, however, plain tmux is likely the better fit.

Boo

At first glance, boo might look like just another GNU Screen alternative. In reality, it's a fairly different take on terminal multiplexing.

Built on Ghostty's terminal emulation library, boo keeps track of the actual terminal state, allowing it to recreate a session exactly as you left it, even after you've detached and reattached.

The project also leans into automation. Besides keeping sessions alive, it includes commands that let scripts and AI agents inspect or interact with detached sessions without needing a live terminal connection.

Okena

Okena combines terminals, tabs, panes, and projects into a single interface, with a strong focus on helping you pick up exactly where you left off.

Close the application, reopen it later, and your workspace is restored much like you never left.

That persistence model is what makes Okena different. Unlike tmux or GNU Screen, it doesn't keep sessions running in the background after the application closes, nor is it designed for detached SSH workflows or remote session management.

Instead, the emphasis is on restoring your local workspace, making it feel more like a modern development environment than a server-backed multiplexer.

Seance

Seance, built with GTK4 and libadwaita, takes a desktop-first approach to terminal session management. It feel more like a modern Linux application than a traditional keyboard-driven multiplexer.

It offers a clean interface with configurable key bindings, workspace management, and session persistence across restarts, so you can reopen the application and continue where you left off.

However, it isn't designed around detached server sessions or remote SSH workflows. Instead, it focuses on providing a polished experience for managing terminal workspaces on your local Linux desktop.

Wrapping Up

As you can see, there's no shortage of ways to organize your terminal workflow. Some of these tools have been around for decades, while others are reimagining what a terminal workspace can look like. The thing is that there's no single "right" choice. It all comes down to how you work.

Whichever you choose, learning to use a terminal multiplexer is one of those skills that pays off over time. Once it becomes part of your workflow, your muscle memory, there is no going back to normal terminal sessions.

By the way, you might be interested in exploring various terminal emulators as well.

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?

People who used Windows 7 and earflier version would remember "My Computer". It's called "This PC" now a days but does the same job.

You click on the icon, and it opens the file explorer and shows you the meta folders (Documents, Pictures, Downloads, etc.) and all the drives on the system and any other mounted devices.

This is useful for many people to see all the locations in the system at a glance.

On the Linux side, GNOME used to have Other Locations page in Nautilus file manager. It served as a central place where you could access network shares, cloud storage such as Google Drive, removable drives, and even your root partition.

Starting with GNOME 47, that page was removed. In its place, Nautilus introduced a dedicated Network folder, while local drives and partitions were moved directly into the sidebar.

This makes sense for systems with only a few drives, but some users still prefer to have a dedicated page that shows everything in one place.

Meet My Computer for Nautilus

My Computer for Nautilus is an extension for GNOME Files (Nautilus) that brings back a dedicated computer view.

Instead of scattering drives and network locations across different places, it puts all your drives, partitions, removable media, and network mounts into a single, organized page. It also comes with a handful of useful features that make Nautilus much more customizable than it is by default.

While bringing back a dedicated Computer view is its primary purpose, My Computer goes beyond that. It adds a few quality-of-life improvements that make Nautilus even more flexible.

Let's have a look at its features.

A dedicated Computer view

The most noticeable change is the new Computer entry that appears at the top of the Nautilus sidebar.

Clicking it opens a dedicated page where all your drives, partitions, removable media, and network locations are neatly organized.

You can even make Nautilus open in this view every time it starts.

Simply right-click the Computer entry in the sidebar and select My Computer Settings.

Under the General tab, enable Start on the Computer View.

Customize what appears in the Computer View

The Computer page is fully customizable.

If you don't want certain sections, such as Preferred Folders, Network, or Removable Media, you can simply hide them. This lets you tailor the page to match your workflow.

For example, you can turn it into a dedicated drives overview by hiding everything except storage devices.

I have removed the Preferred Folders and made the Computer page show only Drives and Network Drives in the image below:

Enjoy Miller columns

One of the most interesting additions is support for Miller Columns.

If you've used macOS Finder before, you'll immediately recognize this layout. Instead of opening each folder in a new window or replacing the current view, folders expand into the next column, making navigation much faster.

The extension also includes a preview pane. Selecting an image or video displays a thumbnail along with basic information about the file without opening it.

Customize the sidebar

Another feature I like is the ability to customize Nautilus' sidebar.

Normally, entries such as Recents and Starred cannot be removed. My Computer adds simple toggle switches that let you hide or show these built-in entries.

To customize the sidebar, open My Computer Settings and switch to the Sidebar tab.

For example, I hid Recents, Starred, and Network to create a much cleaner sidebar.

Customize storage bar colors

If you like personalizing your desktop, My Computer also lets you customize the storage usage bars shown beside your drives.

Open My Computer Settings, switch to the Computer tab, scroll down to Bar Color, and change Color Mode to Custom Gradient.

You can then choose two colors to create your own gradient. Here's how mine turned out.

Install My Computer

My Computer is under active development. Since it is a Nautilus extension rather than a GNOME Shell extension, you'll need to install it as a system package or use the project's installer script.

On Ubuntu 26.04 and newer versions, install it from the official PPA:

sudo add-apt-repository ppa:yannmasoch/nautilus-my-computer
sudo apt update
sudo apt install nautilus-my-computer

Fedora users can install it through the project's COPR repository:

sudo dnf copr enable yannmasoch/nautilus-my-computer
sudo dnf install nautilus-my-computer

If you're using another distribution, including Arch Linux, the project also provides a universal installation script:

curl -fsSL https://raw.githubusercontent.com/yannmasoch/nautilus-my-computer/main/install.sh | sh

Wrapping Up

My Computer brings back several features that many long-time GNOME users have missed over the years. While it doesn't recreate the old Other Locations page exactly, it offers a practical alternative by gathering everything into a dedicated Computer view.

The addition of Miller Columns is another nice to have feature. It's a navigation style I've wanted to see in Nautilus for quite some time. Elementary OS' file manager has offered a similar feature for years, but I never found a reliable way to use it on GNOME until now.

If you're happy with Nautilus' current sidebar-centric approach, you may not feel the need for this extension. But if you miss having a dedicated Computer page or want more control over the file manager's interface, My Computer is definitely worth trying.

Would you install it, or do you prefer Nautilus the way it is? Let me know your thoughts in the comments.

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!

I recently bought an external Dell keyboard that came with a dedicated Copilot key. Since I don't use Microsoft's Copilot, the key was doing nothing useful.

So, I decided to map it to the YouTube Music web app. There is no such app, but I created it as a PWA using Vivaldi.

In theory, it seems like a trivial thing, but making the Copilot key launch that web app came up as a decent challenge. And hence this tutorial.

My first attempt was using KDE's System Settings → Keyboard → Shortcuts. I created a shortcut for the YouTube Music PWA and tried assigning the Copilot key to it.

Unfortunately, KDE only detected the key as Meta+Shift and completely ignored the function key that was part of the key combination.

After a bit of searching, I came across a Reddit post that suggested using the keyd utility to remap the key at a lower level. That turned out to be exactly what I needed.

Instead of trying to use the original key combination, I remapped the Copilot key to Ctrl+Alt+Shift+F12. It is a key combination that is rarely used, making shortcut conflicts highly unlikely.

Why KDE Can't Detect the Copilot Key

On my keyboard, pressing the Copilot key actually sends Meta+Shift+F23.

The problem is that KDE's shortcut recorder only captures the Meta+Shift modifiers and ignores the F23 key entirely. As a result, it is impossible to assign the Copilot key directly through the graphical settings.

The solution is to intercept the key before KDE receives it and translate it into another shortcut that KDE can recognize normally. This is exactly what keyd does.

Install keyd

On Arch Linux, install keyd using:

sudo pacman -S keyd

It is also available in the official repositories of Ubuntu 26.04 and above.

Enable and start the service:

sudo systemctl enable --now keyd

Verify that it is running:

sudo systemctl status keyd

Identify Your Keyboard

First, identify the vendor and product ID of your external keyboard.

Run:

sudo keyd monitor

Locate your external keyboard in the output and note its vid:pid value. Make sure you choose the external keyboard instead of your laptop's built-in keyboard.

device added: aaaa:bbbb:cccccccc Dell KB216 Wired Keyboard Consumer Control (/dev/input/event9)
device added: aaaa:bbbb:cccccccc Dell KB216 Wired Keyboard System Control (/dev/input/event8)
device added: aaaa:bbbb:cccccccc Dell KB216 Wired Keyboard (/dev/input/event7)
device added: dddd:eeee:ffffffff Keychron Keychron K8 Pro Keyboard (/dev/input/event6)

Verify the Copilot Key

To see what the Copilot key actually sends, run:

sudo keyd monitor

Now press the Copilot key.

You should see output similar to:

leftmeta down
leftshift down
f23 down
f23 up
leftshift up
leftmeta up

This confirms that the key sends the combination:

Meta + Shift + F23

Create the keyd Configuration

Create a configuration file for your external keyboard.

sudo mkdir -p /etc/keyd
sudo nano /etc/keyd/externalKeyboard.conf

Replace the keyboard ID with your own vid:pid.

[ids]
aaaa:bbbb:cccccccc
- [main]
leftshift+leftmeta+f23 = C-A-S-f12

Here's what each part does:

The [ids] section limits the remapping to the selected keyboard, leaving your built-in keyboard and other input devices untouched.

• C, A, S, and M represent Ctrl, Alt, Shift, and Meta.
• The left side specifies the key combination received from the keyboard.
• The right side defines the new shortcut that will be sent to the system.

Apply the Configuration

Reload keyd:

sudo keyd reload

Normally, you do not need to log out or reboot.

If this is your first time installing keyd and the remap does not work immediately, a reboot is worth trying.

Verify the Remapping

Run the monitor again:

sudo keyd monitor

Press the Copilot key once more.

This time, you should see the newly assigned shortcut (Ctrl+Alt+Shift+F12) instead of the original Meta+Shift+F23.

keyd virtual keyboard   0fac:0ade:bea394c0      leftalt down
keyd virtual keyboard   0fac:0ade:bea394c0      leftshift down
keyd virtual keyboard   0fac:0ade:bea394c0      leftcontrol down
keyd virtual keyboard   0fac:0ade:bea394c0      f12 down
keyd virtual keyboard   0fac:0ade:bea394c0      f12 up
keyd virtual keyboard   0fac:0ade:bea394c0      leftalt up
keyd virtual keyboard   0fac:0ade:bea394c0      leftshift up
keyd virtual keyboard   0fac:0ade:bea394c0      leftcontrol up

Assign the Shortcut in KDE

Now that the Copilot key sends a standard shortcut, KDE can detect it correctly.

Open System Settings → Shortcuts. Here, click on the Add New button on the top-right and select Application.

From the list of sections, select Vivaldi Apps (or other apps of your choice) and then YouTube Music.

Locate the application shortcut you want to configure, click the shortcut field, and press the Copilot key or CTRL+ALT+SHIFT+F12.

Since keyd is now emitting Ctrl+Alt+Shift+F12, KDE records the shortcut without any issues.

Check for Shortcut Conflicts

Before deciding on a shortcut, it's worth checking whether KDE or KWin already uses it.

For example, whether Ctrl+Alt+Shift+F12 toggles the KWin compositor in X11 sessions.

You can search for existing shortcuts by running:

grep -i "F12\|F13\|F14" ~/.config/kglobalshortcutsrc

A Few Things to Keep in Mind

Before I end this this tutorial, let me share a few things that you should know about using this method.

Hot plugging: keyd automatically detects when the keyboard is connected or disconnected through udev. You don't need to restart the service after plugging in the keyboard.

Mouse remapping: keyd only handles keyboard input. If you need to remap mouse buttons, consider tools such as input-remapper or xremap.

Disable the remapping: If you want to temporarily restore the original keyboard behavior, simply stop the service:

sudo systemctl stop keyd

With that, you should be able to make some good use of CoPilot key on Linux.

There is no shortage of personal knowledge management (PKM) applications available today if you use Markdown notes.

Be it Obsidian or Logseq or Tolaria, there is a pain point associated with almost all of them. They add a layer on top of the plain markdown files. From Wikilinks to custom properties, there is always something that makes the interprotability an issue.

It almost feels like a vendor like in despite Markdown being an open standard.

Recently, I started experimenting with a different idea. Instead of relying on a specialized application, I tried using the KDE Plasma desktop itself as the foundation for this workflow.

Let me share how we can use Dolphin, along with a few KDE tools, to build a simple Markdown-based knowledge management system. I

t is still an experiment, and it certainly has limitations (that I will discuss later), but it has been an interesting workflow to explore.

Create Some Templates

The first step is to create a few Markdown templates that make taking notes faster.

Inside your ~/Templates directory, create two files:

• Markdown.md
• QuickNotes.md

Once these files are in the Templates folder, they become available from Dolphin's right-click context menu, allowing you to create new notes instantly.

Open QuickNotes.md in your preferred Markdown editor and add a simple structure such as:

## Core Concept

---

## Key Characteristics

---

## Examples

---

## Related Reading

---

This is the template I use for quick notes, but you can customize it as per your need.

From now on, you can create a structured Markdown note anywhere in your file manager with just a few clicks.

Create a Folder for Your Notes

Next, create a folder that will hold your entire note collection.

I created mine as ~/Documents/MarkdownSource, but you can choose any location you prefer.

Inside this folder, create sub-folders to organize notes. I also recommend creating two additional folders:

• Inbox, for notes that you haven't organized into a dedicated folder, yet.
• Attachments, for images and other files that your notes may reference.

Keeping attachments inside the root of your notes directory makes them much easier to manage later.Avoiding Vendor Lock-in By Using KDE Plasma As Personal Knowledge Base

Install a Markdown Editor

Since this workflow revolves around plain Markdown files, you'll need a Markdown editor.

I intentionally avoid recommending dedicated PKM applications such as Obsidian or Logseq here, because using one of those would defeat the purpose of this workflow.

I've tried the Ghostwriter Markdown editor from KDE, and it has worked very well for this experiment. Apostrophe is a similar editor, if you prefer a GNOME style application.

On Arch Linux, you can install it using:

sudo pacman -S ghostwriter

For other distros, use your package management commands.

Configure Dolphin to Open Markdown Files

Now make Ghostwriter the default application for Markdown files.

Open System Settings and navigate to Default Applications → File Associations.

Find the Markdown file type and move Ghostwriter to the top of the application list.

This can also be done by right-click on a Markdown file, go top Properties. Here, select the open with option and change the application preference order in a similar interface as above.

From now on, double-clicking any Markdown file in Dolphin will open it directly in Ghostwriter.

Use Dolphin Tags for Organization

Tagging is one of the most useful features in any PKM system. Without it, finding notes later becomes much more difficult.

Fortunately, Dolphin already includes a simple tagging system.

Open Dolphin and enable the information panel by selecting Menu → Show Panels → Information.

A sidebar will appear showing details about the selected file or folder.

Here you'll find a Tags field where you can assign one or more tags to each note.

Once you've tagged your files, Dolphin's search function can quickly locate notes that share the same tag.

Interlinking Notes

We've now covered most of the essential parts of this workflow. The only major feature left is linking notes together.

This is one area where a file manager-based workflow is less convenient than a dedicated PKM application.

Since Dolphin doesn't understand wiki links or automatically manage relationships between notes, you'll need to create standard Markdown links yourself.

One improvement I would recommend is storing all your notes and attachments inside a single dedicated notes directory. Instead of using absolute file paths, create links using relative paths whenever possible.

Relative links are much easier to manage because the entire notes directory can be moved to another location without breaking the internal links, as long as the folder structure remains unchanged.

To make this easier, I created a small Bash function that generates the relative path between two files.

relpath() {
  local from_dir
  from_dir=$(dirname "$(realpath "$1")")
  realpath --relative-to="$from_dir" "$2"
}

I added this function to my .bashrc. I originally wrote this function for a terminal-based PKM workflow, but it fits this KDE-based workflow just as well.

Now, whenever I need to create a link from one note to another, I simply run:

relpath current_file distant_file

The command prints the relative path, which I can directly use in the Markdown link.

A normal Markdown link looks like this:

[Link text](Link address)

It's a manual process, but once the link is created, you can easily navigate between your notes from within your Markdown editor.

And this way, you have a folder containing subfolders of markdown files. The interlinking is the hardest and boring part but once that is done, your knowledge base can be used on any OS, with any Markdown editor.

It Is Not Perfect (Obviously)

And that's not a surprise. You are not using a specialist tool so there are a few limitations worth knowing.

Strict Data Organization Is Needed

With this approach, your desktop environment effectively becomes your knowledge management system.

That also means you are entirely responsible for keeping your notes organized.

If you don't maintain a clear folder structure, your note collection can quickly become difficult to manage.

For example, a note may contain links to attachments stored in completely different folders. Without a consistent organization strategy, finding those files later can become frustrating.

Similarly, if you are linking notes to a PDF file, keep those files organized in a folder and don't mess up with its location. Else, interlinking won't work.

Distro and Desktop Environment Changes

This workflow is tied to KDE Plasma's tagging feature. Moving away from KDE Plasma would likely mean abandoning parts of this workflow altogether.

Link Fragility

You probably have already realized that this is the weakest link in the entire workflow.

The Markdown links point directly to file paths. If you rename or move a file or folder later, every note pointing to that location will break.

Unlike dedicated PKM applications, Dolphin doesn't automatically update links when files are moved. Any reorganization requires manually updating the affected links yourself and that would be a serious pain.

Wrapping Up

I know this approach is far from perfect. Compared to dedicated PKM applications, it places much more responsibility on you to organize your notes, attachments, and folder structure properly.

Personally, I think that's not necessarily a bad thing.

When you organize your notes yourself, you naturally become more familiar with your knowledge base. You're more likely to revisit, reorganize, and improve your notes over time instead of treating them as something you write once and never look at again.

At the same time, this workflow won't suit everyone.

If you depend on advanced features such as automatic backlinks, graph views, embedded queries, or seamless note linking, a dedicated PKM application will provide a much better experience.

On the other hand, if your priority is to keep everything as plain Markdown files while using lightweight tools that are already available on your desktop, this approach is certainly worth trying. In my opinion, this workflow also works well for people following the Zettelkasten method.

I'm still experimenting with this workflow myself, and I'll probably continue refining it as I use it more.

What do you think about this idea? Would you consider using your file manager as a personal knowledge management system, or would you rather stick with a dedicated application? Let me know your thoughts in the comments.

Obsidian and Logseq may seem similar. Both are local-first note-taking apps, both use Markdown, and both are popular among people building their personal knowledge base.

But after using both for nearly three years, I can say this: they are not the same kind of tool. Obsidian feels like a powerful Markdown writing environment. Logseq feels like an outliner built for connecting ideas at the block level.

Both applications use Markdown as their primary note format. However, Logseq is also actively developing a database-based version alongside its traditional Markdown workflow.

I have written several tutorials on both Logseq and Obsidian here on It's FOSS. One of the frequently asked questions in the comments of those articles has been about the differences between Obsidian and Logseq.

Of course, the major difference is that Logseq is open source and Obsidian is not. Yes, Obsidian is one of those tools that feel like they are open source even when they are not.

But that major difference is not a difference for many. They want to know which tool they should use for their perfectly curated knowledge base.

So, I decided to compare both Logseq and Obsidian on certain points that I have noticed in my experience. Instead of trying to declare one as the winner, I'll explain where each application works well, where I struggled, and why I still use both in my daily workflow.

This is not a recommendation to switch to one application or the other. It is simply a collection of my experiences and the workflow that worked best for me.

Here is a quick comparison before we go into the details.

Local Storage of Notes

How an application stores your notes is one of the most important aspects of any note-taking system. Fast access to your data and complete ownership of your notes are essential.

Fortunately, both Obsidian and Logseq follow a local-first approach.

Obsidian

Obsidian stores every note as a standard Markdown (.md) file inside a local folder called a Vault. Since all files remain on your computer by default, you have complete control over your data without depending on external servers or proprietary databases.

You can also create multiple vaults, allowing you to separate different projects or areas of work. Because everything is stored locally, your notes remain accessible even without internet connection.

Logseq

Logseq also stores notes locally using Markdown and Org-mode files. However, the project is gradually moving toward a local SQLite database architecture to improve performance, stability, and query capabilities.

Even with this transition, the developers have stated that they intend to continue supporting the traditional Markdown-based workflow for users who prefer plain text notes.

Like Obsidian, Logseq also allows you to maintain multiple collections of notes and switch between them easily.

Plain Markdown vs Logseq's Bulleted Markdown

Although both applications use Markdown, the editing experience is fundamentally different.

Obsidian

Obsidian follows the traditional Markdown editing approach, where an entire file becomes the main unit of work.

It is well suited for writing long articles, detailed documentation, or structured notes that resemble conventional documents.

Logseq

Logseq is built around an outliner. Every line is a collapsible bullet, making each individual block the primary unit of information.

Instead of thinking in pages, you naturally build ideas by nesting bullets and creating hierarchies through indentation.

Where Obsidian Feels Better for Writing

I use Obsidian whenever I'm writing article drafts or other long-form documents. Its editor feels much more comfortable for continuous writing, and organizing paragraphs is straightforward.

If you're writing regular articles or lengthy notes, Logseq can sometimes feel restrictive because everything starts as a bullet point.

I especially notice this when working with a table of contents. In Obsidian, the document structure is easier to visualize because there isn't a bullet interface surrounding every paragraph.

On the other hand, Logseq is excellent for collecting ideas before writing. Its outline-based interface makes it easy to brainstorm, collapse large sections into a single line, and gradually expand ideas whenever needed.

When you maintain proper indentation, every parent bullet can almost act as a separate note with all of its supporting information nested underneath.

Interlinking Notes

Linking related notes is one of the most important features of any PKM application because that's what separates it from just a random dump of notes and an organized, accessible knowledge base.

Obsidian

Obsidian connects notes by linking entire files using wiki-style links. It also includes a backlinks panel that shows every note linking to the current document.

To visualize these relationships, Obsidian provides an excellent graph view that displays how your notes connect with each other.

Logseq

Logseq does things differently by introducing block-level references.

Instead of linking only to entire pages, you can directly reference or embed an individual bullet from anywhere in your knowledge base.

Like Obsidian, Logseq also includes a graph view to visualize relationships between notes.

Why I Prefer Logseq for Connected Notes

When it comes to interlinked notes, I prefer Logseq every time. The biggest reason is block-level references.

Because Obsidian links entire files, I often end up creating many small notes just so they can be referenced from different places.

Logseq removes that need. If I organize my ideas using proper indentation, I can reference only the specific block I need while leaving the rest of the information in the same page.

Even better, hovering over a reference displays the complete parent block along with its nested content.

This allows me to keep large collections of related ideas together while still being able to reference individual parts wherever I need them.

There is one thing to keep in mind, though. This workflow depends heavily on proper indentation. If the structure becomes messy, references may not include all the information you expected.

Overall, I think Obsidian works better if you're intentionally following a Zettelkasten-style workflow with a strict "one idea, one note" philosophy.

Personally, I believe that Zettlekasten is one of the best ways to organize knowledge. The challenge is that maintaining such a system consistently can become difficult over time.

File Storage Architecture

The way notes are organized on disk and inside the application is very different in Obsidian and Logseq.

Obsidian

Obsidian follows the traditional file and folder approach. You are free to create any folder structure you like inside a vault, whether it is deeply nested or completely flat.

This gives you complete control over how your knowledge base is organized.

Logseq

While Logseq, instead of relying on folders, encourages you to organize information using daily journals, pages, tags, and block hierarchies.

Rather than maintaining a directory structure yourself, the organization gradually emerges through links and references.

Why Obsidian is Easier for Beginners

For most casual users and students, I feel Obsidian's approach is much easier to understand.

Logseq's organization model can be confusing at first. By the time you fully understand how pages, tags, and journals work together, you may already have created hundreds of notes that need to be reorganized.

One thing that initially confused me was the relationship between pages and tags. In many situations, they almost behave like the same thing.

If you come from a traditional folder-based workflow, it's easy to start creating pages as if they were folders. That usually leads to confusion later when your notes begin to grow.

Obsidian, on the other hand, follows a familiar file-and-folder hierarchy that almost everyone already understands. Logseq's approach is certainly powerful, but it requires careful planning from the beginning.

Notes portability

Being able to move your notes between applications is an important consideration. If you ever decide to switch tools, a portable note format can save a lot of effort and frustration.

Obsidian

Obsidian stores everything as standard Markdown files. Because Markdown is widely supported, you can open your notes in almost any text editor without losing the main content.

This makes your notes easy to access in the future, regardless of whether you continue using Obsidian.

Logseq

Logseq also stores notes in Markdown, but its heavy use of block structures and internal block identifiers makes those files less suitable for use in traditional Markdown editors.

While it do provide a way to export the current page to a proper markdown, the default note you created is always in a bullet-structure form.

Which One Is Easier to Move Away From?

Although Obsidian is highly portable, there are still a few things to keep in mind. Obsidian's wiki links are not part of the Markdown standard. If you open those files in another editor, internal links and embedded images may not work as expected.

The same applies to some Obsidian-specific features such as callout blocks.

Fortunately, Obsidian allows you to disable wiki links and use standard Markdown links instead. If long-term portability is important to you, this is a setting worth considering.

Logseq has similar limitations because it also extends Markdown with its own features.

Overall, I still find Obsidian's notes easier to migrate to other applications than Logseq's Markdown files.

Plugin Ecosystem

A healthy plugin ecosystem can greatly extend the capabilities of a note-taking application.

Obsidian

Obsidian has one of the largest plugin ecosystems available. Thousands of community plugins can transform the editor into anything from a task manager to a database-like system using plugins such as Dataview.

Because the core application remains fairly minimal, many advanced features depend on community plugins.

Logseq

Logseq has a much smaller plugin ecosystem. However, it includes many features that Obsidian users often install plugins for, including flashcards, PDF annotation, and advanced queries.

Its philosophy is to provide most of the commonly used PKM features as part of the default installation.

Plugins vs Built-in Features: My Take

I actually give a thumbs up to the Obsidian's plugin model. Providing a simple editor and allowing users to choose only the features they need is a good design approach. Many modern applications, including Visual Studio Code, follow a similar philosophy.

The downside is that depending heavily on third-party plugins introduces additional security considerations.

Logseq takes the opposite approach by including most important features out of the box.

I repeat, one thing to remember for both applications is portability. Many plugins introduce their own syntax that goes beyond standard Markdown.

If your goal is to keep your notes compatible with other Markdown editors, it's worth being selective about which plugins you install.

Callout blocks are a good example. They work well inside the application but may not render correctly elsewhere.

Web Clipper

If you regularly save articles while browsing, a good web clipper becomes an essential part of your workflow. Though, you only need one reliable web clipper.

Obsidian

Obsidian offers an excellent web clipper extension that is available for Chrome, Firefox, Safari, and other browsers.

It lets you save web pages as Markdown notes. When used with Obsidian, the clipped notes are automatically populated with useful YAML front matter such as the title, source URL, author, and other metadata.

Logseq

At the time of writing, Logseq does not have an official web clipper. There have been ongoing discussions about one, but an official release is yet to arrive.

Why Obsidian’s Web Clipper Is More Useful

One thing I really like about the Obsidian Web Clipper is that it doesn't require Obsidian to be installed.

This means I can use it to save web pages as Markdown and then import those notes into other applications, including Logseq.

The only feature you miss without Obsidian is the ability to send clipped notes directly into a specific vault or folder with a single click. That integration naturally requires Obsidian to be installed.

Sync Features

Working on more than one computer? Sync is essential for your workflow.

Obsidian

Obsidian provides its own paid synchronization service called Obsidian Sync. I have used it extensively, and it has worked very well for me.

Since all notes remain local files, you can also use other synchronization solutions such as iCloud, Dropbox, or Syncthing instead of paying for the official service.

One thing worth mentioning is Android. Services like Dropbox and Google Drive do not automatically live synchronize a local folder in the background because of Android's storage restrictions.

This is not an Obsidian limitation. If you want continuous synchronization on Android, tools such as Syncthing generally provide a much better experience.

Logseq

Logseq also offers its own paid synchronization service.

Users can choose alternatives such as iCloud, although it has been known to have occasional issues.

The upcoming database version is also expected to improve real-time synchronization and collaboration between multiple devices.

My Sync Setup and Why I Avoid Direct Comparison

I personally don't use Logseq Sync. Instead, I keep my Logseq graph inside a private GitLab repository to avoid accidental data loss.

Because of that, I don't think it would be fair for me to compare the official synchronization services of both applications. If you've used both, I'd be interested in hearing about your experience in the comments.

Mobile Application Availability

A good note-taking application should work well on mobile devices too. After all, we don't always have a laptop with us.

Obsidian

Obsidian offers official mobile applications for both Android and iOS. In my experience, the app works very well, and Obsidian Sync integrates seamlessly across devices. Since I'm the only person using my vault, I haven't tested its collaboration features, so I won't comment on them.

Logseq

Logseq's mobile experience is currently less polished. There isn't an official Android app for the legacy Markdown version on the Play Store.

Android users can still install it by downloading the APK from the official GitHub repository. iPhone users, however, have an official release available on the App Store.

The new database version is currently being developed with iOS as the primary focus, and an Android release is not expected anytime soon.

Where Obsidian Feels Ahead on Mobile

Regarding Obsidian, one thing I did notice is that the interface can feel a little crowded on smaller screens. The ribbon menus, sidebars, and other interface elements take up a fair amount of space. If you prefer larger fonts while reading or writing notes, the interface can feel even more compact.

I rarely use Logseq on my phone, so I don't think I can fairly judge its mobile experience. It will be unfair if I tried it for the sake of this article, so I leave it to those who use it frequently to judge it, and I'd love to hear your thoughts in the comments.

Git Integration Possibilities

Git is not only an excellent version control system but also a reliable synchronization solution for users who prefer not to use paid cloud services.

Obsidian

Since an Obsidian vault is simply a folder containing Markdown files, it works naturally with Git.

You can store your vault in a private GitHub or GitLab repository and manage its history using standard Git workflows.

In this setup, version history depends entirely on Git rather than the application itself.

Logseq

Logseq also works well with Git when using the Markdown version. Its upcoming database architecture introduces another interesting feature.

Instead of relying entirely on Git history, the database is designed as a "time-travel database." Every change is stored as a timestamped transaction, allowing you to inspect previous states of your knowledge base directly from within the application.

How I Use Git With Both Apps

Both applications provide community plugins that simplify Git operations through a graphical interface.

Between the two, I found Obsidian's Git plugin more polished and easier to understand. It exposes almost every Git operation you might need through a straightforward interface.

Ironically, I rarely use either plugin. I manage my repositories using Lazygit, so I generally prefer handling Git from the terminal.

Open Source vs Proprietary

The licensing model of an application doesn't necessarily affect how well it works, but it is still an important consideration for many users.

Obsidian

Obsidian is proprietary software. The application itself is closed source, meaning only the developers have access to its source code.

It is free for personal use, while commercial use requires a paid license. One important point is that many community plugins available for Obsidian are open source, even though the application itself is not.

Logseq

Logseq is fully open source under the AGPL-3.0 license. Its source code is publicly available, and anyone can inspect, modify, or fork the project.

All local features are available without requiring any payment.

Why I Still Use Obsidian Despite It Being Closed Source

Almost every application I use daily is open source. Obsidian is one of the few exceptions.

There are several reasons for that. I've been using it for a long time, migrating my notes without breaking links would take considerable effort, and I simply don't have enough time to rebuild my entire knowledge base.

Another reason, is the writing experience. For long-form writing, Obsidian is still one of the fastest and most comfortable editors I've used.

My long-term goal is to move toward a completely plain-text, wiki-style note system, but that is still some distance away.

Default Entry Point and Daily Workflow

One of the first things you'll notice when trying a new PKM application is how it expects you to work.

Obsidian

Obsidian starts with a blank note or an existing document. From there, you're free to organize your vault however you like.

You can create folders, move notes between them, and rearrange your structure whenever needed.

Because Obsidian automatically updates internal links, reorganizing notes is generally painless.

Logseq

Logseq is different. Every time you open the application, you're greeted by today's journal.

The idea is simple. Open the application, start writing, and organize everything later using links, pages, and tags.

Why Logseq’s Journal-First Workflow Needs Planning

This journal-first workflow is one of Logseq's biggest strengths, but it also comes with a learning curve.

Personally, I recommend spending some time understanding how Logseq works before filling it with notes.

Learning while building your knowledge base can easily lead to unnecessary pages, duplicate tags, and organizational problems that become frustrating to fix later. At least, that's exactly what happened to me.

Theming Support

A note-taking application should also be pleasant to use. If you enjoy the interface, you're more likely to keep coming back to read and write.

Obsidian

This is one area where Obsidian stands out. Thanks to its large community, there are hundreds of themes available, along with plugins that let you customize almost every part of the interface.

I personally use the Border theme most of the time. Combined with the Style Settings plugin, it lets me customize Obsidian exactly the way I want.

Occasionally, I switch to Retroma, which has a unique appearance that I really enjoy.

Logseq

Logseq isn't far behind, but its theme ecosystem is much smaller.

There are still several good community themes available, although they don't offer the same level of customization as Obsidian.

I usually switch between the Immersion Dark and Bonofix Dark themes.

If you're comfortable editing CSS, you can customize Logseq even further. However, I wouldn't recommend that approach to beginners who simply want to install the application and start taking notes.

Importing Notes Between Obsidian and Logseq

Both Obsidian and Logseq let you work with Markdown files, but moving an existing knowledge base from one application to the other is not as straightforward as it sounds. The biggest reason is the difference in how each application structures notes.

According to the documentation, you can import a folder of Markdown files into Logseq. In practice, however, the results may not always be ideal.

Because Logseq is built around an outline-based structure, imported Markdown files don't automatically adopt its bullet hierarchy. This becomes even more noticeable if you're using the Table of Contents plugin, where the structure may not appear as expected.

If you're particular about keeping your notes properly organized with consistent bullets and indentation, you'll likely have to spend time manually restructuring many of the imported notes.

Obsidian handles Logseq notes a little better. You can simply copy the Markdown files from Logseq's pages folder into an Obsidian vault, and the bullet structure is generally preserved. However, headings and overall formatting may still need some cleanup.

If you've built a large knowledge base in either application, migrating it perfectly to the other is difficult. The underlying architecture of the two applications is simply too different to make the process completely seamless.

Who Are Obsidian and Logseq For?

Although both applications solve similar problems, I think they are designed for different kinds of users.

Choose Obsidian If

You write long-form notes, prefer traditional files and folders, and enjoy customizing your workspace through plugins. It works particularly well if you're willing to invest time in organizing your knowledge base and maintaining a structured note system.

Choose Logseq If

You naturally think in outlines and bullet points. Its journal-first workflow, block-based organization, built-in flashcards, and PDF annotation tools make it an excellent choice for quickly capturing ideas before organizing them later.

It is also a strong option for users who prefer fully open-source software.

How I Use Them Both

For a long time, I've used both applications side by side.

I wouldn't generally recommend this approach unless you're comfortable managing two separate knowledge bases every day.

In my workflow, Obsidian is where I keep long-form notes, article drafts, and web clippings.

Logseq is where I quickly capture ideas, maintain journals, and collect thoughts before they grow into larger pieces of writing.

This workflow still works well for me because my overall note collection is manageable.

As my knowledge base continues to grow, however, I expect to simplify everything into a system that's easier to maintain over the long term.

Wrapping Up

This article was never meant to declare one application objectively better than the other. Obsidian and Logseq reflect two different ways of thinking about notes.

Obsidian works better for me when I need a polished writing environment. Logseq works better when I want to collect, nest, and connect ideas quickly.

At the end of the day, the best note-taking app is the one that fits the way you actually work.

Which one do you use: Obsidian, Logseq, Joplin, Zim Wiki, or something else? Share your workflow in the comments.

One of the biggest strengths of KDE Plasma is its customization, and the System Monitor is no exception.

I have shown this with KDE Konsole tweaks earlier and now I am here to do the same with KDE System Monitor.

Like most other parts of the Plasma desktop, the System Monitor offers plenty of customization options that are easy to overlook.

Let me show you how to transform the default KDE Plasma System Monitor into a clean and powerful system monitoring dashboard.

Understanding the System Monitor Layout

Before we start customizing the System Monitor, let's first understand how KDE Plasma System Monitor arranges sensors on the page.

Take a look at the sample layout diagram below.

This gives you a general idea of how different elements are organized inside the System Monitor.

At the top is the window layer, where everything is arranged in rows. Inside each row is a column layer, where items are arranged into columns.

Within each column, you'll find sections. These sections hold the individual widgets that display system information.

When you enter the System Monitor's edit mode, which we'll cover in the next section, you can hover over the layout to identify these different layers.

As you add or modify widgets, clicking on a particular layer only shows the options available for that layer.

For example, clicking the column layer lets you add more columns, but not sections.

Likewise, clicking the section layer lets you add additional sections, but not columns.

Keeping this layout in mind will make it much easier to customize the System Monitor without any confusion.

As mentioned earlier, KDE Plasma's default System Monitor includes a few pre-built pages that display essential system information.

If you look closely, you'll notice that each item on these pages is essentially a widget, similar to the widgets you can place on the Plasma desktop.

In other words, the System Monitor app works like a canvas where you can add widgets and configure them however you like.

Add a New Page

By default, the Plasma System Monitor includes four pages:

• Overview: A dashboard that displays multiple system statistics.
• Applications: A list of running applications and their resource usage.
• History: Live graphs for CPU, GPU, memory, and network activity.
• Processes: A list of running processes and their resource usage.

For this guide, we'll create a new page instead of modifying the existing ones.

Click the menu button in the top-left corner and select Add New Page.

In the dialog that appears, enter a name for the page and choose an icon.

Next, set Load this page to During application startup.

Finally, click Add.

The new page will now appear in the sidebar. Select it to open it.

You'll be greeted with an empty page. This is where we'll build our custom system monitoring dashboard.

Edit the Page

Now that the new page is ready, it's time to customize its contents.

Open the new page and click the Edit Page button in the top-right corner.

Since the page currently contains only one system monitor widget, click on it. This opens a sidebar where you can configure the selected widget.

Let's turn it into a horizontal bar chart that displays the load on each CPU core.

In the sidebar, change the following settings:

• Title: CPU Load Graph (or any name you prefer)
• Display Style: Horizontal Bars
• Sensors: Select the usage percentage for all CPU cores, as shown in the clip below.

Selecting Sensors

Choosing the right sensors is the most important part of building your dashboard. Most System Monitor widgets work similarly to Plasma desktop widgets and let you display different types of system information.

Depending on the widget, you'll usually find two sensor fields:

• Sensors: Displays the selected sensors as charts, graphs, or other visual elements. You can select multiple sensors.
• Text-only Sensors: Displays the selected sensors as plain text instead of charts or graphs.

Clicking either field opens a categorized list of available sensors.

For example, CPU-related sensors, such as usage percentage, per-core statistics, and CPU temperature, are available under the CPU category.

Likewise, RAM-related sensors are grouped under Memory → Physical Memory.

Here are some of the main sensor categories you'll come across:

• CPUs: CPU usage, per-core statistics, temperature, and related metrics.
• Disks: Disk usage, free space, read/write activity, and other storage information.
• GPU: GPU usage, temperature, video memory, and related statistics.
• Memory: RAM and swap usage.
• Network Devices: IP address, download and upload speed, and other network statistics.
• Operating System: Kernel version, hostname, uptime, and other system details.

The exact sensors available will depend on your hardware and system configuration.

Adding a New Row

Now that we've added the first widget, let's create a new row to add another one.

While still in edit mode, click Add Row. A new empty system monitor widget will appear below the existing one.

This time, we'll configure it as a pie chart to display used and free physical memory (RAM).

If you'd like to see the complete process, check out the short clip below.

Otherwise, configure the widget with these settings:

• Title: RAM Usage
• Display Style: Pie Chart
• Sensors: Used Physical Memory Percentage and Free Physical Memory Percentage

You can also customize the chart colors if you like, but we'll leave them at their default values for this guide.

Add a Column

If the first section looks a bit too wide, you can split the available space by adding another column.

While in edit mode, click the topmost layer of the widget. This opens the menu for that layer.

From there, select Add → Add Column. The process is shown in the clip below.

A new system monitor widget will appear to the right of the existing one. At the same time, the original widget will automatically resize to make room for the new column.

Using the same editing process as before, I configured this new widget with the Color Grid display style to show additional system information.

Change the Position of a Widget

After setting up the dashboard, I felt that the Color Grid would look better before the CPU Load graph.

To move it, I clicked the topmost part of the widget to open that layer's menu.

From there, I clicked on Move and simply dragged the widget to the left of the CPU Load graph.

That's all there is to it.

Organize Widgets with Sections

So far, we've added rows and columns and rearranged widgets.

There is one more organizational feature in the System Monitor called Sections.

Sections let you group related widgets together. For example, you can keep all hardware-related sensors in one section and system information in another.

Let's see how it works. I'll demonstrate this on a new page. By now, you should already know how to create one.

In edit mode, click the top part of the section layer, located just above the widget title.

From the layer menu, select Add → Add Section. A new widget will be added to the right of the existing one.

Both widgets now belong to the same section and share a single section header.

To separate them visually, click the section header and select Add → Add Separator.

Save Your Changes

Once you're happy with the layout, click the Save Changes button in the top bar.

This saves all your modifications and exits edit mode.

Your newly created pages and customized widgets will now be available whenever you open the System Monitor.

Start with Your Custom Page

After creating your custom dashboard, you may want the System Monitor to open with that page by default. Fortunately, that's easy to set up.

Click the menu button in the top-left corner and select Edit or Remove Pages.

In the Start with drop-down menu, select the page you created.

Click OK to save the changes.

From now on, the System Monitor will open directly to your custom page every time you launch it.

Remove a Page

If you no longer need a page, you can remove it at any time.

Click the menu button in the top-left corner and select Edit or Remove Pages.

A dialog listing all available pages will appear. Click the Delete button next to the page you want to remove.

Once you're done, click OK to save the changes.

If you don't want to delete a page completely, simply uncheck it in the list. This hides the page without removing it.

Download Community Pages

You don't have to build every dashboard from scratch. The KDE community has created many custom System Monitor pages that you can download and use.

As with any third-party content, install these pages with caution. They are community-created and may not have been tested by the KDE developers for security or stability.

To browse available pages, click the menu button in the top-left corner and select Get New Pages.

This opens the online catalog, where you can click the Install button next to any page to download and add it to your System Monitor.

Export or Import Pages

If you frequently switch between systems, exporting and importing pages can save you from recreating your custom dashboards every time.

To export a page, first open the page you want to save. Then click Menu → Export Current Page. Choose a file name and click Save.

The page will be saved with the .page extension in your chosen location.

To use it on another system, open the System Monitor and select Menu → Import Page. Then choose the exported .page file to add it to your System Monitor.

Wrapping Up

KDE Plasma's System Monitor is much more than a tool for checking CPU and memory usage. It offers a level of customization that many graphical system monitors simply don't provide.

Despite being a GUI application, it gives you plenty of flexibility to build dashboards that suit your workflow.

Have you customized the KDE Plasma System Monitor before, or do you prefer a different system monitoring tool?

Let me know your thoughts in the comments.

Firefox is my daily driver, my main browser. I have been using it for years and I also pay attention to the features it adds with new releases.

I find it surprising that many people use it just for browsing websites but not utilizing many other features it offers. Trust me, you will be surprised by just how much power and convenience is packed into this browser beyond simple web surfing.

From clever productivity hacks to handy built-in tools, it is packed with features that can help enhance your online experience. You don't need to visit third-party websites for several day-to-day tasks.

Let me share these "lesser known" (if I may call that) features of my favorite open source browser.

Tab Split View

For a long time, the lack of a native split-screen viewing mode was a notable gap in Firefox's feature set. However, modern ultrawide monitor users can now view two tabs simultaneously side-by-side without needing to arrange separate OS windows.

While the feature is currently limited to splitting two tabs at once, rather than tiling multiple layouts, the implementation is clean and works exactly as intended.

To use it, simply hold CTRL key and click on the two tab titles you want to view together. Right-click either of the selected tabs, and choose Open in Split View from the context menu.

Once active, you can easily swap their positions or resize the dividing line to allocate more screen real estate to a specific page.

PDF Viewer and Editor

Firefox offers more than just viewing PDF files. It allows annotating PDF documents with tools such as adding highlights, hand-drawings and texts. The browser also enables signing PDF documents and inserting images within PDF files.

One of its most interesting features is merging multiple PDF documents directly within the application. To do this, navigate to the Pages view, click on the Plus button to select additional PDF files.

Ensure that the last page of the current document is selected for appending. Once all PDFs are added, save the file to create a merged PDF without relying on external websites.

This capability makes Firefox an attractive option for managing and editing PDF documents, as it provides a convenient and accessible way to annotate, sign, and merge files.

I mostly use Firefox as the PDF viewer, because it can highlight and comment PDFs, that is accessible everywhere, like inside my Obsidian PDF viewer.

Built-in Color Picker

Web developers and designers frequently spot colors they want to capture while browsing. Having a color picker built directly into the browser eliminates the need for third-party extensions.

Firefox includes a native Eyedropper tool that allows you to easily pick colors from any webpage. To access it, open the main Firefox application menu, navigate to More Tools, and select Eyedropper.

Once activated, your cursor transforms into a magnified circle with a precision pointer at the center, making it easy to isolate specific pixels. Simply hover over the exact color you want to capture and left-click. Firefox will instantly copy the corresponding hexadecimal color code directly to your clipboard.

If you find yourself using this tool frequently and want to bypass the menus, you can add the Developer item directly to your main Toolbar.

This gives you one-click access to the Eyedropper whenever you need it.

Screenshot Tool

Firefox features a powerful, built-in screenshot tool that removes any need for separate screen-capture extensions or external utilities. To activate it, simply right-click on an empty space within any webpage and select Take Screenshot.

One of the tool's best feature is its ability to intelligently align to individual DOM elements on a page. For instance, if you hover your cursor over an image, a specific text block, or a column, the tool automatically snaps its bounding box to perfectly capture that exact element.

Click on the Download button to save that selection as a PNG file.

Beyond element snapping, the tool offers great flexibility:

• Click and Drag to manually select a specific region of the page.
• Save Visible button to capture exactly what is currently shown on your screen.
• Save Full Page is the standout capability. It captures the entire webpage from top to bottom, even the portions buried far below the fold.

I absolutely loved the full website screenshot, which allow us to capture everything all the way to the very bottom of the page. This is best used when you enable Firefox's reading mode.

Whenever I find an important article, I usually take a full screenshot in reading mode and then annotate the important parts later! It is such a cool feature.

Text and Websites Translation

Newer versions of Firefox have the capability to translate website contents to your favorite language. While translations cannot always be top notch, as far as I read, those are decent and get the job done well enough.

It provides a considerable amount of languages to translate to and from, making it easy to parse international sites.

Also, when you go to Menu -> More Tools -> Translate, you can translate specific words or sentences of your choice to other languages.

This is incredibly handy when you don't need the whole page converted but just want to figure out a specific phrase.

Reading Mode

Firefox has a reading mode, which removes most of the distracting components and gives you a nice readable text. It really cleans up the page, stripping out messy blocks and sidebars so you can just focus on the content.

It takes this even further, too! You can adjust the font, the width of the text, and line spacing by using the Text and Layout settings right inside the reading mode.

Also, you can set a different reading theme like Sepia, Dark, or Light depending on your environment and what's easiest on your eyes.

There is a read it aloud feature as well, which is useful when you want to listen to the article while multitasking.

When you are on articles that can be read in a reader mode, a reader mode button appears on the address bar adjacent to the URL of the article.

Click on it to enter the reading mode, and simply click on it again when you want to exit.

AI Summaries

AI summaries are helpful when you are in a hurry and want to know what an article is all about without reading the entire piece word for word.

Firefox now includes an AI button that allows you to quickly summarize contents and get AI help right inside your browsing workflow. A major advantage here is flexibility.

It lets you choose from and connect to multiple different AI service providers rather than locking you into a single model.

You can sign into your existing accounts with these chat services, which means you can seamlessly access your chat history and previous conversations while you work.

Link Previews

Firefox uses small local models to create link previews and keypoints of links.

You can enable this feature in the General Settings under the Browser settings section. Once you toggle it on, it will take a few seconds for the initial setup.

You will also see a noticeable increase in memory usage when it's running, which happens because a small model is executing entirely locally on your machine rather than sending your data to a cloud server.

Once it is up and running, you can simply left-click and hold on any link for a second to pull up a quick preview of the destination page along with its core keypoints.

If you want to tweak how these features behave, there is now a dedicated settings section specifically for AI-related configurations inside the main Firefox Settings menu.

Tab Group and AI

Firefox offers a powerful tab grouping feature to help you manage numerous open tabs efficiently.

You can manually create tab groups, for instance, by gathering all "It's FOSS" links into an "It's FOSS" group and assigning it a distinct color.

Even more interesting is the AI-powered tab grouping. If you have many tabs open and want to organize them quickly, Firefox's AI can assist with the heavy lifting.

To use this feature, right-click on any tab and select the "Add tab to a new group" option. Choose "Suggest more of my tabs".

Wait for the AI to analyze your open tabs. If related tabs are found, the AI will present a selectable list. You can then toggle which tabs to include in the group, provide a name for the group, and click "Done" to finalize it.

Picture in Picture Mode

Firefox makes it super easy to watch videos without getting distracted. Picture-in Picture (PiP) mode lets you shrink your video down to a little window that floats on top of everything else.

To turn it on, head to the Firefox settings and look in the "General" section under "Browser". You'll find an option to enable PiP mode there.

You can also choose to automatically switch videos to PiP when you switch tabs. This is handy if you want to keep a video playing while you work on something else.

My personal favorite way to use PiP is during online courses; it keeps the video right there in my view while I code alongside searching documentation in tabs.

Vertical Sidebar

Firefox gives you the option to switch up your tab layout with a handy vertical sidebar.

To turn it on, just right-click anywhere on the tab bar and choose "Turn on vertical tabs".

Then, click the settings icon at the bottom of the sidebar. From there, you can customize it to expand and collapse when you hover your mouse over it.

I personally find this layout helps me keep track of a lot more tabs without feeling cramped. Plus, it looks pretty cool!

Quick Forget

To quickly erase browsing history of a short period, Firefox has a quick solution, Forget!

You can access this feature by clicking on the Forget toolbar item in your browser's toolbar. You have to add it first to the toolbar by customizing the toolbar.

From there, you have three options to choose from:

• Forget the last 5 minutes: Removes your browsing activity from the past 5 minutes.
• Forget the last 2 hours: Removes your browsing activity from the past 2 hours.
• Forget the last 24 hours: Removes your browsing activity from the past 24 hours.

Keep in mind that once you clear your history, it cannot be undone, and you will be logged out where ever you signed in.

Browsing History Dashboard

The Firefox View dashboard is like a personal history book for your browsing. It gives you more than just a simple list; it lets you see all your recent activity in detail!

Here's what you can do with it:

• Get a clear view of every site you visited, including tabs from other devices.
• Organize your history based on which sites you visit most often or those that are important to you.
• Easily remove specific browsing history if you need to clean up your online activity.

These are some of the cool features I use frequently, that make Firefox View a great way to keep your browsing organized and in control!

Multiple Profiles

Firefox natively supports using multiple profiles, which makes it incredibly easy to manage your home and work browsing in completely separate environments.

Profiles can be created by going to the main Menu and selecting Profiles -> New Profile. From there, you just give the profile a name, select a distinct color theme if you want to visually distinguish it, and click on Done Editing.

Creating multiple profiles and switching between them is incredibly seamless with Firefox, allowing you to keep your cookies, history, and extensions completely isolated between your different workflows.

Task Manager

With the built-in task manager, you can easily view exactly which tab is consuming your memory, CPU, and other system resources. Being able to sort sites according to these metrics is incredibly useful.

Especially when you are running heavy AI tabs and video streams together and need to track down what's lagging your system.

To pull up the task manager instantly, you can use the keyboard shortcut Shift + Esc. It is also available via the main application menu if you prefer using your mouse.

Copy Link to Highlight

A feature that was absent for a long time, Firefox now supports link to highlights!

You can select a part of the text on a webpage, right-click on the selection, and select Copy Link to Highlight.

When you share this link with others, it will take them directly to that exact spot on the page and they can see the highlighted text instantly in the shared article!

It's incredibly convenient for pointing people straight to the most relevant information without making them scroll through a massive page.

Keyboard Based Controls

Did you know that there's more to the Firefox address bar than meets the eye? By pressing a few key combinations, you can access a set of powerful actions that can help you customize your browsing experience.

To get started, press CTRL+L to focus on the address bar. Next, enter > and press a space. You'll see that an Actions criteria is enabled.

This feature offers several useful actions, including Open a private window, Restart Firefox, etc.

To access these actions, simply use the keys as shown in the table below:

Built-in Game

Are you looking for a fun way to pass the time while waiting for your internet connection to kick in? You're not alone! Many browsers have hidden games that can keep you entertained.

Google Chrome has its popular Dino game, and Microsoft Edge has Surf. But what about Firefox?

The answer is yes, Firefox does have a game mode! But it's not as obvious as the others. To find it, follow these steps:

Go to Menu -> More Tools -> Customize Toolbar. Drag all the items in the bottom of the toolbar to the overflow section. What remains will be the Flexible spacer.

And that's when the magic happens! Click on the small game button in the bottom. The interface transforms into a ball game, where you can bounce the ball and have fun.

It may not be as flashy as some other games, but it's a cool way to pass the time while waiting for your internet connection to stabilize.

Experimental Settings

Now, let's see some experimental settings. Be cautious when using these, as these are either in experimental stage or cause unexpected issues.

Get a rounder corner

Firefox has an experimental feature that allows you to round off the corners of your browser, giving it a more cohesive look across all devices and operating systems, like GNOME desktop.

However, be cautious when using this feature, as it may cause unexpected issues or affect other parts of your system. To enable it, follow these steps:

Open Firefox and type about:config in the address bar. Press Enter to access the experimental settings page. You'll be warned that changing these settings can have serious implications. So proceed with caution!

In the search bar, enter rounded and find the setting called widget.gtk.rounded-bottom-corners.enabled. Toggle its value to true to enable rounded corners.

Now, go to Menu -> More Tools -> Customize Toolbar and disable the titlebar, as shown below.

After making this change, close and restart Firefox.

Customize Keyboard Shortcuts

Want to take control of your browsing experience with custom keyboard shortcuts? Firefox allows you to do just that!

To get started, open Firefox and type about:keyboard in the address bar. This will bring up the experimental page for keyboard shortcut settings.

From here, you can alter key combinations for actions, remove existing keybindings and make any other changes you like.

Firefox Labs

Want to get a sneak peek at some cutting-edge features before they're widely released? Firefox has a section called "Firefox Labs" right in the settings menu.

This is where you can experiment with experimental features that are still under development. Don't worry, your usage data isn't automatically shared just for trying
these out. It only gets sent if you have technical and interaction data turned on in Privacy settings.

I'm currently running Firefox 151, and there are a few cool new features I can try.

Tab Notes seems really handy, but the List and Timer features are also pretty neat. They remind me of the homepage widgets in Vivaldi.

Wrapping Up

As you can see, Firefox is packed with a surprising number of features that go far beyond basic browsing, making your daily online tasks smoother and more efficient.

You don't need to go to Google Translate and copy paste text there. Simple right click works. Need quick screenshot, that' there. PDF reading and editing capabilities are additional blessings.

I can go on and on but I have to stop somewhere. So I stop here and I also let you explore lesser known features of DuckDuckGo search engine. I have a feeling that if you liked this article, you'll like that one too.

And don't forget to share your favorite Firefox feature in the comments below.

Ptyxis is a modern terminal emulator built with GTK4 and libadwaita. It provides a cohesive look for the GNOME desktop, making it feel like a natural part of the system.

The application was specifically developed to meet the needs of modern software development workflows. In my opinion, its standout feature is the seamless container support for tools like Podman, Distrobox, and Toolbox.

Ptyxis is rapidly gaining popularity across the Linux community. It has already become the default terminal for many modern distributions, including Fedora and the upcoming Ubuntu releases.

As I have been using it for some months now, let me share some of my favorite features in this new terminal. I hope you like them as much as I do.

Tabs and Overview

The first thing you notice when opening Ptyxis is the tabs and overview system. While other emulators like GNOME Terminal or Kitty use a standard tab bar, Ptyxis introduces a visual tab selector that feels very similar to the GNOME Activities overview.

If you have multiple tabs open, you can simply click the Show open tabs button in the top-right of the title bar.

This opens an interface where each tab displays its title alongside a small preview, making it easy to see exactly what is running before you click back into a full view.

The flexibility here is excellent because you can drag and drop tabs in the overview to rearrange them.

You can also pin important tabs to keep them visible at the top of the list at all times.

My favorite feature, however, is the ability to easily custom name your tabs and search through them later. By right-clicking a tab in the overview and selecting "Set title," you can choose to either prepend a name to the default process or create a completely custom title.

Once your tabs are named, you can use the search button in the top-left of the title bar to find exactly what you need. This is incredibly helpful when you are managing a large number of active sessions simultaneously.

Color Schemes

A standout feature of Ptyxis is the support for a wide range of preset color schemes. You can access these options by opening the preferences window through the three-dots menu in the top-right of the title bar.

Once inside the Appearance tab, click on the "Show all palettes" option to see the full list. The interface provides a neat preview for each selection, and your chosen theme is applied immediately.

In my opinion, the way these colors adapt is impressive. The scheme is applied intelligently to the tab bar as well, ensuring the entire terminal maintains a cohesive and professional look.

Among the vast list of options, I have a few specific favorites that I think look incredible. Omni, Pixiefloss, and Tomorrow Night, Ubuntu are all excellent choices that provide a very modern feel.

Scrollback Search

The ability to search through what appears on your screen is a massive help during long sessions. While tools like grep are great for text files, you often need to find specific information directly within the shell scrollback.

For example, if you have displayed a massive log file using the cat command, you can quickly find what you need without re-running the command. By pressing SHIFT + CTRL + F, a search interface opens at the bottom of the terminal.

The extra search filters provides better matching. You can choose to match case, match whole words, or even use regular expressions to narrow down your results.

The interface includes simple navigation buttons to move up and down through your search matches. This makes it incredibly easy to jump between different instances of a term within a long output.

Container Support

This is the flagship feature of Ptyxis. The terminal works directly with container technologies like Podman, Distrobox, and Toolbox to make your development workflow much smoother.

If your system has containers using these platforms, Ptyxis detects them automatically and provides a dedicated way to access them. You can simply click the dropdown button in the top-left of the title bar and select a specific container from the list to launch it instantly.

The ptyxis-agent coordinates with your system to handle the discovery and management of these environments. For example, if you are using Distrobox, Ptyxis will execute the proper run commands for you behind the scenes.

Profiles

Okay. This is not new. Almost all modern terminals support the profile feature and yet I think that profiles are the most underrated feature that many people often ignore.

How do they help? Let's say you want to try a new shell like ZSH, you can create a specific profile for it instead of changing your entire system shell. You could also create a dedicated profile for a terminal multiplexer like Zellij.

Ptyxis has excellent support for profile creation and management. You can find these options in the Profile section of the Preferences window.

By default, you will only see an Untitled Profile, but you can use the Add Profile button to create something new. The profile creation dialog is vast and offers many different options.

You can set specific color schemes, choose a custom shell, or even assign a default container to a profile. For example, I can create a profile that automatically opens my Ubuntu Distrobox container every time I launch it.

Once your profiles are set up, you can set one as the default for all future terminals. Alternatively, you can quickly switch between your different profiles using the dropdown menu in the title bar.

Context Awareness

Ptyxis can intelligently identify your current context, such as active root privileged windows or SSH connections. This provides immediate visual feedback about the environment you are working in.

For example, if you run a command using sudo, the title bar of the terminal turns red to notify you of the changed privilege level. If you log in as the root user, the title bar remains red until you finally log out.

Some hidden gems

Apart from the major features I mentioned above, Ptyxis also has a few more tiny functions that deserve attention. The Shortcuts option in the Preferences window allows you to alter existing keyboard combinations or add new ones for various terminal actions.

An advanced addition is the Terminal Inspector. This tool allows you to monitor exactly what is running in the terminal at any given moment, which is a massive advantage for developers.

You can use the inspector to track underlying shell processes, monitor mouse pointer locations, and even peek at OSC (Operating System Command) hyperlinks. It is a specialized feature that makes debugging terminal-based applications much easier than before.

I can see why Ubuntu and Fedora made it default

Ptyxis is a good upgrade from the classic GNOME Terminal. While the container integration might not be for everyone, the app has significantly improved many day-to-day features that improve the overall experience.

What do you think about this new terminal emulator? Will you use it as your main terminal, or are you sticking with your current favorite? Share your opinions in the comments section!