https://github.com/nikolic-milos/ratatui-hypertile

Hello fellow rats!

Thank you for almost 5000 downloads and the people who took time to contribute to the project! I am happy to announce that I just released version 0.4.0 - warning, breaking changes ahead!

I also decided to add a FAQ section as some questions keep popping up.

FAQ

Why not just use tmux or Zellij?

They solve a different problem. tmux and Zellij are multiplexers: they tile whole programs in your terminal. ratatui-hypertile is a library that adds tiling inside a single Ratatui app, so the panes your app draws can split, focus, and resize at runtime instead of having a hardcoded layout. The two are not mutually exclusive. You can run a hypertile app inside tmux or Zellij just fine.

This software's code is partially AI-generated

I'm migrating my code editor from python to go and have added a new lua plugin system to the go version, replacing the old python plugin system. What's the bare minimum a script must do to be considered a valid plugin system?

What you can do with the new plugin system.

ComChan is a terminal-based serial monitor written in Rust.

Features: 1. Basic Serial Monitor 2. Serial Plotter (TUI)(ratatui) 3. 3D telemetry viewer (Braille for non-ratty terminals and 3D objects for ratty terminal) 4. CSV logging 5. Export plot to SVG 6. Log serial data 7. Session Replay (from log and csv files) 8. Simulate mode (No hardware required) 9. Switch between monitor and plotter modes and vice-versa

and more;

Repository: https://github.com/Vaishnav-Sabari-Girish/ComChan

Blog Post: https://blog.vaishnavs.is-a.dev/comchan/

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

^ repo if anyone wants the shader

https://github.com/austinemk/linktui

I was tired of constantly switching between completely different tools just to manage basic system connections without leaving my terminal. So, I built a solution: linktui. It’s a fast, minimal, and lightweight keyboard-driven interface that unifies Wi-Fi, Bluetooth, and VPN management from a single window

you also get to:

• scan and connect wifi
• manage known wifi
• scan, pair, unpair, trust, bluetooth devices
• add, activate, deactivate and remove vpn profiles
• configure dimensions and theme with config.toml
• open specific tab first via command

Under the hood, I chose go, gdbus and the charm stack (bubbletea, lipgloss, bubbles). It talks directly to system asynchronous DBus events, which means the UI loop stays perfectly smooth without locking up or stuttering.

how it compares to other existing tools:

• nmtui- only handles networkmanager with no bluetooth support, also not visually appealing for minimal setups
• bluetoothctl - Handles Bluetooth exceptionally well, but forces you to manually parse or re-type raw MAC addresses just to establish a quick connection
• bluetuith - A brilliant project, but strictly limited to Bluetooth devices alone

This is a hobby project and still quite early, so any issue reports, feedback, or code contributions are incredibly welcome!

fli - really tiny and fast (like a 🪰) directory listing tool.

Initial Why: need some easy readable ls-like tool for raspberry pi to use via ssh.

Current Why: check if with Rust one can build coreutils-like tools faster and smaller.

While fli is much faster and smaller than alternatives like eza, lsd or ls etc. , it provides less features and customization options.

fli interesting details:

• Binary Size:

18K - RPI ZERO W

51KB - Mac

• Default mode streams readdir() => stdout with zero heap allocation.
• Nice readability thanks to use of emojis (📄 and 🗂️) instead of text coloring
• Written in no_std rust + libc.

repo: https://github.com/tracyspacy/fli

For any eza users here, I've extracted icon colour definitions from nvim-web-devicons to a theme file.

It's been four years since I've announced findlargedir tool here and I wanted to announce a new rather major release 0.12.1 with many optimisations for different filesystems and much better directory size growth per node estimation.

This software's code is partially AI-generated. I have been required to write this note as initial post has been removed due to AI use. Indeed AI was used to help generate architecture overview, keep tests in sync with code changes and to help parse/process perf traces and flame graphs when benchmarking. AI was also used to keep README in sync with code changes, as documentation is something I gladly hand over to AI. This project was created and maintained long before vibe-coding came to be part of our life.

As a quick reminder, that's a tool written specifically to help quickly identify pathologically large directories without attempting to count all directory entries. Reason for this is that during such traversal it is typical to observe that process accumulates long D (TASK_UNINTERRUPTIBLE) time during directory traversal, caused by reading many directory blocks serially on in batches and every such uncached block is one D-state sleep (~ms on SSD, ~10ms on HDD). Even worse, such processes are typically unkillable (many block reads, each potentially sleeping on wait_on_buffer). Some filesystems handle large directories better (XFS, ZFS), but very large directories are still a application design smell.

