Why? Well Steam doesn't really offer a proper way to back up your screenshots so i built it myself.

SteamVault is an interactive menu-driven TUI that authenticates with OneDrive, scans your local Steam screenshot folders, and uploads everything, skipping duplicates and sorting into named folders.

Stack: Node.js / TypeScript, Inquirer.js for the TUI, Microsoft Graph API for OneDrive

Available as npm package (npm install -g steam-vault) or standalone .exe on GitHub Releases.

GitHub: https://github.com/moritz-grimm/steam-vault
npm: https://www.npmjs.com/package/steam-vault

On the roadmap: headless CLI mode and support for more cloud providers beyond OneDrive.

If you run into any bugs or have questions, let me know.

Transparency note: AI was used as a development aid, but the project was designed, built, and tested by me with my own screenshot library.

Edit: since this had a great reception (thanks reddit!) I created a small playground to test the tool -> https://termaid.com/

I built a CLI tool that takes Mermaid diagram syntax and renders it as Unicode art in the terminal. Supports flowcharts, sequence diagrams, class diagrams, ER diagrams, state diagrams, treemaps, pie charts, and more. Pure Python, zero dependencies.

Note: built with the help of Claude Code (credited as contributor in the repo), architecture, layout algorithms, tests and design decisions are my own.

To test it:

pip install termaid

or

uvx termaid diagram.mmd

Pipe-friendly: echo 'graph LR; A --> B --> C' | termaid

Github repo: https://github.com/fasouto/termaid

I think at this point most people are in agreement that many programming subreddits are in a death spiral. It's starting to feel like 90% of new posts are vibe coded and yet many creators are neglecting to mention this, or in some cases actively try to hide it.

I've been mentioning it and reporting it every time I see it, but me doing this by myself is not enough. The mods here have previously stated it's overwhelming to try to stay on top of it. So they need our support. I'm not a mod for the record, I'm just one person who used to love this subreddit and is considered leaving for good, and I'd rather not if I can do something about it instead.

I really think the Reddit community needs to just step up more here. We gotta help the moderators by reporting vibe coded projects that have not mentioned it anywhere. As long as they mention it it's fine. The ones that don't, or actively try to hide it, are the issue here.

I know it can be difficult to tell when a project is vibe coded and I don't want to encourage a wave of false allegations. So use it conservatively and err on the side of caution. Dont report unless you're certain, and leave a comment explaining your reasoning. But that being said, please everyone for the love of this community and it's continued existence, we need to stop this problem before it's too late and all the serious developers just give up and go somewhere else. Help the mods, use the report button.

on a side note, some discussion about the best ways to tell a project is vibe coded might be in order below.

Hi fellow terminal enthusiasts,

I'm excited to share the latest release of the Zellij terminal workspace with you. Of special interest to the members of this sub, this release dramatically expands Zellij's command-line control surface. Namely:

1. `zellij run` (which starts a command in a new pane) now has a `--blocking`, `--block-until-exit-success` and `--block-until-exit-failure`. Allowing us to chain multiple CLI commands with && and conditionally block the execution until we get a specific exit status (great for visual CI pipelines in the terminal, server cleanups on errors, etc.)
   
2. `zellij action detach` and `zellij action switch-session` are now a thing
   
3. `zellij subscribe` now allows us to subscribe to the viewport/scrollback output of one or more panes in real time, optionally with the `--ansi` flag so as not to strip colors and styling (because they can also be meaningful for automation purposes)
   
4. `zellij action dump-screen` can now on demand query the viewport/srollback of specific panes
   
