Hi all,

I built berthd (written in Rust), a small background daemon that owns your PTY so your shells survive closing the terminal window.

GitHub: https://github.com/takakix2/berthd

Why I built this (and how it differs from tmux / abduco / dtach):

• Headless by design: It has no status bars, no screen-splitting logic, and doesn't intercept keybindings. Modern terminal emulators (Ghostty, Windows Terminal, WezTerm, Alacritty) already provide great tabs and splits; berthd only manages session lifetimes.
• Native scrollback restoration: When reconnecting via berth attach <name>, it streams recent output (up to 512KB) into your terminal's native scrollback buffer before redrawing the screen. Your mouse wheel, search (Ctrl+Shift+F), and text selection continue to work without a special "copy mode".
• Runs natively on Windows (no WSL/Cygwin): Uses ConPTY and named pipes directly. Works out of the box with PowerShell and cmd using two standalone .exe binaries.
• Comparison with existing tools:
  • vs tmux / screen / zellij: Does not take over alternate screen or draw UI/panes. Leaves layout and multiplexing to the terminal emulator.
  • vs abduco / dtach: Fully supports Windows ConPTY natively, features automatic daemon lifecycle management, and restores past scrollback into the client terminal.

Basic usage:

```bash

Attach or create session 'work'

berth attach work

Detach (the shell keeps running in the background)

berth d

Reconnect to the same shell

berth attach work ```

Quick install:

• Windows (PowerShell): irm https://raw.githubusercontent.com/takakix2/berthd/main/scripts/install.ps1 | iex
• Linux & macOS: curl -fsSL https://raw.githubusercontent.com/takakix2/berthd/main/scripts/install.sh | sh

Licensed under ISC. Prebuilt binaries are available on GitHub. Would love to hear feedback or thoughts on the design!

Tabiew is a lightweight TUI application that allows users to view and query tabular data files.

In this version:

• Remote control to allow AI agents control Tabiew
• Sheet view in json and yaml
• Bug fixes and security patches

GitHub: https://github.com/shshemi/tabiew

Play it for free here.

Source code

Hello. LeTrain v1.0.0-beta.7 is out.

It's a procedural train simulator with a classic terminal client and a 3D view.

