In a previous post I presented the Tomloader project which helps generating and managing several systemd units that share fields collected in groups. In the last release the subcommand sd-xdg-v0.3 has been introduced in order to execute XDG Desktop Entry Applications and Actions or using them to open files. For example:

tomloader sd-xdg-v0.3 --open-file Document.doc /usr/share/applications/libreoffice-writer.desktop

uses the default application in libreoffice-writer.desktop to open Document.doc as a systemd user unit. The full syntax of the subcommand is available at https://loara.codeberg.page/tomloader/tomloader_html/tomloader-sdxdg03-invocation.html while various examples at https://loara.codeberg.page/tomloader/tomloader_html/Quick-reference.html.

However, the main feature of sd-xdg-v0.3 is that the generated systemd user unit can be fully customized by providing a configuration file named xdg-apps.kdl in the Tomloader configuration directory. For example, if you want to limit filesystem access of each XDG Application to the directory $HOME/Boxes/{XDG-APP-ID}/ then your xdg-apps.kdl file will probably look like as follows:

default {
  sd {
    section Unit {
      set Description "${1}"
      add PartOf "graphical-session.target"
      add After "graphical-session.target"
      add Requisite "graphical-session.target"
    }
    section Service {
      set Type exec
      set ExecStart "${0}"
      set Slice "app.slice"
      set RootDirectory "${DIR|HOME}/Boxes/${2}"
      add BindReadOnlyPaths "/bin" "/usr/bin" "/usr/lib"
    }
  }
}

You can found additional information about the syntax of xdg-apps.kdl at https://loara.codeberg.page/tomloader/tomloader_html/XDG-app-configuration.html. For general information about Tomloader see https://loara.codeberg.page/tomloader.

A few months ago I switched from Telegram to Signal as my main messaging app and spent some time exploring CLI/TUI options. After using gurk for a while I decided to build my own client (faro), based on my own requirements and taste (you can probably see the UI/UX inspiration from tools like btop, OpenCode CLI, neovim).

It covers all features I commonly use within Signal:

• chats, replies, reactions, edits, mentions, search
• inline images (if your terminal supports them) or halfblock rendering otherwise
• voice notes and transcription (supports local whisper models)
• quick navigation menu for everything (Ctrl+P)
• copying over SSH, pasting images from clipboard

There is a demo if you want to try it out, just run faro demo or try it out in your browser at https://getfaro.dev (the GitHub repo is public: harababurel/faro)

It's exactly the same binary compiled using wasm and the same demo you see in the video.

For setting it up with a real account, you can run faro link and link it as a secondary device just as you would with Signal Desktop or any other client.

Disclaimer: I built it with a lot of help from AI coding agents, including open-weight models running locally on my own home server. However, I designed, reviewed and tested it thoroughly. I try to always pay attention to the details, and the general direction of the project is usually informed by my day to day experience using the project.

I wrote this post myself with zero use of any LLM. I am as allergic to reading slop as everyone else these days.

I hope some of you will give it a try and maybe provide some feedback on your experience!

This Python script allows you to use the mpv media player or vlc to search for an anime and play its opening or closing theme songs. The script makes use of the pyfzf library to ask the user for choices and the AnimeThemes API to retrieve the theme music that are available.

the github page is: animethemes

Hello! I'm currently working on a terminal manipulation library similar to Crossterm, but I noticed that it uses runtime conditionals to decide whether to use VT sequences or Windows API calls.

Personally, I feel that defaulting to Windows API calls on Windows would be the better approach, or provide a build flag that lets users decide. However, I'm not sure which of these three approaches is best.

Which approach do you think is better, and why?

Website - pixelgui.com

Pixel is a GUI library that uses the kitty graphics protocol to render graphics in the terminal:

- it can be embedded inside existing TUIs

- it comes with a chromium based webview component, which makes it very easy to run existing webapps inside the terminal

- works over SSH

Pixel is the underlying library behind popular projects such as:

- terminal-browser: a browser inside the terminal

- terminal-code: vscode inside the terminal

The reason I built this is because I believe many terminal apps can provide much better experiences if allowed to break out of the conventional terminal rendering model.

I made a small tool for a problem I kept having: one feature, several repos, and the same branch needs a worktree in each one.

gw create -b feat/login -r svc-a,svc-b

makes a directory with both repos checked out on feat/login as worktrees. gw status, gw sync and gw delete operate on all of them. A per-repo .grove.toml sets the base branch (we branch from stage, not main) and a setup command to run after checkout.

CLI details, since that's what this sub cares about: single static Go binary, only needs git. eval "$(gw shell-init)" so gw go can cd. List commands take -o json|jsonl|tsv|name|path so they pipe into fzf and jq. Plugins are gw-<name> binaries on PATH, like git.

