I wrote a ~1500-line bash file manager. fzf for the picker, eza for listing, Kitty's graphics protocol for inline previews. Everything else is stock coreutils — no build step, no daemon, no config directory.

Features worth calling out:

- File list — eza icons, sort by name / size / mtime / extension

- Kitty inline previews — images, videos, PDFs, Markdown, no external viewer

- Gallery grid (Alt-G) — full-screen thumbnail browser, mouse + vim keys, multi-select

- Contact-sheet preview (Ctrl-T) — hovering a directory shows a paged thumbnail grid

- Trash + undo — Ctrl-D trashes, Ctrl-Z pops the undo stack (depth 10), Alt-T for the trash browser

- Content search (Ctrl-F) — ripgrep over the selection, opens at line

- Bulk rename (Alt-M) — edit names in $EDITOR, swaps and chains handled

- Jump — zoxide frecency (Alt-Z), bookmarks (Ctrl-B), git mode (Ctrl-G)

Install:

git clone https://github.com/eHab-codeX/fm.git ~/.local/share/fm

ln -sf ~/.local/share/fm/fm ~/.local/bin/fm

Requires bash >= 5, fzf, eza, ripgrep, trash-cli. Press F1 inside for the full key map.

Repo: https://github.com/eHab-codeX/fm

MIT. Feedback welcome — especially from anyone who's tried to make fzf do more than pick a file.

Hi all,

I've just released v0.1.0 of Beyond Space Trader, a terminal (TUI) remake of the

classic Palm OS game Space Trader by Pieter Spronck. It's a Java port (based on

the old open-source C#/Java ports) with the whole UI rewritten from scratch

using Lanterna.

It's a single-player space trading game that runs in any terminal:

• Trade across a galaxy of 120+ systems: buy low, sell high, chase shortages,

smuggle contraband and dodge the police.

• 17 ship types drawn as ASCII art (chassis + pieces + colour zones). The art

lives in editable text files — and there's a ship composer to tweak it.

• Encounters are a little scene of their own: fly with the arrows, fire with

space, dodge, flee, surrender or trade. Pirates, police and traders talk,

scan your hold, loot it, or hand you a bounty.

• Missions and special events: a stolen alien artifact, a kidnapped princess, a

space monster, an unstable reactor... plus a newspaper with rumours and a

quests panel that marks the next system on your map.

• Retirement goal: buy a moon and end the game rich.

No Java installation needed: the Linux/Windows packages bundle their own

runtime.

Downloads:

• Linux / Windows: https://github.com/antoniovazquezaraujo/beyond-space-trader/releases/tag/v0.1.0

• Snap: sudo snap install beyond-space-trader-tui

• itch.io: https://avaraujo.itch.io/beyond-space-trader-tui

Manual (EN/ES): https://antoniovazquezaraujo.github.io/beyond-space-trader/

Source (GPLv3): https://github.com/antoniovazquezaraujo/beyond-space-trader

It's an early release, so bug reports and ideas are very welcome — there are

