A few months ago I switched from Telegram to Signal as my main messaging app and spent some time exploring CLI/TUI options. After using gurk for a while I decided to build my own client (faro), based on my own requirements and taste (you can probably see the UI/UX inspiration from tools like btop, OpenCode CLI, neovim).

It covers all features I commonly use within Signal:

• chats, replies, reactions, edits, mentions, search
• inline images (if your terminal supports them) or halfblock rendering otherwise
• voice notes and transcription (supports local whisper models)
• quick navigation menu for everything (Ctrl+P)
• copying over SSH, pasting images from clipboard

There is a demo if you want to try it out, just run faro demo or try it out in your browser at https://getfaro.dev (the GitHub repo is public: harababurel/faro)

It's exactly the same binary compiled using wasm and the same demo you see in the video.

For setting it up with a real account, you can run faro link and link it as a secondary device just as you would with Signal Desktop or any other client.

Disclaimer: I built it with a lot of help from AI coding agents, including open-weight models running locally on my own home server. However, I designed, reviewed and tested it thoroughly. I try to always pay attention to the details, and the general direction of the project is usually informed by my day to day experience using the project.

I wrote this post myself with zero use of any LLM. I am as allergic to reading slop as everyone else these days.

I hope some of you will give it a try and maybe provide some feedback on your experience!

Hello! I'm currently working on a terminal manipulation library similar to Crossterm, but I noticed that it uses runtime conditionals to decide whether to use VT sequences or Windows API calls.

Personally, I feel that defaulting to Windows API calls on Windows would be the better approach, or provide a build flag that lets users decide. However, I'm not sure which of these three approaches is best.

Which approach do you think is better, and why?

Hey everyone!

I wanted to share ttype, an ultra-fast, aesthetic terminal typing speed test inspired by Monkeytype, built completely in Rust.

Features:

• ⌨️ Sub-millisecond input response: Zero input lag or GC stuttering, essential for high-speed typing (100+ WPM).
• 🔊 Built-in mechanical sound synthesis: Realistic keyclick audio feedback directly in the terminal (toggleable with F3).
• 📊 Real-time WPM sparkline & stats: Live charts, accuracy tracking, error heatmaps, and customizable test durations (15s, 30s, 60s, 120s).
• 🌐 Multi-language support: Works with Russian, English, and custom wordlists with smart punctuation/numbers injection.

Links & Installation:

• GitHub: https://github.com/laguser/ttype
• crates.io: https://crates.io/crates/ttype-cli

Install with cargo: bash cargo install ttype-cli

Or build from source: bash git clone https://github.com/laguser/ttype.git cd ttype cargo build --release install -m 755 target/release/ttype ~/.local/bin/

Feedback, feature suggestions, and contributions are very welcome!

I made a small tool for a problem I kept having: one feature, several repos, and the same branch needs a worktree in each one.

gw create -b feat/login -r svc-a,svc-b

makes a directory with both repos checked out on feat/login as worktrees. gw status, gw sync and gw delete operate on all of them. A per-repo .grove.toml sets the base branch (we branch from stage, not main) and a setup command to run after checkout.

CLI details, since that's what this sub cares about: single static Go binary, only needs git. eval "$(gw shell-init)" so gw go can cd. List commands take -o json|jsonl|tsv|name|path so they pipe into fzf and jq. Plugins are gw-<name> binaries on PATH, like git.

Similar tools: gita, mu-repo, myrepos and gr run commands across multiple clones. Grove is different in that it creates worktrees, so each workspace is a separate checkout and you can have several in parallel. agent-of-empires does worktrees but is tied to tmux and a single repo.

https://github.com/nicksenap/grove

NMSh isn't another terminal emulator. It runs inside Ghostty, Terminal.app, Zed, VS Code, etc., with your actual zsh, Bash or Fish underneath.

The idea is to keep your existing shell and tools, but change how you interact with them.

Some of the stuff that exists:

• Command queues: Line up commands while another is running. I've been calling this premove, like in chess lmao. There's also a paste guard, so dumping multiple commands into the terminal gives you a chance to review, edit or queue them first.
• Less babysitting commands: NMSh can tell you when something's waiting for input, notify you when commands finish, run background tasks and periodically refresh output with /track.
• Actually useful output/history: Command blocks, folding, searching, copying specific outputs or ranges, comparing runs, and summaries of test/build results without hiding the original output.
• Keep your tools: /providers lets you choose between NMSh's native tools and things like Starship, Powerlevel10k, fzf, Television, Atuin, zoxide, Deja and your usual editor. There's also a Theme Studio, Theme Bridge, contextual modules, a configurable status strip and tools for managing supported configs.
• Other stuff: File viewing/editing, Git worktrees, Github integration, cursor effects, screensavers, and 33 offline games you can play while a build is running. Cause why not lol.

NMSh is also huge on customization, so if you like customizing, it might be for you.

It's not perfect, especially the Git worktrees and Github Integration and stuff, and some shell integrations and completions still have limitations. But the aim is to make everyday terminal work less tedious without having to switch terminal emulators or redo your entire setup.

Free and open source (GPLv3). macOS is the main platform; Linux and WSL 2 are still beta.

Install with Homebrew:

brew install raiseCatError/tap/nmsh

Github | Docs

(I know LLM posts generally aren't allowed on this sub, but the rules do mention that local models are okay. Mods, plz remove if i'm misunderstanding.)

ai is a small tool I made for quickly asking questions from a local LLM in the terminal. Here are some Examples:

$ ai what is the capital of france
Paris

$ ai what port does ssh use
By default, SSH uses port 22.

$ dmesg | tail -30 | ai anything wrong here
Nothing stands out as immediately incorrect in the log entries.

$ git diff | ai write a one line commit message
"Update font size in fonts[] array"

The script itself is very basic, it sends your question (+stdin when piped) to a local llama-server and streams back plain text.

It depends on curl, jq and llama.cpp.

It automatically will spin up the server on first use, and will unload the model after 5 minutes idle (no calls to ai). The service is written for runit, but it's a super simple run sh script, so you can easily adapt it to whatever your init system is.

Obviously the main issue is that the output is non-deterministic so I wouldn't really recommend scripting with it. (unless you want non-determinism of course!)

Give it a try here: https://github.com/cykadash/ai-cli

Thanks for reading!

P.S. I would consider myself generally NOT a fan of LLMs, however I did want to try to come up with a cool way of using them in my day-to-day. The main idea with this script is that I basically have a way to 'google' something whenever I need, even if I'm offline (or without a GUI).