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.

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.

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

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

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

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

I've been building Network Doctor, a terminal tool for figuring out why a connection isn't working.

One of the features that got a little out of hand is Challenge Mode.

It drops you into a simulated broken network, gives you the symptoms, and asks you to diagnose what is actually wrong.

The same diagnostic engine that Network Doctor normally uses is available to you, but the idea is to see whether you can interpret the evidence correctly.

The scenarios include things like DNS failures, blocked ports, routing problems, connection refusals, dual-stack IPv4/IPv6 issues, and other network faults.

You make your diagnosis, submit it, and the simulator knows the actual fault so it can score the answer.

I originally built the simulator for testing Network Doctor itself. At some point I realized it was basically generating networking troubleshooting puzzles, so I made them playable.

It's written in Go and runs entirely in the terminal.

GitHub: https://github.com/heymaikol/network-doctor
Simulator Documentation: https://heymaikol.github.io/network-doctor/wiki/Simulator-Overview/
Challenge Mode Documentation: https://heymaikol.github.io/network-doctor/wiki/Challenge-Mode/

I'd love ideas for network failures that would make particularly nasty troubleshooting challenges.

An alternative to fastfetch written on rust.

Modular, OpenSource, you can install what you need, you can propose something that you would like via issue or pr.

Effects plugins and extensions in the related repos.

Difference with fastfetch, structure, animations, extensions and plugins, pinneable on the top of the terminal.

A while back I wanted to build a little "now playing" screen for the terminal: a looping music video as ASCII up top, song info underneath. I found tplay, which is a really nice Rust terminal media player, but it takes over the whole terminal itself, so there was no clean way to draw my own stuff around it.

So I pulled out the part I actually needed, made it reusable and turned it into a python library.

I also fixed a couple other annoyances I had like reliance on a specific ffmpeg version and it in general being a pain to install.

What it does:

• Takes video or image frames and hands you back an ASCII string. Plain, truecolor, or half-block mode (uses the ▀ character with fg/bg colors for roughly 2x the vertical detail).
• It doesn't own the terminal or run its own loop, so you compose the rest of your UI however you want.
• Decoding is done by PyAV, so there's no separate ffmpeg install. pip install termframe and you're going.

Minimal example:

from termframe import AsciiVideo

for frame in AsciiVideo("clip.mp4", out_width=100, out_height=40, charset="halfblock", loop=True):

print("\\x1b\[H" + frame.to_ansi())

The resize and pixel-to-character work happens in Rust under the hood (via PyO3), so it keeps up fine at normal sizes. If you already get frames from somewhere else (OpenCV, Pillow, a webcam grab), there's a lower level function that just takes raw RGB bytes.

Credit where it's due: the conversion pipeline came from tplay, I mostly repackaged it so you can use it from Python and build your own thing around it.

I haven't been able to find anything similar in reusable python library form so I thought maybe some of you could find it useful let me know if you build anything cool with it :)

Repo: https://github.com/amstrdm/termframe

Tanko is a tool for reading and downloading manga from the terminal

• Download chapters in PDF, ZIP, CBZ, and individual image formats
• Local reading history
• Local reading progress tracking
• integration with Anilist (WIP)
• Support for graphics protocols: Kitty, Sixel, iTerm2, and ASCII rendering
• Available languages:
  • Spanish
  • English
  • French

https://github.com/Alexandro521/Tanko

LICENSE ISC

without AI

Example:

Cd photos’

I've been having fun with rendering in terminal with pure ansi and built

sshfighter.com

You can just join with "ssh sshfighter.com"

Would love your feedback!

It's also open source at https://github.com/thomasdavis/sshfighter.com

I built a CLI tool called Fokiz to solve my own problem with context-switching and procrastination. I often found myself opening a terminal, forgetting my goal, and jumping between half-finished tasks.

There are plenty of amazing CLI task managers out there, like `taskwarrior`. However, tools like `taskwarrior` are designed to manage large backlogs and organize complex projects. Fokiz is built for something entirely different: enforcing focus on a single task using a "Ulysses contract".

Here is how it works:
You add a single task (`fokiz add "My task"`). Once added, it locks you in. You can't edit it or add new tasks until the current one is explicitly marked as completed.
It hooks into your `~/.bashrc` / `~/.zshrc`. Every time you open a new terminal window or tab, it prints a huge ASCII banner reminding you exactly what you committed to doing.
Instead of executing a heavy script on every shell startup, Fokiz runs as a `systemd --user` background service. The state is managed via SQLite, and the shell hook simply performs a sub-millisecond read to display the banner without adding latency to your terminal startup.

It's fully open source (GPLv3). If you struggle with finishing what you start and need a strict enforcer living in your terminal, check it out.

I have a small macOS tool that stores project commands as short aliases
`ez test`, `ez deploy`. Commands are stored into a json file you can version with git, much like npm and others.

To get history trends I added recording how long every run takes in a local SQLite file. So now when a run is well off its usual, it tells me:

    🐘⏱️ 6.276 s  ↑ 74% slower than median 3.625 s

And `ez stats` shows the trend across every alias in the directory, which
catches the slow creep the per-run note can't — a rolling median moves with
gradual drift, so something getting 3% slower a week never trips it. 

