r/CLI

Google has officially announced that #Gemini CLI is being retired in favor of #Antigravity CLI, their new terminal experience.

On June 18, 2026, Gemini CLI and Gemini Code Assist IDE extensions will stop serving requests for Google AI Pro, Google AI Ultra, and free individual users.

The funny part?

Less than 11 months ago, Google published this headline:

“#Gemini CLI: your #open-source AI agent”

Free. Open source. Built for developers.

Fast forward to today - sunset in less than 30 days, no more new model access, no more real future, and people are already seeing errors like:

| Model "gemini-3.5-flash" was not found or is invalid.

| /model to switch models.

Classic Google.

They sell you the open-source dream, get their fanboi hype, then move everyone to the new shiny closed experience.

The new Antigravity CLI is now the path forward if you want access Google AI quota through Google AI plans. Otherwise, you can still go the pay-per-use API key route.

Never trust Google’s “Do no evil” era too much.

Meanwhile, OpenAI Codex was open source from the beginning - just like the name suggested.

OpenAI gave us CLIP, Whisper, GPT-OSS, and Codex-rs.

Say what you want about OpenAI, but these are the tools that actually pushed the AI developer ecosystem forward.

Also, Claude Code was open source for a while too XD

Hope you learn something new today.

As shrimple as that (apart from a gazillion terminal limitations and implementing NES style using text???) @ https://github.com/Strophox/tetro-tui :-)

I got tired of Claude Code silently hitting rate limits, so I decided to build something to address the issue.

Imagine you’re 40 minutes into a refactor. Claude is running tools and making progress, then suddenly, everything stops. The session has reached its rate limit without any warning—no alert saying you’re at 95%, just a complete halt. The usage bars are visible in the UI, but the model itself remains unaware of them.

I discovered that Anthropic has a usage API, and Claude Code already possesses hooks to make it work. This led me to create agent-baton, which reads the usage API and installs hooks to make Claude aware of its limits.

Here are the three hooks you can initiate with one command (baton init):

1. SessionStart: Fetches usage data and injects it so Claude knows from the first message how much has been used.
2. UserPromptSubmit: Performs a time-to-live (TTL) aware check that avoids overwhelming the API. It uses smart caching—checking every 15 minutes when usage is low and once a minute when it's nearing the limit.
3. PreToolUse: This is the crucial one; it checks usage mid-task to prevent the scenario where you “started at 93% and ran out of capacity mid-execution,” catching the problem within 1-2 tool calls.

When the warning threshold is reached, it prompts an interactive question using Claude Code's built-in AskUserQuestion tool:

"Claude 5-hour usage is at 91% — you're in the warning zone."

Options include:

• Continue this task
• Write a handoff document
• Switch to lightweight mode

It also handles full agent handoffs by writing a structured markdown handoff and passing work to Cursor, Codex, or Gemini.

You can install it with the following command:

npm install -g u/codeprakhar25/agent-baton && baton init

For more details, visit the GitHub repository.

A terminal UI Plex client focused exclusively on music — browse your library, queue tracks, and play them, all from the keyboard.

Hi everyone,

I'm building amptui for fun. I started because i'm on a weird asahi arch distribution and couldn't run the plexamp app, and continuing because I love TUI aesthetic and vim like controls.

It's written in Go on top of Bubble Tea + Lipgloss, with mpv driving playback. There's a cache system for your library to load fast (allows fuzzy search feature also) and images can render if your terminal allows it (Unicode block fallback if not).

You can learn more on the README there : Amptui Github

Feel free to use it, fork it, contribute, have fun with it !

Typio is a lightweight Python library that prints text to the terminal as if it were being typed by a human. It supports multiple typing modes (character, word, line, sentence, typewriter, and adaptive), configurable delays and jitter for natural variation, and seamless integration with existing code via a simple function or a decorator. Typio is designed to be minimal, extensible, and safe, making it ideal for demos, CLIs, tutorials, and storytelling in the terminal.

Repo: https://github.com/sepandhaghighi/typio

Hey everyone,

I just published my first open source project on PyPI and would love some honest feedback before I keep iterating.

The problem

Two pain points I kept hitting:

1. No clean way to see what's running where. lsof -i -P -n | grep LISTEN works, but the output is noisy and columnar — you have to mentally filter it every time. There's no single command that just tells you "here are the ports currently in use, by which process."
2. Killing a port-holder is a multi-step dance:

lsof -i :3000 to find the PID, then kill -9 <PID> and hope it's the right one. Two commands, copy-paste a PID, parse columns. Across a workday it adds up.

What lsport does

pipx install lsport

Three subcommands:

• lsport list — all TCP ports currently in use, rendered as a clean table (PID, port, process, user). One command, one glance.
• lsport kill 3000 — kills whatever owns that port, with a confirmation prompt.
• lsport interactive — a TUI to browse and kill from a table view.

Works on macOS and Linux. Windows isn't supported yet — I don't have a reliable way to test it.

