Hi,
I often code right before leaving the comfort of my house to venture into the city, and was frustrated that I had to tackle multiple rounds of auth hurdles (unlock phone -> auth app -> find my bus on the map/UI) to check the departure of my bus next to my house. For easing the pain I built GoKK, which works in Budapest where I live and I use daily. Install tool, save an alias, and I can get the next departure in a second every time. But that would only be useful for Budapest residents, so I spent some tokens on making a similar versions for most major cities+countries that have free APIs with needed info. This extended project is https://github.com/bancsdan/eta
Feedback is always welcome.

I made edamame, a terminal Markdown editor. GitHub: https://github.com/mijowi/edamame

Here's why it stands out:

• Rendered editing: No split screen edit/preview - the line the cursor is on shows raw Markdown while the rest of the document is formatted
• Mouse support and inline image display
• Mermaid diagrams and LaTeX math rendered as images (pure Rust, no extra install)
• First class tables: Rendered with borders and auto-sized columns, one-key add/move/delete rows and columns
• Diff mode: Use it as a git difftool or review changes made externally, e.g. by an agent
• Command palette makes everything easily accessible
• Syntax highlighting, HTML export, 27 built-in themes, Vim mode

It works best in modern terminals like foot, Ghostty, iTerm2, kitty, and WezTerm. Some features, like image display, are not supported in other terminals. edamame's code is partially AI-generated.

so i've been working on a terminal ui library in go and i keep making little games with it to test stuff. this one kind of got out of hand

it's basically snake but every 5 lemons a monster shows up and starts chasing you. each lemon gives you 2 seeds and you spit them at it with space. if it touches your body it just bites the rest of you off which is honestly the most annoying thing ever

funniest part was tuning the difficulty. i wrote a bot with "average human" reaction times to see how far people would get and it kept dying on walls, so now you get like half a step of grace if you turn a bit late lol

oh and if you fill the whole board you win, like real snake

you can play it in the browser here: https://thebanri.github.io/limoni/?app=lemonsnake

(or go install github.com/thebanri/limoni/apps/lemonsnake@latest if you want it in your terminal)

there's a leaderboard, my best is level 11. beat it pls

press T for themes btw, there's 5

Code is here if anyone's curious: https://github.com/thebanri/limoni

Lite Engine is a raycasting game engine designed for FPS games.

I was inspired by Wolfenstein 3D and its raycasting engine. I decided to create my own engine with a similar approach, but instead of rendering pixels normally, it renders the entire game directly in the Windows console, using the █ character as a pixel.

Development started around 5 months ago. The current version (Lite Engine 0.1.8.1), supports simple geometry and different types of entities, including enemies, medkits, ammo, collectibles, and more.

Version-0.1.8.0 added support for custom asset archives (.LED). These archives can store map files, ASCII sprites, and definitions for entities and weapons. You can create and edit them using Lade, my LED editor.

Lite Engine website: https://liteengine.pinwinsoftware.com

Download Lite Engine: https://liteengine.pinwinsoftware.com/downloads

Download Lade: https://liteengine.pinwinsoftware.com/sdk/Lade

I've always loved the idea of JIT-compiled UIs. TempleOS is a fascinating example, using JIT-compiled C to build its UI.

Recently, I've been working on a TUI project where almost everything is customizable at runtime, from the UI itself to the core functionality. I wanted a way to build terminal UIs declaratively, similar to SwiftUI, while keeping the flexibility of runtime customization.

So I built Ito a Lua library for writing JIT-compiled TUIs.

To make it easy to experiment with, we also built a fake TUI canvas in the browser where you can try out Ito live. Give it a try!

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.

It started as a weekend joke and got out of hand.

pikap picks up whatever's playing (Spotify, a browser tab, mpv) and puts the cover on a spinning record. In the video it grabbed a YouTube tab, so Linus is on the vinyl. Not planned, but I'm keeping it.

You can drag the record to scrub, or drop the needle wherever you want. If you give it your own files, pausing actually slows the sound down and dragging scratches it.

It can draw in half blocks, in ASCII, or as a real picture if your terminal supports it. Written in Go.

Repo : https://github.com/thebanri/limoni/tree/main/apps/pikap

