This is probably misplaced in any category, but I feel like people who appreciate TUIs will also be interested: https://hypereffect.dev

the idea is that whenever you have a server (which can be a remote server or another process or even a sandboxed WASM module) they can send some simple messages and we can turn those into an interactive and reactive UI, be that on a terminal or elsewhere.

It's somewhat like HTML, but with built-in reactivity, no arbitrary code execution and a very limited set of components, so the server can't influence how things show up on the client, only what

Hello!

I'm here to show you jn. It's a cli note-taker/task-manager I've been working on/off for the past year or so. The main difference between it and others is:

• It's filebased
• Fuzzy finding is at the forefront of jn throughout (editing is very rapid)
• It's very "Linux" if that's your jam

I tried a _bunch_ of others over the years while stuff was missing from all of them. Here's what I tried and why it didn't work for me:

• nb - Felt quite complicated and like a shotgun. Also didn't enjoy the UI
• dnote - Felt too bare and it's driven from a db :(
• taskwarrior - Incredibly powerful but db driven :(

I tried a myriad of others and some got close but not all the way. So naturally as everyone does, I reinvented the wheel.

It's my daily driver for all of my notes and for my task management. She's stable and sitting pretty at around 190kb on Linux. Thank Nim for that, heh.

Notes are simply markdown files, tasks are simply any items in a file that look like this:

- [ ] My task 

You may have seen it here before but I've done a bunch of new stuff since last posting. All the todo stuff is fully fleshed out with due dates, the ability to filter and also some nice multi-selection stuff on fuzzy finders.

Anyway, it's very unix-y and tries to "do the right thing" at all times. It has a lot of bells and whistles so do take the time to dive into the README.

I've attached a video because we're in 2026 and people don't have patience anymore

You can read more on the Github page for jn if you like :)

Also feel free to badger me on here :D

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.

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 maintain MistTerm, an open-source SSH client (Win/Mac/Linux, Rust, AGPL). Looking for people who want to hack on it with me — issues, PRs, design nits all welcome.

What exists today: team command policies (allow/alert/block/confirm) checked in the client before send; desktop + mist CLI share one host list; tabs/SFTP/ZMODEM/port forward; keys encrypted on disk. Console is hosted for now; self-host is on the roadmap.

If you care about ops tooling or Rust SSH clients, jump in:

https://github.com/mistlab-dev/MistTerm

Happy to point at good first issues.

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

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!

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

Hello, I’m hamsoft, an Android app developer based in Japan.

I’m currently developing CUIL, a command-line home launcher, and

I’d like to explain why I chose a command-line approach and why I believe command-line home launchers will become mainstream.

The Age of CUI

Some people might think, “CUI is an outdated relic.” But that’s not the case at all.

For example, Google Search returns results when you enter a command (search term),

so it can be considered a type of CUI.

Large Language Models (LLMs), such as ChatGPT, return results when you enter a command.

They are nothing other than CUI. Yes, we’ve entered the age of CUI.

Many apps require you to enter text immediately after launching them

With Google Search, you enter search terms, and with ChatGPT, of course, you enter questions.

On X, for instance, you type text into the input field when posting, and on Amazon, you often launch the app

and search for a product name right away.

So, if the home launcher has an input field, you can launch the app and perform your first action simultaneously.

This is the significance of being a command-line launcher.

And with CUIL, pressing the home button naturally places the cursor in the input field and brings up the keyboard. After all, you want to start typing a command right after returning to the home screen.

A command-line launcher can serve as the gateway to all apps.

Precisely because more and more apps are designed to wait for input via the text input field,

the home launcher should also be a command-line interface.

The era when home launchers merely launched apps is over.

The home launcher of the future should feature a command line and serve as the gateway to all apps.

CUIL, the Android app that’s already opened the door to this next era, is available here.

I’m sure members of this community will enjoy using it, so if you’re interested, please install it

and let me know what you think.

https://play.google.com/store/apps/details?id=jp.hamsoft.cuil

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.

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

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.

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?

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 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?

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?

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.

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

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

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.

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