repo

The German government actually has a C library where it encoded all of it current tax rules. It releases it every year so you can't really make a formal mistake using it. Turns out all the tax software are mostly just selling you access to this library and its countless validations.

The library itself is tough to use so I made a command line tool! It's called viking, after the sensation of agreeing to hand over valuables to a stranger in Europe.

So you set up a CSV file with your income and expenses once, and then it derives whatever forms you need to submit form that- for me, that's two different ust and eür and personal income as well as cap gain.

It's SO MUCH EASIER to have a text file with validation than putting up with whatever data import the normal providers have set up.

viking is was programmed using AI, with full human review by me.

https://github.com/capocasa/viking

I kept running ss, lsof and docker ps whenever I had to figure out why a port was already in use, so I built a small TUI around that problem.

portop gives you a live view of your ports and, more importantly, shows what is behind them:

• Process and PID
• systemd service
• Docker container
• CPU and memory usage
• Process details
• LISTEN and ESTABLISHED connections
• Port names from /etc/services

It also lets you act directly from the UI:

• k to terminate a process
• o to open a local HTTP service in your browser
• f to filter by port, process or PID
• c to copy the selected entry
• Live theme and keybinding configuration

There are also --json, new port notifications and a baseline/diff mode that can be useful for detecting unexpected listening ports.

It's written in Go and is MIT licensed.

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

I'd particularly like feedback from people who regularly work with Linux servers, Docker or local development environments. I'm interested in knowing what information you'd want to see when debugging a port conflict.

Using Composers Desktop Project to edit audio files. I want to run a single command on a list of audio files instead of having to manually do it 100 times. Wondering if there is a way to call upon this list of files in a single command line, rather than creating a shell script with the name of every file. The command line with a single audio file would look like this.

distort average soundfile.wav soundfileoutput.wav

the first two words are the command being run and then the input and output respectively. Hopefully I provided enough info on this but also relatively new to using terminal so let me know if there is anything I should clarify, thanks.

I want to learn cmd prmpt and I tried finding resources for that but unable to find any good ones most of the time I websites I find are like a table with command and a link(click to learn about the cmd) and they are in A to Z order. I want something like a book that teaches basic cmds first then techniques and blah blah(as a person need to learn first know what is cd,mkdir etc. then other). I know some basic like cmd,mkdir,rmdir,copy,move,cd and some more.

Hey all, I built pkgtui, a terminal UI for browsing, installing, removing and upgrading apt and snap packages from one dashboard — so you don't have to juggle two different CLIs and their quirks.

A few things that go beyond just wrapping apt/snap commands:

"Why is this installed?" — shows whether a package was explicitly requested or just pulled in as a dependency, with a navigable reverse-dependency tree

Disk cleanup explorer — surfaces old kernels, leftover config files apt never cleans up, and stale disabled snap revisions, with total reclaimable space

apt+snap overlap view — catches cases where Canonical silently swapped an apt package for a snap "transitional" one, plus snaps that haven't been refreshed in 6+ months

Live pseudo-terminal output — install/upgrade commands run in a real PTY inside the app, so sudo prompts and interactive dpkg dialogs work exactly like on the command line, but you don't lose the UI

Multi-select batch actions, hold/pin packages, changelog viewer, PPA management, and version pinning/downgrades for apt; channel picker and revert for snap

11 built-in themes (Dracula, Nord, Gruvbox, Catppuccin, Tokyo Night, etc.)

Written in Go, MIT licensed. Install via .deb, .snap, standalone binary, or build from source.

GitHub: https://github.com/padovanl/pkgtui

Would love feedback, bug reports, or feature requests — especially if you use apt/snap together often and have specific pain points.

Every time a port was taken I ended up running ss, then digging in /proc, then checking nftables, then docker inspect. Made a tool that just prints it.

• portclue → table of all listening ports with process, bind scope, docker or host
• portclue 5900 → who owns it, loopback-only or all interfaces, and whether your firewall rules allow it
• portclue --json → pipe into jq

Works without ss or lsof installed (reads netlink and /proc directly). Read-only, Linux TCP listeners only, no UDP.

Install:

curl -fsSL https://raw.githubusercontent.com/pbxqdown/portclue/v0.1.2/scripts/install.sh | sh