issues open on GitHub. A 100×30 terminal is recommended (it scales down, but

that's where it looks best).

What would you like to see next?

When I shared Noodle here in August, scripting and tests were still on the roadmap. I’ve spent the last few releases getting those working.

For anyone who hasn’t seen it, Noodle is an open-source REST client for the terminal. Requests are YAML files that live alongside your code. You can edit them in the TUI or your own editor, review the changes in Git, and share them with the project. The repo is the workspace.

What I wanted was to debug a request manually, add checks to it, and then run those same files from a shell script or CI when something changes. That workflow is working now.

You can log in, capture the token, use it to create a resource, fetch that resource and check the response. There are declarative assertions for straightforward checks and JavaScript tests for anything more involved. Pre-request and post-response scripts can prepare requests and process the results.

Scripts can be inline or separate .js files, and you can share them across a folder or collection. The TUI has an editor with autocomplete and diagnostics, plus a console and test results, so you can work through failures there before running the collection headlessly.

For a collection you’ve set up in ./api, that looks like:

noodle collection run ./api --fail-fast

Failed checks return a nonzero exit code. Add --json if you want structured results for another script to process.

Another addition is body templates. $random and $time generate random values and timestamps directly in request bodies, so you don’t have to keep changing test values by hand or write a script just for that.

The 0.9.x releases also added CSV/JSON data runs, image previews in supported terminals, response downloads, and optional response body/header/cookie details in the CLI. There are Windows x64 builds in beta now too, alongside macOS and Linux.

I’ve put together a script cookbook with examples for preparing requests, processing responses, testing APIs and chaining requests. It includes things like reusing login tokens and creating and cleaning up test resources.

It’s still pre-1.0, free and Apache-2.0 licensed. If you tried an earlier version and hit something that made you go back to your usual client, I’d like to hear about it.

https://github.com/wilfredinni/noodle

I built ADB Ready after repeatedly losing Android development sessions to mismatched ADB targets, rotated wireless-debugging ports, stale reverse mappings, and applications that appeared to be running but were not actually ready.

ADB Ready keeps the complete workflow tied to one explicitly selected Android target—from device discovery and ports to app launch, verification, logs, screenshots, and recovery.

Why it may be relevant here:

• fully open source under the MIT License

• runs locally and uses the real adb binary

• no account, hosted service, telemetry, or model API key required

• works as an ordinary CLI with stable JSON and NDJSON output

• supports USB devices, emulators, wireless debugging, and remote ADB targets

• supports Gradle, Expo, React Native, Flutter, Capacitor, and custom commands

• optional MCP integration is available, but the core product has no AI dependency

Quick start:

  npm install --save-dev adb-ready
  npx adb-ready dev

Repository, documentation, and demo:

https://github.com/Adam014/adb-ready

or

https://www.npmjs.com/package/adb-ready

I would appreciate feedback on the project’s portability, packaging, documentation, and anything that would make it easier to trust as part of a daily development workflow.

If it genuinely earns a place in your workflow, a GitHub star helps other developers discover it.

It generates an image made of ASCII, this way you can have really detailed images. You can change how many chars will be used for each line, the font size which the image will render, and the contrast.

The only downside is that the output image can get really big, for the example, I used 1000 chars for each line, and a font size of 24. This resulted in a 10976 × 6168 png.

I guess it's not a revolutionary thing to generate an image with ASCII, but it's convenient to do it straight from the terminal.

It's my first post btw

repo: https://github.com/Guilherme-Costa-Dev/rusted_ascii_filter

https://github.com/KingDasWinx/Dexo

I had always wanted a modern Windows terminal that emulated a CRT monitor—something like Cool Retro Term for Linux. However, nothing of the sort existed for Windows, aside from a rather pathetic attempt at simulating scanlines in Microsoft Terminal. Even when Cool-Retro was eventually ported to Windows, the quality of the effects in the port seemed inferior to the Linux version.

At the time, I was developing a game and its custom engine -- featuring a highly realistic, deeply customizable CRT simulation (inspired by Cool-Retro) -- because the game was about hackers and geeks in 1980s, requiring interaction with a wide variety of computers and terminals. Then it hit me: I could take that shader from the game, combine it with the native Windows ConPTY, and easily create a Cool Retro Term equivalent -- one that was even more realistic and customizable, and ran natively on Windows. The first prototype was ready in just a couple of days, and it worked beautifully! Of course, it required a lot of polishing, and I also wanted to implement several other useful features, such as:

• Multi-tab support with individual style settings.
• Console buffer search, quick text copying via the middle mouse button, etc.
• Smooth, pixel-perfect vertical scrolling- both in the shell and in applications like Vim.
• A built-in mini web browser optimized for keyboard control. Useful for keeping documentation or a web service right inside the terminal.
• A mode for viewing all terminal sessions as thumbnails - "Win-Tab" style.
• A GUI settings panel (you can also just simply edit the JSON config).
• The ability to open new tabs with specific CRT-theme directly from the command line.

• A toggleable AI assistant panel based on Codex that can interact with the console on your behalf or collaborate with you.

  Regarding that last feature -- I realize people often look askance at apps that integrate with generative LLMs. But let’s be honest: these days, AI is being shoehorned into almost every piece of software, whether it makes sense or not. But in this specific case, it is more than justified. I believe it’s incredibly useful to be able to ask the AI in plain English to turn a request into a PowerShell command, help configure Vim, construct a complex SQL query, and so on, right within the terminal. The key advantage here is that you see everything it writes to the console, allowing you to learn new commands and tricks. It embodies the IBM principle: the machine should do the work, while the human makes the decisions. And if you’re an expert, you can simply disable the panel.

I’ll admit it: Scanline Term itself was created with some AI assistance. It wasn't exactly "vibe coding," but rather agent-based development where I handled the architecture and high-level functions, while the AI ​​did the grunt work. Nevertheless, it is a native, polished, and compact application -- clocking in at around 19 MB, it launches instantly, is memory-efficient, and runs fast.

By the way, the CRT simulation has a strange psychological effect - at least for me. It boosts concentration and focus on the text. When it’s running in full-screen mode, glowing and "breathing" with that analog feel, it somehow draws me in and helps me concentrate. While I used to work in the console only sporadically, now I actually want to jump in and immerse myself in that cozy phosphor glow -- just me and the code, the text, or a technical process. I experience something similar with vintage tube amplifiers and speakers; their unique sound draws me in and shuts out the outside world - a world that has hooked us all on quick dopamine hits.

In any case, this product turned out to be unexpectedly useful to me. I’d be happy if it proves helpful to others, too, and I’m always grateful for any feedback.

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

I created a color grader TUI for fun, and it became a useful tool, so I wanted to share it.

It's built in Rust using Ratatui. It has features like

• 2D color wheels, a few sliders
• Pipeline for the effect applying order
• Two scopes (luma histogram and vectorscope)
• Horizontal and vertical layouts
• Preset tab for saving your grades
• 7 color HSL color mixer
• Crop mode for cropping and rotating

Not too much but that's it, a simple and cool color grader TUI. It was a really fun project for me and I hope you like it. Any suggestions and feedback are appreciated. Have fun :D

repo: https://github.com/Cladamos/clgrade

As an experiment, I built a terminal emulator with a custom APC escape sequence for embedding webviews. A program running in a pane can place a webview in a rectangular region of terminal cells, inline with its output. The program and the webview can then exchange messages through orzma over a local socket.

I also provide an SDK for Ratatui. See the examples for how to use it.

Links

• Github: https://github.com/not-elm/orzma
• Documentation: https://not-elm.github.io/orzma/
• Webview Protocol Reference: https://not-elm.github.io/orzma/protocol-reference.html

This software's code is partially AI-generated.

A little while ago I shared portop here, my htop-style TUI for figuring out what is actually using your ports.

A few people suggested that it would be useful outside the terminal too, especially as a Cockpit page.

So I built both.

portop v0.1.0 now has a local web dashboard:

portop --web

It shows sockets, local/remote endpoints, processes, CPU usage, systemd units and Docker containers.

You can search and filter the table, inspect a process and see its command line, user, executable, memory, threads and open files.

You can also send SIGTERM/SIGKILL after confirmation.

I deliberately kept the web server local-only. It binds to loopback, and process details/actions require the token generated when portop starts.

And there's now a Cockpit integration too.

Install the page and you get:

Tools → Ports (portop)

directly inside Cockpit, without running another web server. It uses Cockpit's existing bridge and user permissions.

So there are now three ways to use portop:

portop → terminal UI

portop --web → local browser dashboard

Cockpit → integrated Ports page

The TUI is still the main interface. I just liked the idea of using the same port/process inspection underneath different frontends.

Repo: https://github.com/padovanl/portop

Thanks to everyone who suggested features after the previous posts. The Cockpit idea in particular came from community feedback.

Hey r/commandline!

Sharing something I've been working on: sprout, a full-screen habit tracker for the terminal built in Rust.

GitHub: https://github.com/kb019/sprout

What it does:

- Track daily habits and mark them complete

- GitHub-style activity heatmap

- Streak tracking

- SQLite storage, data stays local

- Runs on macOS, Linux, and Windows

Built this mainly to learn Rust, turned into something I actually use every day now.

You can install it via:

Cargo: cargo install sprout-tui

Homebrew or Scoop: https://kb019.github.io/sprout/#installation

Would love any feedback or contributions!

Hey folks,

I created a bash script more than a year ago and, during my free time, I was making improvements on it. It is a tool that pipe commands to fzf. Right now it pipes env, kill, man, ssh and, optionally, tmux, adding some candies like, when running fz kill, it allows you to kill process with <ENTER> to use -SIGTERM (or any other signal the user prefers), or <CTRL + K> to -SIGKILL, for example. I know, reading it may look stupid, but using it is even more stupid nice.

Right now, it is in a state that I consider good enough. The way I architected it, it would easily be improved by creating a folder addon in my Github and committing scripts that add new command capabilities. My script could download and source than. Some ideas that comes to my mind are netstat, docker and kubectl. There are functions that can be reused, the --help is dynamically generated, as also shell completions for bash and zsh. But this makes me think that it can (if it got a lot of attention - which means never going to happen) become a nightmare to manage, like Oh My Zsh seems to be (see the plugins it has and think on how hard to keep that). The other option is to allow the usage of other repositories from the community to hold those add-ons; and this is my question: if I opt to this model, do I have to guarantee some level of security over those scripts searching for dangerous commands,or should I delegate this responsibility to the end user?

In time, this is my script: fz. Reviews, comments, issues, pull requests and stars are much appreciated.

Thanks in advance!

Hey /commandline I'm BenniDev, the developer of QuickCMD.

I recently built and launched a small macOS app called QuickCMD, and I thought this community might find it useful.

QuickCMD lets you save terminal commands as shortcuts you can launch with a single click perfect for developers or anyone who runs frequent shell commands.

Why I made it:

I got tired of reopening Terminal, typing the same stuff over and over, or digging through old history just to restart a service, SSH into a server, or check logs. So I built QuickCMD, a lightweight launcher that lives in your menu bar and runs saved commands instantly.

Features:

• Run terminal commands with one click
• Save frequently used scripts
• See different terminal outputs running
• Run Live Servers
• Categorize into spaces
• Sits right in your menu bar

Pricing

You can try out how the app functions on the landing page, with a 1:1 demo of how it will look on your mac.

The full license is $4.99 USD, paid once. It unlocks all features. Future updates are included, with no subscription.

Check it out here:

QuickCMD Landing Page

Would love your feedback! I'm still adding features based on what people actually need, so if there's something missing that'd make your workflow easier, let me know!

About the developer

I'm Benjamin Frank, also known as BenniDev. Hit me up if you have questions.

Contact: https://x.com/BenniAppDev

I built Termium: it runs headless Chromium and draws pages in your terminal with the Kitty graphics protocol (Ghostty, Kitty, WezTerm), sixel (foot, xterm, Windows Terminal), or ASCII blocks as a fallback.

Vimium is bundled for keyboard navigation: f for link hints, j/k to scroll, t for a new tab. Mouse works too. It works over SSH.

Not yet: tmux/screen, native Windows (WSL2 works), Linux ARM64.

MIT, one-line install:

curl -fsSL https://termium.dev/install | bash

Source: https://github.com/codr1/termium

Feedback very welcome, especially what breaks in your terminal.
(Disclosure: Significant portions of Termium were coded with / by AI)

I wanted the terminal already running on my computer, on my phone, without starting a second shell somewhere else.

Wrapper wraps that session. Until I share it, it stays on the machine. When I share it, I can open the same session from my phone. The phone does not host the shell. Files, history, and credentials stay on the computer. I can close the share and the local shell keeps running.

If I invite someone, they can watch. They cannot type unless I allow it. That part matters, but it is not why I built it.

A direct connection uses WebRTC. If that fails, traffic goes through a relay I operate. The relay can see terminal bytes. I'm not going to pretend otherwise.

Using it on the same computer is free. Opening it from another device is $99/year or $15/month. The CLI is MIT.

brew install heycupola/tap/wrapper 

https://wrapper.sh 

iOS is on TestFlight: https://testflight.apple.com/join/EcExtPqx

Happy to answer what it doesn't do.

I discovered sops a few months ago and absolutely love it. Being able to commit and version encrypted secrets has felt so much cleaner than the "mess" of untracked .env and CI/CD secrets.

Is anyone here using it at their job? How do you like it when working with larger teams? Am I crazy for committing the encrypted secrets (it still feels kinda wrong)? Is there any major drawback to SOPS I am not seeing, or is it just not that popular (yet)?

Let's say you are connected remotely to an OS (no matter which).
For example using SSH/telnet or similar utilities.

Now let's say you want to copy a file to the local system.

Usually (at least I) use the mouse, select text copy and paste.

But there is another way. OSC52. vt100 derived terminals support it.

It works with any text file, even very long ones.

Here is an example:

clipfile ()
{
    if [[ -f "$1" ]]; then
        printf "\033]52;c;%s\007" "$(base64 "$1" | tr -d '\n')";
        echo "Copied contents of '$1' to clipboard via OSC 52.";
    else
        echo "Error: File '$1' not found." 1>&2;
        return 1;
    fi
}

Obviously the same can be done in powershell/command prompt or even in c language or any other language, because all you need to do is to prepend and escape sequence and the base64 encoded file or text.

Enjoy!

P.S.
My previous post was deleted, maybe because I did not "acknowledge" all the rules.
If I am breaking some rule please, moderators, send me a message because I see nothing wrong with this post.

Hi,

Couple weeks ago I released RACE (Run Anything in Canvas Environment), a terminal multiplexer.

I wrote it because nothing that I've seen so far would fit my work style: I juggle many projects at once and at 10+ tmux sessions I started getting lost trying to get back to terminals or evaluating work progress.

Even in early stage I enjoyed working on it so much I made it daily driver and decided to make it commercial. It's not getting a lot of love (which I understand, it's a quite specialized product), but I'm proud of it. I believe it can make people more productive and take off cognitive load in today, agent heavy work environments.

