Yesterday in HN "what are you working on", dr_dshiv presented SourceLibrary [1] which has tons of machine translation of beautiful texts.
Here's my "Let Me SourceLibrary That For You" using their Librarian search which presents the "The Yoga Vāsiṣṭha (The Expanded Mokṣopāya)" [2]
ETA: My apologies, I went deeper and the links therein are scans/ocr of English translations of that text. The library does have other Sanskrit translations, but not of that?
This is cool to see from a research team. A few weeks ago I was exploring a similar idea with ntcharts, where a user or LLM can specify a chart in a Golang or JSON object...
and then that spec would be rendered either to a Bubble TUI via NTCharts or to HTML/SVG via ECharts. That Echarts HTML could be naturally served by a Golang http service.
But Flint goes much deeper with semantic layers and settings optimizations. Perhaps a NTChart, or whatever terminal chart, could be a rendering target? I'll add it to the list to explore...
@antirez wrote about the development of that data structure last month, which includes how he used LLMs to do it (which was before ds4 for the co-comment mentioning it ;). The PR he linked goes into the motivation.
I really enjoy using Golang to make TUIs and the Charm ecosystem.
> But I think we will swing back to using GUIs
I've been pushing on BubbleTea Kitty and Ghostty quite a bit to hybridize this. The TUI / GUI distinction to me is about task centrism and delivery. There's an appropriate surface and workflow for every task; beyond TUI/GUI sometime it needs to be a VR headset or an immersive room or a literal sandbox.
A demo of this is web-delivery of our BubbleTea TUI examples ('t' toggles between glyph/kitty):
The delivery uses our WIP Booba tool, which is Ghostty-based. The CLI tool can be used to remote or embed any TTY program, but was generally built for BubbleTea.
https://github.com/NimbleMarkets/go-booba
Right now I'm working on multiple ds4 TUIs using this stack, for example generating SVGs from a prompt and then rendering it in TUI. Another generates CSG object graphs and renders/composites them in terminal. Here's a gist with screenshots:
The upstream ds4 project is using C for their TUIs. I have done TUIs in C and C++ (and many other languages) and will not go back to that. Really fun engine though and a great place to stick a TUI. I am a Camel furry (https://cameltopia.org) but wouldn't use OCaml to make a TUI either (makes sense for Jane Street of course).
The concept is marrying the flexibility of Golang with a specific local high-performance inferencing engine. The clean C interface made it easy. Initial release wraps the API using purego and requires pointing to a DS4 installation.
I'm now adding some pre-built installer ergonomics and directory opinions and demos.
For Golang, I highly recommend yzma to explore this surface. I’ve used it for embedding and summarization (with small models) and just mucking around with integrated LLM BubbleTea TUI idea (with bigger models).
Although a maintainer answered you, watch the video from the blog. There's a WASM demo at the end, which is great. It also has a good explainer for those confused about the HTTP decision.
And I appreciate that the Hannes still appreciates the magic of the WASM. [And I keep hearing quark which makes me hungry for tangy creamy German yogurt]
That's pretty handy, thanks for the links. IDE is slick!
Given the structure, I think one could make a threejs backend on for ghostty-web. Makes sense if one will pull in more of three.js anyway. I'm adding it to my backlog to explore.
I've been playing with Golang and WASM lately; hands-on WASM was new to me.
I found that many dependencies in the ecosystem (especially older ones) do not support GOARCH=wasm nor GOOS=js / GOOS=wasip1. I've had to fork and add support and then do go.mod replace directives. It can get messy.
Golang build tags make it awesome to have different implementations for different systems.
In the browser, it's all single threaded, so goroutines starve each other. I had to put in "breaths" for interactivity.
There's no local filesystem, so you have to figure out other solutions. Some dependencies use the filesystem as an implementation detail or try to shell out. The program will build, but will error at runtime.
That said, it is pretty sweet when it works. You can make WASM games with ebitengine [1] and it emits instructions for a WebGPU renderer; very efficient and many interactivity concerns are handled for you. The NTCharts demo page [2] combines Zig (Ghostty), WASM+Typescript+GLSL (Ghostty Web), and Golang (booba/ntcharts). The WASM size for the demos there is ~5MB each.
My goal is to make tools for terminal remoting and simplify bringing TUIs to the browser.
[1] https://ebitengine.org
Really fun project! Dude, I spent the last week implementing Kitty Graphics and Clipboard protocols in ghostty-web in the Canvas render.
Then I added WebGL and WebGPU renderers [1], including support for Kitty.
Then I see this this project on a Monday morning... so now I have to implement Ratty Graphics Protocol?!?! [2].
ETA: I looked into this; Ghostty would need patched to support Ratty since Ghostty-Web now defers APC handling there. It would also require pulling in a 3D engine like three.js or otherwise implementing file parsing, lighting, etc. Finally, since local filenames are part of the protocol, a browser would need some file resolver helper, either to get the data over the APC channel or via a URL.
While I felt this in 2025, I do not feel this in 2026. I use Claude and the rest with BubbleTea all the time.
But I will say... you have to know Golang. You have to have at least tried to make a BubbleTea app yourself and try to understand ELM architecture. You have to look at the code and increment with it.
It makes total sense for OP to switch to Rust and Ratatui if they don't know Golang well. But I don't think it's a better language for it. [Ratatui has brought me great inspiration though!]
Independent of framework, the LLMs get the spacial relationships. I say things like "the upper right panel's content is not wrapping inside and the panel's right edge should extend to the terminal edge" and the LLM will fix it. They can see the resultant text, I'm copy-pasting all the time.
TUI code is finicky; one mis-rendered component mucks everything up. The LLMs will decide themselves make little, temporary BubbleTea fixtures to help understand for itself when things aren't right.
The only real problem with LLMs and BubbleTea is that upon first prompt, they insist on using BubbleaTea v1 versus BubbleTea v2, released in December 2025. But then you just point it to the V2_UPGRADE.md and it gets back on track. That will improve as training cutoffs expand.
I vibe-coded this TUI for Mom's last night. I actually started with Grok (who started with v1) and then moved into Claude Code after some iteration:
I've been advocating heavily this approach since January for non-coding use. The important property is an editable, understandable (by LLMs and humans), and renderable source-of-truth that can be incrementally modified.
I talk to laypeople about their AI work -- I am constantly doing this, inserting myself into AI conversations on the street like an anthropologist when I encounter them...
HTML artifacts are the new browser URL bar, wherein some users have a mental model that that bar is actually Google.
Many people now talk about their "spreadsheet" or their "presentation" or "marketing tear sheet", or "slide show", "competitive analysis", "hvac system diagram" or whatever the thing they were working on and how lame it was working with ChatGPT or Claude Web.... and how miraculous Claude Code or OpenClaw is with creating these new documents...
I will ask them what the documents actually are and what the difference in experience was. It takes a lot of teasing (because they don't have the computing vocabulary yet) or having them show me, and it will always come down to that the artifact is HTML.
Their pleasant experience is that it is iterating on an HTML file (+CSS +images) living on a filesystem with high quality instant rendering; plus it can sprinkle JavaScript when it needs to. It might even revision control it without them knowing if there's a git system. [I suggest they checkpoint their work if they don't; revision control is the next stage of learning for the laypeople?]
Whereas the Web-embedded experiences are stabbing multiple times on a DOCX/PPTX/XLSX lingering in a context window and a vague notion of local storage (rendered as HTML anyway in a sidebar), etc. The HTML workflow also allows other media to be integrated much more easily.
So really all this presentation work is Vibe-Coding by the masses; they don't need to know about all the turtles underneath them. But if they are willing, they could crack it open and see and edit it; or easily hand it off to another agent.
Go figure that the system created for collaborative multimedia communication ends up being useful for the machine intelligence to help us communicate.