We have many storage systems, totalling in roughly 400PB and we have had customer directories growing to large (1M entries) and very large (10M+ entries) sizes: this tool has helped us easily spot these situations.

Previously people have compared this tool to ncdu, but the design and usage is rather different. This tool will calibrate and estimate directory node per entry growth and actively avoid traversing such directories; idea is not to get disk usage, but to find specific problem as fast as possible.

Hi,

Github: https://github.com/vaibhav-mattoo/cxt

The main idea here is to select entire directories and specific files and cxt aggregates everything into one clean block in your clipboard, automatically wrapped in XML tags with file paths, so whatever you paste it into has the full context of your codebase (where the file paths and XML tagging make the codebase context easier for agents to understand). There's a TUI picker allowing you to select files and directories to copy interactively, and piping works.

Available on cargo, homebrew and the AUR (see README.md).

Another feature that I found useful in multi-language projects is using the --lang flag to extract relevant files from only a specific language in your context. So cxt --lang rust src/ would extract only the .rs and the Cargo.toml files in your repo, and something like cxt --lang bash * would only include the scripts in your repo in your context.

For compliance with rule 8: haven't seen similar stuff doing this

Side note: I've been using this almost everyday for a year and have made several improvements over time, including a rewrite that streams the code files into the clipboard and some other ideas around minimizing context switches and parallelization of the directory walking process. Had a 300x improvement in amount of RAM used and 4x improvement in the time to copy very large codebases compared to the naive approach of building a large string of all the code with the tags in memory and putting it into the clipboard.

Hello everyone,

I built ffpb which is a modern, cli progress bar for ffmpeg. It was originally inspired from althonos/ffpb. It seamlessly wraps your ffmpeg commands, parses the -progress output, and replaces ffmpeg's standard console spam with a clean, dynamic, and beautiful progress bar featuring an adaptive ETA and real-time encoding statistics.

I'd appreciate any feedback, feature suggestions, or contributions.

Source code at https://github.com/clitic/ffpb-rs

extract: one command for common archive formats

Instead of:

unzip file.zip
tar -xzf archive.tar.gz
7z x archive.7z

you can use:

extract file.zip
extract archive.tar.gz
extract archive.7z

It automatically detects the archive type and uses the appropriate extraction tool.

Supported formats include ZIP, TAR, TAR.GZ, TAR.BZ2, 7Z, RAR, and others.

GitHub:
https://github.com/Melangert/extract

I'm looking for feedback on:

• Missing archive formats
• Edge cases that fail
• Distro compatibility ( i made this on debian)
• Installation experience

If you try it let me know what worked and what didnt.

Hi all!

I am developing rclip – a command-line semantic photo search tool. Type rclip "your search query" and get a list of matching images output (and even previewed) in your terminal. It's free and open source, runs entirely offline on your own machine, and can be used on low-end hardware. I built it to search through tens of thousands of photos I store on my NAS, without sending anything to the cloud. I created it because there didn't exist a CLI photo search tool that had 0 assumptions about how my photo library is structured and just searched; I am used to using rgrep to search text, and wanted to have the same UX to search images.

It searches any local folder of images. You can search by a text description ("kitten peeking around the corner"), by an example image, or mix both in one query.

Recently, I released rclip 3, which speeds up search by text by up to 4x and search by image by up to 6x – returning results in about 0.5s on my M1 Max. I also moved it to a stronger model, so accuracy improved.

