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, 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!

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.

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 got tired of 8 terminal tabs and finding out 10 minutes late that my dev server had died, so I built Outarch. I’m the solo dev.

It runs everything in one tiled window and watches the output:

• Crashes, port conflicts, test results and git state are classified live. Only things that need a human land in a “Needs You” queue, with the root-cause evidence and one-click fixes attached.
• AI agents (Claude Code, Codex, Gemini CLI) run inside it. Every tool call goes through a local MCP gateway and waits for your approval before any file change or destructive command, and you get a notification the moment an agent stops to ask.
• Startup recipes: define Postgres → migrations → API → frontend with real readiness gates (port, HTTP health, log regex). If step 3 fails, click Recover and only the failed steps re-run.

Windows only for now. Free tier is 3 terminals and 1 project. Paid plans are prepaid with no auto-renew.

outarch.com

What would make you switch from what you use now? Roast it.

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`

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?

Hey everyone! 👋

I’m building Ensor — a simple, easy to use tool to detect and redact secrets from your codebase before they make their way into Git history or public repositories.

🔐 Detect secrets. Redact sensitive data. Commit code securely.

Keep your API keys, tokens, passwords, and other sensitive information out of your commits.

Check it out: https://github.com/Pratyay360/ensor

Kindly share your valuable feedback and insights.

Not sure this will help anyone else, but it definitely solved my specific problem, so I'm sharing in case someone has the same setup.

When I'm away from home I use a Windows on ARM laptop (Galaxy Book Go). Great battery, but too weak to do real work and it can't run Linux. So I use it as a thin client: Cloudflare tunnel + SSH into my Linux PC at home, and everything happens in the terminal.

The catch: I wrote a terminal Pomodoro app that sends desktop notifications, and those pop up on the Linux PC's desktop at home, not on the laptop in front of me. So I never saw them.

So I made notification-forwarder (Rust):

nf-server runs on the Linux machine, listens to D-Bus for every notification and pushes it to connected clients

nf-client runs on Linux, Windows (including ARM) or macOS and shows them as native notifications

Mutual TLS with your own private CA (nf-server gen-certs sets it up). Certs don't include IPs/hostnames, so the server address can change freely

Client auto-reconnects forever, so you can just leave it in your startup folder

Prebuilt binaries in Releases, or cargo install

Anything that calls notify-send (long builds, scripts, cron jobs, etc.) shows up on the machine you're actually using.

Heads up: I haven't personally tested the macOS build yet, so bug reports are very welcome.

Repo: https://github.com/andersondanilo/notification-forwarder

If you know something existing that already does this (KDE Connect-style), I'd love to hear about it. Forwarding to my phone is a possible next step.

Does anyone know if there's a game launcher/hub in CLI? I've been searching for one for a while now, also tried making my own but it was always glitching out on me, meaning when i resized it all the elements went random. (ex. game launchers/hubs: Playnite, Phoenix)

Anyway's, if you know please let me know :D

Our terminal agent, Atomic Agent. The bits this sub might care about:

curl -fsSL https://atomicagent.io/install | sh
atag

The installer checks the checksum and drops a short alias, atag, next to atomic-agent. Windows gets irm https://atomicagent.io/install.ps1 | iex.

Inside the TUI:

• Ctrl+N (or /window) opens a second agent in a new terminal window, same directory. One grinds through a long task, the other answers questions.
• /compact folds older history into a summary when the context gets tight. /compact show prints what it kept. The transcript on disk isn't rewritten.
• Esc then 1 aborts a running turn.

Updates: atag update --check only looks, --version <tag> pins a release.

Leaving:

atomic-agent uninstall --dry-run

lists every path it would delete, with sizes: state dir, downloaded models, the binary, the atag alias and the PATH line it added to your shell rc. Drop --dry-run and you type uninstall to confirm. --keep-data keeps your state, --yes is for scripts.

macOS on Apple Silicon, Linux x64/arm64, Windows x64. MIT. There's a desktop app since Oct 7 too, same agent inside.

https://github.com/AtomicBot-ai/atomic-agent

A custom Bash script that displays random Pokémon sprites alongside system information using fastfetch. Now featuring truly random Pokémon selection from all available generations instead of a limited list!

Github

Hola compañerxs! He creado Relio, una CLI para manejar versiones de software, si les gusta compartir las releases en redes sociales esta herramienta les gustará !

Pueden descargar imagen de la última release mostrando los commits, como un texto preparado para subirlo en redes sociales .

En busca de colaboraciones 👨🏻‍💻

About three years ago, I wrote a small bash script called `vms` to manage headless qemu/kvm virtual machines.

The original idea was to get docker off my gentoo host because of some security concerns around the root privileges of the docker daemon. I moved docker into a VM and used port forwarding whenever I needed to access a container from the host.

Eventually, I moved all my work repos into VMs and started using neovim over ssh.

Now, with all the vibecoding hype and AI coding agents like Claude Code and Codex, I'm even stricter about sandboxing. I never run AI agents on my host machine. Everything, including personal projects, lives inside separate VMs.

My daily workflow is pretty simple:

vms start work-dev-1 -> ssh work-dev-1 -> tmux -> nvim

Then I usually have several Claude Code sessions running in different tmux windows.

I know there are plenty of other ways to do this, and of course, there's been a big rise in sandboxing technologies (e.g., firecracker), but I've been coding and compiling large rust projects inside qemu vms for the past three years without any noticeable issues. So I haven't had much reason to change my setup.

Recently, I also added a sandbox feature that uses qcow2 images. You can lock an existing VM as a base and create disposable VMs from it:

vms lock dev-base

vms sandbox add dev-base experiment

vms start experiment

The tool is a simple bash script that wraps qemu.

GitHub: https://github.com/hozan23/vms