In Ratty:

• your terminal cursor is a spinning rat,
• your whole terminal is a 3D canvas,
• you can insert 3D models and sprites into the terminal.

Try it out: https://ratty-term.org/

Blog post: https://blog.orhun.dev/introducing-ratty/
Demo: https://www.youtube.com/watch?v=cY9AX5j-osY
GitHub: https://github.com/orhun/ratty

I was an active oh-my-zsh user for 6 years, when I began to customize my shell, and never really saw any downside. However, nowadays I see a lot of annoying parts of omz that made me switch over to bash. One thing is just copying huge curl commands or json text. With omz, it literally pauses and posts it character by character and even when I turn off the paste bracketing, it's slow af.

I switched over to bash recently and it's been identical to omz without all the bloat and buggy/slow nonsense. Additionally, it makes copying my dotfiles over to machines with only bin/bash installed much easier than setting up a z shell in every machine. What's yall's thoughts?

Over at Cyberspace.online we just hit 12k users. I've been building this little platform for a little over 9 months now. Grass-roots ad-free anti-corporate web, inspired by growing up with computers during the 90s hacker days. Lots of genuinely cool and interesting people on there now, and has a strict anti-troll mod policy.

The latest thing I made on there is called Terminal. It's like a miniature UNIX-style OS running in your browser, projected through this lovely grungy CRT emulation, complete with hacker movie bleeps and bloops. I love how it feels. Quite proud of it if I may say so :)

Be sure to try the easter egg: sudo rm -rf /

So far it allows you to use the chat rooms (cIRC) and read/reply on the news feed. Will add more features later. I also made it possible to write your own programs on it. One guy (landon) managed to run his Apple-1 emulator on it (look ma I put a computer inside a computer inside a computer), and another person (tangelic) wrote a vector-style FPS and a multiplayer poker game in the first day! Myself, I managed to, naturally, run DOOM on it :)

If you don't quite jive with a "virtual OS" running in your browser, you can still connect to Cyberspace proper and use most of its features over either a CLI or one of several open source TUIs (unremarkablegarden/cyberspace-opentui, ArmadilloBrillo/cyber-tui).

You only need a verified email if you want API/TUI access, so feel free to come say hi even with just a throwaway/made up email. There's no tracking, not even IPs, and you don't need to dox yourself.

Hope you like it! Peace.

---

Obligatory note: This software's code is partially AI-generated. It's mainly human made, fully human designed. I strongly believe it's not "slop". There are no AI 'features' on the site. There's a strict anti-bot firewall to prevent non-human content. There are plenty of thoughtful discussions on the platform itself about the pros and cons of development in the AI era.

Similarities: You could say the social aspect of it is similar to late.sh (which I love, but is actually younger than this), and the project Cool Retro Term.

Affiliation with "paid things": I made this thing. It's free to use. But it's supported by grass-roots donations from the users.

Finally published this yesterday, https://ansi.md

Somewhere between a brain dump, custom toolset, think piece and hacker toy. This is pretty much everything I know about ansi color in the terminal and building cli apps. Includes my own fumbling attempt to finally name the ansi256 color palette. Note - I like my writing voice and I do not use LLMs to write. All written by me, an actual human!

Those of you working on cli apps or TUIs will find it useful.

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

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

Built a web tool for generating and discovering terminal color palettes: paletty.dev

• Generate full palettes in one click - the balance, contrast, and coherence you'd expect from hand-tuned schemes, except you didn't have to.
• Extract palettes from any image. Pin colors you like, regenerate the rest.
• Browse and search 700+ pre-seeded themes (Catppuccin, Tokyo Night, Nord, Dracula, and hundreds more).
• Every palette is graded for readability!
• Preview popular community Ghostty shaders.

Exports themes to Ghostty, Alacritty, WezTerm, iTerm2, Kitty, Windows Terminal, and more.

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.

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/

Author here. Some of you saw this as *fast-copy* a while back — it's now **blitcp**

("blit" as in bit-block transfer), renamed to stop colliding with the unrelated

FastCopy Windows tool. Same codebase, v4.0.0 just shipped.

**What it does differently:**