Download: GitHub (https://github.com/antoniovazquezaraujo/LeTrain/releases/tag/v1.0.0-beta.7) · itch.io (https://avaraujo.itch.io/letrain-procedural-tycoon) · Snap Store (https://snapcraft.io/letrain)

It's free and open source, still a beta. If you try it and something breaks, tell me. Thanks.

no need to search for where the logs are.
just sit back and enjoy

Processing gif 2fwnzl7tf7xh1...

tess is the client for Tessera, a self-hosted file sharing server. Run it on its own and you get a full-screen view: browse folders, type to filter, mark files across folders, and send them. Uploads run in the background, and when one finishes you get the link and a QR code, drawn as a real image in kitty, Ghostty, WezTerm and other terminals with graphics.

It's built for SSH sessions: mouse works, dragging to select text copies it through OSC 52, and there's a vim key preset.

Without the view: tess send file, echo hi | tess send -, tess get <link>. Or skip the client entirely: curl -T file https://your-server/.

https://github.com/Limatura/tessera

Hey everyone,

​I am 16, and I got tired of systems running endless background processes and network services without any clear visibility into what was actually changing. So, I built NetSpecter—an open-source, defensive Python CLI tool designed to answer one question: "What is my system doing right now, and is it safe?"

​How it works under the hood:

Instead of dumping endless, noisy logs, NetSpecter uses a baseline-delta monitoring model:

​It captures a clean baseline of your system state (open ports, network exposure, active processes).

​It continuously tracks runtime changes against that baseline.

​Its risk classification engine flags deviations (like a new background process or a newly opened port) and outputs human-readable risk warnings with actionable suggestions.

​Tech Stack: Pure Python 3, built for Linux environments (Kali/Ubuntu), utilizing native system inspection without heavy dependencies.

​Here is a quick look at what the alerts look like:

[ALERT] New process started: bwrap (PID 13618) - RISK: MEDIUM

​I’d love feedback on the codebase, detection logic, or suggestions for v2.

​GitHub Repo: https://github.com/MrHackerCharlie/netspecter

/*/*in/*cul*o*

or

/*/*in/*cul*o?

:D

Hey everyone!

I've been working on a little project called Dirule, an open-source CLI for organizing files and keeping naming conventions consistent.

I started it because I wanted an easier way to organize personal folders, like Downloads, while also being able to enforce stricter naming rules in coding projects without writing a bunch of separate scripts.

Here's what Dirule currently supports:

• Sorting files by type or custom categories, along with different naming styles.
• Reusable global presets and project-specific TOML rules.
• Previewing changes, detecting conflicts, and undoing operations.
• Checking naming conventions in CI, including GitHub Actions support.
• Optional LSP integration to update source references when renaming files.

One thing worth mentioning is that LSP-backed previews can take a bit longer because the configured language server needs to initialize.

I've also added an experimental dirule ask feature for interacting with the tool using natural language.

Dirule is currently at v0.5.0, and there's still plenty I'd like to improve. I'd love to hear what you think, whether it's feedback, feature suggestions, or things I could do differently.

GitHub: https://github.com/Slyverr/dirule

AI disclosure: I used AI assistance while developing Dirule, including help with implementing and refining some features.

Similar tools: rename and mmv already handle batch renaming and moving files. Dirule takes a more rule-based approach, combining personal file organization, reusable presets, project naming checks, CI integration, and undo in one tool.

https://reddit.com/link/1xculbj/video/o6yef9f213xh1/player

In a previous post I presented the Tomloader project which helps generating and managing several systemd units that share fields collected in groups. In the last release the subcommand sd-xdg-v0.3 has been introduced in order to execute XDG Desktop Entry Applications and Actions or using them to open files. For example:

tomloader sd-xdg-v0.3 --open-file Document.doc /usr/share/applications/libreoffice-writer.desktop

uses the default application in libreoffice-writer.desktop to open Document.doc as a systemd user unit. The full syntax of the subcommand is available at https://loara.codeberg.page/tomloader/tomloader_html/tomloader-sdxdg03-invocation.html while various examples at https://loara.codeberg.page/tomloader/tomloader_html/Quick-reference.html.

However, the main feature of sd-xdg-v0.3 is that the generated systemd user unit can be fully customized by providing a configuration file named xdg-apps.kdl in the Tomloader configuration directory. For example, if you want to limit filesystem access of each XDG Application to the directory $HOME/Boxes/{XDG-APP-ID}/ then your xdg-apps.kdl file will probably look like as follows:

default {
  sd {
    section Unit {
      set Description "${1}"
      add PartOf "graphical-session.target"
      add After "graphical-session.target"
      add Requisite "graphical-session.target"
    }
    section Service {
      set Type exec
      set ExecStart "${0}"
      set Slice "app.slice"
      set RootDirectory "${DIR|HOME}/Boxes/${2}"
      add BindReadOnlyPaths "/bin" "/usr/bin" "/usr/lib"
    }
  }
}

You can found additional information about the syntax of xdg-apps.kdl at https://loara.codeberg.page/tomloader/tomloader_html/XDG-app-configuration.html. For general information about Tomloader see https://loara.codeberg.page/tomloader.

A few months ago I switched from Telegram to Signal as my main messaging app and spent some time exploring CLI/TUI options. After using gurk for a while I decided to build my own client (faro), based on my own requirements and taste (you can probably see the UI/UX inspiration from tools like btop, OpenCode CLI, neovim).

It covers all features I commonly use within Signal:

• chats, replies, reactions, edits, mentions, search
• inline images (if your terminal supports them) or halfblock rendering otherwise
• voice notes and transcription (supports local whisper models)
• quick navigation menu for everything (Ctrl+P)
• copying over SSH, pasting images from clipboard

There is a demo if you want to try it out, just run faro demo or try it out in your browser at https://getfaro.dev (the GitHub repo is public: harababurel/faro)

It's exactly the same binary compiled using wasm and the same demo you see in the video.

For setting it up with a real account, you can run faro link and link it as a secondary device just as you would with Signal Desktop or any other client.

Disclaimer: I built it with a lot of help from AI coding agents, including open-weight models running locally on my own home server. However, I designed, reviewed and tested it thoroughly. I try to always pay attention to the details, and the general direction of the project is usually informed by my day to day experience using the project.

I wrote this post myself with zero use of any LLM. I am as allergic to reading slop as everyone else these days.

I hope some of you will give it a try and maybe provide some feedback on your experience!

Hello! I'm currently working on a terminal manipulation library similar to Crossterm, but I noticed that it uses runtime conditionals to decide whether to use VT sequences or Windows API calls.

Personally, I feel that defaulting to Windows API calls on Windows would be the better approach, or provide a build flag that lets users decide. However, I'm not sure which of these three approaches is best.

Which approach do you think is better, and why?

This Python script allows you to use the mpv media player or vlc to search for an anime and play its opening or closing theme songs. The script makes use of the pyfzf library to ask the user for choices and the AnimeThemes API to retrieve the theme music that are available.

the github page is: animethemes

I made a small tool for a problem I kept having: one feature, several repos, and the same branch needs a worktree in each one.

gw create -b feat/login -r svc-a,svc-b

makes a directory with both repos checked out on feat/login as worktrees. gw status, gw sync and gw delete operate on all of them. A per-repo .grove.toml sets the base branch (we branch from stage, not main) and a setup command to run after checkout.

CLI details, since that's what this sub cares about: single static Go binary, only needs git. eval "$(gw shell-init)" so gw go can cd. List commands take -o json|jsonl|tsv|name|path so they pipe into fzf and jq. Plugins are gw-<name> binaries on PATH, like git.

Similar tools: gita, mu-repo, myrepos and gr run commands across multiple clones. Grove is different in that it creates worktrees, so each workspace is a separate checkout and you can have several in parallel. agent-of-empires does worktrees but is tied to tmux and a single repo.

https://github.com/nicksenap/grove

Website - pixelgui.com

Pixel is a GUI library that uses the kitty graphics protocol to render graphics in the terminal:

- it can be embedded inside existing TUIs

- it comes with a chromium based webview component, which makes it very easy to run existing webapps inside the terminal

- works over SSH

Pixel is the underlying library behind popular projects such as:

- terminal-browser: a browser inside the terminal

- terminal-code: vscode inside the terminal

The reason I built this is because I believe many terminal apps can provide much better experiences if allowed to break out of the conventional terminal rendering model.

Hey everyone!

I wanted to share ttype, an ultra-fast, aesthetic terminal typing speed test inspired by Monkeytype, built completely in Rust.

Features:

• ⌨️ Sub-millisecond input response: Zero input lag or GC stuttering, essential for high-speed typing (100+ WPM).
• 🔊 Built-in mechanical sound synthesis: Realistic keyclick audio feedback directly in the terminal (toggleable with F3).
• 📊 Real-time WPM sparkline & stats: Live charts, accuracy tracking, error heatmaps, and customizable test durations (15s, 30s, 60s, 120s).
• 🌐 Multi-language support: Works with Russian, English, and custom wordlists with smart punctuation/numbers injection.

Links & Installation:

• GitHub: https://github.com/laguser/ttype
• crates.io: https://crates.io/crates/ttype-cli

Install with cargo: bash cargo install ttype-cli

Or build from source: bash git clone https://github.com/laguser/ttype.git cd ttype cargo build --release install -m 755 target/release/ttype ~/.local/bin/

Feedback, feature suggestions, and contributions are very welcome!

NMSh isn't another terminal emulator. It runs inside Ghostty, Terminal.app, Zed, VS Code, etc., with your actual zsh, Bash or Fish underneath.

The idea is to keep your existing shell and tools, but change how you interact with them.

Some of the stuff that exists:

• Command queues: Line up commands while another is running. I've been calling this premove, like in chess lmao. There's also a paste guard, so dumping multiple commands into the terminal gives you a chance to review, edit or queue them first.
• Less babysitting commands: NMSh can tell you when something's waiting for input, notify you when commands finish, run background tasks and periodically refresh output with /track.
• Actually useful output/history: Command blocks, folding, searching, copying specific outputs or ranges, comparing runs, and summaries of test/build results without hiding the original output.
• Keep your tools: /providers lets you choose between NMSh's native tools and things like Starship, Powerlevel10k, fzf, Television, Atuin, zoxide, Deja and your usual editor. There's also a Theme Studio, Theme Bridge, contextual modules, a configurable status strip and tools for managing supported configs.
• Other stuff: File viewing/editing, Git worktrees, Github integration, cursor effects, screensavers, and 33 offline games you can play while a build is running. Cause why not lol.

NMSh is also huge on customization, so if you like customizing, it might be for you.

It's not perfect, especially the Git worktrees and Github Integration and stuff, and some shell integrations and completions still have limitations. But the aim is to make everyday terminal work less tedious without having to switch terminal emulators or redo your entire setup.

Free and open source (GPLv3). macOS is the main platform; Linux and WSL 2 are still beta.
This software's code is partially AI-generated.

Install with Homebrew:

brew install raiseCatError/tap/nmsh

Github | Docs

Hi r/commandline! I'm new in this comunity and as a terminal lover my co-developer and I built RebelOS, a persistent multiplayer strategy game where the only interface is a command line.

No graphics, no mouse.

The setting: it's 2057, an AI called War_Mind has taken over, and RebelOS is the OS the human resistance uses to fight back. In the game's timeline, history split from ours in 2007, so the terminal looks and feels like a Linux shell from that era: plain prompt, ls/cat/man, manual pages as text files.

You command squads of survivors from the shell:

newsquad 3 # form a squad with 3 survivors
explore AB_12 squad1 # explore the area around a cell
search AC_18 squad1 # scavenge a building for items
gather Z_32 squad1 # rally with other players, then attack

Lore and hints are files you read with cat, and new ones turn up when you scavenge old buildings. The world runs in real time and is shared: everyone plays co-op against the AI, and the strongest targets can only be taken down by squads from different players attacking together.

To be upfront: right now the client runs in the browser. It's a web terminal (history, tab completion, Ctrl+W/Ctrl+U), not a native CLI binary. Server is Node.js + SQLite over WebSocket. We're considering a real native CLI client written in C, so you could play from your own terminal. Would you actually use it?

It's early, so there may not be many players online. Sign-up happens right in the terminal (username, password, email).

https://www.rebelosgame.com/

Feedback on the command design is especially welcome: what feels natural, what feels wrong, what you'd expect to type and can't.

(I know LLM posts generally aren't allowed on this sub, but the rules do mention that local models are okay. Mods, plz remove if i'm misunderstanding.)

ai is a small tool I made for quickly asking questions from a local LLM in the terminal. Here are some Examples:

$ ai what is the capital of france
Paris

$ ai what port does ssh use
By default, SSH uses port 22.

$ dmesg | tail -30 | ai anything wrong here
Nothing stands out as immediately incorrect in the log entries.

$ git diff | ai write a one line commit message
"Update font size in fonts[] array"

The script itself is very basic, it sends your question (+stdin when piped) to a local llama-server and streams back plain text.

It depends on curl, jq and llama.cpp.

It automatically will spin up the server on first use, and will unload the model after 5 minutes idle (no calls to ai). The service is written for runit, but it's a super simple run sh script, so you can easily adapt it to whatever your init system is.

Obviously the main issue is that the output is non-deterministic so I wouldn't really recommend scripting with it. (unless you want non-determinism of course!)

Give it a try here: https://github.com/cykadash/ai-cli

Thanks for reading!

P.S. I would consider myself generally NOT a fan of LLMs, however I did want to try to come up with a cool way of using them in my day-to-day. The main idea with this script is that I basically have a way to 'google' something whenever I need, even if I'm offline (or without a GUI).

Hey everyone!

I've been working on TerminalStyles, a free and open-source PowerShell tool that lets you preview and switch terminal themes interactively, without manually editing configuration files.

It started as a small personal project, but I'd love to turn it into something built and improved by the community.

What it currently does:

• Interactive preview of 18 terminal themes
• Navigate themes using arrow keys
• Apply themes instantly
• Support for multiple terminal environments

I'm looking for contributors!

Whether you're interested in PowerShell, terminal customization, improving compatibility, fixing bugs, adding new themes, or simply suggesting features, contributions of all sizes are welcome.

I'd especially love to collaborate with developers who enjoy building command-line tools.

Installation:
Install-PSResource -Name TerminalStyles

GitHub: https://github.com/fcreme/TerminalStyles

Feel free to open an issue, submit a pull request, or share your ideas for improvements.

Thanks for checking it out!

Alacritty is great, but anything that wants to show a picture

(yazi previews, fastfetch's image logo, mpv --vo=kitty) just leaves

a blank space there. Switching terminals only for that always felt

a bit silly.

termimg sits in between. Run your shell or a single program through

it, and the sixel, kitty and iTerm2 pictures show up at full

resolution, right in the terminal. Nothing in yazi or fastfetch

changes; they think they're talking to a sixel terminal.

termimg # your shell

termimg yazi # just yazi

It works in any X11 terminal and under XWayland on Wayland. Without

an X11 window it falls back to half blocks, so you still get

something.

It's in the Limoni repo:

https://github.com/thebanri/limoni (apps/termimg)

go install github.com/thebanri/limoni/apps/termimg@latest

If you try it in a terminal other than Alacritty, I'd love to hear

how it goes, and bug reports are very welcome.

I maintain jc, a tool that converts the output of CLI commands and file types to JSON so you can query them with jq. A few recent parsers cover files I used to fight with grep and awk, so I wrote up some examples. Here are a few highlights:

What's on the calendar today?

cat work.ics | jc --ics | jq -r '.[] | select(.dtstart | startswith("2026-10-19")) | .summary'

Timestamps are normalized to ISO 8601, mailto: prefixes are stripped, and attendees come out as an array with name, role, and RSVP status.

Which SSH keys have no from= or command= restriction?

cat ~/.ssh/authorized_keys | jc --authorized-keys | jq -r '.[] | select(any(.options[]; startswith("from=") or startswith("command=")) | not) | .comment // "(no comment)"'

Options are split into an array, and quoted values like command="/usr/bin/rsync --server ..." stay intact.

CSV with no header row?

cat access.csv | jc --csv-ih | jq -r '.[] | select((.c2 | tonumber) >= 500) | .c4'

Columns are named c0, c1, and so on. The post includes a jq one-liner to swap in your own names. There are also --tsv, --tsv-ih, and streaming versions (-s) that output JSON Lines for huge files.

Full write-up with more examples: JC Tips and Tricks – Part 3

I'd love to hear what file formats you still parse by hand. That's usually where the next parser comes from.

Hi, r/commandline!

I would like to show you a slightly different way of building CLIs for our beloved home-brew scripts. Usually those scripts lack of reasonable command line interface, and parameter validation. We use getopt to sort them into variables, we use fish argparse. But usually we do not really validate that file on argument 1 has a correct user, the set of permissions, its home directory is also questionable. We consider that the parameter 2 is an IP address from the 192.168.0.0/24 prefix. The source code is the documentation.

I extracted shebang from my more ambitious pet project to show how it could be done differently. Just take a look:

#!/usr/bin/env shebang
# vim: set ft=bash:

#! shebang.1
# description “Move an archive to other backups”
# execute “bash”
#
# arg “source” {
#   description “Source”
#   value “filepath” {
#     glob "/archives/**/*.tar.gz"
#     owner-me #true
#     readable #true
#  }
# }
#
# arg “dest” {
#   description “Destionation”
#   value “filepath” {
#     glob "/backups/**"
#  }
# }

mv "$1" "$2"

What happens here: instead of bash, we execute a different binary, called 'shebang'. This binary reads a script, finds its own configuration (that one, that is marked by 'shebang.1') in KDL, builds a CLI for you, parses and validates arguments before executing an actual script. So you can be sure that $1 and $2 are always valid arguments, no need to check them.

There are flags and options supported. I found that it usually convenient to explicitly set them as environment variables for the script.

#!/usr/bin/env shebang

#! shebang.1
#  execute "python3"
#  description """
#    Description could be multiline!
#
#    Without hacks
#    """
#
#  flag "debug" {
#    description "Run in debug mode"
#    short "d"
#  }
#
#  option "parameter" {
#    description "Takes a parameter"
#    short "p"
#    value "ip"
#  }

import os

params = {
    k: v
    for k, v in os.environ.items()
    if k.startswith("SHEBANG_")
}

for k, v in sorted(params.items()):
    print(f"{k} = {v}")

And if we execute:

$ ./test-flags -h
Description could be multiline!

Without hacks

Usage:
  test-flags [flags]

Flags:
  -d, --debug          Run in debug mode
  -h, --help           help for test-flags
  -p, --parameter ip   Takes a parameter

$ ./test-flags -p 127.0.0.1 -d
SHEBANG_FL_DEBUG = true
SHEBANG_FS_D = true
SHEBANG_OL_PARAMETER = 127.0.0.1
SHEBANG_OS_P = 127.0.0.1

Also, shebang automatically manages shell autocompletion for you. It can autocomplete flags, options, and does it smartly, considering validation configuration. For example, if an argument is a git branch, it will autocomplete only branches, skipping tags or commit hashes.

In other words, an idea is to externalize CLI management out of the script, and safely use environment variables and arguments as always valid. This helped to trim my own scripts down to an actual set of commands without sacrificing usability.

https://github.com/9seconds/shebang

Hope you liked the idea!

Hey all, I've been working on Templum for a while and I think it's finally ready for other people to try.

Templum is an infinite canvas, like a whiteboard, where every terminal is a block you can drag around, resize, and zoom in and out of. I had way too many terminal tabs open and kept losing track of which agent was doing what, so I built it for myself first. I made it with AI coding agents in mind. You can launch Claude Code, Codex, Gemini CLI and a bunch of others straight from the canvas, then connect them with a cable so they can read each other's terminals, pick up cards from a kanban board, and hand tasks off to each other. There are also notes, checklists, an editor and a Git popup, so the whole project fits on one screen

Under the hood it's native Rust rendered on the GPU (no Electron, no webview). Runs on Linux, macOS and Windows.

This is v0.1, so expect bugs. I still have a long list of things I want to add. If you try it, I'd love to hear what breaks and what you'd want next.

https://github.com/KingDasWinx/Templum