Playable Link: https://deux.chronos-game.com

Platform: Browser (desktop & mobile) - runs in any modern browser, no install or signup

Description: A rogue thing walked out of an air-gapped vault, and you're the one chasing it. It leaves a breadcrumb in every machine it passes through - and the machines are real: a gas-station security camera, a bank's SWIFT terminal, a phone network, a power grid, a reactor. You don't play a computer, you operate real ones with the genuine tools and commands, era by era, each intrusion drawn from something that actually happened (Mirai, a SWIFT heist, SS7, the Ukraine grid attack). The catch is the thing you're chasing isn't running from you. It's leading. And every breadcrumb it leaves is a person.

It opens with a cold intro that sets the stakes, the first system is a gentle on-ramp, and it's terminal-native and period-accurate throughout : Cyrillic and Farsi shells when you're on foreign machines, synth audio, live status panels around the terminal. There are multiple endings depending on how you play and what you piece together. A full run is roughly 45–90 minutes, and you can restart at any level you've reached, so a timer running out isn't game-over.

This is a standalone sequel to CHRONOS, you don't need the first to follow it. I'd love feedback on whether the opening hooked you, where you got stuck, whether the hints landed, whether you reached an ending, and any bugs. There's a "tell the maker" link on the end screen.

Involvement: Solo developer,  I designed and built the whole thing: the engine, all the era content and puzzles, the writing, the audio, and the deployment. CHRONOS II is my project; this is its public launch and I'm looking for honest playtest feedback.

https://github.com/PhantomLambSoft/CmdBox

CmdBox is a CLI tool that lets you save and quickly recall commands by name. It lets you store commands with named variables, like <host> and <port>, and either prompts you for values at runtime or lets you store values so they are reusable in several commands.

I hated having to try and remember or google complex commands that I didn't use often, and I especially hated having to type tedious commands that I used a lot, so I built this tool to make this easier.

The main goal is that it is very quick to run commands. Command aliases can be kept short and parameter values let you type less or create several commands using the same variables for even faster use. All it takes to run a command is cb command-name.

Some of its other features:

• Stored execution context per command (working directory, shell, environment variables, and timeout) with runtime override
• Multi-line command templates executed as scripts
• Tag based organization and filtering
• Field based search across commands and variables
• Import and export for sharing commands
• Configurable global settings for shell, output capture, color, and more
• Command execution history with the ability to rerun past executions
• A shell function (cbe) that lets you run commands in your current shell session, like cd or activating a virtual environment

It is installable via pip, pip install cmdbox-cli, and works on Windows, Linux, and macOS.

AI disclaimer:

This software's code is partially AI-generated - Only in test files and docstrings. All implementation code is written by me.

Similar projects:

pet offers comparable core functionality (saving commands).

Whenever I want to do something I keep worrying about prerequisites and whether I really know what is needed before, like I know the general usage of ssh when I connect to the OverTheWire games, the same with ifconfig, etc, because I know some networking from here and there, and half completed courses on YouTube, so whenever I want to use something like wireshark or nmap, I start thinking that I don't know enough yet, while I know what is an IP, ports, basic information about some like that DNS translates Domains to IPs, and DHCP sets the IP addresses automatically so that we don't have to set each manually, http for web while https is just encrypted, but none of those I know about the inner workings.

What do you all think?

So I don't know if I'm allowed to post this, but I've been working on a learning project, which is a shell that currently supports: command history, environment variable exporting in the TOML configuration, commands that should run at startup in the configuration also, command editing, and it shows the current directory in green text inside the prompt. Here is the repository if anyone is interested: https://github.com/BlackHoleMX12892/ishell

I know generally speaking that init is the first process and gets PID 1 and so on, I know that there are many implementations of it especially systemd being the most popular.

I learnt few things about init and systemd but I can not use it for reasons like that my computer is 32 bit so I'm limited in terms of distro choice because most low-end distros use other obscure init implementations which don't have much tutorials. Let alone that I heard that many people now tend to leave systemd because of privacy related stuff and its being bloated.

So I would like to hear from you all how to learn about init in the given circumstances.

This toy retro synth runs on esp32-p4 as a 37kB ELF file. It uses my work-in-progress immediate mode TUI library in C. There is also a build for Mac/Linux console, and a wasm online version via emscripten.

Web demo and source code: https://mini000.itch.io/beeper

Youtube demo: https://www.youtube.com/watch?v=uCH9XYZ7QB0

The main challenge I was going for was actually finding a nice minimal set of controls. Usually there are 40-50 of them in "simple" synths; I ended up with 16.

In terms of TUI, I wanted to see if it would be practical at embedded C scale to use a modern approach similar to ratatui, Dear ImGui, or Nuklear. I am quite happy with it so far. Will keep using and extending it for more esp32 apps.

I did not publish the library as a separate project yet; it is not mature enough. Feel free to reuse it via good old copying for now if you like it. I have been working on it for some unpublished prototypes for a while. If you want menus or dialog boxes, I can share those as well.

