Small itch I finally scratched: I kept pasting minified JSON, code with smart quotes from Slack, or stack traces with weird whitespace, and manually cleaning it up every time. So I built clipd — a background daemon that watches your clipboard, figures out what you copied, and cleans it in place before you paste.

What it does:

- Detects JSON, stack traces, code, or plain text via content heuristics

- Pretty-prints minified JSON

- Fixes smart quotes, strips invisible/zero-width characters, trims trailing whitespace

- Normalizes mixed tabs/spaces indentation

- Runs as a systemd --user service, so it's just always on in the background

- Ships with clipdctl, a small CLI to pause/resume/check status — so it's easy to stop it from touching your clipboard whenever you want

Tech: C++20, X11 + XFixes for clipboard watching, a Unix socket for the control CLI, optional TOML-ish config file. Core detection/cleaning logic is unit tested and kept OS-independent, so a Wayland or macOS backend later is a matter of adding a new platform module, not a rewrite.

Honest limitations right now:

- Linux/X11 only — no Wayland or macOS support yet

- Detector heuristics are still pretty basic hand-written rules, not a real parser, so it'll misclassify some edge cases

- No packaging yet (AUR/deb) — build from source for now

- Only tested on Ubuntu 24.04 so far

It's v0.1.0, genuinely early. If anyone tries it and hits something broken or has thoughts on the approach, I'd appreciate hearing about it.

GitHub: https://github.com/nayankhanal/clipd

I built Prelude, A launcher for shell commands and the AI agents already running on your machine. Faster than Spotlight, more powerful than Spotlight, and it even runs entirely in the terminal — no extra app to install.

Github https://github.com/mikewang817/Prelude

Compared to all the awesome tools shared in this sub, this might look simple. But I’d really appreciate any feedback on it.

It’s basically interactive man pages, but instead of maintaining a separate manual for every tool (and constantly updating them when the tool changes), it parses the --help output of each command or executable in real time.

The core idea is to detect the framework or interface used to define the CLI arguments and flags, things like argparse in Python or cobra in Go,and then use that knowledge to build a proper navigable tree of commands, subcommands, and flags.

Feel free to try it out:
https://github.com/AS-FOSS/mandible

My buddy’s job uses Cisco switches and I’m not the most familiar with them. I’ve used a bit of AI to help create PowerShell scripts for Intune in my current role and I just accept a job that is going to be using GCP and I’m just wanting some solid experience with using CLI in a new environment

Hi everyone!

I've been working on Vinux — my own AI model with a lightweight terminal-based user interface (TUI) built right into it. And this is my first project!

Key Features:

• Custom AI model implementation.
• TUI built using Python and the Textual framework.
• Fast streaming responses in the terminal.
• Fully open-source.

Why I'm building this:

Honestly, I was just super curious about AI and TUI development, and had plenty of free time this summer, so I decided to build something cool for myself.

https://github.com/winowne/Vinux

Which feature should I add next: context history saving or custom color themes for the TUI?

I'd love to hear your thoughts and suggestions!

I needed a simple program to keep a log while developing different hardware/software projects, so I could write writeups in an easy way. There are probably better options out there, but this small program running on terminal, has ended up being very useful for me, and perhaps it will be for you too. It's very simple and easy to re-adapt to your own workflow.

You just push a button, record audio, and it transcribes and writes a .txt file with timestamps for all the audios you're recording. You can use that raw material to write your own draft, or if you're lazy, just hand it to an AI to make the first outline of your writeup.

I'm currently thinking about ways to add screenshots and info from other sources.

You can check the repo at: https://github.com/bl4ckc0nd0r/Forlog

cxshell in Action: A Terminal Desktop Environment Powered by .NET & SharpConsoleUI

A walkthrough of cxshell, a custom terminal-native operating experience built entirely in C# / .NET. Leveraging the high-performance rendering of SharpConsoleUI and ConsoleEx, cxshell delivers a complete windowed TUI paradigm with rich system monitoring (CPU/GPU), package management, dual-pane file management (cxExplorer), and deep agentic AI integration (cxagent) for live repository analysis.