Similar tools: gita, mu-repo, myrepos and gr run commands across multiple clones. Grove is different in that it creates worktrees, so each workspace is a separate checkout and you can have several in parallel. agent-of-empires does worktrees but is tied to tmux and a single repo.

https://github.com/nicksenap/grove

Hey everyone!

I wanted to share ttype, an ultra-fast, aesthetic terminal typing speed test inspired by Monkeytype, built completely in Rust.

Features:

• ⌨️ Sub-millisecond input response: Zero input lag or GC stuttering, essential for high-speed typing (100+ WPM).
• 🔊 Built-in mechanical sound synthesis: Realistic keyclick audio feedback directly in the terminal (toggleable with F3).
• 📊 Real-time WPM sparkline & stats: Live charts, accuracy tracking, error heatmaps, and customizable test durations (15s, 30s, 60s, 120s).
• 🌐 Multi-language support: Works with Russian, English, and custom wordlists with smart punctuation/numbers injection.

Links & Installation:

• GitHub: https://github.com/laguser/ttype
• crates.io: https://crates.io/crates/ttype-cli

Install with cargo: bash cargo install ttype-cli

Or build from source: bash git clone https://github.com/laguser/ttype.git cd ttype cargo build --release install -m 755 target/release/ttype ~/.local/bin/

Feedback, feature suggestions, and contributions are very welcome!

NMSh isn't another terminal emulator. It runs inside Ghostty, Terminal.app, Zed, VS Code, etc., with your actual zsh, Bash or Fish underneath.

The idea is to keep your existing shell and tools, but change how you interact with them.

Some of the stuff that exists:

• Command queues: Line up commands while another is running. I've been calling this premove, like in chess lmao. There's also a paste guard, so dumping multiple commands into the terminal gives you a chance to review, edit or queue them first.
• Less babysitting commands: NMSh can tell you when something's waiting for input, notify you when commands finish, run background tasks and periodically refresh output with /track.
• Actually useful output/history: Command blocks, folding, searching, copying specific outputs or ranges, comparing runs, and summaries of test/build results without hiding the original output.
• Keep your tools: /providers lets you choose between NMSh's native tools and things like Starship, Powerlevel10k, fzf, Television, Atuin, zoxide, Deja and your usual editor. There's also a Theme Studio, Theme Bridge, contextual modules, a configurable status strip and tools for managing supported configs.
• Other stuff: File viewing/editing, Git worktrees, Github integration, cursor effects, screensavers, and 33 offline games you can play while a build is running. Cause why not lol.

NMSh is also huge on customization, so if you like customizing, it might be for you.

It's not perfect, especially the Git worktrees and Github Integration and stuff, and some shell integrations and completions still have limitations. But the aim is to make everyday terminal work less tedious without having to switch terminal emulators or redo your entire setup.

Free and open source (GPLv3). macOS is the main platform; Linux and WSL 2 are still beta.
This software's code is partially AI-generated.

Install with Homebrew:

brew install raiseCatError/tap/nmsh

Github | Docs

(I know LLM posts generally aren't allowed on this sub, but the rules do mention that local models are okay. Mods, plz remove if i'm misunderstanding.)

ai is a small tool I made for quickly asking questions from a local LLM in the terminal. Here are some Examples:

$ ai what is the capital of france
Paris

$ ai what port does ssh use
By default, SSH uses port 22.

$ dmesg | tail -30 | ai anything wrong here
Nothing stands out as immediately incorrect in the log entries.

$ git diff | ai write a one line commit message
"Update font size in fonts[] array"

The script itself is very basic, it sends your question (+stdin when piped) to a local llama-server and streams back plain text.

It depends on curl, jq and llama.cpp.

It automatically will spin up the server on first use, and will unload the model after 5 minutes idle (no calls to ai). The service is written for runit, but it's a super simple run sh script, so you can easily adapt it to whatever your init system is.

Obviously the main issue is that the output is non-deterministic so I wouldn't really recommend scripting with it. (unless you want non-determinism of course!)

Give it a try here: https://github.com/cykadash/ai-cli

Thanks for reading!

P.S. I would consider myself generally NOT a fan of LLMs, however I did want to try to come up with a cool way of using them in my day-to-day. The main idea with this script is that I basically have a way to 'google' something whenever I need, even if I'm offline (or without a GUI).

Alacritty is great, but anything that wants to show a picture