Thanks for checking this out! I welcome any questions and feedback about the app and the library.

The default help output is functional, sure, but I just wanted something more pleasant to look at.

More details here:
https://github.com/microsoft/winget-cli/discussions/6348

This guide keeps Unix composability while treating modern CLIs as human-facing interfaces.

Hello!

I wanted to learn a little bit about the ncurses library so I spend some break times at work to make a Columns-like command line game. Hope you like it! : D

Featuring:

• 6-different blocks. Align them vertical / horizontal / diagonally to remove them!
• 16 colors / monochrome terminal compatibility (although playing it without colors and relying only in the different ascii characters is kinda difficult...)
• Increasing speed / multiple levels
• Combo count / Max hi-score

Works nice on my coffee breaks for a quick run or two!

Source code and more pics on its repo: https://github.com/theisolinearchip/tcols (tested on my Debian 12 - also some friends tried it on their Mac computers and worked fine)

I built SecretSpec because my secrets were scattered across dotenv files, shell profiles, password managers, cloud vaults, and CI settings.

SecretSpec lets a project declare the secrets it needs in `secretspec.toml`, then resolves them from the stores you already use. The CLI can check, set, run with, or export secrets across different profiles and providers.

Unlike SOPS, Infisical, direnv, or dotenv tools, SecretSpec does not try to replace your existing stores. It provides one workflow across them.

I maintain the project and would appreciate feedback from other command line users.

https://secretspec.dev/

Hi, I'm the dev behind this. Open a terminal and ssh cli.poker to try it out.

The games are heads-up texas hold'em tournament style games - should take 5-10 minutes to play a full game (fast paced blind raises). all games are ranked using glicko-2. cli.poker connects to the chips of fury app's player network, so usually you will find a human match. but if not, you will be matched to a bot after ~45 seconds.

How it is built

used charm's stack for this. wish is being used to run the ssh server and the UI is done with bubbletea. AI model used to code - fable 5. The polish took some real effort, and I hope it will come through in the user experience. I'm hosting this on fly.io, and I've found it to be perfect for this kind of a use-case. The closest ssh server to your location is chosen (currently hosting one each in US, Europe and SE Asia).

Hope you give it a spin. Please share feedback if you do !

[Edit] while i have some attention - do you think a 1v1 mode would be useful i.e. you could play with a buddy, instead of public matchmaking?

I just found this sub and think it's dope and I want to share a small script I made two years ago for automating the process of setting up wifi on OpenBSD.

The script:

#!  /usr/local/bin/bash


ifconfig iwn0  up

ifconfig iwn0 scan | 

sed '/iwn0/,/network/d' |

sed -e 's/.*nwid\(.*\)chan.* /\1/' |

sed '/""/d' | sed '/0x0/d' | uniq | head -n 10 

read -p "Type out the name of your ssid: " ssid_name

read -p "Enter your passphrase: " WPAkey

cd  "../../.."

cd "/etc"

echo inet autoconf join ${ssid_name} wpakey ${WPAkey} >> hostname.iwn0

sh /etc/netstart

description:

OpenBSD Automated Wifi automates the process of scanning SSIDs, going to the /etc directory, creating/editing hostname.iwn0, and restarting iwn0. Simply put, OpenBSD Automated Wifi automates the process of setting up wifi on OpenBSD so all a user has to do is type in the wifi name and password.

As part of a larger project called Nerve (an IPC bridge for Rust, Go, Python, and JS), I built a CLI monitor to track and debug the communication between these languages in real-time.

I wanted the CLI to be fast, direct, and distraction-free. It hooks into the local IPC channels and outputs the message flow, which has been incredibly useful for debugging cross-language data structures.

It is still a work in progress. Things I am planning to add to the CLI:

• TUI elements for a more structured view of active connections.
• Filtering options to only show logs from specific languages or payload types.
• Customizable output formats (e.g., raw JSON vs human-readable summaries).

I'm currently reading The Linux Command Line book (TLCL), wondering about whether I can skip some parts that I feel like I don't need them at least for now or that what I know about them already is enough, like the "Advanced Keyboard Tricks" Chapter, I already know some of them like the "!!" thing, history, clear and ctrl+L and most of the frequent stuff, but noticed that there are parts that don't seem to be that frequent like the "!string" thing, so I think I will skip like that or things that I think I already know what is enough and go straight to what I might need frequently

What do you all think about this?

hdi working against a demo Sinatra app / readme

"How do I" surfaces install, run, test and deploy steps and commands.

You've just cloned a repo, fired up an editor, and you're scrolling a 400-line README looking for the "Install" section.

Or more typical for me - I'm back at a project after a month and can't remember if it's npm run dev, npm start or npm run serve...

Run hdi, pick a command, copy it or hit Enter to run.

I've written this to be as flexible as possible regarding READMEs and their formatting, and put together quite a collection of them in the test fixtures. More examples, especially those which don't work as well with hdi, are always welcomed!