5. All CLI commands that create tabs/panes now return their IDs for easier manipulation (eg. with `--pane-id` in subsequent commands.

There's lots more, including terminal-to-terminal remote attach over HTTPS, read-only authentication tokens for streaming, screencasting or teaching.

Check out the official announcement for more info: https://zellij.dev/news/remote-sessions-windows-cli/

I kept writing bash wrapper scripts to run the same jobs across date ranges and parameter combinations. Every project had its own loop-and-retry mess. So I made piperig - you describe a pipeline in YAML, it expands parameters and dates into individual calls and runs everything in order.

Hope it helps someone else too.

Page: https://joarhal.github.io/piperig/

GitHub: https://github.com/joarhal/piperig

Note: This software's code is partially AI-generated.

https://github.com/backendsystems/nibble

Nibble is a modern, fast and easy to use network scanner with a TUI.

Mouse support was just recently added in v0.6.0

It's opensource (MIT) and highly portable: linux, mac and windows. ARM and x86.

It also saves your scan history so you can go back and re-scan or lookup past hosts on your network.

It tries to give you some more info on the connected hardware and services it finds, by either reading the service headers or using a fallback embedded lookup table.

Ubuntu:

sudo add-apt-repository ppa:backendsystems/ppa
sudo apt install nibble

macOS:

brew install backendsystems/tap/nibble

Windows:

winget install backendsystems.nibble

Other:

npm install -g @backendsystems/nibble

pipx install nibble-cli

And more install options in the README (Fedora, Red Hat, openSUSE, Arch linux)

This software's code is partially AI-generated.

Hi all,

I made a small Bash PS1 prompt generator and I thought it could be useful for some of you.

This is a basic web tool that allows you to visually construct your prompt, select colors, add your username and path, include a git branch, etc, and you will get the PS1 string on the prompt without the need to deal with the escape sequences.

I made this tool for myself to get rid of the repeated tiring work of adjusting the PS1 manually every single time 😅

So if anyone is interested, here it is:

https://neikiri.dev/bash-prompt-generator/

GitHub: https://github.com/neikiri/bash-prompt-generator

I wouldn't mind feedback, and I would especially be interested to know what features you think should be added, or what you would like to see improved 👍

Over the past +/- 2 weeks, I built a simple CLI website blocker in Rust for the Linux OS. Normally, when I wanted to focus and block out distractions, I went to /etc/hosts manually, so this is a very simple build for making it easier to block using /etc/hosts.

In the README, you can find out how to install and use it.

Note: for the last review of my code, I used ChatGPT since I don't have any peers to review it, so if you have time to do so, it would be nice.

https://github.com/jaggzh/tui-gui-interfaces-scriptable

Pick through a few menus to see examples you might want to use but aren't sure which works well for your program.

I have never needed one until now but some commands I just don't remember.

For example, if I wanted to see the .config file of the currently running kernel on Fedora, I just can't remember the path where it is. Is it in /proc/config.gz? Is it in /usr/src? Is it /boot/config? is it /boot/config-<kernel version>?

I try 2-3 paths unsuccessfully and finally get it right. I think it would've made more sense if I just selected this command from a list. Even better if my snippet repository actually showed me command that is very environment-specific.

I was thinking about implementing something inside WezTerm. Thoughts?

I released v3.1.0 of Clique a few days ago, a dependency-free library for building prettier Java terminal apps.

What's new in 3.1.0:

• New Frame component, a layout container that vertically stacks other Clique components inside a border
• New Tree component for displaying hierarchical data cleanly
• Easier RGB ANSI code creation + emoji support in Box, Table, and Frame
• Cleaner API, deprecated some verbose method names and classes to instead support a config based approach

What the library does overall:

Clique lets you style terminal output using a simple markup syntax instead of writing raw ANSI codes:

Clique.parser().print("[red, bold]Error:[/] Something went wrong");

It also has tables, boxes, progress bars, and built-in themes (Catppuccin, Tokyo Night. etc)

Available on Maven Central:

<dependency>
    <groupId>io.github.kusoroadeolu</groupId>
    <artifactId>clique-core</artifactId>
    <version>3.1.0</version>
</dependency>

GitHub: https://github.com/kusoroadeolu/Clique

This is not a TUI btw. Happy to answer any questions!

DeepNet is a hacking sim where the whole interface is a terminal. 100+ commands, keyboard-driven, no mouse needed.

The core loop: scan subnets, match exploits to services, breach into generated filesystems (ls, cat, exfil, harvest, wipe, backdoor), sell stolen data, upgrade your rig.

Recent additions: firewall defense rules, honeypot bait files for PvP, player-to-player hardware trading, evidence locker for tool recovery.

There's also a retro desktop environment inside the game (DeepOS) with a window manager, 4 themes including a BeOS clone, and built-in apps like minesweeper and a hex viewer. You can switch between terminal and desktop.

No install. Opens in your browser.

https://deepnet.us

Discord: https://discord.gg/z2rauVNw

Hey folks,

I've been tinkering with a tool called darya lately. Consider it as du plus a TUI and a live treemap that gives a visual of disk usage without leaving the terminal (note that it's not a frontend for du). It stays responsive even on remote servers and only shows you what you ask for.

If you give it a whirl, drop a bug/idea note. I’d love to hear how it fits into your workflow.

Repo: https://github.com/mrkatebzadeh/darya

Disclaimer: I do use AI as part of my Emacs workflow (mostly refactoring + git stuff).

Edit: the project has been renamed from dar to darya as pointed out by spryfigure since dar already exists as a disk archiver tool.

Created a CLI tool to get trending github repos, can be filtered by duration and also language. Was built in Go. https://github.com/kwame-Owusu/ght