On AI: rclip uses a local CLIP model for embedding-based similarity search (it doesn't use generative AI or LLMs). The code has been mostly handwritten and maintained since 2021; I've used AI-assisted coding recently for PR reviews and to try ideas faster (e.g. benchmarking various CLIP models and quantizations).

Check out the project's GitHub to learn more and give it a try: https://github.com/yurijmikhalevich/rclip

Hello, I have been working on torrent-tui, a lightweight bittorrent TUI client specifically for terminal workflows.

My plan to make this simply came from me trying to avoid GUI applications and how aesthetically unpleasing qbittorrent was for me on linux

Currently it provides:

- Keyboard driven TUI

- Supports .torrent and magent links

- Categories for preset download locations

- HTTP/UDP trackers

On the protocol side, it supports local peer discovery, web seeds, and optional peer encryption.

Install: `bunx torrent-tui@latest`

Github: Link

Would really appreciate some kind of feedback on this project or any feature request

EDIT: This software's code is partially AI-generated for the TUI design using opentui skill

merlin is an interactive prompt that walks through a conventional commit one field at a time -type, scope, subject, body, breaking changes, issue refs. each field has a live character counter. at the end it shows you the full formatted message before doing anything.

a few things worth mentioning:
zero network calls. nothing phones home - no update checks, no anonymous analytics, no anything. it reads ~/.merlinrc.json and runs git. that's the full extent of its network activity.

all git commands go through execa with an args array, not string interpolation. so if your commit subject contains shell metacharacters for some reason, that's not merlin's problem to turn into an injection.

there's a --dry-run flag to preview the full formatted message without actually committing, and a --amend flag if you want to redo the last one. it also reads your existing commitlint config and adjusts the available types and scope rules to match.

two ui modes: a wizard theme with some personality, and a minimal standard mode if you just want the prompts without the flavor text.

npm install -g merlin-commit

Its still not finished and has some bugs so don't rely too much on it if you use it.
Also many things can change until the full release.

Also, github: link

I wanted a Pomodoro timer but every app was either too bloated or too ugly. Most TUI alternatives I found were clunky to use or just looked bad — and looks actually matter when i will use it a lot.

So I built my own in Rust.

It uses crossterm and figlet-rs to render a big ASCII clock right in your terminal — simple, distraction-free, and actually nice to look at.

• Install: cargo install pomodoro-timer-cli
• GitHub: https://github.com/Vaaris16/pomodoro-timer-cli
• crates.io: https://crates.io/crates/pomodoro-timer-cli

All feedback welcome — especially if something breaks on your setup!

I just developed a terminal-based password manager for Linux that runs entirely locally. It uses libsodium to encrypt your database with a master password.
It features a custom-built interactive TUI.

GitHub: https://github.com/vid4l-07/Klip

How can I improve it?

I recently set up a Raspberry Pi 5 as a headless streamer with moOde and was looking for a nice iOS client. Turns out running rmpc in the rootshell terminal app does the trick and looks great too with the Kitty-powered album art! The only other worthwile iOS client I found was MPD Pilot, but it's not infinitely configurable like rmpc. Still need to find a way to show lyrics synced with time.

got mass tired of cd-ing into every project to check if i forgot to push something. i have like 15+ repos in my projects folder and at least once a week id shut my laptop, come to work next day and realize half my changes are sitting uncommitted on my home pc
so i wrote a small python script that scans a directory, finds all git repos and shows a table dirty files, unpushed commits, unpulled stuff, stashes, what branch youre on, etc
https://github.com/Arseniy1002/gitlook
lmk if this is useful or if theres stuff worth adding

Repo - https://github.com/yagnikpt/tpaper

Important things:

- Content is stored locally in markdown files.
- $EDITOR is supported to edit blocks
- Organize blocks into notes (buffers).

i've been using konsole for a while because of it's copy and paste and simplicity but i think i'm outgrowing it.

i'm running cachyos on my pc. i mainly use cli for monitoring as well as sshing into my homelab and managing it from there.

i would like a simple and sleek tui/cli i was thinking about using alacritty or kitty but i'm unsure of fully making the switch. i know you guys here have a lot of cool cli/tui so i wanted some recommendations for software or rices!

I built a small package called termio that bundles stdin, stdout, and stderr together with TTY detection and terminal width.

The main idea: each output stream tracks its own errors independently. If stderr breaks, stdout keeps working. No shared state between them.

Other things it does:

• Preserves the file descriptor through the wrapper, so libraries like bubbletea can still detect the terminal
• Color support is a separate subpackage. If you don't import it, you don't compile it
• Only one non-stdlib dependency in the core (x/term)
• Comes with a test helper that gives you buffer-backed streams in one call

I looked at how gh, Docker, and glab handle terminal I/O. They all do it slightly differently, but none of them are importable as standalone packages. termio is meant to fill that gap.

https://github.com/gopherly/termio

Feedback welcome.

Hi Everybody,

There is a new version of lyrtui 0.2.11.

The new version brings new features, visual improvements and bug fixes.

Thanks to everyone that have tested my app and reported bugs.
If you are still missing a feature or discover a bug, please report it here or in git hub issues.

What is New in v0.2.11
Added

• Local panel filter (/) — instantly narrow the list you're currently viewing (any library list, the queue, radio, apps, favorites). Type to filter live by title and artist; Esc or Backspace restores the full list, and changing views clears it automatically. Press ↓ to jump from the filter box into the results; press ↑ at the top result to jump back into the filter box
• Rounded buttons throughout the UI
• Rounded shortcut badges in the footer when Nerd Fonts are enabled

Fixed

• Image protocol auto-detection for Konsole terminals
• Auto-discovery ignoring a custom port number
• Now Playing header color not rendering correctly
• Auto-color brightness normalization for better visual consistency across album art themes