Terminal Root

Query JSON, CSV, and TSV Files Using SQL in the Terminal

Fri, 24 Jul 2026 18:32:04 +0000

qo is a command-line tool written in Go that allows you to run SQL queries on structured data. It features an interactive TUI (Terminal User Interface) where you write your query and see results in real time, and it also works seamlessly in Unix pipelines.

Its main features include:

Query JSON, CSV, and TSV files.
Uses SQL syntax based on SQLite.
Interactive interface for quickly testing queries.
Works in pipelines (stdin → stdout).
Open-source project written in Go under the MIT license.

Installation

Using brew:

brew install qo

Using Go itself:

go install github.com/kiki-ki/go-qo/cmd/qo@latest

You can also compile the project directly from the source code available on GitHub.

Basic Usage

Imagine a users.json file containing a list of users.

You can open the interactive interface:

qo users.json

Or run a query directly:

qo users.json "SELECT name, age FROM data WHERE age >= 18"

Since the tool works well with pipelines, you can also do:

cat users.json | qo

The SQL syntax makes operations like these easy:

SELECT
WHERE
ORDER BY
GROUP BY
JOIN (when applicable to the data)

This makes exploring files much more intuitive for those already familiar with SQL.

For more information, visit the repository.

TUIOS: A Terminal Window Manager

Tue, 21 Jul 2026 20:11:18 +0000

TUIOS is a terminal multiplexer and window manager that allows you to create multiple terminals and organize them in side-by-side layouts (BSP tiling).

Installation

The project offers several installation methods:

Homebrew

brew install tuios

go install github.com/Gaurav-Gosain/tuios/cmd/tuios@latest

Installation script

curl -fsSL https://raw.githubusercontent.com/Gaurav-Gosain/tuios/main/install.sh | bash

There are also pre-built binaries available for download and an official Docker image. The main requirement is to use a modern terminal with True Color support, with Ghostty, Kitty, and WezTerm being some of the recommended options.

Basic Usage

After installing, simply start TUIOS:

tuios

Some useful shortcuts:

n → creates a new terminal.
Ctrl + P → opens the command palette.
Esc → returns to window management mode.
z → maximizes/restores the current panel.
Ctrl + B → prefix key for advanced commands.

You can also create persistent sessions:

tuios new my-session
tuios attach my-session

This way, you can close the terminal and resume exactly where you left off later.

For more information, visit the repository: https://github.com/Gaurav-Gosain/tuios

SkiftOS: A Modern Operating System written in C++ from scratch

Mon, 20 Jul 2026 21:24:14 +0000

SkiftOS is an open source operating system developed practically from scratch, without relying on a Linux kernel or BSD.

Warning: the developer himself states that the project is still in its early stages and should not be used as a primary operating system or in production.

Developed primarily in C++20, it aims to combine:

simplicity;
modularity;
modern design;
clean APIs;
integrated graphical interface.

Unlike many hobby OS that focus only on the kernel, SkiftOS has practically its own entire stack:

Bootloader
Microkernel
Graphics framework
Standard library
UI toolkit
Desktop Environment
Native applications

All developed specifically for the system.

Main components:

Hjert: The system’s microkernel.
Karm: The project’s base library.
KarmUI: Reactive graphics framework inspired by modern technologies.
Hideo: The graphical environment (Desktop Environment).

Technologies used:

The project makes use of several modern technologies:

C++20
LLVM/Clang
Ninja
NASM
Python
QEMU
x86-64 architecture
microkernel
IPC
Capability-based Security

Installation

Currently the project does not have a traditional installer.

The recommended way is to compile the system from source code.

On Linux or macOS install:

Git
Clang (18+)
LLVM
Ninja
NASM
Python 3.11+
QEMU
SDL2
mtools
liburing

The official manual provides specific commands for Ubuntu and Arch Linux.

In short: clone the project

git clone https://codeberg.org/skift/os.git

cd skift

Set up the environment:

./skift.sh tools setup

Then check if everything was installed correctly:

./skift.sh tools doctor

Install dependencies:

./skift.sh install

Build:

To start the system in QEMU:

./skift.sh boot

You can also run just the graphical shell:

./skift.sh run --release hideo-shell

Or generate a disk image:

./skift.sh dist --format=hdd

Usage

After starting the virtual machine, the system loads its own graphical interface.

Available features include:

window manager;
terminal;
text editor;
image viewer;
native applications;
integrated desktop.

There are still several limitations, as the project continues under active development.

SkiftOS is one of the most interesting hobby OS projects today. Instead of just implementing a functional kernel, it aims to deliver a complete experience, including microkernel, standard library, graphics framework, desktop, and its own applications.

For more information, visit the SkiftOS repository.

