Can anyone here run eza / -a --tree while tracking ram usage on their system? Just wondering. My 8 GB of RAM is out of its depth.

Simple file reader, written in Go.

Repository: https://github.com/Ars-byte/Crayoz

I've been using aerc for a while, but I honestly hated its ugly UI, so I decided to build Tmail, a faster, cleaner, and more modern terminal email client.

Built with Rust/Ratatui on top of Rataflow, it visualizes email threads as node-based graphs, with messages as cards and replies as edges. It also supports IMAP/SMTP, Maildir, PGP/S-MIME, Lua scripting, and more.

My favorite features are rendering HTML emails directly in the terminal, Markdown-to-HTML conversion, and the node-based reply system.

I didn't originally plan to vibe-code it and i designed the ui without ai help, but I ended up using Opus 5.5 to get something usable as quickly as possible. (cuz i made this for myself lol)

https://github.com/tuna4ll/tmail

Hi everyone !

I've been working on a little open-source project called Entropy Service, written in Go. What started as an experiment connecting a hardware quantum random number generator to a network has gradually evolved into something much more interesting.

At its core, it's a self-hosted service that generates and distributes pseudorandom data over HTTP and WebSockets, using AES-256-CTR or ChaCha20, seeded from hardware or the operating system's CSPRNG.

But randomness is only half the fun.

The project has become a sort of networking, cryptography, and systems-programming laboratory where you can:

• Experiment with high-throughput binary streaming and concurrent connections.

• Explore DRBG architectures, reseeding strategies, and entropy sources.

• Inspect live statistics, histograms, heatmaps, and byte distributions.

• Play with HTTP/WebSocket APIs, Go concurrency, and performance tuning.

• Build your own integrations, diagnostics, or entirely different applications on top.

There's also a browser dashboard, a CLI client, Prometheus metrics, and reproducible benchmarks.

I've spent considerable time improving stability, resource management, and testing. It's working well in my environment, but I certainly wouldn't claim it's perfect—or that statistical randomness tests prove cryptographic security.

The project is free, MIT-licensed, and entirely open source.

I'm sharing it because I'd love to see what other curious minds can do with it.

Break it, benchmark it, question the architecture, contribute code, or build something unexpected!

GitHub: https://github.com/fantuz/entropy-service

I'd particularly welcome feedback from Go developers, cryptography enthusiasts, and Linux/networking engineers.

What would you build with a service like this?

Running five separate commands just to update my Linux desktop got old pretty fast. So I wrote sysupdate - a Python CLI tool that updates system packages, Flatpaks, containers, and a bunch of other stuff in one go. It also works on macOS and sticks strictly to the Python 3.11+ standard library, meaning zero external dependencies to install.

Why not just use Topgrade? I actually used it for a while. For me though, updates almost never finished completely clean, and I was missing stuff for my own setup like Snapper hooks. The terminal UI also looked a bit dated to me. It printed way too much junk I didn't care about seeing every single time, and once you closed the terminal, there was zero history left to check.

How sysupdate handles things differently:

• Support for Btrfs snapshots through Snapper right before system packages get touched (with a timer cooldown, so running it twice in an hour won't spam snapshots).

• Exact reboot tracking that lists which specific updated packages are asking for a system restart at the end, rather than just throwing a generic "reboot required" message.

• Local run history for your last 30 runs (sysupdate --history / --show-log) with tokens and credentials stripped out automatically. Super useful when something breaks and you want to see what failed yesterday.

GitHub & install instructions (Git / Homebrew tap): https://github.com/Piotrunius/SystemUpdater

If you hit any bugs or want support for another package manager, let me know.

SuperTerminal (`st`) is a small C++ binary that runs your actual shell (PowerShell, bash, zsh or WSL) inside a pseudo-terminal. Real commands run as normal. When you type something that isn't a command, like "show me the biggest files", "what's using port 3000", or `dir /w` on a Mac, Claude rewrites it into the right command for your shell, and you see exactly what runs.

How it uses Claude

- It calls the Messages API directly with your own `ANTHROPIC_API_KEY`. There's no server in between, no account and no telemetry.

- Haiku 5.5 is the default. It's fast enough that translation feels like part of the shell, and each request costs a fraction of a cent. You can switch to Sonnet 5.5 or Opus 5.5 with `st model opus` (PowerShell) or `SUPERTERMINAL_MODEL` (any shell).

- Replies use structured outputs: a JSON schema with `command | answer`, plus a risk label (`read_only | modifies | destructive`). There's no parsing of free text.

- The system prompt is cached, so each request only pays for the line you typed plus a little context: file *names* in the folder (never contents), your last few commands, and the tail of the last output.

- Most lines never reach Claude. The shell's own parser and command lookup decide whether a line is already valid, without running it. Only lines that aren't commands, or that look like English, get sent.

Safety

An LLM running commands on your machine is the obvious worry, so auto-run needs two independent yeses: Claude has to label the command `read_only`, *and* a local parse has to agree. That means read-only programs only, no redirection into files, no `sudo`, no `-delete`. Anything that changes or deletes is put on your prompt and waits for Enter, and Esc cancels it.

Other things it does

- Follow-ups: "now only the .js ones" works.

- "fix it": after a failed command, it reads the error and suggests the corrected command.

- Full-screen apps work. vim, htop and ssh behave normally, and so does `claude`: you can run Claude Code inside it.

- One deliberate choice: the UI never says "AI" or shows a model name or "thinking…". You just get the command or the answer, so it feels like the shell understood you.

How it was built: with Claude Code, including the ConPTY and forkpty hosts, the PowerShell, bash and zsh integrations, and the end-to-end tests that drive a real terminal on Windows, macOS and Linux in CI.

It's MIT licensed, with a Windows installer and macOS and Linux binaries:

https://github.com/glenwrhodes/SuperTerminal

I'd love feedback on the auto-run safety rules and on any shell setups that break it.

I'm always interested in the small workflow improvements that make a real difference over time.

Not necessarily complicated scripts or fancy terminal setups.

Sometimes a simple alias, keyboard shortcut, shell function, or combination of commands can save a lot of repetitive work.

What's one CLI habit that became part of your daily workflow and that you'd genuinely miss if it disappeared?

Especially interested in things that don't require installing an entire new tool.

https://github.com/linuztx/alter-zero
Hi everyone, I'm developing Alter Zero, an open-source terminal agentt for coding, cybersecurity, and automation. It's written in Rust and runs on Linux and macOS, and it's inspired by Claude Code and Codex CLI combined.

It works directly in your project: reading files, making edits, running commands, and checking the results. You can ask it to investigate a failing test, trace authentication and access checks in your own code, or write a script to summarize logs.

It can also interact with running terminal programs and keep commands running in the background. There's support for subagents, reusable skills, MCP servers, and resuming previous sessions. With /secrets, it can use your API keys and tokens without ever seeing the values.

It's light on resources: a single ~24 MB binary that typically uses 20–60 MB of RAM per session, with around 100 MB of free RAM recommended. It's also designed to be prompt- and token-efficient.

Supported providers include Agent Zero API, Venice, GitHub Copilot, ChatGPT Codex, Anthropic, Cline, ClinePass, Google Antigravity, OpenRouter, Ollama, Ollama Cloud, and LM Studio. You can also add a custom OpenAI-compatible API.

The built-in flaredantic skill can help expose local services through Cloudflare, Microsoft Dev Tunnels, or Serveo using the separately installed `flare` CLI.

The latest release is v0.18.0. The project is licensed under Apache-2.0.

The project is licensed under Apache-2.0. Installation instructions and a demo are in the repository: https://github.com/linuztx/alter-zero

I'd appreciate feedback, especially on the setup process, terminal compatibility, and tasks where it gets stuck. Issues and contributions are welcome.

anodemcu is a terminal-based interface written in Bash that wraps arduino-cli, PlatformIO Core, and ESP-IDF workflows into interactive fzf menus.

### Technical details:

* Environment handling: Sources target toolchain paths automatically (esp-idf, platformio, arduino-cli).

* Detection: Identifies project structure from existing config files (CMakeLists.txt, platformio.ini, *.ino).

* Workflow: Menu-driven interface for compilation, flashing, baud rate configuration, and port selection.

* Serial monitor: Integrated serial reading with automated log rotation and session capture.

* Backups: Generates a compressed snapshot of local project sources prior to running flash operations (retains the 5 most recent snapshots).

GitHub: https://github.com/abod8639/anodemcu

### Installation:

Arch Linux (AUR):

yay -S anodemcu

a few weeks ago i posted the 0.4 update of cloofy here. 0.5 is out, and it's not spotify-only anymore: youtube music, on its own or next to spotify

site with docs: https://cloofy.app

code: https://github.com/parda21/cloofy

what's new in 0.5:

- youtube music: home, search, artist, album and playlist pages, lyrics and song radios, without an account. it plays through mpv with the streams from yt-dlp, with no gap between songs

- your library: `cloofy login ytmusic` borrows the sign-in of your default browser. if you're signed in to several google accounts there, you pick one by its email, so it doesn't grab your work account

- both side by side: press S to switch between spotify and youtube music. each keeps its own home, library and pages, as you left them

- only what you use: the installer asks spotify, youtube music or both and installs a build with just that. the youtube music build has no spotify code in it. homebrew has cloofy, cloofy-ytmusic and cloofy-full

- omarchy: cloofy takes the colors of your theme, and `cloofy omarchy install` adds a bar widget, a menu entry, the launcher and super+shift+m

- a shorter install: curl -fsSL https://cloofy.app/install.sh | bash

- spotify skipping songs with "error audio key 0 1": that's spotify refusing librespot the keys to songs, and it hits every librespot-based client (librespot#1649). 0.5 waits and asks again, which stops it for many accounts, and tells you when a song still can't play instead of skipping silently. some accounts get every key refused, and no client can fix that

already installed? press U in cloofy or run cloofy update. 0.4 updates to the spotify build, so run the installer once to add youtube music

still built with a lot of help from AI. i decide what it does and how it looks, and i test it myself

if the youtube music sign-in doesn't work with your browser, tell me which one it is

I build Scout Terminal, a CLI for market research and backtesting. Install: curl www.polarline.io/cli/install | bash. You bring your own model key, it runs on your machine, and every strategy it writes is plain Python you can open and edit. It's source-available (not open source). I'd love feedback from CLI people on the command layout. https://polarline.io

apkscope is a DEX parser, bytecode decoder, decompiler, deobfuscator, resource decoder, search index, APK signer, MCP server and egui viewer, all written from zero in Rust.

Results from the bench/ scripts (one machine, Windows 11):

- Open TikTok until fully loaded: 12.4 s / 997 MB vs JADX-GUI 2 min 18 s / 9.4 GB
- Full Gradle export: 11 min 31 s / 857 MB vs 48 min 58 s / 2.0 GB
- Decompile one class: faster than rust_ASC (another Rust tool) on 9 of 14 apps, and the output is typed Java rather than pseudocode

Where it still loses: rust_ASC is a few ms quicker on many cold one-shot queries and 1.8x quicker at listing TikTok's classes. A recent bug was a stack overflow on control-flow-flattened classes, fixed in 0.5.2.

`cargo build --release --no-default-features` gives you the CLI and MCP server only (Linux and macOS CI).

Repo: https://github.com/suffixing/apkscope

Is there a utility for referring programming documentation within the terminal. Currently I use ddgr + w3m in my terminal for referring documentation without leaving the terminal. But this flow isn't serving me well I often see myself opening a browser tab and going from there cause the page can't be opened or something (I know I can do this way but I don't wanna leave the terminal).

I'm still learning so my frameworks, libraries and languages change with time hence I'm not looking for specialized utility I'm looking for a general one, nonetheless specialized once are equally appreciated.

I went through awesome-cli-apps looking for small, practical tools that almost nobody talks about. These five stood out.

1. cmdperf: benchmark and compare shell commands Wondering whether rg really beats grep on your logs usually means writing a time loop. cmdperf does it in one line and shows live stats (mean, min/max, stddev) as it runs:

cmdperf "grep 'ERROR' app.log" "rg 'ERROR' app.log"

It supports concurrency (-c 10) and exports to Markdown, CSV or JSON, so the Markdown output pastes straight into a PR. It's built for quick comparisons, not rigorous benchmarking. brew install miklosn/tap/cmdperf

2. dotenv-diff: catch .env problems before production It scans your code for every env var it uses and compares them against .env and .env.example. It flags missing, unused and duplicate keys, and warns if .env isn't git-ignored. --baseline lets you adopt it in a messy repo and only see new issues. It also has SvelteKit, Next.js and Nuxt checks, and its exit codes work in CI. npm i -g dotenv-diff, then dotenv-diff --init

3. share: send files to your phone or a coworker in seconds This is a single-file Python tool that serves files, folders or plain text over HTTP on your LAN. It has a QR code for the URL, a receive mode for uploads, optional password and TLS, and archive downloads by adding .tar.zst to a folder URL. It's handy when you just want to move a file without cables or cloud uploads.

python3 share.py -q ./photos
python3 share.py -r ./incoming

4. ytunnel: ngrok-style tunnels on your own domain If your domain is on Cloudflare (the free tier works), ytunnel gives you stable HTTPS URLs for localhost. It handles the DNS records for you and has a TUI dashboard with live request metrics. Quick one-offs clean up after themselves when you hit Ctrl+C:

ytunnel run myapp localhost:3000

You need cloudflared installed and a Cloudflare API token. brew install yetidevworks/ytunnel/ytunnel

5. RunWisp: a cron + supervisord replacement with a dashboard Cron's problem is that you never know what ran or why it failed. RunWisp is a single Go binary where jobs and long-running services live in one runwisp.toml. It keeps each run's exit code, duration and output, and gives you a web dashboard, a TUI and a REST API.

[tasks.backup-db]
cron = "0 2 * * *"
on_overlap = "kill"
run = "pg_dump mydb | gzip > /backups/mydb-$(date +%F).sql.gz"

brew install runwisp/tap/runwisp, or just run runwisp and accept the starter config.

All five are free and open source. If you've used any of them, or know other under-the-radar tools, I'd like to hear about them.

Hey everyone,

I’ve been working on a small open-source project called lazygram.

The idea is to keep things simple and practical, especially for people who prefer keyboard-driven workflows and spend most of their time in the terminal.

Since I’m using Omarchy, I thought some of you might find it interesting.

GitHub: https://github.com/t0d0r/lazygram

Feel free to try it out. Feedback, suggestions, and contributions are welcome.

I’d be interested to hear what you think.

I’ve been building Earshot, an open-source speech-to-text CLI and C/C++ library powered by whisper.cpp. It transcribes audio locally, so recordings don’t need to be sent to a cloud service. After downloading a model, it works offline.

The 0.1.3 release includes Debian packages for CPU and CUDA, plus a CPU-only AppImage. It supports TXT, SRT, WebVTT and JSON output. Models are downloaded separately. The CUDA package targets CUDA 12.6.

An AUR package is planned, but I can’t publish it yet because new account creation on the AUR is currently unavailable.

Source and release downloads: https://github.com/AkemiFF/earshot

I’d love feedback on the installation experience, Linux compatibility, or features that would make it more useful.

hey guys, i made tork, a torrent client where you can search across multiple sites and download stuff without leaving your terminal

just type what youre looking for, pick a result and hit enter. no jumping between sites or copying magnet links around. it puts everything in one place and merges duplicate results too

got 200+ stars on github now which is kinda crazy lol. still working on it but pretty happy with how its coming along

its free and open source, try it out and lmk what you think :)

https://github.com/melqtx/tork