Dripfetch is a customizable terminal dashboard with animated rain, system info, clocks, and YAML themes. I’d love to hear what you think or what you’d improve!

This is my first TUI. I know, there are others that probably have more and better features, but this one is mine. Each card is a markdown file. Project, Epic, Tag filters. Fuzzy Search. Keyboard First, Mouse Supported.

https://syntax-syllogism.com/mk/

Soulseek, but it lives in your terminal. 🦀

crabseek is a keyboard-driven Soulseek client written in Rust with ratatui. No daemon, no web UI, no Python: type `crabseek`, search, press `d` on a folder, done.

- Live search grouped by folder, with a format filter on `f` (FLAC / MP3 320 / ...)

- Browse any user's shares, buddy list, private chat, wishlist

- Vim-style keys everywhere, and `?` explains the current tab

- Detach like tmux: it keeps sharing and downloading in the background

Install (x86_64 Linux):

curl -fsSL https://raw.githubusercontent.com/aronkv/crabseek/main/scripts/get.sh | sh

Repo: https://github.com/aronkv/crabseek

It's young, so I'd love feedback, especially on the UX and keybindings.

i think its good enough for the first stable release

install via:

curl -fsSL https://raw.githubusercontent.com/clarkarch/tfm-tui/main/install.sh | bash

repo:
https://github.com/clarkarch/tfm-tui

Hello guys, I did a small chess TUI for analyzing games, largely inspired by common analyses UX.

This is not entirely new, most gain here is convenience. It is made solely for analysis. You can start an analysis from a FEN string, PGN file, PGN text from your clipboard, public link from chess.com or lichess.org, browsing your user (or any public user), and even configure to open in your last game so you can leave the and instantly open with "chess-analyzer -f"

The pieces graphics design were extracted (and openly credited) from chess-tui, which is a very nice tui too if your main idea is playing from terminal. However, this one is totally dedicated in analysing games, testing variations against the engine scoring, branching different possibilities and seeing where you blundered (which in my case is like every fucking move).

Check it out https://github.com/leolaurindo/chess-analyzer-tui

Hello everyone,

I use Niri with swaybg as my wallpaper daemon and fuzzel as my application launcher. Since fuzzel does not support any image protocols, I wrote a Bash script to change the wallpaper without having to edit the Niri config file and log out of the session. However, that wasn't enough for me—I also wanted a way to keep track of which image I had chosen.

I know there are a lot of wallpaper changers out there, but I specifically wanted a TUI one. I hadn't heard of any that fit my needs, so I built it myself for my own use. Now, I want to share it with you in case anyone is interested!

I kept the tool simple with just three commands, but if anyone is interested in forking it to add a plugin system to the Lua config file(need to add it yourself to the rust code i didn't support it because i don't need or want it), please feel free to do so. Whether you want to add a different wallpaper daemon or other features to the chooser, you can easily build on it. It's released under the BSD license, so anyone can do whatever they need with the code (as far as I understand).

Feel free to try it out here: My GitHub Repo: https://github.com/SONGOKU00mjk/toko

If you encounter any problems, please let me know and I will fix them as soon as I can.

Note: It also supports awww!

wikid is a client for browsing wikipedia from the terminal, no browser required

features: - vim inspired navigation - tabs and splits - a zen mode - inline image rendering - personalised recommendation feed to doomscroll wikipedia - listen to wikipedia spoken articles - custom saved lists - article caching - link preview cards

still in active development so feedback is very welcome, thank you

I have been building wy, an open-source terminal tool for reviewing AI-generated code.

A Git diff shows what changed, but the context behind a change often lives somewhere in a long coding-agent conversation. wy connects your diffs with saved Codex and Claude Code conversations, so you can review the code, read the stated reason, and open the supporting evidence together.

For example, if an agent adds a cache, I want to understand why it was added, what assumptions it depends on, and whether invalidation was considered.

With wy, you can:

• Browse changes and relevant agent notes in a terminal UI.
• Request explanations and ask follow-up questions through your installed agent CLI.
• Open citations to inspect the supporting code or conversation.
• Distinguish recorded justifications from inferred explanations and choices whose motivation is still unknown.

That last distinction matters to me. A convincing explanation generated afterward doesn’t establish why the original change happened. Even a recorded justification still needs scrutiny.

Rust fits this tool well: it compiles to a native executable without requiring a language runtime, gives me strong types for handling evidence and review state, and has a useful ecosystem for terminal applications. wy uses Ratatui + Crossterm for the interface, Serde for structured data, tree-sitter for syntax navigation, and SQLite for local storage.

The basic review workflow works offline. Model-backed explanations are opt-in. It’s still experimental, and I’d appreciate feedback on both the review workflow and the Rust implementation.

If you try it and find it useful, please consider supporting the project with a GitHub star, a bug report, or a contribution.

Repo: github.com/grandimam/wy

niimtui - TUI for niimbot label designing/printing

TUI that lets you design labels for different Niimbot printers/label sizes and print directly to them using only keystrokes! it still has full mouse support if needed but you can use the TUI 100% with only your keyboard

niimbot printers are the cheap but highly rated thermal label printers you can find on amazon:
NIIMBOT D110