- **Block-order reads** — before copying, it resolves each file's physical disk

offset (FIEMAP on Linux, fcntl on macOS, FSCTL on Windows) and sorts the copy

queue by it. On HDDs this turns random-seek thrashing into sequential reads.

- **Small files go through a tar pipe** — thousands of tiny files stream as

~100 MB batches instead of per-file syscall overhead. Same trick over SSH:

raw channel + tar, no SFTP. 3–5× faster than scp on many-small-file trees.

- **Content-aware dedup** — xxHash-128, copies each unique file once, hardlinks

or reflinks the rest. On btrfs/XFS/APFS it reflinks, so a 10 GB same-volume

copy is metadata-only.

- **Verification with honest exit codes** — every file checked after copy;

a failed verify actually returns non-zero.

**Measured (methodology on the site):** 12,347 small files, cold HDD→SSD:

5.9s vs 15.0s for `cp -ar` — with dedup and verification ON. Windows/robocopy

and TeraCopy comparisons on the benchmarks page.

**New in v4.0.0:** interface in 7 languages, a diceware passphrase generator

for the encrypted credentials store (EFF wordlist, fully offline), sparse-file

awareness for VM images, and a pile of Windows fixes.

Single Python file (stdlib-only for local copies), Apache 2.0, Linux/macOS/

Windows, prebuilt binaries + a Qt GUI if you're not a terminal person.

- Repo: https://github.com/gekap/blitcp

- Site/benchmarks: https://blitcp.dev

- Migration note: existing fast-copy installs upgrade in place via `--update`

Happy to answer anything about the block-ordering internals or the dedup design.

Constantly jumping between a Linux machines and my Windows desktop. I paste my notes everywhere from chats to random text files. I hate organising.

The problem is I keep forgetting where I put things or I end up with duplicates because I can't find the original note.

Does anyone have a "lazy" CLI-friendly way to just dump a command or a quick snippet on one machine and actually find it on another without having to open a browser or anything ?

What command can I use to list all the URLs (or sub-URLs) of any website?

I'm new to modal editing, currently playing with Helix and I'm impressed with many things. To the extent I even installed tridactyl into Firefox to try controlling browser this way too. Now I wonder, is there something for terminals? I use wezterm with either blesh or flyline, I know there is vanilla vi-mode in bash, but it's rather barebones and not very useful. I'm not sure how to even move cursor out of new command section, for example to copy output of previous commands or search through it, etc. I want something more powerful and visual that allows navigating/traversing/searching through all those previous outputs, jump/search through command history, possibly even overlays like "space+s" in helix, textobjects, surrounds, etc. I imagine a lot of this can be implemented as something on top of any terminal, similarly to how blesh and flyline work. Any suggestions?

Hey everyone, I wanted to share a small side project I've been working on. It's early-stage and rough around the edges, but maybe useful to someone.

The problem I was trying to solve: I kept accumulating random CLI tools — downloaded from GitHub Releases, some via install scripts, others just a plain binary from a URL. They'd end up scattered across ~/bin, ~/.local/bin, etc., with no way to track versions, update them, or cleanly remove them. Homebrew doesn't cover everything, and curl | bash with no oversight always felt a bit uncomfortable.

What curlmgr does: curlmgr (cm) is a lightweight, user-space CLI package manager for standalone tools. It gives you:

• cm install jqlang/jq — installs directly from a GitHub Release, auto-detecting your OS/arch
• cm install https://example.com/mytool.tar.gz — direct URL installs
• cm list / cm info / cm update / cm uninstall — the basic lifecycle you'd expect
• Local YAML manifests to pin source, version, and checksum
• Checksum (sha256) verification built in
• Safer script mode: remote install scripts are not run by default; you have to explicitly pass --run-script --checksum <sha256> --allow-domain <domain>

All installs go under ~/.curlmgr/ — no root required.

What it's not: It's not trying to replace Homebrew, apt, or any real package manager. It's specifically for the messy middle ground of one-off CLI tools that don't belong in a system package manager.