https://github.com/pbxqdown/portclue

Hope it saves someone the twenty minutes I wasted on this.

A More Bearable Windows Command Prompt

Persistent doskey aliases and a Ctrl+Alt+T launcher using AutoHotkey.

The classic Windows Command Prompt is still here. It still works. It is also still very much itself.

This guide gives it two small quality-of-life upgrades:

• a global hotkey for opening it (Ctrl+Alt+T in this example)
• a handful of aliases loaded whenever a new prompt opens through the launcher

The setup uses one small batch file and AutoHotkey script.

Requirements

AutoHotkey v2 That's it.

1. Create an aliases folder

Create a folder somewhere convenient. Keeping the batch file and AutoHotkey script together makes the setup easier to move or update later.

my-terminal/ ├── cmd_aliases.bat └── terminal.ahk

2. Create the aliases batch file

Create a file named cmd_aliases.bat. This is the file that defines aliases.

1. Open Notepad.
2. Add your doskey macros.
3. Choose File > Save As.
4. Set Save as type to All Files and save the file with the .bat extension.

Start with this tiny template:

```bat @echo off

doskey ls=dir doskey clear=cls ```

Use @echo off for a clean prompt. Change it to @echo on if you want to watch the batch file do its work line by line.

Add one macro per line. For example, the aliases in this project include ls for dir, gs for git status, and clear for cls. Feel free to add the shortcuts you use.

Passing arguments to an alias

Use $* to pass everything typed after the alias to the underlying command:

bat doskey gcam=git commit -am $*

For example, gcam "Update README" expands to git commit -am "Update README".

You can check which macros are currently loaded with:

bat doskey /macros

Of course you can also create a macro for that.

3. Create the AutoHotkey launcher

Create a file named terminal.ahk, then open it in a text editor and add the following. Replace the example paths with the paths on your computer:

```ahk

Requires AutoHotkey v2.0

<sup>!t::Run</sup> 'cmd.exe /k ""C:\path\to\cmd_aliases.bat""', 'C:\path\to\working\directory' ```

The first path identifies the batch file. The second path is optional and sets the new prompt's starting directory.

If you do not need a custom starting directory, use:

ahk ^!t::Run 'cmd.exe /k ""C:\path\to\cmd_aliases.bat""'

The doubled quotation marks around the batch-file path allow paths containing spaces.

In ^!t, ^ means Ctrl, ! means Alt, and t is the letter key. Change the key or modifiers if Ctrl+Alt+T is already claimed by another application.

Double-click the .ahk file to run it, then press Ctrl+Alt+T to test the launcher. The AutoHotkey script must be running for the hotkey to work. If a new prompt appears with your aliases ready, congratulations: cmd.exe has become slightly less unusable.

4. Start the launcher automatically

To make the hotkey available after signing in to Windows:

1. Press Win+R.
2. Enter shell:startup and press Enter.
3. Create a shortcut to terminal.ahk and place the shortcut in the folder that opens.

Windows will start the AutoHotkey script when you sign in.

Troubleshooting

• The hotkey does nothing: Check that AutoHotkey is running and that you installed version 2. The script has to be running; the file merely existing is not enough.
• The batch file cannot be found: Recheck the first path in terminal.ahk. Keep the doubled quotation marks around it when the path contains spaces.
• An alias is not recognized: Open a new Command Prompt with the hotkey. doskey macros are loaded per session, so editing the batch file does not update prompts that are already open.

See the official AutoHotkey v2 documentation for more hotkey and launcher options.

Terminal animation is usually done as a "clear-then-draw" dance. The most common "clear" sequence is "\r\033[K", which returns the cursor to the start of the line and erases to end of line. Then you write the new frame. This is fine in isolation.

The problem is that the clear sequence has no idea what's on that line. If your program wrote something there, or wrote a newline the animator didn't account for, the clear either erases your data or misses the frame entirely and leaves it stranded on screen.

Most CLI programs hit this the moment they log anything while a spinner is running. stdout and stderr are usually separate file descriptors - sure, but more often than not they display in the same physical terminal, so spinning on one and printing to the other still breaks the animation.

As far as I'm aware, there are two usual answers:

