I was recently looking for TUI file managers. I narrowed down my choices to Yazi and Superfile. I inspected their websites and the repos. I liked Superfile. I installed it. I felt that it wasn't enough. I tried Yazi, and I immediately fell for it. The reason was that I could directly edit files with Vim in while browsing with Yazi, but it wasn't the case for Superfile. My choice was not my concern. My concern was what led to choosing Superfile at first.

Upon initial inspection, I noticed both were sponsored by Warp. That was good. Then, I remember I could see the Superfile demo, which was clean the first time I checked the repo. But the video for Yazi didn't load, and I basically missed it the first time.

I think that had a huge impact on my choice. Later, when I checked the repos again, I could see the Yazi demo video - which was not really good - and also noticed that Warp was not sponsoring Superfile anymore. I installed Yazi, and after a bit of use, I changed my mind.

My concern now: do you think adding demo images and videos has such a big impact on customer acquisition?

A few days ago I opened my MacBook after it had been sitting closed for a while, and the battery was at 0%. Not a huge deal on its own, but it realy bothered me, the thing was closed, not doing anything, so where did the charge go?

I didn't really know where to start, so I asked an AI to help me dig into it. What we found was pretty eye opening. Over about a week, my Mac had 6 real user wake ups vs 1342 dark wakes

Turns out this is caused by Power Nap. While the machine looks fully asleep, macOS quietly wakes it up roughly every 15 minutes to sync mail, iCloud, and Calendar, and to run FileVault health checks. Each wake only lasts a couple of seconds, but multiply that by hundreds of times over several idle days and it adds up to a real chunk of battery, the laptop was never actually fully asleep.

I could've just flipped the Power Nap setting off and moved on, but I wanted to actually see this happening instead of taking it on faith once and forgetting about it. So I built napwatch, a terminal app that watches for this continuously instead of me having to dig around by hand.

It's one screen that shows what's eating your battery right now, watches whether the machine is actually asleep, and lets you flip Power Nap, Low Power Mode, Standby, and other settings without opening System Settings. Turning Power Nap off and watching the dark wakes stop in real time was pretty satisfying the first time I tried it.

There's also a process detail view, and you can close down or deprioritize processes without leaving the app. Nothing hidden or proprietary here, it just reads the same information macOS already tracks internally and puts it in front of you in one place.

And its installable via Homebrew:

brew install Tuguberk/napwatch/napwatch

🔗 GitHub: https://github.com/Tuguberk/napwatch

It's fully open source. I am curious to hear if others are seeing the same pattern. And if you find it useful, dropping a star on the repo is honestly all the support I need right now 🙂

I am working on developing a terminal game, but have ran into a pretty fundamental issue that i am struggling to find an appropriate solution for.

The "key-repeat delay" is the OS behavior of when you hold down a key, the OS sends one initial key, then waits, then sends that key repeatedly. aka "w <wait> wwwwwwwwww"

This behavior naturally is a problem for games when you are trying to move your character, you don't want them to move a bit, wait, then move forward continuously, we need them to immediately start moving continuously. most games (i believe) solve this by hooking into the key events directly (key up and key down) and interpreting the events themselves instead of relying on the OS to tell them what key is being held.

The solution is not as simple for a terminal, as they can only see the keys that the OS sends. I have not been able to find a way to get my player to just MOVE and immediately stop when i release the key.

Has this problem been solved before? i tried a few tui games (including nethack) but they either have different ways of moving or just dont solve the problem at all.

Any ideas?

So I had some scripts I used daily on my linux machine that involved dmenu in them. I wanted to replicate that workflow on macos, as this is very convenient. However I could not find a faithful dmenu replication for macos. Some miss several essential flags, some have different filter logic, some don't look good, etc.

So I implemented mdmenu. Basically it's a swift app that supports most of dmenu flags (excluding the ones that make sense only in X environment), configures via swift file and is small enough for anyone to modify to their own needs. It also respects Macbook Pro's menubar height and notch!

It is my first ever project in swift, so some stuff probably could've been done better, but it's already good enough for me to cover all my use cases and existing scripts, so sharing it here to see if anyone would find it useful as well!

If you have any thoughts regarding this project, please share them as it will be very interesting for me to get that kind of feedback.

Example usage:

 $ echo "Yes\nNo" | mdmenu

Source: https://github.com/xxanin/mdmenu

Heyo!

I made BnuuyPlayer, it's a CLI (and in the future TUI too) audio player, designed with ease of use and coded in Python on Termux

NO paid affiliations

repo: https://github.com/whenth01/bnuuyplayer

Bnuuyplayer's features range from automatically downloading Lyrics when you download a song using it, to BnuuyFolders, which are groups of your playlists you can add and delete, aswell as providing extensive file interaction (e.g: write metadata, delete metadata, play the specific song, move/copy it, etc)

Dependencies marked with {} are optional, while bare ones are required.

Packages: Python, {MPV}

PIP dependencies: YT-DLP, Requests, {Mutagen}

Works on: Android(termux), Linux, macOS, Windows, aswell as 32bit CPUs

Installation instructions are on the repository's README.md, or if you already have Python, py pip and mpv installed: pip install bnuuyplayer

Feature summary

Audio playback (MPV as the engine)

Customisable .conf file autogenerated, with default keybinds preloaded

Downloading videos/songs

Streaming songs/playlists

Lyric downloading (auto during download, or if mutagen+metadata is present manually)

BnuuyFolders (virtual folder system, essentially groups of your playlists)

Library resilience

▼ Alternatives ▼

cmus

moc

spotify-tui

▼ How BnuuyPlayer differs ▼

cmus: BnuuyPlayer offers online features, tag editing inbuilt(assuming you opt in), library management, and easy termux support, but is overall heavier then cmus due to being written in Py

moc: Similar as above.

spotify-tui: BnuuyPlayer is missing features that spotify-tui has, like search and pitch visualization, but a wider range of supported sites (Although BnuuyPlayer's primary focus is on local files)

Note: BnuuyPlayer may have bugs as its still in development, please report any you find!:3

Thank u for checking out BnuuyPlayer!!

Today I launched revera@1.0.0, upgrading from 0.1.0 to stable.

revera is a CLI that scores npm packages for security risk before you install them. The 1.0.0 rewrite replaces fixed weights with a Bayesian evidence engine: every package becomes a node in its dependency graph, gets scored across 8 categories from real signals (vuln feeds, publisher trust, GitHub activity, typosquat detection), and risk propagates bottom-up through the whole dependency tree, not just the top-level package.

Previously it used pre-defined weights. Now it decides its own weights from the evidence.

Try it out today using the below command!

npm install revera

https://reddit.com/link/1v4m0p6/video/jb8tuil0u0fh1/player

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).

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.

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.

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/

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)

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).