TUI Framework Repo : https://github.com/thebanri/limoni/

Maze Ways is a maze game. You play as a yellow cube, navigating through 10 simple square mazes. Each maze is made of the ASCII characters, and has an exit on the right side of the maze.

You can try this game out here: https://pinwinsoftware.com/Game/3/Maze_Ways

I wrote a Go Program called tardigrade (https://github.com/smoothyy3/tardigrade) that grows a creature from a single cell inside your terminal. It is a Neural Cellular Automaton. Every cell runs the same learned 24k parameters rule on its neighborhood, and the only ever stable shape the rule has is the creature itself. So when you damage it, it grows back.

It is meant to be a fun tool, an introduciton to NCAs/ CAs or simply a screensaver.

Currently, there are 4 creatures (jellyfish, gecko, tardigrade, mouse), but the repo lets you train your own from a PNG.

It ships as a single binary with the weights inside, no image file present (brew install --cask smoothyy3/tap/tardigrade or go install

The technique originates from Mordvintsev et al. (https://distill.pub/2020/growing-ca/). Everything else is in the README.

I hope that I phrased it properly. I'm using yt-dlp command-line utility to download videos from YouTube. I have a simple .bat file to start it all in a proper directory, so I could fire commands quickly:

start
cd C:\Users\Username\youtube-dl

Now I want to start it with a prefilled bit of text "yt-dlp", since every command begins with that bit anyway. How do I achieve this?

For about 11 years, I’ve been working on TXTLock—a free, console-based diary and note manager for Linux—and I’ve just released version 1.90.

I built TXTLock because I wanted a private, lightweight place to keep my notes, reminders, and journal entries without relying on cloud services or heavy GUI applications. Everything lives in a single encrypted file, and you work with it entirely from the terminal.

Key Features:

• 🔒 Security: Dual-layer protection (password + PIN) with native AES-256 encryption.
• 📝 Create & Modify: Write and edit entries (txtblocks) in your favorite text editor, such as nano or Sublime.
• 🗂️ Organized Your Way: Use named txtblocks, folders, and subfolders with unlimited entries in a single TXTLock file.
• ⏰ Reminders: Set reminders for specific dates so you never forget what matters.
• 🔎 Search & Find: Quickly search and locate past entries with ease.
• ⚡ Fast Access: Jump straight to any txtblock by name or set up aliases for quick navigation.
• 🧰 150+ Commands: Built-in tools and shortcuts make it much more than just a diary.
• 🐧 Linux (32/64-bit): Native console application compiled using Free Pascal.

Software License & Download:

• License: Freeware / Proprietary (Not Open Source). It is 100% free to download and use, though the source code is closed.
• Website & Download: You can learn more and grab the release at txtlock.co.uk.

I’d love to hear your feedback, feature ideas, or bug reports!

I'm happy to answer any questions about the project or its development in the comments.

Dripfetch is a customizable terminal dashboard with animated rain, system info, clocks, and YAML themes. It just passed 50 stars on the github and already got its first few issues and pull requests! it is totally customizable so it is quite easy to match everything to your own setup/rice. this was a passion project and through the creation of it I learnt a lot about design patterns and how to deploy a project through and through. AI was used for the roadmap creation and concept explenation. Went through numerous frameworks such as textual and curses to find the desired angle for this project. I’d love to hear what you think or what you’d improve!

I live in the terminal, but every time I had a nasty rebase or a conflict, I'd open a GUI. So I forked serie, a Rust project which draws the commit graph as real images in the terminal. Then I kept adding what I was missing until I stopped leaving.

It's called gitoui. Say "oui" to it, tell me what's missing, or build it with me !

What it does:

- The commit graph drawn as images (Kitty graphics, iTerm2 or Sixel), with a text fallback for other terminals

- Interactive rebase as a list you edit in place: move commits, reword, squash, fixup, drop

- A 3-way conflict editor: ours, theirs or both, per hunk

- Diffs with hunk staging, blame, file history

- GitHub pull requests and issues: read, comment, approve or request changes, merge

- And many more things you have to discover by using it 👀

Similar tools: lazygit, gitui and tig in the terminal, serie (the graph viewer I forked), and GitKraken on the GUI side (no affiliation). What's different in gitoui: the graph is drawn as images rather than text characters, and the GitHub side lives inside the TUI.

This software's code is partially AI-generated. I've been building it since May and I use it every day.

Repo: https://github.com/NayJi7/gitoui (MIT, Rust, Ratatui)

Website : https://nayji7.github.io/gitoui/ (documentation & informations)

One last question: what's the one git task that still sends you back to a GUI?

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 made a terminal toy. It fills your screen with a grid of hex tokens that never move, and only the colors change: a curl-noise fluid field pushes blobs of red through the grid, and token pairs randomly flicker to new values like a live memory dump.

It listens to system audio through PipeWire (bass/mid/treble via simple IIR filters, no FFT) and feeds that into the same fluid sim, so the music disturbs the liquid rather than driving an equalizer.

• 9 accent colors (keys 1-9), 3 visualizer modes, adjustable fluid/flicker speed
• pure C + ncurses, PipeWire optional
• one-line install, no root

Repo: https://github.com/atif-1402/hextrix

It's v1.0 so expect rough edges, especially the audio path on odd sample rates. CPU use is around 14% of a core at 60 FPS on a 200x50 terminal, so I'd run it at 30 if you're on weak hardware (-f 30). Feedback and bug reports welcome.

The game has 3 levels and 3 enemy types.

You can try this game out here: https://pinwinsoftware.com/Game/2/Streit

This is a personal use project that aimed at playing a m3u and moving m3u entries around in a collection of m3us as you are listening to each track. This is especially helpful if you mass import a large amount of audio files to a testing m3u, go through each of them and sort them into your "production" playlists. Of course, playlists are not set in stone, and your "production" playlists needs correction from time to time, which this also help.

This workflow straddles fzf for the management actions, qmmp for playing, tmux for pane splitting. The rest are mostly pure bash or poxis tools.

Support windows-style file paths, tested on linux. Trashing folder for audio file removal, persistently logged and undo-able. Will support windows and playing from ssh file mount in the future.

Github link: https://github.com/dtinhvo/PLM

AI assistance disclaimer: I dont deal with terminal color codes, I just look at them and see that they are correct. Mostly syntax help in terms of abstracting logic, poxis flags and escape sequence nightmares

Hi r/commandline,

I built FOSSWire (https://fosswire.org) as a keyboard-driven, terminal-style web feed reader focused on Linux, kernel releases, and open hardware.

Key Aspects:

- Vim Navigation: Full keyboard navigation without touching the mouse:

* j / k (or arrow keys) to navigate between articles

* Enter or o to open the selected article

* g / G to jump to top / bottom

* / to trigger instant live search

* t to toggle dark/light theme

* ? to open the interactive keybinding cheatsheet

- Typography & UI: Minimalist TUI look powered by the JetBrains Mono font across the entire interface.

- Privacy & Zero Tracking: No third-party ad networks, no analytics trackers, and no commercial tracking cookies.

- Public Telemetry: Real-time Cloudflare Edge metrics and request logs are publicly available at https://fosswire.org/open-data

Links:

Live Reader: https://fosswire.org

Open Data Dashboard: https://fosswire.org/open-data

GitHub Repository: https://github.com/ozdil/fosswire

Feedback on keyboard ergonomics, feed selection, or keybinding suggestions is welcome.

Hello!!!!!

I've been building ranma, a tiling window manager that runs inside your terminal. Every window is a PTY, laid out with i3's container tree and Hyprland's dwindle placement. It's my daily driver now, and I'm looking for people to try it and break it (please).

What it does - dwindle tiling, tabbed groups, a floating layer and a scratchpad - workspaces and sessions with fuzzy switchers - a leader key plus a modal WM mode; leader ? lists every key, leader : runs any action by name - runs as a server: closing the terminal or losing SSH only detaches, and ranma again picks up where you were - copy mode and history search, copying to your system clipboard (OSC 52, works over SSH) - a waybar-style bar with Lua and shell modules; config in Lua, themes in TOML, live reload

What's different from tmux and zellij: it's extended like Neovim. Plugins are plain Lua using the same API as your config, they get screens built from ready-made blocks, and a plugin that errors is dropped whole while the rest keep running. A watchdog stops one that hangs. There's a plugin manager too, hako, shaped like lazy.nvim, plus a few plugins: regex history search, writing a prompt in $EDITOR and having it pasted into the pane (handy for AI CLIs), and Ctrl+click to open paths.

This software's code is partially AI-generated, as the rules require :B Thank you for reading till here!!

https://github.com/masshirodev/ranma

wbsh: a minimal bash-compatible shell for Windows (plus a terminal built around it)

Hey all. For a while now I've been working on a shell that lets me run bash commands and scripts natively on Windows. I actually need this at my job, which is what kept me going.

Think of it as a minimalistic take on Cygwin. Full Cygwin was overkill for my use case, so I built something smaller and more focused.

Along the way I also wrote a customizable terminal, wbshterm, which runs wbsh through ConPTY. So you can either invoke wbsh directly from PowerShell/cmd, or use it inside wbshterm.

It's reasonably stable at this point, but I've hit the limit of what I can find on my own. I need other people's workloads to shake out bugs and performance bottlenecks.

If you have any use case for a bash-compatible shell on Windows, I'd really appreciate issue reports, and pull requests are welcome too. LLM-assisted PRs are fine, but please read the docs first and review the changes thoroughly before opening one.

i found out that docker output is really a mess so i added support of docker in my parse

Inspect shows a short summary instead of 300 lines of JSON, masks secrets, and warns on things like OOMKilled or a missing bind mount. Anything it doesn't recognize passes through unchanged.

You can install the latest release by -

go install github.com/atif-1402/parse@latest

or

yay -S parse

Would love to hear feedback on this : https://github.com/atif-1402/parse

fancy gui like terminal file manager for linux 💀

install it via:

repo:curl -fsSL https://raw.githubusercontent.com/clarkarch/tfm-tui/main/install.sh | bash

repo: https://github.com/clarkarch/tfm-tui

note: I used agents to help me make this project, take it or leave it

Hello guys, I did a small chess TUI for analyzing games, largely inspired by common analyses UX.

This is not entirely new, most gain here is convenience. It is made solely for analysis. You can start an analysis from a FEN string, PGN file, PGN text from your clipboard, public link from chess.com or lichess.org, browsing your user (or any public user), and even configure to open in your last game so you can leave the and instantly open with "chess-analyzer -f"

The pieces graphics design were extracted (and openly credited) from chess-tui, which is a very nice tui too if your main idea is playing from terminal. However, this one is totally dedicated in analysing games, testing variations against the engine scoring, branching different possibilities and seeing where you blundered (which in my case is like every fucking move).

Check it out https://github.com/leolaurindo/chess-analyzer-tui

Hi r/commandline,

I've been working on Merman, a Rust implementation of Mermaid, and just released v0.8.0. Thought its CLI might be useful to some people here.

It renders Mermaid diagrams without Node.js or Chromium. The goal is to get the same output as official Mermaid: we generate reference SVGs with the official CLI (mmdc) and compare our output against them automatically. Font and browser text measurement can still cause differences.

Zed uses Merman for Mermaid rendering. Other people have been using it in blog generators, Markdown viewers/editors, and CI documentation builds. Their bug reports have helped improve it over the past few releases.

You can install it with:

brew install merman-cli

Or on Windows:

scoop install main/merman-cli

Then:

merman-cli render diagram.mmd
merman-cli render diagram.mmd --format png
merman-cli render diagram.mmd --format unicode --output -
merman-cli batch README.md

It also exports JPEG/PDF and has linting. If you already use mmdc, there's a compatibility command:

merman-cli mmdc -i diagram.mmd -o diagram.svg

The official mmdc and native tools like mmdr are alternatives. My focus with Merman has been matching upstream Mermaid output and fixing compatibility issues as people run into them.

Full disclosure: much of the implementation was bootstrapped with AI coding tools. My work has focused on upstream comparisons, regression tests, reviewing and fixing the implementation, and following up on user reports.

https://github.com/Latias94/merman

If you try it and a diagram breaks or looks different from official Mermaid, I'd appreciate an issue with the source. That's been one of the most useful ways to improve it.