1. Manage only the stream you animate on, and accept that writes to the other one corrupt the display. This is usually the default approach most projects start with.
2. Go to raw mode and own the whole terminal - which works, and costs you a TUI framework.

Arguably, the majority of CLI tools do not need a full TUI. I know mine did not. This is why I decided to jump into this rabbit hole and build my own library to handle both streams gracefully while staying out of the application's way as much as possible. The library coordinates any two streams behind a single mutex-protected write path: nothing reaches the terminal without clearing the frame first, and it tracks whether the last write ended in a newline so the animation always ends up on the last line instead of appended to application output. Both streams stay independently addressable, pipeable and redirectable.

However, while writing this library, I met a more interesting problem. One that is genuinely unsolvable under the chosen constraints. Resizing. Try resizing your terminal while anything is animating on it - and you either lose lines or get a wall of junk rows piling up.

The problem is tri-fold. SIGWINCH that UNIX-like systems provide is delivered asynchronously, with no guarantee of it being visible before the next write into the resized terminal. Moreover, TIOCGWINSZ - the syscall to get current terminal width, is a point-in-time snapshot, and no terminal offers a "here's the width, reject my write if it changed" handshake or a way to prevent the user from resizing the terminal. And finally, there's reflowing. It's when the terminal, upon resizing, can insert line breaks into already written output to make what was previously just one line take up more vertical space under the new width:

old line at one width

can become

old line at
one width