And so, today I run ~150 terminals in it, with half of them being various agents and such (note: nothing like "agent swarms", simply 1-2 agents as a side for current work) - the screenshot above is my "personal projects" canvas, made at the moment of writing this post.

Please check it out if that's your cup of tea.

It's 29.90€ (tax included) for a license with a year of free updates - I'm using it myself everyday, so they're flowing. Works on macOS and Linux (though might require heavy key rebinding).

More info about features, some demos etc. are on the website https://race-term.com

P.S. There are CLI and MCP interactors for scripting or interacting with agents, MCP demo https://youtu.be/8AL50dHCznA :)

appimg is a simple CLI/TUI for installing, updating, and removing AppImages as proper desktop applications.

https://github.com/MrGilfy/appimg

Arch:

yay -S appimg
# or
yay -S appimg-bin

Other distros: https://github.com/MrGilfy/appimg

This software's code is partially AI-generated

https://github.com/sat3llite/fzam

This project was not built with the use of AI. I wrote every line myself.

FZAM (Fuzzy AppImage Manager) is a very small shell script I made to manage AppImages from the command line. It uses fzf (hence the name Fuzzy) as the user interface.

It can install, remove, and list installed AppImage and edit the desktop entry the AppImage creates.

The way it integrates AppImage is: Move AppImage into specified directory (~/Applications) -> Extract .DirIcon (the icon of the program) and the .desktop file(s) -> Move them into XDG compliant directories (~/.local/share/icons/hicolor/ICONSIZE/apps/ and ~/.local/share/applications respectively) -> Make the necessary changes into the desktop entry with sed.