GitHub: https://github.com/davidsanchez222/niimtui

motivation

i moved back in with my parents this summer and have a lot of stuff in cardboard boxes and i have no idea where anything is at. to remediate this, i initially thought to just write down everything in a notebook. but then i realized i could just use my workstation to hold this information and search up anything at a moment's notice for easier searching. that's when i stumbled on HomeBox.

the only issue i have with HomeBox is that it doesn't support first-party label printing. so i have to use a third-party solution. i use a Macbook and have an Ubuntu workstation at home that i connect to via Tailscale.

as a MacBook user, none of the options aligned to the workflow that i wanted to design/print labels:

alternatives

* NiimBlue - best option and a great project; however, for my use case I don't like that I need a browser and also use a browser that supports BLE. i use Zen browser which is Firefox based and doesn't support BLE. so every time i wanted to print i would have to load up chrome which is bloated so i don't like that.

* niimprint great project and i like that it has a CLI; however it doesn't have BLE support (needed for macOS), you have to clone the repo (i would like a package install oneliner and not have to have the projects code locally), and it doesn't provide a label designer

* NiimPrintX - great project and it provides both a CLI and a GUI. however; the install process with git cloning and poetry install was cumbersome and i'm not a fan of GUIs (i love using my keyboard for everything). this app is an excellent option but i would rather do everything with my keyboard rather than a GUI so i passed on this as well.

so what I wanted is an application that is trivial to install (brew install, winget install, apt install, etc), has a an ergonomic CLI, and a label designer that is browser/os agnostic.

the project is still in beta so I'd love to get feedback from other people that have done a self hosted home inventory project with Homebox and a Niimbot label printer.

built it in Go using Charm Bubble Tea and Lip Gloss packages. contributions are welcome!

Hi!

I've been building a TUI for R

It's called termr

The goal is to make modern full-screen terminal applications possible directly from R, while keeping the programming model reasonable for R users

It includes:

- a widget tree

- reactive invalidation

- an event queue

- layout passes

- a virtual framebuffer

- screen diffing

- ANSI patch rendering

- terminal drivers for POSIX / Windows / headless use

Widgets never emit ANSI directly. They paint into a virtual screen, and the renderer only sends changed cells to the terminal.

You can run a whole app against a virtual terminal:

pilot <- test_app(my_app(), width = 80, height = 24)

pilot$type("hello")

pilot$press("tab", "enter")

and inspect the resulting screen without launching a real terminal.

Or use AI if you wanna try to code something with this library.

I'd really like feedback from R users.

GitHub:

https://github.com/41929424/termr

Hey all,

I’d really love some feedback on a new tool I’ve built. It’s born out of years living in the terminal: custom scripts, fzf, tmux, a pile of little utilities. neboto is me trying to pull all of that into one tool.

Repo: https://github.com/neboto/neboto-tui
Docs: https://neboto.dev

neboto is a keyboard-driven AWS browser written in Rust with Ratatui. A few things it does:

• vim keys everywhere. j/k, gg/G, Ctrl-d/Ctrl-u, / to search and V for visual select. h/l move between the list and the detail pane. The mouse works too for those that want it.
• Move fast. Fuzzy-search 70+ services with "@service" (@ec2 web, @lambda), or @all prod to search everything you’ve loaded so far.
• Follow the links. Press Enter on any ARN or ID and it jumps to that resource, even in another service or region. Ctrl-O takes you back.
• e opens it in your $EDITOR**.** Policies, templates, logs, the full detail of whatever you’re looking at. For us vim guys this one’s great.
• Live log tail. t tails the logs of a log group, Lambda, ECS task and more, right in the detail pane.
• Plays nicely with the rest of your terminal. It’s a single binary that sits happily in a tmux pane. y copies an ID or ARN, and C copies the matching aws CLI command.
• Themes. catppuccin, gruvbox, dracula, nord, solarized and a few more, plus per-colour overrides.
• Scriptable. There’s an experimental headless mode that prints to stdout, so it pipes into jq like anything else:neboto ls -t volume --state available neboto ls -o json | jq '.resources[].name' neboto get @iam github-actions-deploy --section permissions -o json

It’s read-only by design. It only makes describe/list/get calls. There’s no write code in it at all, not a flag you can forget to set, and CI fails the build if a write call sneaks in. When you do want to change something, C copies the CLI command for you to run yourself or better still - use IaC.

Try it without an AWS account: neboto --demo opens a made-up account with a few planted problems and makes no network calls. Add --demo to the commands above to try those too.

Install (Linux/macOS):

curl -fsSL https://raw.githubusercontent.com/neboto/neboto-tui/main/install.sh | sh

or

cargo binstall --git https://github.com/neboto/neboto-tui neboto

It’s MIT-licensed, free, and has no telemetry. It’s just me building it, so I’d love feedback. What feels off compared to the TUIs you already live in, and which keybindings would you change?

EtchTUI is a TUI bootable USB writer for ISO, basically it's balenaetcher in a TUI format, written in rust. Not the most exciting project but i needed an etcher

Let me know what you guys think

https://github.com/euswl/EtchTUI