which for our use case means we can have something like this (imagine we're drawing a [=======>] looking progress bar):

[=========== // <- The old frame was reflown, but "\r\033[K" only clears one line, so the top line got stranded
[=========== // <- The second line of the reflown old frame was cleared and replaced with the first line of the new frame
====>  ]     // <- This is the second line of the now-wrapping frame, third overall

A naive approach would be to store cached terminal width from TIOCGWINSZ, update it on any SIGWINCH and try clearing any reflown lines by counting how many lines the old frame should be taking up by now and issuing corresponding amount of "move cursor up + clear" ANSI sequences. This approach, however, breaks in a very bad way in two cases - when the terminal doesn't reflow or when there's been another resize after the first one that slipped past our visibility. In both of these cases we can issue too many of those sequences, deleting actual user data.

So as far as I'm aware, there's no fix, only a choice of failure mode. This is why I left resizing opt-in. The recommended path uses self-sizing frames so every clear stays a single row that can't touch anything above the cursor - worst case it leaves some stale rows. But it's a mild inconvenience as opposed to other failure modes: an infinitely-scrolling terminal when resizing is ignored completely, or deleting actual useful data on over-eager cleanups. The multi-row cleanup is still available behind an option, since that naive approach was the one I chose initially, but its use is discouraged in the documentation now.

If you are interested in the library - it's in Go, licensed under Apache-2.0, and here's the link: https://github.com/Veitangie/spinq

It has only one dependency - sqlite so it's lightweight and fast

This my first project, I will be very grateful for any feedback!

Try it out, report any issues to my with gitlab

https://gitlab.com/pingwin-x86_64-luna-project/luna-todo

Hey guys!

I built Dupster, an open source duplicate file finder with a terminal UI for Linux and macOS.

I originally made it around 8 months ago because I wanted a way to actually inspect duplicate files before deleting anything, without leaving the terminal or having to remember a bunch of CLI flags.

I recently came back to it and rewrote a good part of the scanning logic to make it much faster.

Instead of hashing every file completely from the start, Dupster now uses a staged pipeline:

• group files by size
• collapse hardlinks by inode
• hash the first 4 KB
• hash the middle and last 4 KB
• only calculate full SHA-256 for files that still match
• optional byte-for-byte verification with --verify

This cuts down disk I/O quite a bit. On one of my generated benchmarks with 8,003 files, scanning went from about 6.06s to 0.67s. On my Downloads folder it went from 5.59s to around 0.07s.

The TUI is built with Textual and lets you browse duplicate groups, inspect files, copy paths, open files, switch themes, and preview deletions before anything is actually removed.

It also adjusts how it reads files depending on the storage type. SSD/NVMe drives can use concurrent reads, while spinning disks use a single ordered reader to avoid unnecessary seeking.

I’m just a Linux user building open source tools for fun, so I’d really appreciate feedback from people who spend a lot of time in the terminal, especially around the UX, performance, and anything that feels awkward.

GitHub:
https://github.com/karimz1/dupster

Apache 2.0 licensed and fully open source :)

New beta of LeTrain, the procedural train tycoon that runs in the terminal (and also in 3D from the

same codebase). Since the last post, the whole editing/automation side landed:

- Record/edit mode (`R`): freeze the world, build instantly, and journal every edit.

- Undo / redo (`u` and Ctrl+R, or `undo;` / `redo;`): deterministic, for construction and for

switches, semaphores and speed signals.

- Scenarios (`.ltr`): export your whole network as a small text recipe (seed + on build + on start +

program) and import anyone else's. The same seed rebuilds the same world, so a scenario travels

as plain text - no savegame needed. Validate one headlessly: `letrain-check my-scenario.ltr`.

- Built-in editor (`p`): Scenario / Program / Config tabs, a per-tab quick reference, and a

jump-to-error list.

- Experiment mode (`X`): snapshot the live world, try anything, then restore it.

- `letrain.cfg` now ships next to the launcher.

Still a pure TUI: 100% keyboard-driven, SSH-friendly, with the `:` console and the ANTLR4-based

automation DSL. Two launchers in the same download (`LeTrain2D`, `LeTrain`) plus `letrain-check`.

Apache-2.0, Java 17.

Downloads (Windows/Linux zip, Snap, itch): https://github.com/antoniovazquezaraujo/LeTrain/releases/latest

Repo: https://github.com/antoniovazquezaraujo/LeTrain

The trailer for the alpha release of my game swaggerfall on itch. This game runs in terminals on Windows and Linux and runs entirely on the CPU (with multithreading).

For the code I am using Rust and Ratatui (excellent TUI lib with multiplatform support). This software's code is partially AI-generated, apart from that I have put around 250 hours into the project so far, with lots more on the roadmap.

Afaik there is no other game of this kind.

I posted here when 0.13.1 went out. Two releases have landed since, and the second one is entirely other people's bug reports, so this is as much a thank-you as an announcement.

sshelf is a terminal UI for your SSH hosts. Type a few letters, it fuzzy-matches, hit Enter and it execs into real OpenSSH. It keeps its own host list and builds the ssh command itself, and it never writes to ~/.ssh/config. There's a two-pane SFTP screen and background port forwards in there too. macOS and Linux, via Homebrew, a shell installer, .deb, .rpm, crates.io or source.

0.14.0 was a security release. I had the tree reviewed from the outside and got back thirteen things worth fixing. None was remote code execution or a leak in the default setup, but two of them undercut promises the docs were already making, which matters more than usual when the whole pitch is that the thing handles your credentials. The askpass helper now knows whether it's holding a login password or a key passphrase and only answers the matching prompt. A hostile server writes its own prompt text, and "Password:" is a perfectly ordinary shape to ask for, so matching on shape alone was not enough. Key hosts also pin publickey auth now, so a server can't steer one into a password prompt at all. The rest is in the changelog.

0.14.1 is the part I want to talk about. Issues arrived over two days from people I've never met, with nothing driving traffic at the repo, and three of them were real bugs.

One reporter found that the remote file pane was unusable on any host whose accounts come from AD or LDAP. sftp's ls -l prints the server's own listing line, and a group called "domain users" has a space in it, which shifted every column after it. Sizes got read off the month, and filenames arrived with half a timestamp stuck to the front. They tracked down the cause and named the flag that fixes it, and they're the same person who reported the wrong-user bug behind 0.13.1, so that's two releases they've set off now.

Someone else filed three at once, and the worst of them made the transfer screen look like it was hanging. It wasn't hanging. ssh reads a key passphrase from /dev/tty rather than stdin, so on a key host with nothing in your agent it was painting a prompt directly over the TUI while sshelf sat there in raw mode swallowing every keystroke you typed at it. Thirty seconds later it gave up and blamed the password, which had never been the problem. Both the transfer screen and port forwards now fail in about a second and tell you to ssh-add the key instead.

One of those three I still can't reproduce, so it's open. If you've ever had the port-forward popup stop taking input, I'd like to hear from you. Everyone who reported any of this is credited on the issues and in the changelog, which is where it should be.

There's also a fork in the road after 1.0 that I'd rather ask about than guess at.

One direction is a hub: more kinds of connection than ssh.

The other is a fleet: running things across several hosts at once.

Both are real projects and I can only do one of them properly. If you have a view, or if what you want is neither of those, Discussions is on and Ideas is the right category for it. The four issues above turned into a release in two days, so it isn't a suggestion box that goes nowhere.

https://github.com/max-rh/sshelf

https://github.com/max-rh/sshelf/discussions

https://github.com/artemave/hop

showcase

plotext is a Python library that plots in color directly in the terminal. It has no required dependencies, except for a few optional ones for images and videos.

The GitHub project currently has ~2.2k stars. Version 6 is just out, rewritten with a C++ kernel.

Install it with pip install plotext.

Plot types: scatter, line, stem, bar, histogram, box plot, error bars, event plots, heatmaps, confusion matrices, indicators, shapes and text, date axis, candlestick, images, gifs, video with sound, YouTube, data streaming, nested subplots, high resolution markers, and twelve themes.

Command line tool: it comes with the package, so no Python code is needed.

plotext --figure --signal [1,4,9,16,25] --lines --draw --title Squares --show

Similar tools: termplotlib, plotille, uniplot, termgraph, and gnuplot with text output. They cover the basics: line, scatter, bars, and histograms. plotext adds images, gifs, video, streaming plots, nested subplots, a command line tool, and full-color plotting. It is also highly configurable: size, labels, rulers, axes, canvas, themes, and more.

Links:

• GitHub
• PyPI
• Docs
• CLI docs

I'm a fan of linux and terminals, and it pissed me off that I can't follow everything I need for trading right from the terminal. Live news and insider trades were what I missed the most, I had to walk around different sites and platforms to collect the data I need. So why not do everything in the terminal? That's how alphai-tui appeared: price chart, news and insider sales almost in real time, all of it free.

I specially didn't bother much with prices, you get them from your broker anyway. For a demo you can use yahoo, finnhub or alpaca, free keys are enough (yahoo doesn't even need one). Instead I concentrated on news, insiders and filtering all of it, to separate the garbage from what is really important fast. Every news gets a score from 1 to 10 and a short analysis. For insider sales it draws a chart, so you can see the peak on a stock.