brew install grega/tap/hdi

https://hdi.md

https://github.com/grega/hdi

This software's code is partially AI-generated (notes are in the README).

Hey folks! I was killing time at the airport and decided to start prepping for an upcoming TTRPG campaign (Mythic Bastionland), but forgot to bring dice. I tried different dice rollers but none sparked my creativity:

• Web apps like Google's dice roller and dddice were slow for repeated rolls and didn't support dice notation, so I tried CLIs.
• rolldice, dice-roller, and other CLIs addressed those two concerns but lost the visual excitement of rolling, so I tried TUIs.
• Then I couldn't find any TUIs with visual rolling.

So I made this to emulate the joy I have rolling physical dice:

• Shake and roll dice with simulated throws and physics.
• Hear them bounce with synthesized sounds and effects.
• Supports popular TTRPG dice notation.

It’s been surprisingly satisfying to use over the past month, so figured I'd share.

https://github.com/puradox/tinhorn - cargo install tinhorn

Designed by me, programmed largely with AI (Fable 5), and reviewed myself.

I kept jumping between ss, lsof and nethogs to answer one simple question:
who's listening on this port, and which connection is using my bandwidth
right now?

So I built portwho, a small terminal tool that shows all of it in one screen:

• listening sockets and active connections (TCP/UDP, IPv4/IPv6)
• the process behind each socket (PID, command, user)
• live upload/download speed per connection, with a little sparkline

It runs as a normal user, no root needed, and has no dependencies beyond ncurses.
There's also a --json output if you want to pipe it into other tools.

It's written in C and MIT licensed. Feedback and bug reports very welcome!

https://github.com/vpintidev/portwho

Went through the whole prompt journey (robbyrussell → spaceship → starship) and keep landing back on Powerlevel10k for one reason: speed.

It uses a compiled git daemon (gitstatus) for instant git status, plus an "instant prompt" mode that re-renders your last prompt from cache the second a shell opens. No blank gap, ever. Compare that to:

- Starship: looks great, but I could feel the lag in big repos. Fresh process every render.

- Spaceship: gorgeous but slow, shells out for everything.

- Pure: fast but too barebones.

p10k renders async too, so slow segments never block the prompt.

But the default "rainbow" look fills every segment with a solid colored block. Informative, but heavy, like colored legos across the terminal. I wanted the info without the weight.

So I built ghostline. One idea: hollow out the segments. No background fill, anywhere. Each segment's color lives only in the text and the thin chevron separators. Same info (dir, git, cmd time, exit status), just glowing on dark instead of sitting in colored boxes.

Highlights:

- Semantic git colors via a custom formatter: green = branch/clean, peach = changes, sky = untracked, red = conflicts. Read your repo at a glance.

- Style, not a colorscheme. The whole palette is one block at the bottom. Retheme in seconds. Ships Catppuccin-ish, swap to anything.

- Thinner end caps: chevrons instead of chunky powerline triangles.

- Always hollow, even conditionally-shown segments (AWS, k8s), so nothing pops in with a random block.

I run it on Ghostty and the colors really pop. No fill means nothing competes with the text.

Customizing is easy: palette = one block, git roles = five lines, end caps = two lines. No need to read the full config.

Repo (MIT, feedback welcome): https://github.com/iamrohithrnair/ghostline

Got a palette that'd look good on it? Drop it.

So, I made a post on here a few months back asking about terminal/tui-based word processing software. One of the ones that someone recommended on that post was one called Pure. I think it looks pretty good, from what I can see on the Github page, but I haven't been able to actually try it out, since whenever I try installing or building it, running the command it says to run on the github repo (pure document.ftml was the example), it just tells me the command wasn't found.

Has anyone else on here used Pure before? And if so, what am I missing?

For extra info, my current laptop is running Linux Mint 22.3 Cinnamon, and the terminal I'm using is GNOME Terminal.

I've got a Linux box next to a couple of Windows machines and wanted PowerToys' Mouse Without Borders to include it. No Linux client existed, so I wrote a small headless one.

It runs as a systemd user service, no GUI, single Go binary, one TOML config. Input goes through uinput, edge detection via cursor polling. It speaks the MWB protocol directly, so nothing extra runs on Windows beyond PowerToys. Mouse, keyboard, and clipboard both ways (text and images), edge switching, AES-256-CBC handshake.

How it differs from the usual options: Synergy, Barrier, Input Leap, and Deskflow each run their own server on every machine and replace MWB. This one instead joins an existing MWB setup by implementing its wire protocol, so the Windows side stays stock PowerToys.

Heads-up: bidirectional (Linux driving Windows) is X11-only for now, receive-only works under XWayland. Non-US layouts can have key quirks since MWB only sends Windows virtual-key codes.

Repo, one-liner install, and a .deb: https://github.com/lucky-verma/mwb-linux MIT, free, no affiliation. Would like feedback on the Wayland side.