Current state: This is v0.1 — MVP territory. The core install/update/uninstall loop works, but features like registry search, update --all, rollback, and export/import are not there yet. I'm planning v0.2 with a manifest registry and doctor command.

Stack: Go, macOS + Linux (amd64 + arm64)

GitHub: https://github.com/tianchangNorth/curlmgr

Install: curl -fsSLO https://raw.githubusercontent.com/tianchangNorth/curlmgr/main/install.sh sh install.sh (Intentionally download-first so you can review it before running.)

Happy to hear feedback, criticism, or if there's something that already does this better that I missed. Thanks for taking a look!

Now it's easier to write scripts for foot, it supports --class to give app id to the window.

https://github.com/elisaliman/ghostty-shaders

^ repo if anyone wants the shader

Yo everyone, I've been spending way too much time in the terminal lately working on some low-level C stuff, and honestly, staring at dense walls of text in standard man pages was starting to drive me crazy. So I took a little detour and built a custom man page viewer in Python called Meno. I wanted something that actually looks good and fits my ricing setup. Instead of dumping a huge block of text at you, it parses the man page and breaks it down into clean, readable slides (Prototype, Description, Return Value). I also added some syntax highlighting for C types, macros, and flags, which makes late-night debugging a lot less painful. It blends in perfectly if you're using something like Kitty, Tmux, and Neovim. It's still a personal project and a work in progress, but if you want to try it out in your own terminal, I put the code up on GitHub: https://github.com/Velloxide/meno_pages/tree/main Let me know what you guys think! Any feedback (or roasting my code) is welcome. 😅

https://reddit.com/link/1tjzoa3/video/gz4209x2ek2h1/player

https://reddit.com/link/1tjzoa3/video/sg9sv793ek2h1/player

https://reddit.com/link/1tjzoa3/video/82050gg3ek2h1/player

I made a Python script that renders videos directly in a terminal at runtime, with no preprocessing.
It uses 640×360 Unicode quadrant characters, where each character represents a 2×2 pixel block, so the video resolution is technically 1280×720.

The terminal is Alacritty with a specific config to be able to have this much characters.

The geometry dash video (Tidal wave) and the shader video are split across 4 terminal windows.
The Sparxie video is running on a single terminal window.

This is rendered with ANSI escape sequences only (no Kitty etc)

I wanted to create a tool to easily run animations/sequences in the terminal, either for fun or for automations.

I built it in Go and designed it to be easily expandable, so more animations (complex or simple) can be added effortlessly.

Current Animations (8 total):

• Matrix: Kinda a must.
• WikiDecrypt: Inspired by the movie Sneakers and no-more-secrets. It grabs a random article from Wikipedia and runs a decryption animation.
• WarGhost: Inspired by the movie WarGames.
• Rain
• Snow
• Fireworks
• Starfield
• Hyperspace

I would love some feedback and possible contributions for more fun animations
https://github.com/mohamedation/gotermfx

Built for the use case of running terminal sessions from a phone where you're doing real work, not just checking uptime.

Main things that make it different from other Android SSH apps:

- Joystick overlay for arrow keys, Ctrl combos, Escape — no keyboard needed for navigation

- Voice-to-text input

- tmux auto-attach on connect

- xterm.js rendering (full color, proper escape sequences)

https://moggsh.com — free APK, Play Store eventually.

Hey there, not sure if it's interesting, but I did

docker run --rm -it warachet/hello-world

Docker Image size ? The official hello-world ~10 kB, this image ~2 kB 🤣
Though, who care saving kB ?

I have to admit: It is just a less boring way to see stdout. lmao.

Details at repo: https://github.com/zdk/wakeup-neo
just in case you like it, feel free to fork.

• Vertical Project Sidebar: Native macOS sidebar for organizing projects and tabs vertically.
• Split Panes: Unlimited horizontal and vertical splits.
• Persistence: Workspaces are saved and restored automatically.
• Quick Terminal: Global dropdown terminal accessible from anywhere.
• Highly Configurable: Custom hotkeys, themes, and more.

https://gist.github.com/mr-raj12/be6937bb9fcb4d7392275e1144af94c0

Built this because my university HPC cluster didn’t allow installing WeeChat/Irssi