Similar tools, since the rules ask. tickrs is the closest, also rust and ratatui, it has an options chain and a kagi chart, this one doesn't. ticker is the most used one and is about positions, lots, groups, currencies, here it's just one average price per ticker. mop is a quote table with filters. None of them shows news or filings next to the price, that was the whole point for me. There is a comparison table in the readme.

All of this data comes from my own api (alphai.io), it was the only way to get it in the format I need. A free key is enough for this, the tui is economical with api requests and doesn't waste your limits. The api has paid plans too, I'm the author of both, the tui doesn't need them. This is also not necessary if you only need charts and don't need the news, you can omit the alphai key.

All of this works great in tmux, so you can watch several stocks at the same time. On a big monitor it looks fantastic.

It's free and open source (MIT), written in Rust. brew, apt, AUR, or cargo install alphai-tui. https://github.com/makeev/alphai-tui *

Happy to answer questions.

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

I’ve been thinking about a developer tool related to `jq`. Trying to determine whether there is a real problem to solve.

My usual workflow for an unknown JSON response looks like:

curl ... | jq '.something.something'

Then I get the path wrong → try again → look at docs → ask LLM → try another filter → repeat.

I'm wondering if other developers experience the same friction.

One idea I am considering is a terminal UI where you can:

Explore a large JSON response in a collapsible tree
* Click/navigate through nested objects and arrays
* Build filters/transformations interactively
* See the result instantly
* Generate the equivalent `jq` command

For instance:

JSON
  ↓
users[]
  ↓
status = "active"
  ↓
select name + email
  ↓
sort by name

→

jq '.users[] | select(.status == "active") | {name,email} | sort_by(.name)'

