Skip to content
Back to search

limoni

Terminal UI engine for Go that tests can click and AI agents can drive (MCP). Zero-allocation rendering, immediate mode + Elm architecture, 3D, images, charts, accessibility, WebAssembly.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/thebanri/limoni with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/thebanri/limoni'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/thebanri--limoni/badge.svg)](/listings/thebanri--limoni)

HTML

<a href="/listings/thebanri--limoni"><img src="/api/listings/thebanri--limoni/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

go get github.com/thebanri/limoni
package main

import "github.com/thebanri/limoni"

func main() {
	limoni.Run(func(f *limoni.Frame, ev *limoni.Event) bool {
		if ev != nil && ev.Type == limoni.EventKey && ev.Key.Type == limoni.KeyEsc {
			return false // quit
		}
		f.RenderComponent(limoni.Border(
			limoni.Center(limoni.Label("Hello from Limoni 🍋  (Esc quits)", limoni.Bold())),
			limoni.SymbolsRounded,
			limoni.Fg(limoni.Hex("#FFCC00")),
		), f.Area())
		return true
	})
}

Or generate a project that runs straight away, with a test already written:

go run github.com/thebanri/limoni/cmd/limoni@latest new myapp    # -template counter|dashboard|form|chat|ssh
cd myapp && go mod tidy && go run .
go test ./...                                                     # a uitest test comes with every template