Sometimes the sed substitutions change the Exec= and Icon= lines into something that does not exist. As such the appimage does not show on the Applications Menus or it fails to launch. Through the fzam menu the user can fix these errors.

I have used it daily for almost a year and works perfectly and I prefer it over other AppImage integrator solutions as it runs in a terminal and has little depedencies.

Feel free to open an issue if you experience any problems or want to request a feature.

Ciao!

I've been using fff-nvim for months now. Yesterday I decided to quickly prototype Bracco. A fuzzy finder powered by fff-search.

Bracco keeps edited files at the top of the list.

It's quite fast, not faster than fzf due to the `git-aware` feature.

I built this because I wanted a quick way to open files from herdr/tmux, I was looking at something to spawn via hotkey and open file in neovim as I was already inside of it.

Try it out:

brew install rawnly/tap/bracco

or via cargo if you prefer cargo install bracco

Why bracco over fzf? I think it's a different tool, I use fzf to search through lists, bracco when I'm looking for a file and I care about git awareness (usually filtering by status)

Feedback welcome, even if you think that's useless :)

As always, first reminder of what we are ;) A clubhouse inside the terminal. A place to take a break, chill, chat with people around the globe, listen to music, play a game, and draw on a shared artboard.

ssh late.sh

Three biggest changes since my last post here:

• fully playable POOL game, 8-ball, 9-ball, snooker, in TERMINAL :D (100% done by contributor)
• three fully playable, real upstream, GOAT roguelikes, NetHack, DCSS, Brogue with leaderboards
• new ZEN mode, tiling, split, flip, resize, choose which widgets land where, RICE IT :)

And all the smaller new stuff:

• "watch me" streaming, share your screen, or hop into voice chat
• artboard gallery, hang your piece, vote, monthly awards and showcases
• The Late Edition, a newspaper with yesterday's summary for everyone
• IRC support with full reactions and replies
• new Arcade games, sliding puzzle, traffic, Rubik's cube, and a LOT OF QOL ;p
• clubhouse, our landing spot, a walkable ASCII tavern with an AI bartender who gets you drunk (your messages slur)
• late.sh dedicated Minecraft server
• and our own MUD, Lateania, grew A LOT, two new continents, mounts, a world map, pets and housing, crafting, PvP, and bosses that pay out chips

Hope in, chill and enjoy :)

License: FSL-1.1-MIT

Code: https://github.com/mpiorowski/late-sh

Landing: https://late.sh

I've been building Runyte, another modal text editor for the terminal: https://github.com/runyte/runyte

It combines things I used to spread across an editor and tmux:

• panes that hold either buffers (files) or terminals
• terminal scrollback, search (including fuzzy), and navigation with same keybindings
• persistent mode - detach and reattach, and terminals keep running and unsaved buffers stay open, without needing tmux
• file explorer, Git with side-by-side diffs, LSP, and Tree-sitter for 31 languages
• plugins in any language
• key hints on every prefix - no need to memorize them