Meet this Open Source Launcher inspired by Raycast

Fri, 17 Jul 2026 19:20:53 +0000

If you enjoy the Raycast experience but use Linux, you’ve probably already looked for a truly fast, modern, and extensible alternative. Vicinae was created exactly with that goal in mind.

Vicinae is a launcher written in C++ and Qt, offering native performance, low resource consumption, and compatibility with various extensions from the Raycast ecosystem available for GNU/Linux.

Available features include:

Application search and launching
Clipboard history
File search
Built-in calculator
Emoji picker
Quick window switching
Volume control
Browser tab search
Text expansion (snippets)
Installed fonts navigation

Installation

There are several ways to install it.

AppImage

Download the AppImage from the project’s Releases page:

Vicinae GitHub Releases

Then (example for x86_64):

chmod +x vicinae-vX.Y.Z.AppImage
./vicinae-vX.Y.Z.AppImage server

If your system does not have FUSE support:

./vicinae-vX.Y.Z.AppImage --appimage-extract
cd squashfs-root
./AppRun

You can also download the file:

vicinae-linux-x86_64-vX.Y.Z.tar.gz

Then:

tar -xzf vicinae-linux-x86_64-vX.Y.Z.tar.gz

Copy the executable to a directory in your PATH, such as:

~/.local/bin

Usage

After installation, the first step is to start the service:

vicinae server

If an instance is already running:

vicinae server --replace

Once the server is running, simply use the configured shortcut (or create one in your graphical environment) to open the interface.

You can also control the launcher via the command line:

vicinae open

Close:

vicinae close

Toggle between open and closed:

vicinae toggle

Calculator

Type an expression:

125 * 48

sqrt(144)

The result appears immediately. Other features include: emoji, snippets, …

For more information, visit: the repository.

Meet This SSH Multi-Server Manager

Tue, 07 Jul 2026 10:30:32 +0000

If you manage multiple servers via SSH, you should check out LazySSH.

It’s a terminal-based (TUI) SSH manager, inspired by tools like lazydocker and k9s, that makes it easy to navigate and manage entries in your ~/.ssh/config file.

Search by alias, IP, or tags
Pin favorite servers
Add, edit, and remove hosts directly from the interface
Ping to check availability
SSH connection with a single Enter
Sorting and filtering options
Preserves your ~/.ssh/config by creating automatic backups before making changes

Installation

Homebrew (macOS and Linux)

brew install lazyssh

Building with Go (Linux, macOS, and Windows)

If you already have Go installed:

git clone https://github.com/adembc/lazyssh.git
cd lazyssh
go build -o lazyssh ./cmd

Then, optionally, move the binary to a directory in your PATH:

sudo mv lazyssh /usr/local/bin/

Or install it directly using:

go install github.com/Adembc/lazyssh/cmd@latest

Usage

After installation, just run:

lazyssh

The program automatically reads the file:

~/.ssh/config

So all you need is to have your SSH hosts already configured as usual to start using it.

For more information, visit: https://github.com/adembc/lazyssh

Easily Create Progress Bars in C

Sat, 09 May 2026 18:54:59 +0000

c_progress_bar is a library for C that helps you create:

Colorful progress bar
Estimated remaining time
Elapsed time tracking
Works with MSVC, Clang, and GCC
Written in C99 with minimal dependencies

Installation

git clone https://github.com/c-modules/c_progress_bar
cd c_progress_bar/
cmake . -B build
cmake --build build/
sudo cmake install build

Simple example

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

#include "c_progress_bar.h"

#define N 1000000000

int main(void)
{
    double sum = 0.0;

    // Setup progress bar
    CPB_Config config = cpb_get_default_config();
    config.description = "Processing";                // Default: ""
    config.min_refresh_time = 0.1;                    // Minimum refresh time in seconds. Default: 0.1.
    config.timer_remaining_time_recent_weight = 0.3;  // Weight for recent rate in remaining time estimation. Range: [0, 1]. Default: 0.3.

    // You don't need to modify anything for CPB_ProgressBar.
    // Just call cpb_init
    CPB_ProgressBar progress_bar;
    cpb_init(&progress_bar, 0, N, config);

    // Main loop
    cpb_start(&progress_bar);
    for (int64_t i = 0; i <= N; i++)
    {
        if (i % 1000 == 0)
        {
            cpb_update(&progress_bar, i);
        }

        sum += (i % 100) * 0.0001;
    }
    cpb_finish(&progress_bar);

    printf("Final result: %f\n", sum);

    return 0;
}

For more information, visit the repository

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.

Learn Qt

https://terminalroot.com.br/qt

Complete C++ Course

https://terminalroot.com.br/promo

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.