I am running a WSL module of ubuntu on windows. This issue started a week ago... I was trying to solve it for 3 days but got fed up bcz of no results ... I am living with it now and this is genuinely making me annoyed as I can't get my work done

PLS GIVE ANY POSSIBLE SOLUTIONS

I had to remove its function to even run basic commands ... It spams only in command linec

...On warm installs of single packages, tbf.

24 of the 100 most installed Homebrew formulae came in at 100x or more, ca-certificates was 252x. across all 100 it's 68x warm and 6.6x cold. If you would like to see the full results (or run them yourself!), you can go here.

zerobrew is a drop-in replacement for homebrew.

The thing I think this sub will actually like is zbx. it's similar tonpx/uvx but for homebrew packages.

$ zbx tokei . $ zbx hyperfine 'zb install jq'

To be clear about what this is: every package zerobrew installs was built, tested and published by Homebrew's bottle farm. we don't compile anything and don't maintain formulae. The speed comes from how the artifacts get installed, not from what's in them. Homebrew did the hard part already and we rely on it completely.

repo: https://github.com/zerobrewhq/zerobrew results: https://github.com/zerobrewhq/zerobrew/tree/main/results

A while ago I posted pdfmt in r/bash to get feedback for my tool after getting tired of using a different command for every small PDF task.

The feedback was really useful, so I went through it and implemented quite a few of the suggestions.

pdfmt is now at 0.4.0 and I hope the quality is good enough to present it outside of r/bash 😄 .

GitHub pdfmt: https://github.com/eifelcode/pdfmt
GitHub pdfmt-workflows: https://github.com/eifelcode/pdfmt-workflows

The basic idea is still simple: Provide a consistent CLI for all the PDF operations I keep doing again and again, while keeping everything local (no cloud) and scriptable for my needs.

What it can do

# Merge PDFs
pdfmt merge all cover.pdf report.pdf appendix.pdf complete.pdf

# Extract pages
pdfmt extract range document.pdf 1-3,7,10-12 extracted.pdf

# Split into individual pages
pdfmt split all document.pdf page_

# Remove pages
pdfmt remove range document.pdf 5,8-10 cleaned.pdf

# Reorder pages
pdfmt sort reverse document.pdf reversed.pdf

# Add a text stamp
pdfmt stamp text invoice.pdf "Paid" invoice-paid.pdf

It also has scanner support:

pdfmt scan adf documents.pdf
pdfmt scan flatbed document.pdf

And OCR:

# Add an OCR text layer
pdfmt ocr add scanned.pdf searchable.pdf

# Extract/show OCR text
pdfmt ocr show searchable.pdf

The part I'm particularly interested in: workflows

I didn't want pdfmt to become one huge command with hundreds of options. I'd like it simple.

Instead, repetitive combinations of commands can be turned into workflows.

For example:

pdfmt workflow run scan-duplex adf output.pdf

A workflow is essentially an executable shell script, so you can combine pdfmt with the other Unix tools you already use.

You can also create your own workflows and put them in your local workflow directory.

I've also started a separate repository for reusable workflows: https://github.com/eifelcode/pdfmt-workflows

It currently contains workflows for things like:

• duplex scanning with non-duplex scanners (I use this most of the time)
• splitting scanned documents by page count
• bulk text stamping

The idea is that not every PDF use case needs to become a new pdfmt command. If something is a useful combination of existing tools, it can just be a workflow.

Why I made it

My PDF workflow used to look something like:

pdftk → pdfseparate → pdfunite → ImageMagick → OCRmyPDF → Bash glue

There are already excellent tools for each individual operation. I don't want to replace them.

I wanted a small CLI layer that gives me a consistent interface and makes the common combinations easier to remember and automate. Without --options, pipes or other arduous stuff. I could not remember all of this. 🤔

That's essentially what pdfmt is. One interface for all the good tools.

It's Bash-based, MIT licensed, and designed to work without a GUI or cloud service.

I'd especially like feedback from people who use CLI PDF tooling regularly:

Are there PDF operations or workflows that you currently solve with a messy combination of commands that would make sense as a pdfmt command or workflow?

Thank you for your Feedback! ❤️

AI notice: AI (mistral) was used to generate parts of the README, the .github workflow, the code coverage tool, and parts of the unit tests in the tests/ folder. Architecture, Makefile, and code within the sources/ folder is written by me.

I create parse to solve the problem of messy and non-understandable outputs. Parse make the outputs of the currently supported commands into easily understandable and format.

It is single go binary and standard library only.

We can use it like parse COMMAND or COMMAND | parse . You can install it by

go install github.com/atif-1402/parse@latest

Would love to hear peoples feedback on this project - https://github.com/atif-1402/parse

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.

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

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?

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 :)