Terminal Root

Quickshell: Build Your Own Desktop on Linux

Wed, 06 May 2026 09:37:06 +0000

Quickshell is a modern toolkit built with C++ for creating desktop interface components — bars, widgets, lock screens, launchers, and even complete environments — using QtQuick + QML.

It is not a “bar program”.
It is also not a complete, ready-made desktop.

It is a foundation for building a custom desktop, running alongside a compositor like Hyprland, Sway, or i3.

In practice, it replaces several pieces:

status bar
notifications
widgets
lockscreen
display manager
system controls

Example

Quickshell uses:

QtQuick (UI)
QML (configuration/programming)
Hot reload (save → instant update) ([Quickshell][2])

Simple example (bar):

PanelWindow {
  anchors {
    top: true
    left: true
    right: true
  }

  implicitHeight: 30

  Text {
    anchors.centerIn: parent
    text: "hello world"
  }
}

Native integrations:

One of its strengths is that it comes already integrated with the system:

Wayland + X11 (windowing)
Hyprland, i3, Sway (workspaces)
PipeWire (audio)
BlueZ (Bluetooth)
UPower (battery)
MPRIS (media players)
standard system tray

This eliminates a lot of boilerplate.

Installation

Arch Linux / EndeavourOS / Manjaro

yay -S quickshell
### Or
paru -S quickshell

Or build from scratch on any system:

Dependencies:

sudo apt install cmake ninja-build qt6-base-dev qt6-declarative-dev \
qt6-wayland wayland-protocols libpipewire-0.3-dev \
libdbus-1-dev libxkbcommon-dev

Clone:

git clone https://github.com/quickshell-mirror/quickshell.git
cd quickshell

Build:

cmake -B build -G Ninja
cmake --build build

Install:

sudo cmake --install build

Run:

quickshell

Configuration:

~/.config/quickshell/main.qml

Minimal example:

import QtQuick
import Quickshell

PanelWindow {
    anchors.top: true
    anchors.left: true
    anchors.right: true
    implicitHeight: 30

    Text {
        anchors.centerIn: parent
        text: "Quickshell is working"
    }
}

Works best on Wayland (Hyprland, Sway, etc.)
May be limited on X11
Still in development → bugs are normal
No config = blank screen

For more information, visit the repository.

Meet this modern docking framework for JavaFX

Wed, 06 May 2026 09:03:00 +0000

SnapFX is a docking framework for JavaFX, focused on creating flexible interfaces in the style of:

IntelliJ / VS Code
IDEs in general
tools with multiple panels

Lightweight and modern, designed for dynamic and organized layouts, without you having to reinvent drag & drop for windows.

Installation

Via Gradle

implementation("org.snapfx:snapfx-core:<version>")

Build:

git clone https://github.com/Beowolve/SnapFX.git
./gradlew publishToMavenLocal

Simple Example:

import org.snapfx.SnapFX;
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.TextArea;
import javafx.stage.Stage;

public class SimpleDemo extends Application {
    @Override
    public void start(Stage stage) {
        SnapFX snapFX = new SnapFX();

        // Dock nodes
        snapFX.dock(new TextArea("Editor 1"), "Editor");
        snapFX.dock(new TextArea("Console"), "Console");

        // Build layout
        Scene scene = new Scene(snapFX.buildLayout(), 800, 600);

        stage.setScene(scene);
        snapFX.initialize(stage);
        // Optional: switch theme at runtime via named catalog entry
        // snapFX.setThemeStylesheet(SnapFX.getAvailableThemeStylesheets().get("Dark"));
        stage.show();
    }
}

For more information, visit the repository.

Route application traffic via command line

Wed, 15 Apr 2026 22:03:23 +0000

toricli.sh is a tool written in Go, focused on making it easy to route application traffic via the command line. The goal is to simplify the use of anonymization on Linux without relying on complex configurations.

It falls into the same category as tools like torsocks, but with a more direct and automated approach.

Installation

For Windows, use WSL

# systemd
curl -fsSL https://raw.githubusercontent.com/thobiasn/tori-cli/main/deploy/install.sh | sudo sh

# Arch
yay -S tori-cli-bin

# macOS
curl -fsSL https://raw.githubusercontent.com/thobiasn/tori-cli/main/deploy/install.sh | sh -s -- --client

Docker:

