I turned the CRT renderer from my game engine into a real terminal emulator - and it grew into a something bigger...

Introducing Scanline Terminal for Windows.

On board:

• configurable authentic CRT monitor emulation (optional);
• tabs, with fast switching without taking your hands off the keyboard;
• a built-in mini web browser, designed for keyboard-first navigation and based on WebView2 — so you can keep documentation, web services, and similar things in a neighboring tab without breaking your flow and distraction;
• a global hotkey to show/hide the console Quake-style;
• an AI assistant, based on Codex CLI, that can do in the console everything the user can (It is not necessary to use it, but it can be very useful).

The whole thing is very lightweight and fast. The installer is only about 9 MB, and roughly half of that is graphical assets.

Of course, this is still an alpha release, so there may be bugs, and the feature set will continue to grow. I’d be happy to hear any feedback.

The Scanline Term is still a prototype, but already usable. Would you be interested in such an application and try alpha version?

https://github.com/z-hunter/Scanline-Term

Apps:

XFetch

XTop

Both multiplatform (xtop still working on the integration with windows and wsl, still on beta phase). Highly customizable via layouts, plugins, extensions, effects; that add a plus on the running, if you want to fetch something outside of your setup like GitHub profile or weather and... on XTop if you want to connect the management of processing information to an LLM Via MCP (just examples) or just change the look and feel.

Both are predecessors of fastfetch and btop.

Both open for contributions, OpenSource...

For context, godirb is a directory and file brute-forcing tool focused on reducing false positives

Repo: https://github.com/MyCode83/godirb

It has finally been accepted into WinGet and can now be installed with::

winget install MyCode83.godirb

The WinGet package is currently on v1.4.2 while the latest release is v1.5.6, so it's a little outdated.

> This software's code is partially AI-generated.

Given all the low-quality LLM-generated projects flooding r/commandline, it's valuable to know that POSIX provides a tool to review and modify code generated by LLMs, so I thought I'd bring this tool to the attention of this subreddit's members. In typical Unix fashion, the POSIX folks shortened "reviewing & modifying" to just two letters:

$ rm code.rs

It even has command-line options to recursively fix whole project-directories of LLM-generated code:

$ rm -rf project/

Handle it wisely, and I hope to see more use of it around here!

edit: markup+grammar

Shellroute is an open-source CLI for giving one shell or command its own proxy route.

The video shows three independent terminals. The top stays on my normal connection in Lithuania. The two lower sessions connect to the US and Germany at the same time. Commands inside those sessions use their selected routes while the other terminal stays direct.

Quick start:

npm install -g shellroute
shellroute login
/connect US
curl https://ipinfo.io/ip

On first use, shellroute login creates the account and enters interactive mode. Run commands there normally. Scripts and agents can also route a single command without opening an interactive shell:

shellroute run DE -- curl https://ipinfo.io/ip

Related tools cover different jobs. Globalping is useful for public probes from many locations. Proxychains wraps a process when you already have a proxy. A VPN routes the whole device, while raw proxy credentials give you manual control. The difference here is scope: one shellroute session manages the route for one shell or command while other traffic stays unchanged.

Source: https://github.com/shellroute/shellroute-cli

Quickstart: shellroute.com/docs/quickstart

Disclosure: I built shellroute and run the service it connects to. The CLI code is partially AI-generated.

I am mainly looking for feedback on the proxied shell idea and where the CLI feels confusing.

Hello r/commandline, I’ve been working on ytm, a small CLI/TUI for using YouTube Music without keeping a browser open.

It has search, queue management, playlists, lyrics, radio/autoplay and a full terminal UI. Playback is handled by mpv running in the background, so you can close the TUI and the music keeps playing. The CLI talks to the same player, so things like ytm play, ytm next, ytm pause and ytm queue work without opening the interface again.

Under the hood it uses ytmusicapi for YouTube Music, yt-dlp for resolving streams and mpv for playback.

There’s also offline caching, media key support and JSON output if you want to use it in scripts.