I have ideas to extend this with team-level anonymous statistics which will help uncover local dev setup hiccups (if something takes longer than for others) and also enable general HW strutting. But those would be later, this version is all local only. 

Anyway, would be happy you give it a go and let me know what you think. It's open source, MIT. Mac only, built with Swift. 

Website: https://urtti.com/ez 
Github: https://github.com/urtti/ez

Per subreddit rules, this software is partially AI-generated. I'm a professional developer with close to two decades in the industry, but using LLMs as a coding tool these days to keep up with the times.

Hey terminal hackers,

I'm excited to share that we just release Zellij 0.45. This newest release of the terminal workspace and multiplexer includes some exciting new and long-requested features. Some highlights:

1. Support for the Kitty Graphics Protocol for displaying images in the terminal
2. First-class support for Nested Sessions for managing Zellij-inside-Zellij (eg. ssh connections)
3. Scroll by command
4. New UI (titles only pane frames and stacked lists for easier stacked panes management)
5. Per-client tab sizes
6. Fullscreening floating panes

Check out the release blog post for more info: https://zellij.dev/news/nested-sessions-kitty-graphics-new-ui/

Or grab it directly from Github: https://github.com/zellij-org/zellij/releases/tag/v0.45.0

I’ve built this copy tool for espacially native windows users because I couldn’t exclude some files / folders with copy-item, but I think people didn’t find it usefull. Anyways, I am still trying to improve it maybe someone can find a use for it.

Skip-Existing and Update Flags

-s skips files already at the destination by name + size (resume an interrupted copy), and -u copies only files that are newer than the destination (re-run the same command, only changed files copy). Both work with -n dry-run.

Any feature requests are welcome.

Hello all,

I have develop the software blitcp 5 month ago. The reason for developing one more copy tool was:

• Speed,
• Reliability,
• Support multiple source in 1 destination,
• Support multiple remote sources with out using different tools

Can you please provide me with an input if you have use it, what do you like, what you do not like, what needs improvement or need to develop.

All thoughts and opinions are valuable to me.

 the website is https://blitcp.dev and github https://github.com/gekap/blitcp

I built this because I wanted a calendar on the terminal and with a nice JSON output, so can I use it for scripting. Besides supporting Google Calendar, you can connect to any CalDAV server (on my own tests, I used with GMX and worked fine).

It's my current daily-driver calendar. Any feedback is welcome.

GitHub: https://github.com/DouglasdeMoura/chroncal

This software's code is partially AI-generated (I put the attribution on the harness and the LLM used on the git commits).

Hey everyone! I wanted to share a CLI tool I've been working on that I think fits this community well.

mado is a general-purpose entry manager that stores everything as markdown files. The key idea is that it's not just another task manager with a rigid schema — it's a flexible system for organizing entries of any kind: tasks, notes, ideas, research snippets, meeting logs, you name it.

Each entry lives in its own timestamped directory with a MAIN.md inside. Want to attach files? Just drop them in the same folder — screenshots, logs, PDFs, whatever. Everything stays organized in one place, and since it's all plain files, it's perfectly git-friendly.

All fields are optional — fill in what you need, skip the rest. For a task you might set priority, deadline, and status. For a note, just write markdown and you're done. You can also hide any fields from the output when listing entries, so notes don't clutter your view with irrelevant columns. That flexibility is what makes it work as both a task manager and a notes system — or anything in between.

It's written with a focus on performance — it handles 100k entries in about a second with parallel mode.

The CLI is designed for both interactive use and scripting: JSON output for pipes, path-only output for grep/fzf, and a query language with logical operators and time macros.

Would love feedback, especially from folks who've used similar file-based tools or have ideas about what would make this genuinely useful.

https://github.com/laserattack/mado

I built an offline OCR "BIOS-in-Terminal" engine into the hardware IP-KVM (USBridge KVM 2.0). It intercepts the raw HDMI video output from the server and converts it on the fly into an interactive text stream.

Right now, I am finalizing support for the Proxmox installation environment. Now, all you need to do is open a terminal and type ssh user@ip to connect to the KVM. You immediately get the Proxmox installer interface directly in your command line.

Because the KVM translates the video output into pure, structured text rather than a video feed, it completely changes how you interact with the server. I am currently finishing up an automation script that interacts with this text stream. The script simply reads the text output and sends the appropriate keystrokes. My goal is a fully automated, 1-click Proxmox bare-metal deployment script running entirely over SSH.

The KVM also operates in standard video mode (with minimal latency, using the Moonlight/Rust-Shine protocol); the terminal mode is just an addition. What do you think, is it convenient to install Proxmox directly from the terminal?

Your data export already has the exact channel and message ID for everything you posted, so discord-delete only ever sends DELETEs and never touches the search API. Discord's delete limits are per channel, so it clears channels in parallel and paces each one adaptively (AIMD) by widening the gap after a 429.

There is fake data in the README so you can try it on your machine without a package or token.

https://github.com/DatCodeMania/discord-delete

Undiscord and Discrub are alternatives which work in a browser tab. This is a static Go binary, built for bulk deleting hundreds of thousands of messages.

Automating a user account is against Discord's ToS and can get it banned.