docker run -d --name tori \
  --restart unless-stopped \
  --pid host \
  -v /var/run/docker.sock:/var/run/docker.sock:ro \
  -v /proc:/host/proc:ro \
  -v /sys:/host/sys:ro \
  -v /run/tori:/run/tori \
  -v tori-data:/var/lib/tori \
  -v ./config.toml:/etc/tori/config.toml:ro \
  ghcr.io/thobiasn/tori-cli:latest

Usage example

toricli curl example.com

And the traffic is anonymized.

For more information, visit: https://toricli.sh/.

Pyrite64, a Modern Engine for Nintendo 64

Sun, 12 Apr 2026 22:11:56 +0000

Pyrite64 is an open-source engine + visual editor for creating native 3D Nintendo 64 games — not “N64-style”, but games that actually run on original hardware or accurate emulators. For development (scripting) with C++ or C

What’s the idea?

Replace the old workflow (confusing SDKs + broken toolchains)
Bring something closer to Unity/Godot, but focused on the N64
Generate real ROMs compatible with the console

Features:

Visual editor with scene management
Model import (GLTF / Blender + Fast64)
Node graph (basic visual scripting)
Runtime engine (rendering, collision, audio, etc.)
HDR + bloom adapted for N64
Asset manager with automatic cleanup ([AlternativeTo][2])

Installation

Windows

The project itself automates almost everything.

Download the release (or clone the repo)
Run the editor
It automatically installs everything:

GNU/Linux

Dependencies:

GCC/Clang
CMake
Basic build libs
libdragon toolchain

Then just clone, compile, and install

git clone https://github.com/HailToDodongo/pyrite64
cd pyrite64
mkdir build && cd build
cmake ..
make
sudo make install

Getting Started

Create a project

Inside the editor:

New Project
Set name + folder
It creates the structure with project.p64proj

Configure toolchain + emulator

File:

project.p64proj

Important fields:

"pathEmu": "ares",
"pathN64Inst": "/path/to/toolchain"

pathEmu → emulator command
pathN64Inst → toolchain root ([Instagit][3])

Import assets

Typical workflow:

Model in Blender
Export GLTF
Import into the editor

Build the scene

Add objects
Adjust transforms
Define materials

Game logic

Two options:

Node graph (visual)
C++ (more control)

Build and run

“Run” button
Generates ROM
Opens automatically in the emulator

For more information, visit the official website with FAQ.

Install This Modern Network Scanner with TUI Mode

Wed, 25 Mar 2026 10:43:42 +0000

If you’ve used tools like nmap and found them heavy, verbose, or too slow for simple tasks, Nibble solves exactly that problem.

Nibble is an open-source network scanner focused on simplicity, speed, and usability. It allows you to discover devices and services on your local network without needing to memorize complex commands or configure anything manually. It works on GNU/Linux, macOS, and Windows (x86 and ARM).

Installation

brew install backendsystems/tap/nibble
pipx install nibble-cli
npm install -g @backendsystems/nibble
go install github.com/backendsystems/nibble@latest

Or run it directly with:

npx @backendsystems/nibble

Nibble repository.

Manage APT packages with a modern terminal interface

Mon, 23 Mar 2026 11:13:08 +0000

APTUI is a TUI (Terminal User Interface) written in Go that acts as a frontend for APT.

The concept is simple: do everything you already do with APT, but without leaving the screen and without typing repetitive commands.

Main features

Real-time filtering as you type
Fuzzy search (no need for exact name)
Fallback to apt-cache search

Installation

Via Go

go install github.com/mexirica/aptui@latest

Or via APT (Debian/Ubuntu)

(custom repository available in the project)

Then just run:

aptui

For more information, visit the repository.

Manage Your SQL Databases via Terminal with This App

Wed, 04 Mar 2026 08:49:08 +0000

Pam is a minimalist command-line interface (CLI) tool written in Go, designed to simplify managing and executing SQL queries across multiple databases. Inspired by “The Office,” Pam pays homage to the character who organizes everything efficiently.

Key Features

Query Library: Save and organize your most-used SQL queries for easy access and reuse.
Multi-database Support: Compatible with PostgreSQL, MySQL, SQLite, Oracle, SQL Server, ClickHouse, and Firebird.
TUI (Terminal User Interface): Keyboard-focused navigation with Vim-inspired shortcuts for efficient manipulation of query results.
Direct Editing: Update cells, delete rows, and edit SQL directly in the results table.
Data Export: Export results in formats such as CSV, JSON, SQL, Markdown, or HTML.
Parameterized Queries: Support for parameterized queries, enabling dynamic searches without rewriting SQL.