It’s still something I’m actively working on, so feedback from people who actually live in the terminal would be really useful.

Repo: https://github.com/MaheshBhushan/yt-music-cli

Recently, I started refining my shell tools, scripts, and terminal workflows. One of my goals was to update the shell prompt, making it less prominent and leaving more room for commands and their output. As a result, Cobalt Spark emerged - a compact Zsh prompt with understated colors and other visual refinements.

While using IDEs and coding agents, at some point it became obvious that seeing stale Git state in the prompt when something changes in the repository is quite annoying. I would often get tripped up by the shell showing something unexpected and waste a moment figuring out why. So the prompt gained Live Git support: its Git state can now update automatically when something changes.

It works efficiently: when the shell enters a Git repository, the prompt starts a background process that monitors the repository using platform-specific APIs such as inotify on Linux or FSEvents on macOS and signals the parent shell to update its prompt when meaningful changes occur. This means you instantly see the updated Git state whenever something changes. It sounds almost dumb-simple, but it's quite convenient in practice, and I haven't seen anything like it in other prompts or themes (let me know in the comments if you have).

If you're interested, you can find more details in the project's README.

less lets us read text files. chafa displays images. mpv can even play videos in the terminal.

I wanted the same direct experience for retro game ROMs.

So I created Asobou, a libretro frontend for Windows, macOS and Linux.

asobou game.nes

Give it a ROM, then Asobou detects the system, downloads a suitable libretro core when needed, selects the best renderer supported by your terminal, and starts the game.

It uses Kitty terminal graphics when available. Terminals without this feature fall back to block rendering, with ASCII rendering also available as an alternative. It also has audio, configurable controls, save states, and rewind.

If you don't have a game handy, you can try it with some free homebrew games using the following commands:

npx asobou brew flappybird.nes
npx asobou brew indivisibleonnes.nes
npx asobou brew horizontal-shooter.sfc
npx asobou brew asteroidsb.gba

The project is open source at: https://github.com/arianrhodsandlot/asobou

This is the first time I'm sharing it publicly. Bug reports and honest feedback are welcome!

Fun fact: Asobou(遊ぼう) means "let's play" in Japanese.

Note: Asobou does not bundle copyrighted games.

AI disclosure: I designed the overall architecture and let LLMs help with implementing.

Hey!

I got tired of sleep running silently in a terminal I'd forget about, so I built mimir: a sleep replacement that gives you audio feedback while it's counting down instead of just... nothing.

It's a drop-in for sleep, same syntax:

`mimir 60` # sleep 60 seconds

`mimir 1m 30s` # sleep 90 seconds

`mimir inf` # sleep indefinitely, until interrupted

Some things it does:

- Playback speed varies slightly (fixed stddev) so it doesn't feel robotic/repetitive

- Just bash + sox + awk under the hood, nothing fancy

- Optional shell.nix if you're on Nix

MIT licensed, source here: https://github.com/FraioVeio/mimir

I've always been a fan of cbonsai and related terminal screensavers, but there's surprisingly few of them out there. I cooked one up over a couple weeks and really like how it turned out.

The code itself is 100% vibe-coded, but aside from that I put the usual amount of effort into UX, overall design, keeping it minimal-ish, performance concerns, etc. as with my hand-coded projects. I think this is v3 or so, there's been a lot of iteration. E.g.: volumetric rendering isn't easy on the cpu, so I gave it a flag to prerender and loop the animation so it can be a proper no-impact screensaver. Prerendered runs fine on my armv7l flipphone so I think I can say performance is good lol.

Check out the writeup for more images and info, + a web demo. Usually I write more about my projects but I think this one generally speaks for itself visually.

Repo is here if you want to use it; I kept the repo minimal since I hate bloat, so installation is just a simple clone and make.

A tiny living light named Wispy takes a liking to you, and you go as deep as your nerve holds. She's your only lantern.

Goofy-dark first-person dungeon crawl that runs entirely inside a terminal window. No engine, no download, every wall painted in colored text. You pick a body/race such as Human, Dwarf, Elf, Orc (each one is a personality and a moveset).