Tech

Python 3.9+, single-module. psutil for cross-platform socket/process enumeration, rich for table rendering and the TUI, tests with pytest, lint/format with ruff. Published via PyPI Trusted Publishing (OIDC) — no API tokens stored anywhere.

Why not just fuser -k 3000/tcp or a shell alias?

Fair question. fuser is Linux-only and the UX is rough. lsof | grep | awk | xargs kill works but is fragile, and it still doesn't solve the "show me everything at a glance" case. I wanted something opinionated that handles the 90% case and reads naturally.

I'm also aware tools like kill-port (npm) exist — lsport is in that family but Python-native and adds the listing + TUI layer.

What I'd actually love feedback on

• Code quality and project structure — this is my first OSS project, so blind spots are guaranteed
• The kill confirmation flow — too noisy, or about right?
• Windows support — happy to mentor anyone who wants to take a stab
• Subcommand naming and UX

Repo: https://github.com/0xBroom/lsport PyPI: https://pypi.org/project/lsport/

MIT licensed. Issues and PRs are open. Tear it apart — I'd rather hear it now than later.

I think I did something beautiful.

Spent my last few days building and refining a TUI app to browse and download the whole khinsider download catalouge: khi-explorer

You can easily search for OSTs, navigate albums, download individual tracks and YES even whole albums at once!

I think that's the most outstanding feature a lot of people want - just press D-key on an entry and you will see a progress bar showing you when it's finished.

On first launch the app will create .khi_explorer.yaml in your home directory. There you can set:

• Download path (default: [HOME_DIRECTORY]/khi_explorer)
• Default format (you can switch this anytime inside the app by pressing TAB-key)
• Player for live playback (you must have mpv, ffplay or vlc installed but most people already have)

It's built in Go using the Bubbletea library, so it's easy to cross-compile and you can install it on Windows, Linux or macOS using the linked install scripts on GitHub or by just downloading the binary directly from the releases page (Linux binary is heavily compressed using upx; macOS sadly not supported; Windows Defender says no-no very bad)

Happy exploring! 🙂

https://github.com/madLinux7/khi-explorer

A simple program of a cat chasing your mouse in a terminal.

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

Hi! it's my first project with bubble tea and lipgloss. also uses sqlite, mpv, and yt-dlp.
It plays music you curate with any agent via mcp connectors. the agent can manage and create playlist, also play and pause any songs for you. you can favorite a song or download to ~/music/tuitube/ and play it offline. there are 14 themes and 2 visualizers and the db i made ships with 8000+ songs. there are no ads as it uses yt-dlp.
there are probably other similar tui app but it's got the features that I mainly use and very easy nav imo + agent native tooling.

https://github.com/gitcoder89431/tuitube

open source with mit license, 2 releases cause i only have a linux and mac os machine. I can publish on homebrew or aur if anyone needs it. thank you for your time. 😆

Following up on my earlier r/cli post about malt - a Homebrew-compatible package manager for macOS written in Zig, with a native post_install interpreter. v0.10.0 just shipped. Quick recap of what landed since.

Brew-parity for the commands people actually use.

• mt pin / mt unpin for formulas and casks; mt upgrade honours pins; mt outdated --pinned-only for CVE watch on held-back versions.
• mt shellenv - drop-in for eval "$(brew shellenv)" (bash/zsh/fish, same HOMEBREW_* exports so brew-aware scripts keep sniffing).
• mt which <bin> - reverse lookup that pairs with mt uses; offline, one call.
• mt install --only-dependencies, mt run --keep (caches the bottle for next time), mt services logs --follow, mt bundle cleanup, mt doctor --fix for the safe warning classes (stale lock, broken symlinks, refcount-0 store blobs).

mt outdated is now instant - a cached snapshot, filtered through the live DB at read time so a freshly-uninstalled keg can't ghost in. Safe to wire into a shell prompt. MALT_OUTDATED_MAX_AGE tunes the TTL.

Warm installs got 10-17× faster. Four targeted patches collapsed the per-dep cost on the warm path: a post-relocation keg cache keyed by bottle SHA256, a parsed-formula cache, a short-circuit when the keg is already present, and a skipped cask-ambiguity probe on the unambiguous path. Apple Silicon, GHA macos-14, median of 5, true-cold prefix + bottle-cache wipe between rounds:

Package	warm before	warm now
tree (0 deps)	0.019s	0.012s
wget (6 deps)	0.070s	0.007s
ffmpeg (11 deps)	0.416s	0.024s

The per-dep cost that used to dominate the warm-install path is essentially gone.

More of the toolchain installs end-to-end without Ruby. openssl@3, gnupg, ca-certificates, libidn2, and zig (which depends on llvm@21) all run their post_install inline in the Zig interpreter now. When it genuinely can't handle something, you get a specific --use-system-ruby=<name> hint instead of a silent skip pretending success. "post_install completed" means exactly that.