Installation

You can install Pam via Go, by downloading the binary directly from the releases repository, or using Nix/NixOS.

go install github.com/eduardofuncao/pam/cmd/pam@latest

Basic Usage

After installation, initialize a connection to your desired database:

pam init mydb postgres "postgresql://user:pass@localhost:5432/mydb"

Add queries to your library:

pam add list_users "SELECT * FROM users"

And run them interactively:

pam run list_users

The TUI interface supports Vim-like shortcuts (j, k, h, l), copy cell (y), export data (x), edit cell (u), delete row (D), and more quick commands.

Pam stores its configuration in ~/.config/pam/config.yaml, allowing you to adjust row limits, column widths, and color schemes for the interface.

The app provides example commands for easily connecting to various database types, including PostgreSQL, MySQL, SQL Server, Oracle, SQLite, ClickHouse, and Firebird.

For more information, visit the repository

How to optimize the cd command to go back multiple folders at once

Fri, 20 Feb 2026 13:26:03 +0000

Everyone in the UNIX/GNU world constantly uses the cd command to navigate into folders through the terminal.

The cd command, also known as chdir, is a command implemented in command-line interfaces of various operating systems (Unix or any Unix-like system, DOS, Windows, OS/2 and AmigaOS).

On GNU systems (used by most Linux distros) it is a shell builtin, meaning it’s a bit more complicated to create a patch.

The cd command is very useful, however, one of the most annoying things is when you navigate into many folders and want to go back an exact number of steps, requiring commands like:

cd ../../../../../../
# Or
cd ..
cd ..
cd ..
cd ..
cd ..
cd ..

In both cases above, you need to go back 6 times.

But we can create a Bash function that reduces the amount of typing, making it faster and like a boss to go back to the 6th folder without much difficulty, like this: cd -6. Just add this function below to the end of your ~/.bashrc:

cd() {
    if [[ "$1" =~ ^-[0-9]+$ ]]; then
        local n=${1#-}
        local path=""
        for ((i=0; i<n; i++)); do
            path+="../"
        done
        builtin cd "$path"
    else
        builtin cd "$@"
    fi
}

Then reload your ~/.bashrc with the command: exec $SHELL or source ~/.bashrc and then just test it:

cd -6

In other words, use -(dash/minus) followed by the number of folders you want to go back, examples: cd -8, cd -7, cd -11,…

Remember that to go to your home folder, simply run: cd(without arguments) and to return to where you were, use: cd - without specifying any number!

Simple and practical, isn’t it?!

Vix: The 'Node.js' of C++, Without a Garbage Collector

Fri, 30 Jan 2026 12:52:19 +0000

vix is a modern runtime/framework in C++20 for building high-performance and distributed backend applications (offline-first, peer-to-peer, etc.) — a native alternative to Node/Deno, featuring async HTTP, routing, ORM, and modules.

It’s used to create web servers, APIs, and distributed applications in C++ with contemporary ergonomics (no garbage collector, no overhead from “old” frameworks). It features:

Async HTTP server (Asio)
Routing, middleware, native JSON
CLI for scaffold/build/run
Optional modules (ORM, WebSockets, utilities) Everything is designed for performance and offline/P2P applications.

Installation

Clone the repository and compile with CMake:

git clone https://github.com/vixcpp/vix.git
cd vix
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j

Optional: install headers/artifacts system-wide (according to the project docs).

To use it as a dependency in your project, include the compiled headers/libs and configure CMake to link with “vix”.

Basic Example (HTTP Hello world)

Create a main.cpp file:

#include <vix.hpp>
using namespace vix;

int main() {
    App app;

    app.get("/", [](Request&, Response& res) {
        res.send("Hello world from Vix!");
    });

    app.run(8080);
}

Compile with your CMakeLists that links the Vix runtime. When running, access localhost:8080.

For more information, visit: https://github.com/vixcpp/vix

Copy Files via Command Line with C++

Fri, 02 Jan 2026 23:05:48 +0000

How about the convenience of copying files via the command line? You can quickly create your own command with C++.

See the step-by-step guide below!

Dependencies

Example for distros that use APT as the package manager

Look for corresponding names for your distro.

sudo apt install build-essential libx11-dev libxcb1-dev libpng-dev

Also compile and install clip

git clone https://github.com/dacap/clip
cd clip
cmake . -B build
cmake --build build
sudo cmake --install build

Create the Code

Example: main.cpp

#include <clip.h>
#include <fstream>
#include <iostream>
#include <sstream>
#include <memory>

const auto use = [](){
  std::cerr << "Use: xclip++ <file> [file...]\n";
};

class Xclip {
  public:
    Xclip(int argc, char** argv){
      std::ostringstream buffer;

      for (int i = 1; i < argc; ++i) {
        std::ifstream file(argv[i], std::ios::binary);
        if (!file) {
          std::cerr << "Error opening: " << argv[i] << "\n";
          std::exit(1);
        }

        buffer << file.rdbuf();

        if(i + 1 < argc){
          buffer << '\n';
        }
      }

      clip::set_text(buffer.str());
    }
};

int main(int argc, char** argv){
  if(argc < 2){
    use();
    return 1;
  }

  auto xclip = std::make_unique<Xclip>(argc, argv);
}

Compile and Install

g++ main.cpp -o xclip++ -lclip -lxcb -lX11 -lpng -pthread
sudo install -v xclip++ /usr/local/bin/

Use Easily

xclip++ file.txt
# Or multiple files
xclip++ file1.txt file2.md file3.cpp # ...

Update and Fix

If you notice, when trying to use the pipe (|) it doesn’t work, for example:

cat file.txt | xclip++
echo 'Lorem Ipsum' | xclip++

To fix this, I added:

<unistd.h>
Overloaded the constructor: Xclip(const std::string& content) to clip::set_text(content);
And finally added setvbuf(stdout, NULL, _IONBF, 0);

Code ready to use with pipe:

#include <clip.h>
#include <fstream>
#include <iostream>
#include <sstream>
#include <memory>
#include <unistd.h>

const auto use = [](){
  std::cerr << "Use: xclip++ <file> [file...]\n";
};

class Xclip {
  public:
    Xclip(int argc, char** argv){
      std::ostringstream buffer;

      for(int i = 1; i < argc; ++i){
        std::ifstream file(argv[i], std::ios::binary);
        if(!file){
          std::cerr << "Error opening: " << argv[i] << "\n";
          std::exit(1);
        }

        buffer << file.rdbuf();

        if(i + 1 < argc){
          buffer << '\n';
        }
      }

      clip::set_text(buffer.str());
    }

    Xclip(const std::string& content){
      clip::set_text(content);
    }
};

int main(int argc, char** argv){
  setvbuf(stdout, NULL, _IONBF, 0);

  bool has_pipe = !isatty(STDIN_FILENO);

  if(has_pipe){
    std::ostringstream ss;
    ss << std::cin.rdbuf();
    std::string input = ss.str();

    Xclip xclip(input);
  }else if (argc > 1){
    Xclip xclip(argc, argv);
  }else{
    use();
    return 1;
  }

  return 0;
}

Compile and install:

g++ main.cpp -o xclip++ -lclip -lxcb -lX11 -lpng -pthread
sudo install -v xclip++ /usr/local/bin/

If you want a shorter command name, also run:

mv xclip++ xclip
sudo install -v xclip /usr/local/bin/

Now just use the xclip command, examples:

# Single file:
xclip++ file.txt

# Multiple files:
xclip++ file1.txt file2.md file3.cpp # ...

# Via pipe:
echo 'My test' | xclip
cat file.txt | xclip

Terminal Root

Quickshell: Build Your Own Desktop on Linux

Example

Native integrations:

Installation

Learn Qt

https://terminalroot.com.br/qt

Complete C++ Course

https://terminalroot.com.br/promo

Meet this modern docking framework for JavaFX

Installation

Route application traffic via command line

Installation

Usage example

Pyrite64, a Modern Engine for Nintendo 64

Installation

Windows

GNU/Linux

Getting Started

Install This Modern Network Scanner with TUI Mode

Installation

Manage APT packages with a modern terminal interface

Installation

Via Go

Or via APT (Debian/Ubuntu)

Manage Your SQL Databases via Terminal with This App

Key Features

Installation

Basic Usage

How to optimize the cd command to go back multiple folders at once

Vix: The 'Node.js' of C++, Without a Garbage Collector

Installation

Basic Example (HTTP Hello world)

Copy Files via Command Line with C++

Dependencies

Create the Code

Compile and Install

Use Easily

Update and Fix