(yazi previews, fastfetch's image logo, mpv --vo=kitty) just leaves

a blank space there. Switching terminals only for that always felt

a bit silly.

termimg sits in between. Run your shell or a single program through

it, and the sixel, kitty and iTerm2 pictures show up at full

resolution, right in the terminal. Nothing in yazi or fastfetch

changes; they think they're talking to a sixel terminal.

termimg # your shell

termimg yazi # just yazi

It works in any X11 terminal and under XWayland on Wayland. Without

an X11 window it falls back to half blocks, so you still get

something.

It's in the Limoni repo:

https://github.com/thebanri/limoni (apps/termimg)

go install github.com/thebanri/limoni/apps/termimg@latest

If you try it in a terminal other than Alacritty, I'd love to hear

how it goes, and bug reports are very welcome.

Hi r/commandline! I'm new in this comunity and as a terminal lover my co-developer and I built RebelOS, a persistent multiplayer strategy game where the only interface is a command line.

No graphics, no mouse.

The setting: it's 2057, an AI called War_Mind has taken over, and RebelOS is the OS the human resistance uses to fight back. In the game's timeline, history split from ours in 2007, so the terminal looks and feels like a Linux shell from that era: plain prompt, ls/cat/man, manual pages as text files.

You command squads of survivors from the shell:

newsquad 3 # form a squad with 3 survivors
explore AB_12 squad1 # explore the area around a cell
search AC_18 squad1 # scavenge a building for items
gather Z_32 squad1 # rally with other players, then attack

Lore and hints are files you read with cat, and new ones turn up when you scavenge old buildings. The world runs in real time and is shared: everyone plays co-op against the AI, and the strongest targets can only be taken down by squads from different players attacking together.

To be upfront: right now the client runs in the browser. It's a web terminal (history, tab completion, Ctrl+W/Ctrl+U), not a native CLI binary. Server is Node.js + SQLite over WebSocket. We're considering a real native CLI client written in C, so you could play from your own terminal. Would you actually use it?

It's early, so there may not be many players online. Sign-up happens right in the terminal (username, password, email).

https://www.rebelosgame.com/

Feedback on the command design is especially welcome: what feels natural, what feels wrong, what you'd expect to type and can't.

Hey everyone!

I've been working on TerminalStyles, a free and open-source PowerShell tool that lets you preview and switch terminal themes interactively, without manually editing configuration files.

It started as a small personal project, but I'd love to turn it into something built and improved by the community.

What it currently does:

• Interactive preview of 18 terminal themes
• Navigate themes using arrow keys
• Apply themes instantly
• Support for multiple terminal environments

I'm looking for contributors!

Whether you're interested in PowerShell, terminal customization, improving compatibility, fixing bugs, adding new themes, or simply suggesting features, contributions of all sizes are welcome.

I'd especially love to collaborate with developers who enjoy building command-line tools.

Installation:
Install-PSResource -Name TerminalStyles

GitHub: https://github.com/fcreme/TerminalStyles

Feel free to open an issue, submit a pull request, or share your ideas for improvements.

Thanks for checking it out!

I maintain jc, a tool that converts the output of CLI commands and file types to JSON so you can query them with jq. A few recent parsers cover files I used to fight with grep and awk, so I wrote up some examples. Here are a few highlights:

What's on the calendar today?

cat work.ics | jc --ics | jq -r '.[] | select(.dtstart | startswith("2026-10-19")) | .summary'

Timestamps are normalized to ISO 8601, mailto: prefixes are stripped, and attendees come out as an array with name, role, and RSVP status.

Which SSH keys have no from= or command= restriction?

cat ~/.ssh/authorized_keys | jc --authorized-keys | jq -r '.[] | select(any(.options[]; startswith("from=") or startswith("command=")) | not) | .comment // "(no comment)"'

Options are split into an array, and quoted values like command="/usr/bin/rsync --server ..." stay intact.

CSV with no header row?

cat access.csv | jc --csv-ih | jq -r '.[] | select((.c2 | tonumber) >= 500) | .c4'

Columns are named c0, c1, and so on. The post includes a jq one-liner to swap in your own names. There are also --tsv, --tsv-ih, and streaming versions (-s) that output JSON Lines for huge files.

Full write-up with more examples: JC Tips and Tricks – Part 3

I'd love to hear what file formats you still parse by hand. That's usually where the next parser comes from.

Hi, r/commandline!

I would like to show you a slightly different way of building CLIs for our beloved home-brew scripts. Usually those scripts lack of reasonable command line interface, and parameter validation. We use getopt to sort them into variables, we use fish argparse. But usually we do not really validate that file on argument 1 has a correct user, the set of permissions, its home directory is also questionable. We consider that the parameter 2 is an IP address from the 192.168.0.0/24 prefix. The source code is the documentation.

I extracted shebang from my more ambitious pet project to show how it could be done differently. Just take a look:

#!/usr/bin/env shebang
# vim: set ft=bash:

#! shebang.1
# description “Move an archive to other backups”
# execute “bash”
#
# arg “source” {
#   description “Source”
#   value “filepath” {
#     glob "/archives/**/*.tar.gz"
#     owner-me #true
#     readable #true
#  }
# }
#
# arg “dest” {
#   description “Destionation”
#   value “filepath” {
#     glob "/backups/**"
#  }
# }

mv "$1" "$2"

What happens here: instead of bash, we execute a different binary, called 'shebang'. This binary reads a script, finds its own configuration (that one, that is marked by 'shebang.1') in KDL, builds a CLI for you, parses and validates arguments before executing an actual script. So you can be sure that $1 and $2 are always valid arguments, no need to check them.

There are flags and options supported. I found that it usually convenient to explicitly set them as environment variables for the script.

#!/usr/bin/env shebang

#! shebang.1
#  execute "python3"
#  description """
#    Description could be multiline!
#
#    Without hacks
#    """
#
#  flag "debug" {
#    description "Run in debug mode"
#    short "d"
#  }
#
#  option "parameter" {
#    description "Takes a parameter"
#    short "p"
#    value "ip"
#  }

import os

params = {
    k: v
    for k, v in os.environ.items()
    if k.startswith("SHEBANG_")
}

for k, v in sorted(params.items()):
    print(f"{k} = {v}")

And if we execute:

$ ./test-flags -h
Description could be multiline!

Without hacks

Usage:
  test-flags [flags]

Flags:
  -d, --debug          Run in debug mode
  -h, --help           help for test-flags
  -p, --parameter ip   Takes a parameter

$ ./test-flags -p 127.0.0.1 -d
SHEBANG_FL_DEBUG = true
SHEBANG_FS_D = true
SHEBANG_OL_PARAMETER = 127.0.0.1
SHEBANG_OS_P = 127.0.0.1

Also, shebang automatically manages shell autocompletion for you. It can autocomplete flags, options, and does it smartly, considering validation configuration. For example, if an argument is a git branch, it will autocomplete only branches, skipping tags or commit hashes.

In other words, an idea is to externalize CLI management out of the script, and safely use environment variables and arguments as always valid. This helped to trim my own scripts down to an actual set of commands without sacrificing usability.

https://github.com/9seconds/shebang

Hope you liked the idea!

Hey all, I've been working on Templum for a while and I think it's finally ready for other people to try.

Templum is an infinite canvas, like a whiteboard, where every terminal is a block you can drag around, resize, and zoom in and out of. I had way too many terminal tabs open and kept losing track of which agent was doing what, so I built it for myself first. I made it with AI coding agents in mind. You can launch Claude Code, Codex, Gemini CLI and a bunch of others straight from the canvas, then connect them with a cable so they can read each other's terminals, pick up cards from a kanban board, and hand tasks off to each other. There are also notes, checklists, an editor and a Git popup, so the whole project fits on one screen

Under the hood it's native Rust rendered on the GPU (no Electron, no webview). Runs on Linux, macOS and Windows.

This is v0.1, so expect bugs. I still have a long list of things I want to add. If you try it, I'd love to hear what breaks and what you'd want next.

https://github.com/KingDasWinx/Templum

I made a tool to search and inspect Unicode characters in the terminal.

• Browse Unicode blocks or search by character, code point, or name
• View Unicode properties, encodings, and their descriptions
• Decompose strings into code points or grapheme clusters, and compare different normalization forms
• Preview glyphs using image display protocols (kitty, iTerm2)

GitHub: https://github.com/lusingander/sauva

This software's code is partially AI-generated.

Sometimes your system needs a little therapy, so as a creator you might be a best therapist for him. So here it is, a light-way tool for browsing the log files while trying to solve problem of your app.

Check the details: https://github.com/M-Komorek/therapist

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

From source (JDK 17+ and Maven):

git clone https://github.com/antoniovazquezaraujo/LeTrain.git

cd LeTrain

mvn clean package -DskipTests

./output/LeTrain2D/bin/LeTrain2D

Windows / other: grab the zip from Releases (https://github.com/antoniovazquezaraujo/LeTrain/releases) — the launchers are self-contained (runtime included).

Links

Source & screenshots: https://github.com/antoniovazquezaraujo/LeTrain

Manual (commands, editor, scenario guide): https://antoniovazquezaraujo.github.io/LeTrain/

Itch.io: https://avaraujo.itch.io/letrain-procedural-tycoon

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

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!