Trust posture closed. Every release is cosign-signed keyless via GitHub OIDC. install.sh and mt version update both verify cosign + SHA256 against the pinned signing workflow identity before any byte lands on disk; the binary swap is rename-based atomic with .old rollback. Homebrew-installed malt detects the brew receipt and points at brew upgrade --cask malt instead of overwriting it.

Other rough edges fixed. Third-party tap casks shipping DMG/PKG/zip-app payloads now route to the cask installer (was failing through the formula path). macOS 26 bottles install (new arm64_tahoe tag). Light terminals render legibly (OSC 11 detection, WCAG AA contrast). v0.9.1 was a hardening release: 19 fixes around memory ownership, error propagation, archive extraction, lock retry-on-EINTR, and self-update edge cases. Mostly invisible, recommended for everyone.

Still experimental, still early-stage - I use it as my primary package manager and it handles my day-to-day, but expect rough edges on less-common formulas. Bug reports very welcome.

• Repo: https://github.com/indaco/malt
• Full changelog: https://github.com/indaco/malt/blob/main/CHANGELOG.md

Transparency note (same as last time): all implementation Zig was written by AI (Claude Code + ruflo). Design, architecture, ADRs, threat model, and every merged change were directed and reviewed by me. The interesting question remains the tenth refactor, not the first commit.

Ask questions across your Markdown notes using a fully local Graph RAG engine. Built for Obsidian vaults, works with any folder of Markdown files. Extracts entity-relation triples from wikilinks & YAML frontmatter, retrieves answers via hybrid search (vector + BM25 + temporal). Multilingual. No cloud. Runs on Ollama.

https://github.com/benmaster82/Kwipu

I simple cli gui the edit aliases, mostly for those who hate to type commands over and over and newcomers to linux that are not familiar with the liases file or its format.

Install from: https://github.com/geovanielegend/bae

Concord, a terminal UI client for Discord written in Rust with Ratatui.

The new update adds voice support. Concord can now join voice channels, play received voice audio!

Other features include:
- Guild, channel, thread, forum, and DM navigation
- Sending, editing, deleting, replying, pinning, and reacting to messages
- Inline image previews in supported terminals
- Desktop notifications
- Vim-style keyboard navigation

Checkout more features in readme.

Github repository : https://github.com/chojs23/concord

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

Shipped v0.16.0 with end-to-end Deep Packet Inspection.

- **Packets tab:** INFO column is L7-aware and color-coded. Filter syntax: `app:quic`, `sni:reddit`, `host:github`.

- **Dashboard top-talkers:** real hostnames in the bandwidth panel.

- **Packets detail pane:** decodes QUIC v1/v2 Initial packets and shows the inner CRYPTO/PADDING/PING frame structure.

Full RFC 9001 / 9369 QUIC Initial decryption — HKDF-Expand-Label keys, AES-128 header protection, AES-128-GCM AEAD,

cross-packet ClientHello reassembly. Most peer tools just tag flows as `QUIC`; this one tells you the hostname.

cargo install netwatch-tui

# or

brew install matthart1983/tap/netwatch

Rust + ratatui, MIT. https://github.com/matthart1983/netwatch

Hey everyone. We're building Ota, an open-source CLI for repo readiness.

The problem we kept running into is that a repo can look complete on GitHub, but still be hard to actually run. The real setup and runtime truth is often scattered across READMEs, scripts, CI config, env files, Docker files, and tribal knowledge.

That creates a few familiar problems:

1. new contributors lose time getting to first success
2. local and CI behavior drift
3. setup steps slowly become stale
4. automation and agents guess wrong because the repo has no explicit operational contract

Ota is our attempt to make repo working state explicit.

The core flow is:

ota doctor — diagnose what is missing or blocking readiness
ota up — prepare the repo
ota run — run declared tasks from the contract

With Ota a repo gets one operational front door so humans, CI, and automation can understand what the repo needs and how it becomes ready.

Repo: https://github.com/ota-run/ota

I'd love feedback from OSS maintainers and contributors:

- does this problem feel real in projects you maintain or contribute to? - would you accept an ota.yaml PR if it made contributor setup clearer? - what would make this useful rather than just another config file?

I got tired of writing wrapper functions by hand or creating aliases that take too much mental space when I just wanted to patch an existing API.

That's why I created Monkeypatsh.

Monkeypatsh is a tool for easily monkey patching commands in the shell:

• It wraps any command you register with it, npm, git, ls, docker... and lets you attach custom behavior to any existing or new subcommands, flags, or default invocation, while keeping the command's API intact.
• It centralizes all your patches under one tool and extends the original completion with them.
• Choose whether these patches stay only in your interactive shell, or are globally available through the $PATH variable.

The gif above shows how easy it is to patch npm run <script> to log the run to a log file.

Would appreciate some feedback. Thanks.

Repo: https://github.com/solisoares/monkeypatsh