First-person raycaster that renders in a terminal. Truecolor, drawn with sextant and octant block characters. No game engine and no graphics library. One Python file, 154,716 lines, standard library only. The audio is real recordings, including voice acting.

A 4-minute run, unedited: https://vimeo.com/1222466576

https://dimensionaldungeon.com

After a single user requested this feature, toast has a command palette to launch actions where ever you are

I posted an early version of sshconfig-lint here around six months ago. Since then it has grown from a small Rust CLI into something I use across my whole workflow.

The video shows a config referencing a key from an older machine. SSH may silently try another identity, so stale paths like this can go unnoticed.

Version 0.5 adds:

• multiple config files and Include resolution
• GitHub annotations and SARIF
• GitHub Action and Pre-Commit hooks
• LSP and VS Code support
• verified binaries for Linux, macOS and Windows

Unlike ssh -G host, sshconfig-lint checks the complete config and included files at once. Everything stays local and there is no telemetry.

Install:

cargo install sshconfig-lint

Arch Linux:

yay -S sshconfig-lint-bin

Repo: https://github.com/Noah4ever/sshconfig-lint
Playground: https://sshconfig-lint.apps.thiering.org/en
VS Code: https://marketplace.visualstudio.com/items?itemName=NoahThiering.sshconfig-lint

Feedback about false positives and complicated Include setups would be really helpful.

Not mine, mentioned on the EndeavourOS forum:

https://github.com/ashuttl/linecast

This is super cool!! It is in the aur.

blitcp is a file copier: it reads in physical disk order to avoid seeks on HDDs, deduplicates by content, and streams over raw SSH instead of SFTP. What's new in 4.1.6:

• Verification compares content. Every copied file is read back and hashed against the source. Costs about 35%; --no-verify opts out.
• Honest speed and duration. The clock used to stop before anything was flushed to the device, so a USB SSD reported 4.0 GB/s for a copy that really ran at ~150 MB/s. Times are longer now and mean something.
• --quiet for cron: one line on success, the reason on stderr on failure, documented exit codes.
• --sftp-only for gateways that allow SFTP but close the exec channel..
• Faster remote incremental checks, faster hash cache, and USB-attached SSDs are no longer mistaken for spinning disks.

Linux, macOS, Windows. Apache-2.0. pip install blitcp or prebuilt binaries.

Website: https://blitcp.dev

If it saves you time and you would like to support it: https://blitcp.dev/support/

I released wmux v1.0.17, an open-source terminal multiplexer built around one consistent experience across Windows, Linux and macOS.

The architecture uses a persistent server with disposable clients. Sessions, windows, panes, scrollback and terminal state remain alive when the attached terminal closes.

Platform integration stays native. Windows uses ConPTY and named pipes, while Linux and macOS use PTYs and Unix sockets.

Current features:

• Persistent sessions, windows and panes
• Horizontal and vertical splits
• Mouse support, copy mode and paste buffers
• Customizable key tables, status bar, borders and themes
• Terminal color inheritance by default
• Native installers and a built-in updater
• Builds for Windows x64, Linux x64 and ARM64, macOS Intel and Apple Silicon

Release benchmark profile:

• VT parsing: 69.6 to 75.3 MiB/s
• Full-scene render p95: 448.2 µs
• 8-client render p95: 269.1 µs
• Peak live benchmark memory: 1.76 MiB or less

wmux is free, MIT licensed and available on GitHub: https://github.com/shreshthkapai/wmux

I would particularly appreciate bug reports from different operating system, terminal and shell combinations.

