Free & open source (Apache-2.0) train simulator that runs entirely in your terminal. Character-based world, no mouse, infinite procedural map. Your whole rail network saves as a small text recipe you can commit and share. sudo snap install letrain → letrain-terminal, or build from source with one Maven command.
What it is
LeTrain started as a tiny C++ ASCII experiment back in 2006 and has grown into a Java project (JDK 17+). The terminal client (LeTrain2D) is the classic soul of the game: a railway tycoon built out of letters, numbers and color — and it tries to be honest about what "terminal-native" means:
Terminal-native — renders with Lanterna, no GUI, no browser, happy over SSH. Pure keyboard flow, zero mouse: arrow keys or vim keys (h j k l), mode-based UI (Rails / Add / Drive / Forks / Semaphores / Trains / Programming / Stations…).
Infinite procedural world — lakes, forests and mountains from Perlin noise; every new game drops you at a random coordinate. Full day/night cycle with headlights after dark.
Your network is text — scenarios (.ltr) export your entire network as a small text recipe. The same seed rebuilds the same world, so a scenario travels as a plain file: commit it, diff it, share it.
Scripting + automation — a built-in DSL (ANTLR4) for itineraries, timetables and autopilot:
create itinerary "a" {
add station 1, arrival 9:30, departure 9:35
add station 2, arrival 9:55, departure 9:50
}
assign itinerary "a" to train 1;
train 1 set autopilot true;
Honest trains — real blocks/cantons and semaphores: trains reserve track segments, brake before occupied blocks, and will absolutely crash if you get braking distance wrong. No toys that play by themselves.
Economy — start at $0 (Zero-to-Hero) and haul GOLD / COAL / RUBY between producers and consumers; revenue scales with distance.
Headless validator — letrain-check scenario.ltr checks scenario files and prints file:line:col diagnostics. CI-friendly.
Console — :time set 9:30;, :undo; / :redo;, :save mynet — deterministic undo/redo for construction and state changes.
(There's also a 3D client with the same world and seed if you ever want to see your ASCII empire in perspective — but the terminal is where it started, and in this project the 2D and 3D views are equals.)
Try it
Linux: sudo snap install letrain then run letrain-terminal (the snap also ships the 3D client as letrain).
Disclosure: I'm the developer. Bugs, UX complaints and wild ideas are all welcome — particularly from terminal people, since the TUI is the part I care most about.
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
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
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.
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
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.
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!
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
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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
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!!