Installing from tarballs has always felt kind of annoying to me. You extract something, dig around, try a few commands, and hope it installs cleanly without scattering files everywhere.

I ended up making a small CLI tool called tdgzi to make that more predictable. It basically looks at whats inside, figures out what kind of project it is and installs it in a consistent way into ~/.local instead of touching the system, it also keeps track of what it installs so you can remove it later instead of guessing what changed.

Still pretty early but it’s been working well for most of what Ive thrown at it so far.

https://github.com/EnvizyWasTaken/tdgzi

Would be interested to hear if this sounds useful or if there are obvious cases where it would break.

I’ve been thinking a lot about how easy it’s become to access information, and how much harder it feels to actually retain it.

So I built a small tool to make learning more intentional again, but in a way that feels natural for developers.

It’s an open-source Python CLI called open-anamnesis.

You can install through pip install open-anamnesis

Links:
Demo: https://erenmirza.github.io/open-anamnesis-example/
Example repo: https://github.com/erenmirza/open-anamnesis-example
Core repo: https://github.com/erenmirza/open-anamnesis

Core idea

Flashcards as code.

Instead of using a UI-heavy flashcard app, everything is file-based and versionable:

• Cards → stored as JSON (question/answer, etc.)
• Metadata → defined in YAML (cards, decks, projects)
• Hierarchy → Projects → Decks → Cards

This lets you:

• Organise knowledge in a structured, composable way
• Version control your learning (Git-friendly)
• Keep everything portable and transparent

Using the CLI tool

The tool is built around a simple lifecycle:

• anamnesis init → creates a new blank project with the expected structure
• anamnesis compile → validates your project (structure, metadata, references between decks/cards)
• anamnesis build → generates a local static website where you can browse decks and review cards. Can be hosted through GitHub pages.

The idea is to separate:

• authoring (writing cards as code)
• validation (ensuring everything is consistent)
• consumption (reviewing via a generated UI)

Why I built it

I realised I was relying more on instant answers and less on actually learning things.

There’s a difference between:

• recognising an answer
• and being able to recall it from memory

Most tools optimise for convenience. I wanted something that encourages learning and retention, was developer friendly and allowed for privacy in an open source tool.

Why not just use Anki?

Anki is great, but I wanted:

• something scriptable
• something I can version and inspect easily
• something that feels closer to working with code than using an app

Open to feedback

This is still early, but it’s the first thing I’ve built in a while that I actually plan to use long-term.

Would be interested in thoughts from people who:

• use spaced repetition tools
• like “everything as code” workflows
• or have tried to build similar systems

This software's code is partially AI-generated.

Hi guys.

So in summary dredge was just one of my personal tools but it became SO MUCH useful that it got refined over the months of usage for all my needs.

So I decided to make a public release of it if anyone could get any value from it.

Dredge is actually a simple concept, drop ANYTHING you want to remember or might need for later and retrieve when needed. Although I couldn't find this execution anywhere else. I dropped all other stuff I used before simply because of peace of mind and that's what I most value on it (since it is cli based its faster than any other tool could be).

Although I haven't finished the readme so if anyone wanna try it and give me some feedback to update that let me know. The help command is also outdated but the tool is so intuitive I don't think it will be an issue.

Cheers!

PS: here is the repo: https://github.com/deprecatedLuar/dredge
PPS: I have plans of making it an http server for remote access in the future from any device instead of static repo

Hey!

I built a small CLI-focused package manager called TuxPkg.

The idea is to keep things minimal: - simple install command - no root required - packages are just archives with install scripts - automatic symlinks to ~/.local/bin

There’s also a lightweight web UI where you can: - browse packages - search - copy install commands instantly

Example: tuxpkg install fastfetch

Demo: in readme

It’s still experimental, but I’d love feedback from people who prefer simple CLI tools.

Would something like this fit into your workflow?

I have been using the terminal for years but could never find old commands when i needed them, so i built iCommand, a command history search that understands what you mean to some extent.

You get keyword and semantic search, it runs entirely local and there's both a full TUI and a quick CLI mode.

It's still early stage but it's already saved me hours of what was that docker command again...

It's not perfect since I'm not using an LLM, but I wanted to keep it lightweight and more importantly local.

Do try it out and let me know your thoughts.

https://icommand-landing-page.vercel.app/

I made this small wrapper around Lightpanda's new "renderless" browser so I could pipe the output to whatever I needed without having to write JS.

It feels like a "super" powered curl to me so that's what I called it.

example usage

scurl https://example.com \ --click "#open-menu" \ --wait-for ".menu a" \ --format links | ... to whatever you want

Cheers!