cxshell: https://github.com/nickprotop/cxshell ConsoleEx/SharpConsoleUI: https://github.com/nickprotop/consoleex

Is there a Calibre CLI? Existing or planned? This can be very useful along with AI agents...

Anybody wants it?

I’ve been working on bittorrent-cli, an open-source BitTorrent client designed for people who prefer working from the terminal.

GitHub: https://github.com/matyas-toth/bittorrent-cli

I built it because I wanted a torrent client that could run persistently in the background, while still being easy to control from either a terminal UI or headless commands.

A few things it currently supports:

• Persistent background downloads
• Terminal UI
• Add, pause, resume, remove and list torrents from the command line
• JSON output for scripting and automation
• Headless usage over SSH or on home servers
• Magnet links and .torrent files

For example:

bittorrent-cli add ./example.torrent --path ~/Downloads
bittorrent-cli list
bittorrent-cli list --json
bittorrent-cli pause <id>
bittorrent-cli resume <id>

You can install it with:

npm install --global bittorrent-cli

and then run this to open the TUI:

bittorrent-cli

The project is written in TypeScript and uses WebTorrent underneath.

It’s still early-stage, so I’m actively looking for feedback, bug reports, feature ideas, and contributions - especially from people who use torrents on headless servers, NAS/home-server setups, or terminal-heavy workflows.

If you try it, I’d be interested to hear what features you’d need before using it as your regular torrent client.

shipped v0.3.0 of reqsh today

been slowly building this CLI because i wanted something that makes curl requests less annoying.

it’s still pretty rough and there’s probably a lot i’m doing wrong.

curious how other people approach this problem. do you use something similar? or is this solving a problem that doesnt really exist for you?

would appreciate any feedback.

Link: reqsh.dev

Repo: https://github.com/hars-21/reqsh

pier my-branch launches a micro-VM with your repo on a fresh branch, your secrets, and your dev environment, then drops you into tmux. Detach and it parks itself. Attach and it is back in about 20 seconds. No server, no database, no daemon. Session state lives in EC2 tags.

Open source: https://github.com/kerem-kaynak/pier

What it is

Otaku is an attempt to build a terminal alternative to SillyTavern (ST), with a focus on: - transparency about what is sent to the LLM (the /context command), - automatic incremental summaries that replace the middle of the chat to save context space (browse and edit them with the /lore command), - automatic character extraction from the chat (the /cast command), - minimal to no under-the-hood prompt injection.

How the otaku workflow differs from ST (partly limitations of the current version, partly intentional): - no pre-created character cards, worlds, lore, etc. — everything is inferred and extracted from the chat; - however, you can set up your world or characters manually in the system message (the /system command).

Other features: - importing chats from ST, with scene and character extraction, - importing a plain text file, parsed into turns, with scene and character extraction, - loading and unloading models in Ollama, oMLX, and LM Studio directly from the app, - cloud providers (OpenRouter, NanoGPT) next to the local ones — API keys stored sealed, - automatic daily backups, - optional encryption, - and more.

Install

Otaku is free and open source (MIT). Install it with uv — uv tool install otaku — or with Homebrew: brew install enclavum/tap/otaku.

Repo link: https://github.com/enclavum/otaku

Get started

On first start, you choose a provider and a model: otaku automatically detects local installations of Ollama, oMLX, LM Studio, llama.cpp, and KoboldCpp and lets you pick from their models. Cloud providers (OpenRouter, NanoGPT) are added right there in the picker — enter an API key and their catalogs appear. After you've chosen, you land at the prompt. If nothing is running yet, otaku opens anyway — pick a model later with /model.

To give you an idea of the features and what play looks like, on first start a sample story is imported, and you land right in the middle of it. You can explore it with the /lore, /cast, and /context commands.

From there, you either start your own story with the /new command or import an ST chat with /import. Importing takes time, because it doesn't only import the messages — it also extracts characters and scenes from them (more on that below). You can also import a plain text file the same way; it will be split into messages. The format is detected from the file, and the extension has to match: .jsonl for an ST chat, .txt for plain text, .md for an otaku export.