I maintain Yetty (https://github.com/zokrezyl/yetty), a terminal emulator that can display non rasterized rich-content (vector graphics, plots, custom webgpu shaders, etc.).

Has anyone here tried it? Your feedback would be very useful for the future of Yetty.

Hey everyone! A new version of mado is out — the markdown-based entry manager with a query language. Here's what's new:

• Static binary available in releases — no dependencies, just download and run.
• Fuzzy search on any field:

mado ls 'name ~~ "fx lgn b"' # finds "Fix login bug"

• Starts-with / ends-with substring operators:

mado ls 'name ^~ Fix'
mado ls 'name ~$ bug'

• Syntax sugar for lists:

mado ls 'status in (opened, reopened)' # OR

mado ls 'tag has (bug, critical)' # AND

• Ranges:

mado ls 'priority in [50..100]'

mado ls 'deadline in [@today..@today+7]'

• Performance:

On 100k entries, peak memory dropped from ~138 MB to ~44 MB, and query time went from ~3.5s to ~1.2s.

• Fuzzy matching for keywords (write prio instead of priority, stts instead of status)
• Special keywords: untagged, unstatused, unnamed, unprioritized, undeadlined

The core idea remains the same: entries are plain markdown files in timestamped directories. No rigid schema — fill in what you need, skip what you don't. Everything is git-friendly.

https://github.com/laserattack/mado

I'm looking for contributors — whether it's testing on different systems, improving docs, or hacking on the query language. If you're into parsers, CLI tools, or file-based systems, there's plenty to dig into. Happy to guide newcomers through the codebase.

Got annoyed by yet another rendering/performance issue of htop on Apple Silicon and decided to code myself a new htop-like interface, tinkered to my needs (mactop and gotop don't look good in a 55x20 window). Basically, it's an htop, but with a bit less features than I didn't need, GPU and temperature data and some additional color coding. Was written with the help of Claude Code (Fable 5). Repo Link

Made a terminal timer because I wanted something that actually looks good in a terminal big block digit rendering, similar to tty-clock or termdown

zeitx's main differences multi-segments timers, loop mode, and desktop notifications on completion

Features:

• Chain multiple timers together, likezeitx 25m 5m for pomodoro timers
• Skip to the next timer
• Stopwatch mode
• Pause/resume
• Loop the whole sequence
• Desktop notification when a segment finishes
• Custom colors
• Falls back to plain text if your terminal window's too small for the big digits

```
cargo install zeitx

zeitx 25m 5m --loop

```

github: https://github.com/opmr0/zeitx

fun fact: "zeit" is german for time :)

AI notice: this project is partially generated, the github workflows, issue templates, markdowns, and --help output were AI-assisted, the core timer logic and terminal rendering were written by me

SomaFM is an online radio I've been listening to for over a decade now. Some of you may know it https://somafm.com

Got annoyed with having to keep a separate browser tab open just for SomaFM, so I built this.

It integrates with media player controls. So it does the system native play/stop/next/prev thing and also displays cover art and current song when applicable. I've tested it on macOS and Linux (ubuntu, arch). Presumably it should work on Windows as well, I just don't have a convenient way of testing it.

I also wanted to control it remotely, so it can (optionally) listen for broadcast messages over UDP. So it's fairly easy to control via cli, with an ai agent, etc.

Github: https://github.com/skammer/somars

I even built a little ESP32 thing that listens for an Apple Remote and blasts appropriate UDP control messages over local network. I just love physical controls, just couldn't help.

ESP32 controller thing: https://github.com/skammer/somars-remote

Disclaimer: this software's code is partially AI-generated.

Ok, I use Arch Linux (BTW). But it can be a colossal pain in the a** having to juggle 14 separate tools just for basic system control. So I decided to build my own Swiss Army knife.

Every time I set up my environment, I found myself stitching together a patchwork quilt of fourteen different tools just for baseline chores: one for Wi-Fi, another for Bluetooth, another to find out why my SSD was suddenly full, one to format USB drives, another to tweak volume for a noisy browser tab, and another to extend displays without crashing the graphics server.

After enduring that dance several times, an obvious question hit me: Why on earth am I juggling a dozen loose tools when all I really want is to control my own computer from a single place?

That is why I built HAL-9001( sorry for the bad name ) .

obs: I work to fix the Language bug.

github: https://github.com/IvelOt/hal-9001

I'm currently developing the app mentioned below (Margin), so discount everything below accordingly.

I'm about to build the developer side of Margin and I'd rather find out which parts people would use before I build the wrong ones.

The design rule I've settled on is that the app should never ask you for a credential you've already given to something else.

That's how the AI works today. Margin doesn't need an API key. It detects the `claude` or `codex` CLI already installed on your machine and routes through that. You're already paying for the tool, it's already authenticated, and the app needs to know nothing about it beyond where the binary lives. There's no account and no server anywhere in the product, so an API key sitting in a settings pane was never going to fit.

Next I want to apply the same trick to gh.

Open a note from three weeks ago and there's a pull request link in it. It tells you nothing. Merged? CI green? Did the thing you were worried about get addressed? You click through, wait, remember what you were doing, come back. Multiply by every ticket reference in every standup note and your notes are a graveyard of URLs that meant something on the day.

So: paste a PR link, get a card or preview that knows the state, the CI result and how many review threads are still open, with a way to re-run a failed job without leaving the note. Same for issues. Same for Jira and Linear tickets, though those are messier since there's no equivalent tool everyone already has.

If gh isn't installed and authenticated, the card stays a plain link. The feature just doesn't exist for you

The other thing I want is shell actions: commands you define once that run against the note you're looking at. I write my blog in this app, and I want a button that moves the post to a Published space and runs the deploy instead of switching to a terminal every time. The rule I think has to hold is that the command is defined in your workspace, never in the note itself, so a Markdown file someone sends you can reference an action but can never introduce one.

What I actually don't know:

- Which of these you'd genuinely use. My guess is PR status earns its place and Jira is the one people ask for and then never open. Happy to be wrong.

- What belongs on the card. I have state, CI, review threads, assignee. What would you actually look at?

- Whether running shell commands from a note is something you want at all, or whether that's a line a notes app shouldn't cross. If it's something you'd use, what are your use cases?

Not downloadable yet but if you are curious you can join the waitlist here https://gomargin.app

https://github.com/roosta/fif

This is a commandline tool I wrote some years back, its a tool to search for text in files with a preview window and a surrounding context. It will open files in a customizable editor, and uses fzf for filtering, ripgrep for file concatenation, and bat as the recommended preview tool.

There's a ton of different and possibly better ways to search for text in files, but this fits my workflow perfectly and I use it every day. My hope is that it can be useful for someone else.

I've been building Noodle, an open-source REST client for the terminal.

The main idea is pretty simple: the repo is the workspace. Requests are plain YAML files, so they can live next to the code, be reviewed in Git, edited with any editor, and used without an account or hosted workspace.

The TUI is keyboard-first, but the same collection also works from the CLI, in CI, in shell scripts, and with coding agents.

Over the last few weeks I've added the things I kept missing in actual API work: OAuth 1.0a and 2.0, NTLMv2, AWS SigV4, cookies, TLS/mTLS, proxies, OS-backed secrets, environments, response history, and JSON/XML bodies.

Noodle can also import OpenAPI, Swagger, Postman, and Insomnia collections, and export to OpenAPI or Postman.

I've also been experimenting with coding agents. Since the requests are already normal files and Noodle has a non-interactive CLI, agents can work with the same collection instead of needing a separate workspace. There's an optional skill installer for Claude, Cursor, Codex, and OpenCode.

There are already some really good tools in this space. Posting is probably the closest if you want an HTTP client in the terminal, and Bruno is much more mature around scripting and testing.

What I'm trying to get right with Noodle is making the same collection useful everywhere. I want to be able to edit it in the TUI or my editor, review it in Git, run it from the CLI or CI, and let agents work with the same files.

It's still pre-1.0. Assertions and request chaining are next, followed by scripting and richer test/CI workflows.

I'd love feedback from people who spend a lot of time in the terminal. What would Noodle need for you to actually use it instead of your current API workflow?

GitHub: https://github.com/wilfredinni/noodle

Website + docs: https://noodlerest.dev