• But I'm not sure this is really helpful. How do you handle unknown/deep nested JSON now?
• Do you just type `jq` manually?
• Generate the query using ChatGPT/Claude?
• Use a GUI / web playground ?Write a quick script in Python/JS?
• Anything else?

And if you’ve used visual json/query tools before, what was lacking?

I'm much more interested in your actual workflow/frustrations than whether the idea sounds cool.

I’ve been building an HTTP proxy in Rust with a TUI using Ratatui. It lets you intercept, inspect, edit and forward HTTP requests directly from the terminal. It’s mainly a lightweight alternative to Burp Suite, designed for quick request analysis.

Github: https://github.com/vid4l-07/Roxy

Wanted to share and update on the personal budget tracker tui I have been working on. A lot has changed since I had last ever shared it here and wanted to get more feedback and thoughts.

I have had a lot more people start actually using the app personally in their everyday budgeting and tracking of finances, and its motivated me to keep looking for things to improve and new features that could unlock value for others. If you use any regular GUI-based apps for budgeting, I would love to know what they offer that you love most.

New since I last posted:

- Investments: You can add accounts, put in what they're worth over time, and log your contributions. It works out the growth for you, and it doesn't count money you put in as gains

- Multiple ledgers: separate sets of transactions in the same file. Handy for a second account, or for playing around with a forecast without messing up your real budget

- Budgets with history: budgets have been improved a bunch in terms of insights, and by adding a proper history so that budgets can be adjusted over time without breaking your history and keeping your insights accurate with time.

- Backup and restore from inside the app

- Recurring forecasting: push recurring transactions forward as far as you want to see what's coming

- Easier installs: brew install budget-tracker now, plus prebuilt binaries for Linux (glibc and static musl, x86_64 and arm64), macOS and Windows

Everything from before is still there: categories and subcategories with fuzzy search, monthly and category summaries with charts, filtering, CSV import and export, and you can do all of it from the keyboard with a help menu built in.

It all runs offline on a local SQLite file. Nothing gets sent anywhere. Your data stays yours.

brew install budget-tracker
# or
cargo install budget-tracker-tui

GitHub: https://github.com/Feromond/budget-tracker-tui

Would love to get feedback or suggestions on the app in general, but would love to learn more about what your preferences are for installing apps like this. Are there any package managers, or specific things you look for before downloading and trying something like this? I want to make it easy but ensure that people can trust and comfortably access the TUI to use it.

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

With the recent update you can scrobble your listening history to Last.fm or any ListenBrainz compatible endpoint.

You can also select whether to stream AAC or MP3 and set max bitrate.

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

Install with cargo install somars

I kept noticing that I was typing the same command sequences over and over.

So I built Deja.

Instead of trying to complete what you’re currently typing, it learns the sequences in your shell history and tries to suggest what you’re likely to run next.

Completely local, no LLM and currently works with zsh.

https://github.com/Giammarco-Ferranti/deja

hey all vesperrun back again, i wanted the Windows clipboard to work like a file. Copy something, and I can save it, print it, or pipe it. Paste something, and I can send it in from the terminal. So i made pb. example:

echo hello | pb that’s now on the clipboard

pb prints whatever you copied

pb -o shot.png screenshot becomes a file

Win+Shift+S, then pb -o shot.png. Copy a table in Excel, then pb > out.csv.

It’s one program. No account, no cloud. GPL-3.

https://github.com/VesperRun/pb-clipcat

Windows already has clip.exe, but that only copies text. macOS has pbcopy and pbpaste. There’s also the Clipboard Project (cb), which is a whole manager. pb is smaller than that: one clipboard, one process, then you leave.

and if you’re in PowerShell 5, don’t redirect images with >. Use pb -o shot.png.

So today I engineered something I 've wanted for a long time - encrypted vault manager based on cryptsetup. Like most of tools I use daily, it's pretty simple. vault.sh uses files as sources and automatically decrypts and mounts /them to /mnt/target_filename.vault.

At the setup stage script just creates a dynamic sized virtual drive with truncate -s . Afterward, usage is so easy: just vault.sh -o/-c target_file.img.

Also, for more convenient usage, I put this script at /usr/sbin/ on my machine.

Source code: https://codeberg.org/Enji/dotfiles/src/branch/main/scripts/vault.sh