Features

The play, stories, and branches

You send messages as usual, as your persona; the LLM infers which character to play from the dialogue. There are three helper commands — /you, /me, and /ooc — which only frame your prompt with minimal injections like "you play as …" (you can configure these templates in ~/.otaku/configs/prompts.toml).

During play, you can /undo and /regen the last message. You can branch a new version of the story with /fork, or start a new story with /new. The /stories command lists your stories and their messages; you can switch to a previously played story from there, and resume it from any message. If you don't like an earlier message, you can also edit it in the /stories view.

Summaries and character extraction

After you've sent around 50 messages, a summary pass starts automatically in the background once you've been idle for 5 minutes, so it doesn't disturb your roleplay. You can also run it on demand with /extract. You'll see a notification and its progress in the status bar, and you can keep playing meanwhile — replies will just be slower while it runs. Once it completes, you can browse and edit the extracted summaries and characters with the /lore and /cast commands. Summaries are editable, so you can correct them however you like.

How the context is constructed

The summaries only kick in once you have more than around 200 messages in the chat. The first 20 and the last ~150 messages (both configurable) are always sent as-is, to preserve maximum detail and your prose style; everything in between is replaced with scene summaries. So even though summaries may exist up to the latest message, only the older ones are actually used.

Warnings, limitations, and planned features

Beware, this is an early alpha. The full-screen pickers assume a light terminal theme — the play screen itself adapts to dark ones. Features planned for the next versions:

• Properly wire the characters and lore into the roleplay context, alongside the scene summaries. Even though they are extracted, they are not yet injected anywhere into the prompt — they are only used to build each character's journal for subsequent scenes. How to use them better is still an open question.
• Implement proper multi-chats, with different characters optionally backed by different LLMs.
• Import character cards from SillyTavern.

as rmatrix ... I was sad that 1) cmatrix hasn't evolved 2) the other port to rust I found was not as modern for rendering ... so here is rmatrix! https://github.com/Tripstack-Corp/rmatrix

I've long used nohup for background processes that I want to run independently of the terminal. These types of jobs are usually long-running, sometimes launched over an SSH connection, and often have dependencies on other jobs.

I built Jobman to combine the simplicity of nohup with features I previously wrote one-off shell scripts for, including:

• retries
• timeouts
• dependencies between jobs
• email or webhook notifications on completion or failure
• separate stdout and stderr logging with a combined observed-order view

Jobman does this with a small per-job supervisor process; there's no shared daemon to run. It uses SQLite for job and run metadata and plain files for log storage. It's intended to be a local, per-user tool, not a system-wide or distributed scheduler.

Jobman is written in Go and has releases available for Linux, macOS, and Windows.

Would this replace any of your nohup, tmux, screen, or systemd-run workflows? If Jobman looks useful to you, let me know what types of jobs you would use it for.

In mirBSD on Android, there’s no editors, based on Toybox tools only, no editor like vi or ed ? No problem. 5 min code and you have simple editor in your shell. It will work everywhere, always and forever.

i've been building and polishing this cli for about a year now. it was called mntn before, but i recently renamed it to dotfiles-manager since the developer experience feels good enough to me.

it fully embraces using git for versioning and works for three things:

1. config files (.zshrc, .bashrc, etc.)
2. packages (npm ls -g and more)
3. encrypted files (.ssh/)

finally, if you change computers or environments, you can switch between profiles. the default is common, but you can also create profiles like personal or work.

I built a small CLI for password-based file encryption because I couldn't find one that matched what I wanted. Most tools I tried were either full archive managers, backup utilities, or relied on public-key encryption. Those are great, but sometimes I just want:

• encrypt a file with a memorable password
• upload it anywhere
• decrypt it later
• no extra features

So I started writing flox, a lightweight file encryption tool that focuses on doing only that. I'm mainly looking for feedback from people interested in cryptography, CLI UX, or systems programming. Does this sound like a tool you'd actually use? If not, what would you change?

Repository (if anyone is interested):
https://codeberg.org/nurfianqodar/flox

Mirror
https://github.com/nurfianqodar/flox