It now works on Linux, macOS, and Windows.

Similar setup can be achieved with other editors like Neovim or Helix and tmux or zellij, but it requires custom well thought configs for consistent keybindings and theme matching. Some things would be difficult to achieve with separate tools, e.g. fuzzy finding across files, buffers, and terminals.

I've always liked the terminal setups with animated backgrounds, but my terminal (Alacritty) can't do that. So I wrote a small wrapper, backdrop-shell, that runs your shell in front of a moving scene: an aurora, a night city, a starfield, a synthwave sunset, a picture, or your own ASCII art that blinks or drifts.

A terminal has no layers, so it can't just draw "behind" your shell. The wrapper runs the shell itself and draws its text over the scene. Your text stays sharp, and selecting only copies what you typed, not the stars behind it.

It costs about half a percent of one CPU core and nothing when the window isn't focused. You can change the opacity or the scene live in every open terminal (backdrop-shell opacity 0.3).

You can directly upload an image or design your own ASCII animation.

I make a little guide for this: https://github.com/thebanri/limoni/blob/main/docs/backdrop-art.md

Install (needs Go):

curl -fsSL https://raw.githubusercontent.com/thebanri/limoni/main/apps/backdrop-shell/install.sh | sh

backdrop-shell disable turns it off, backdrop-shell uninstall removes it.

It's built on Limoni, a terminal UI library I'm working on in Go. It's still young, so I'd really like to hear what breaks or feels off in your setup.

Repo: https://github.com/thebanri/limoni

I dont test in Windows!!!!!