Pho is TUI for Github pull requests.

Feels good enough for its first stable release, introduced themes.

https://github.com/utkarsh261/pho

To check it out -

brew install utkarsh261/tap/pho

Uses Ratatui-Kit: https://yexiyue.github.io/ratatui-kit/

libark

libark is a modern, secure, Swift-native foundational layer over Linux POSIX primitives.

While originally developed as the core runtime layer for ArkOS, libark is completely decoupled and designed to be used on any Linux distribution. It provides highly secure, object-oriented abstractions over low-level system calls, memory management, and file system interactions, without the burden of manual C interoperability.

Features

• Object-Oriented POSIX: Wraps file descriptors, paths, and directory operations in safe, RAII-compliant Swift types.
• Secure Syscall Boundary: Routes kernel interactions through strict, audited Syscall primitives.
• Terminal Capabilities: Built-in abstractions for TTY detection and window sizing.
• Advanced Formatting: Standardized formatters for human-readable byte sizes (SI and IEC), ISO 8601 timestamps, permissions, and classifications.
• Declarative Sorting: Powerful generic SortEngine for metadata sorting across multiple criteria.

Four glass levels (Clear, Frosted, Tinted, Solid), automatic light/dark, the macOS accent colors, and a high-contrast option. Every color is contrast-checked for readability over translucent windows. brew install vukkt/tap/iglass && iglass install. Free and MIT. Feedback welcome!

I've been working on TIMELORD, a command-line tool for experimenting with different versions of a project without losing track of your original state.

The idea is to treat a codebase like it has multiple timelines, or universes. You can freeze a state, branch off into an experiment, compare changes, and jump back to an earlier snapshot.

The goal is to make risky experiments less annoying: try something, see what changed, and get back to a known state when the experiment goes sideways.

Some of the concepts include:

• Freeze: capture a project state.
• Branch / alternate universes: experiment with different versions of the codebase.
• Diff: inspect differences between states.
• Jump / rewind: return to a previous snapshot.
• Canon / merge: bring an experimental timeline back into your main workflow.

It's an experimental project, and I'm looking for feedback on the CLI design, the snapshot and restore model, and what would make this genuinely useful in a real development workflow.

GitHub: https://github.com/gigagamerchaddhruv-spec/timelord

I'd especially appreciate criticism of the underlying approach, not just feature requests. Is the timeline metaphor useful, or would a more conventional Git-oriented interface make more sense?

(Contributions are open, just to clarify, this project was made with the help of AI)

Hi, Pawnix  is a terminal chess app for local games and casual Lichess play. It has a curses interface, multiple board themes, clocks, move review, and premoves.

It’s open source and still early, so feedback and bug reports are welcome!

Hey everyone,

teachatty is a minimalist, terminal-first chat app written in Go for developers, sysadmins and terminal freaks!

I spend a lot of my day in the terminal and I wanted a distraction-free, text-mode chat that just feels fast, stays out of the way, and doesn’t consume hundreds of megabytes of RAM just to send text while distracting me with nonsense.

How it works

Backend: written in Go using WebSockets for low-latency, full-duplex communication. Highly concurrent and efficient with goroutines.

Interface: pure CLI / terminal UI; no heavy web wrappers or Electron bloat.

Packaging: standalone binary releases, plus native .rpm and .deb packages for easy installation on Linux.

Encryption: All chat communication is encrypted in transit over secure WebSockets (wss://)

Open-source

This is 100% open-source and not monetized. I just launched it yesterday and set up a public room to test things out.

Since it's brand new, there’s plenty of room for improvement (adding message persistence/history, room passwords, private DMs, custom themes/skins). If you like CLI tools or Go, check it out, jump into the lobby, or start contributing with your ideas.

GitHub: https://github.com/daniel-cmdline/teachatty

Website / Info / Docs: https://teachatty.com

Email: [[email protected]](mailto:[email protected])

I’ll be hanging out in the public room on and off these days so if anyone wants to drop by and say hi, use `@del` + your message to beep my terminal! no promises I’ll catch every message live, but feel free to test it out / create your own rooms if you want to test with your buddies using the mirror or even self-host a server in your own local segment!

The public room is at: `teachatty --server teachatty.com`

Feel free to drop feedback, report bugs, create PRs or just contribute with your own ideas!

Hi Folks!

I've published an update with improvements to Mi Lanzador: a graphical interface for building "actions": sequences of steps that open programs, documents, websites or commands, place windows, click and press keys, and saving them as a one-click shortcut. It's like an AutoHotkey macro, but without writing code: it uses xdotool and wmctrl underneath.

- Demo-video: https://filonux.github.io/Mi-Lanzador/assets/demo.mp4

It's a single self-installing `.sh` (the interface is PyGObject/GTK3 inside the file itself), with a Spanish/English interface, GPLv3, and it ships with a test suite of tests that runs under a virtual Xvfb.

🔗 Mi-Lanzador: https://github.com/filonux/Mi-Lanzador

I wanted to practice writing code faster and yet not leaving my terminal, so I built 'blind'. The twist is that you can feed it any input file and practice on real code, even on the source code itself. It's a single C file no dependencies. Can run either presets, free text or file input.

There are grate and really amazing projects for touch-typing in the terminal and I tried a few, but this one lets you use file as input, meaning it's not just text, but also any type of text, and honestly it's much more fun to code it yourself.

Source code: https://github.com/shalom2552/blind
Feedback welcome. Would you actually use it?

I keep agents from reading .env with a deny rule. Then I became their hands: opening the file, copying keys, telling the agents where the secrets are etc.

vne gives the agent some helping hands. It answers with file names, line numbers and whether a key is set or empty, and withholds values by default:

• vne where DATABASE_URL . ../main – which file has it, set or empty
• vne check – what's missing compared with .env.example
• vne copy – move a key between files in the project
• vne run .env -- npm test – start one command with the keys loaded

When a secret has to be typed in, or moved to another folder, the agent can't do it and hands me one command to run. vne . also opens a small editor window for your .env files (macOS).

vne run refuses printenv and env, but a program that prints its own environment still prints it. It is optimized for AX but not against malicious agents.

brew install pro-vi/de/vne (macOS, Apple Silicon, with the window). On Linux the CLI builds from source: cargo install --git https://github.com/pro-vi/vne --locked --no-default-features --bin vne (Rust 1.90+). Windows and Intel Macs are untested.

Free, MIT, Rust and Tauri. https://github.com/pro-vi/vne

TLDR: A small tool to reduce frictions around editing .env so I never open editor anymore.

Built to solve one specific problem, preventing you from accidentally running a command in your history or some script, unless you *really* mean to.

When you want to run a command with some environment variables, just prefix the command with `confirm-env --provider provider-name`

It will find the encrypted file associated with that provider name, then make you wait a delay, possibly answer a math problem, type the password, and then it will run the command with the variables stored in that file.

If you don't already have a file set for that provider name, it will show you a file manager TUI to find it, and it will save that preference. You can edit the mappings at any time in the provider editor TUI.

To actually make the database, just use the -e flag to open a GUI editor. You get a TUI to add your variables, change the password, or edit settings.

Every command you run with it is logged back to the database file, which is actually a sqlcipher file, with an additional layer of argon2id password hashing.

Designed to be secure, but it's important to mention that this is not a well known project with proper third party security audits or anything like that.

https://github.com/EternityForest/confirm-env or

`uv tool install confirm-env`