**Next:** [Getting started](docs/getting-started.md) · [Widget gallery](docs/widget-gallery.md) · [Examples](#examples)

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 417 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <p align="center">
  2. <img src="assets/logo.png" alt="Limoni Logo" width="160" />
  3. </p>
  4. <h1 align="center">🍋 Limoni</h1>
  5. <p align="center">
  6. <strong>A terminal UI engine for Go that tests can click, AI agents can drive,<br>and the garbage collector never sees.</strong>
  7. </p>
  8. <p align="center">
  9. <a href="https://github.com/thebanri/limoni/actions"><img src="https://img.shields.io/github/actions/workflow/status/thebanri/limoni/ci.yml?branch=main&style=flat-square&logo=github" alt="Build Status"></a>
  10. <a href="https://pkg.go.dev/github.com/thebanri/limoni"><img src="https://img.shields.io/badge/go.dev-reference-007d9c?style=flat-square&logo=go&logoColor=white" alt="Go Reference"></a>
  11. <a href="https://golang.org"><img src="https://img.shields.io/badge/go-%3E%3D%201.25-blue?style=flat-square&logo=go" alt="Go Version"></a>
  12. <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache_2.0-blue?style=flat-square" alt="License"></a>
  13. <a href="docs/benchmarks.md"><img src="https://img.shields.io/badge/draw%20path-0_B%2Fop-brightgreen?style=flat-square" alt="Zero Allocations"></a>
  14. </p>
  15. <p align="center">
  16. <a href="README.md">English</a> • <a href="README_TR.md">Türkçe</a>
  17. </p>
  18. <p align="center">
  19. <strong><a href="https://thebanri.github.io/limoni/">▶ Try it in your browser</a></strong> — the same engine compiled to WebAssembly, no install.
  20. </p>
  21. <p align="center">
  22. <a href="https://buymeacoffee.com/thebanri"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="50"></a>
  23. </p>
  24. <p align="center">
  25. <img src="assets/xray.gif" alt="A pixel-art night city with a moon and a passing train; an X-ray pass lights up only the cells Limoni's diff sends each frame, with a counter of bytes sent against a full repaint" width="100%" />
  26. <br><sub>Only what changed is sent: <code>go run ./examples/xray</code> lights up every cell the diff writes.</sub>
  27. </p>
  28. ---
  29. ## Quick start
  30. ```bash
  31. go get github.com/thebanri/limoni
  32. ```
  33. ```go
  34. package main
  35. import "github.com/thebanri/limoni"
  36. func main() {
  37. limoni.Run(func(f *limoni.Frame, ev *limoni.Event) bool {
  38. if ev != nil && ev.Type == limoni.EventKey && ev.Key.Type == limoni.KeyEsc {
  39. return false // quit
  40. }
  41. f.RenderWidget(limoni.Border(
  42. limoni.Center(limoni.Label("Hello from Limoni 🍋 (Esc quits)", limoni.Bold())),
  43. limoni.SymbolsRounded,
  44. limoni.Fg(limoni.Hex("#FFCC00")),
  45. ), f.Area())
  46. return true
  47. })
  48. }
  49. ```
  50. Or generate a project that runs straight away, with a test already written:
  51. ```bash
  52. go run github.com/thebanri/limoni/cmd/limoni@latest new myapp # -template counter|dashboard|form|chat|agent|ssh
  53. cd myapp && go mod tidy && go run .
  54. go test ./... # a uitest test comes with every template
  55. ```
  56. **Next:** [Getting started](docs/getting-started.md) · [Widget gallery](docs/widget-gallery.md) · [Examples](#examples)
  57. ---
  58. ## Why Limoni
  59. ### 1. Your TUI has a semantic tree, so tests and agents address widgets by name
  60. Most terminal automation, such as [termwright](https://github.com/fcoury/termwright) or
  61. [mcp-tui-test](https://github.com/GeorgePearse/mcp-tui-test), parses the rendered character
  62. grid, so a test breaks when the layout moves by one column. A Limoni app builds a
  63. semantic tree every frame (the same tree a screen reader uses), and the tools below
  64. work on that tree instead.
  65. **`uitest`: Playwright-style tests.** Checks wait instead of sleeping, and a failure
  66. prints the whole tree of the last frame.
  67. ```go
  68. page := uitest.Run(t, 80, 24, app.draw) // in process: no terminal needed
  69. page.GetByRole("input", "New task").Type("Tag v1.0")
  70. page.GetByRole("button", "Add task").Click()
  71. page.Expect(page.GetByRole("list-item", "").Within(page.GetByRole("list", "Tasks"))).ToHaveCount(3)
  72. page.Expect(page.GetByID("status")).ToContainLabel("Added")
  73. ```
  74. **`limoni-mcp`: let an AI agent drive the app.** It gives Claude Code, Cursor or any
  75. MCP client eight tools (`tree`, `click`, `type_text`, `wait_for`…) that work on the
  76. same tree. In one recorded run, Claude Code completed a release checklist in 17 tool
  77. calls. That run included typing a deploy token the agent could not read back.
  78. ```bash
  79. go run -tags limoni_debug ./examples/agent_checklist
  80. claude mcp add limoni -- limoni-mcp -socket "$XDG_RUNTIME_DIR/limoni-checklist.sock"
  81. ```
  82. The automation socket only exists in `-tags limoni_debug` builds. It is closed by
  83. default, only the same user can connect, and secret fields are never exposed.
  84. → [Semantic automation, MCP and uitest](docs/automation.md)
  85. ### 2. Fast where you can feel it
  86. - **Zero heap allocations per frame** for the renderer, every widget's drawing, and the click handling of the common input widgets, enforced in CI, so animations don't stutter from GC pauses. That includes widgets that drag or call your code — Table, Slider, Dialog, TreeView, CommandPalette — once their state is attached. [The details](docs/architecture.md#5-allocation-free-interactive-frames).
  87. - **Few bytes per frame.** Blank runs become `ECH`/`EL` and repeats become `REP`: a full-screen redraw is **377 bytes**, and an idle app sends **nothing**. Bytes, not CPU, are what you feel over SSH.
  88. - **Virtual tables and lists.** One million rows scroll at ~2.7 ms a frame, because only visible rows are touched.
  89. | Measured on a Ryzen 5 5600, Go 1.27.1 | Latency | Allocations |
  90. | :--- | ---: | ---: |
  91. | Full-screen diff, 120×40, every cell changed | ~50 µs | 0 |
  92. | 10% of the screen changed | ~11 µs | 0 |
  93. | Nothing changed | ~2 ns | 0 |
  94. | 100 layered blocks, drawn and diffed | ~68 µs | 0 |
  95. Absolute numbers depend on the machine. The comparisons against Ratatui 0.30.2,
  96. Ultraviolet and Bubble Tea v1.3.10, including which ratios are *not* meaningful, are in
  97. [docs/benchmarks.md](docs/benchmarks.md) and the [methodology](docs/benchmark-methodology.md).
  98. One earlier run showed a 4,700× lead; it came from a bug in the benchmark harness,
  99. and the [methodology](docs/benchmark-methodology.md#the-4700-that-was-a-harness-bug) explains how it was caught.
  100. ### 3. Batteries that other TUI libraries leave to you
  101. | | |
  102. | :--- | :--- |
  103. | 🕶️ **3D** | A software rasteriser for OBJ/STL/PLY/GLB with Lambert and Gouraud shading, drawn in terminal cells |
  104. | 🖼️ **Images** | Kitty, Sixel, iTerm2 and half-block fallback |
  105. | 📊 **Charts** | Braille line charts, bar charts, pie charts, sparklines |
  106. | 📝 **Markdown** | Headings, lists (nested, numbered, tasks), quotes, tables, links, and fenced code highlighted by language — including a block still streaming in |
  107. | ♿ **Accessibility** | A semantic tree, a screen-reader line mode, `NO_COLOR`, high contrast, reduced motion |
  108. | 🧬 **Unicode** | UAX #29 grapheme clusters (Unicode 17.0, all 766 conformance tests), so flags and emoji families take one cell |
  109. | 🔗 **Hyperlinks** | OSC 8 links, in markdown or any style — and where the terminal cannot show them, the address is printed instead |
  110. | 📃 **Inline mode** | Render in a band of the normal screen, like `gum`, with scrollback intact |
  111. | ⏺️ **Session replay** | Record a session, replay it as a regression test ([docs](docs/session-recording.md)) |
  112. | 🌐 **Everywhere** | Linux, macOS, BSD, Windows, WebAssembly in the browser, SSH sessions |
  113. The only dependencies are `golang.org/x/sys` and `golang.org/x/crypto`.
  114. <table>
  115. <tr>
  116. <td><img src="assets/treeview.gif" alt="TreeView with image preview" /></td>
  117. <td><img src="assets/chart.gif" alt="Charts" /></td>
  118. </tr>
  119. <tr>
  120. <td align="center"><code>go run ./examples/treeview</code></td>
  121. <td align="center"><code>go run ./examples/charts</code></td>
  122. </tr>
  123. </table>
  124. ### Is Limoni the right choice?
  125. **Pick Limoni if** you are writing a terminal app in Go and any of these matter:
  126. - **You want to test the UI, or let an AI agent use it**, by widget role and label
  127. rather than by screen coordinates (`uitest`, `limoni-mcp`).
  128. - **It redraws a lot**: dashboards, log viewers, monitoring, games, animation,
  129. anything over SSH. The draw path makes no garbage and sends few bytes.
  130. - **It needs things other libraries leave to you**: 3D models, images, charts,
  131. markdown, a million-row table, screen-reader support, WebAssembly in the browser.
  132. - **You want both styles in one library**: immediate mode (`limoni.Run`) for
  133. dashboards, the Elm architecture (`limoni.RunProgram`) for forms and wizards.
  134. - **You want a small dependency tree**: `golang.org/x/sys` and `golang.org/x/crypto`.
  135. **Pick something else if:**
  136. - You need a **stable 1.0 API** today. Limoni is pre-1.0 (see [Status](#status)).
  137. - You rely on the **Charm ecosystem** (Bubbles, Huh, Glamour, Wish) and its
  138. community. Bubble Tea is the larger and older project. If you already have a
  139. Bubble Tea app, `compat/bubbletea` runs your models on Limoni
  140. ([migration guide](docs/bubbletea-migration.md)), so you can try it without a rewrite.
  141. - You are writing **Rust**: use Ratatui.
  142. - The app is a **one-shot prompt** (a single question, a spinner): a small prompt
  143. library is less to learn.
  144. A feature-by-feature table against Bubble Tea v1/v2 and Ratatui 0.30 is in
  145. [docs/comparison.md](docs/comparison.md).
  146. ---
  147. ## Built with Limoni: zest
  148. <p align="center"><img src="assets/zest.gif" alt="zest filtering a million-line log to billing errors, opening a line's details, then clearing the filter to show it in context" width="100%" /></p>
  149. [**zest**](cmd/zest) is a log viewer and Limoni's flagship app. It follows files and pipes, colours by
  150. level, and filters a million lines without stalling. A 67 MiB, 1,000,000-line log is on screen in about half
  151. a second.
  152. ```bash
  153. go install github.com/thebanri/limoni/cmd/zest@latest
  154. zest -demo 1000000 # or: zest app.log, kubectl logs -f pod | zest
  155. ```
  156. Or [try it in the browser](https://thebanri.github.io/limoni/): the "Logs · zest" scene.
  157. ### And: globe
  158. [**globe**](apps/globe) is a world you can turn, search, zoom into and pin — and what a Limoni
  159. application looks like from the outside, since it is a module of its own that depends on a
  160. published Limoni and uses nothing but its public API.
  161. ```bash
  162. go install github.com/thebanri/limoni/apps/globe@latest
  163. globe -at Türkiye
  164. ```
  165. `go install` puts the binary in `$(go env GOPATH)/bin` — `~/go/bin` unless you changed it —
  166. which a fresh Go install does not add to your `PATH`. If `globe` is "command not found", add
  167. that directory to `PATH` or run `~/go/bin/globe`.
  168. Everything on it is in the semantic tree, so "find Turkey on the world map" is something an agent
  169. can do over MCP: type into `search`, click the row, read `image#globe` back as
  170. `value="39.3°N 34.5°E · zoom 2.6×"`. Nothing of it reaches you when you import Limoni — a
  171. directory with its own `go.mod` is not part of the module around it.
  172. ### And your shell: backdrop-shell
  173. <p align="center"><img src="assets/backdrop-shell.gif" alt="backdrop-shell: a fish prompt over an animated aurora; ls lists files in front of it, backdrop-shell opacity 0.9 brightens it at once, and backdrop-shell enable -scene synthwave switches the running terminal to a striped sunset over a neon grid" width="100%" /></p>
  174. [**backdrop-shell**](apps/backdrop-shell) puts a moving scene behind your shell, in any terminal —
  175. an aurora, a night city, a starfield, a synthwave sunset, a picture, or ASCII art of your own that
  176. blinks or drifts. The text in front stays sharp, selecting copies only what the shell wrote, a
  177. narrower window keeps every line, and the opacity or the scene changes at once in every open
  178. terminal. It costs about half a percent of one core, and nothing while the window is in the
  179. background.
  180. ```bash
  181. curl -fsSL https://raw.githubusercontent.com/thebanri/limoni/main/apps/backdrop-shell/install.sh | sh
  182. backdrop-shell opacity 0.3 # quieter, in every open terminal
  183. backdrop-shell enable -scene synthwave # or -image wall.jpg, or -art my-art.txt
  184. ```
  185. Drawing and animating your own: [docs/backdrop-art.md](docs/backdrop-art.md). The same scenes go
  186. behind any Limoni application with `limoni.WithBackdrop(backdrop.Aurora())`.
  187. ### And some games
  188. [**Lemon Drop**](apps/lemondrop) is falling blocks where a piece that lands crumbles into sand of its colour.
  189. A run of one colour that reaches from wall to wall is the line: it flashes and goes, and what rested on it
  190. falls, sometimes into the next one.
  191. ```bash
  192. go install github.com/thebanri/limoni/apps/lemondrop@latest
  193. lemondrop
  194. ```
  195. Or [play it in the browser](https://thebanri.github.io/limoni/?app=lemondrop), with sound and a
  196. world leaderboard.
  197. [**Lemon Snake**](apps/lemonsnake) is a snake that eats lemons. Every five, a monster climbs out of the far
  198. corner and hunts the head; spit the seeds your lemons bring at it, and where it steps on
  199. the body it bites the rest off. Every level is faster, and so is its monster; fill the board to win. `t` switches between five
  200. colour themes at any time. It glides in half-block pixels, plays soft synthesised sounds, and
  201. sends finished runs to the same shared leaderboard as Lemon Drop.
  202. ```bash
  203. go install github.com/thebanri/limoni/apps/lemonsnake@latest
  204. lemonsnake
  205. ```
  206. Or [play it in the browser](https://thebanri.github.io/limoni/?app=lemonsnake), with its sound and the
  207. world leaderboard.
  208. <p align="center"><img src="assets/lemonsweep.png" alt="Lemon Sweep: a giant crab mini-boss under its health bar at the top, a tview modal, a Bubble Tea cup and an ncurses box among terminal-window walls, green bytes in the air, a boomerang and an arc of lightning, the minimap at the top left, the heart and the dash mark at the bottom left" width="100%" /></p>
  209. [**Lemon Sweep**](apps/lemonsweep) is a first-person roguelite in a terminal made of terminals: the walls
  210. are a shell, a log viewer, some Go and htop. You are the garbage collector, and Bubble Tea, Ratatui, tview,
  211. Ink and ncurses have come for the heap, each drawn the way its own apps look: pink rounded boxes and
  212. spinners, Ferris, double-lined modals that split into their buttons, `</>` that splits in two. Aim with
  213. the mouse (an empty heap reloads by itself), and take an augment card every level; once every card held
  214. is at its last rank, a level is a random stat. Shots that split, bounce, explode and arc multiply each
  215. other into something broken, and the RECIPES book says which cards do.
  216. Pick one of four maps on the title: a mini-boss comes every two minutes, a boss every two and a half, and
  217. the map's warden at ten; if it stands, the pressure builds (armour, insulation, speed), and no build holds
  218. it for long. Experience hangs in the air until you walk over it, and a corner is no place to hide. There is
  219. no leaderboard: records stay on the machine, or in the browser.
  220. ```bash
  221. go install github.com/thebanri/limoni/apps/lemonsweep@latest
  222. lemonsweep
  223. ```
  224. `command not found`? `go install` puts programs in `$(go env GOPATH)/bin`, usually `~/go/bin`, which
  225. macOS does not put on the `PATH`. Run `~/go/bin/lemonsweep`, or add
  226. `export PATH="$PATH:$(go env GOPATH)/bin"` to `~/.zshrc` and open a new terminal.
  227. Or [play it in the browser](https://thebanri.github.io/limoni/?app=lemonsweep), where the pointer is locked
  228. for mouse look. A frame allocates nothing, the most broken build's full pools included.
  229. <p align="center"><img src="assets/pikap.gif" alt="pikap playing its demo record: the needle is put down half-way in, the record is dragged back and forth to scratch, then it is drawn in ASCII" /></p>
  230. [**pikap**](apps/pikap) is a record player drawn in half blocks (or ASCII). It follows whatever the computer is playing
  231. (Spotify, a browser tab, mpv, anything on MPRIS): the cover turns on the record and the tonearm moves
  232. across it. Dragging the record or the arm moves the song back and forth. Given files, it plays them
  233. itself, and then pausing slows the music down with the platter and dragging the record scratches.
  234. ```bash
  235. go install github.com/thebanri/limoni/apps/pikap@latest
  236. pikap # follow what is playing
  237. pikap ~/Music # or play files
  238. ```
  239. ### Used by
  240. - [**residual**](https://git.merith.xyz/residual/) — a work-in-progress Alpine-based OS with a
  241. from-scratch Go userspace.
  242. - [**TuiSense**](https://github.com/Phobby/TuiSense) — controller management and diagnostics in the
  243. terminal (DualSense first), with a rotating 3D controller.
  244. ---
  245. ## Two ways to write an app
  246. | | Immediate mode | Declarative (Elm architecture) |
  247. | :--- | :--- | :--- |
  248. | **Entry point** | `limoni.Run(func(f, ev) bool)` | `limoni.RunProgram(ctx, model)` |
  249. | **State lives in** | your closure | a `limoni.Model` with `Init` / `Update` / `View` |
  250. | **Best for** | dashboards, 3D, games, animation | forms, wizards, CRUD tools, async work |
  251. | **Runtime gives you** | a redraw on every event | commands, cancellation, panic recovery, session recording |
  252. Both use the same renderer and widgets and are available from the root package.
  253. [`examples/counter`](examples/counter) is a complete declarative app in under 80 lines.
  254. Coming from Bubble Tea? See the [migration guide](docs/bubbletea-migration.md).
  255. ---
  256. ## Widgets
  257. | Category | Widgets |
  258. | :--- | :--- |
  259. | **Layout** | `VStack` / `HStack` / `ZStack`, `Flex`, `Border`, grid layout (`layout.GridLayout`), `Block` (with border merging), `SplitPane` (draggable), `Viewport`, `Dialog`, `Popup`, `StatusBar` |
  260. | **Data** | `Table` (virtual), `List` (virtual), `TreeView`, `FilePicker`, `Calendar`, `Sparkline`, `ProgressBar`, `Gauge`, `LineGauge`, `RichText` |
  261. | **Charts** | `LineChart`, `BarChart`, `PieChart` — Braille, sextant or quadrant markers |
  262. | **Input** | `TextInput`, `Autocomplete`, `TextArea`, `Checkbox`, `RadioGroup`, `Select`, `Slider`, `ColorPicker` |
  263. | **Navigation** | `Tabs`, `Scrollbar`, `CommandPalette`, fuzzy search, keybinding manager |
  264. | **Feedback** | `Spinner`, `Toast`, desktop notifications (OSC 9 / OSC 99) |
  265. | **Graphics** | `Canvas` (Braille, sextant, quadrant, block), 3D meshes as dots or as a picture over kitty/iTerm2/Sixel, `Image` |
  266. | **Text** | `Markdown`, `CodeView` (syntax highlighting), `BigText`, `Label`, `Paragraph` |
  267. | **Tooling** | `DevTools` HUD (`F12`), themes, validation |
  268. → [Widget gallery](docs/widget-gallery.md) · [Widget reference](docs/widgets-reference.md)
  269. ---
  270. ## Examples
  271. | Example | What it shows |
  272. | :--- | :--- |
  273. | [`demo`](examples/demo) | The feature trailer: a 3D lemon in ASCII, Braille and half-blocks |
  274. | [`xray`](examples/xray) | A night city under an X-ray: every cell the diff sends lights up, with measured bytes against a full repaint (`-film` for recording) |
  275. | [`showcase`](examples/showcase) | Tabs, forms, matrix rain, 3D, command palette, DevTools (`F12`) |
  276. | [`3d_viewer`](examples/3d_viewer) | OBJ/STL/PLY viewer with shading and orbit controls (`-fps 240`) |
  277. | [`dashboard`](examples/dashboard) | Live CPU and memory sparklines, a process table, streaming logs |
  278. | [`table_virtual`](examples/table_virtual) | A one-million-row table |
  279. | [`agent_checklist`](examples/agent_checklist) | An app built to be driven by an AI agent, and tested with `uitest` |
  280. | [`todo`](examples/todo) | A declarative todo app with tags, filters and fuzzy search |
  281. | [`counter`](examples/counter) | The smallest declarative app |
  282. | [`composable`](examples/composable) | Layout with `VStack`, `HStack`, `Border`, `Flex` |
  283. | [`forms`](examples/forms) · [`layer_demo`](examples/layer_demo) · [`treeview`](examples/treeview) · [`charts`](examples/charts) | Inputs, modals, file tree, charts |
  284. | [`ssh_server`](examples/ssh_server) · [`wasm`](examples/wasm) | Serving over SSH, running in the browser |
  285. Run any of them with `go run ./examples/<name>`, or without cloning:
  286. `go run github.com/thebanri/limoni/examples/3d_viewer@latest`.
  287. All examples: [docs/examples.md](docs/examples.md).
  288. The [games](#and-some-games) and full applications live in [`apps/`](apps), each its own module.
  289. ---
  290. ## Documentation
  291. | | |
  292. | :--- | :--- |
  293. | [Getting started](docs/getting-started.md) | Install, first app, both application models |
  294. | [Architecture](docs/architecture.md) | The flat cell grid, the diff, why the draw path doesn't allocate |
  295. | [Layout](docs/layout-guide.md) · [Widgets](docs/widgets-reference.md) · [Core API](docs/core-api.md) | Reference |
  296. | [Semantic automation](docs/automation.md) | The automation socket, `limoni-mcp`, `uitest` and the security model |
  297. | [Session recording](docs/session-recording.md) | Record and replay sessions as regression tests |
  298. | [Graphics](docs/graphics-and-canvas.md) · [Animation](docs/animation-and-physics.md) · [Accessibility](docs/accessibility-and-theming.md) | Feature guides |
  299. | [Drivers and platforms](docs/drivers-and-platforms.md) | Unix, Windows, WebAssembly, SSH |
  300. | [How it compares](docs/comparison.md) | Against Bubble Tea v1/v2, Lip Gloss and Ratatui, with the caveats |
  301. | [Benchmarks](docs/benchmarks.md) | Every measured number and how to reproduce it |
  302. | [Rendering FAQ](docs/faq.md) | Hairline gaps, recommended terminals, emoji |
  303. | [Stability](docs/stability.md) · [Changelog](CHANGELOG.md) | What may change before 1.0 |
  304. Turkish documentation: [docs/tr](docs/tr/README.md).
  305. ---
  306. ## Status
  307. Limoni is **pre-1.0**. Patch releases don't break the API; minor releases may, and
  308. every break is listed in the [changelog](CHANGELOG.md). The core renderer, layout and
  309. widgets are settling; the automation, `uitest` and session packages are new and
  310. experimental. See [docs/stability.md](docs/stability.md) for what has to happen
  311. before v1.0.
  312. ## Community and contributing
  313. - **Questions and ideas:** [GitHub Discussions](https://github.com/thebanri/limoni/discussions)
  314. - **Bugs:** [open an issue](https://github.com/thebanri/limoni/issues/new/choose). The template asks for your terminal emulator, since most rendering bugs depend on it.
  315. - **First contribution:** issues labelled [`good first issue`](https://github.com/thebanri/limoni/labels/good%20first%20issue) are scoped to one file and say how to verify the change. Start with [CONTRIBUTING.md](CONTRIBUTING.md).
  316. - **Built something?** Add it to [AWESOME.md](AWESOME.md).
  317. - **Like it?** A ⭐ helps others find it, and you can [buy me a coffee](https://buymeacoffee.com/thebanri).
  318. AI assistants (Claude, Gemini) were used during development for scaffolding, tests
  319. and documentation drafts. The architecture was designed, profiled and benchmarked
  320. by the author, and the benchmark harness exists to check claims, from people or tools.
  321. [Security policy](SECURITY.md) · [Code of Conduct](CODE_OF_CONDUCT.md) · Apache License 2.0

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.