neomantra

A funny typo that evokes a whole different vision of food regulation.

This is my version of that for ds4:

https://github.com/NimbleMarkets/ds4go-apps#svgpad

We have a bunch of interactive Kitty Graphics demos, which run embedded in browser or from terminal. This weekend I was working on watercraft simulation:

https://nimbleterminal.github.io/nt3d/water/

I hadn't thought about this angle -- inspiring as expected from Ghostty hacking!

Just took our TinyBubbles framework (TinyGo + BubbleTea) and added TinyGhostty [1]. We had all the parts in place.

The web demos use Booba [2] and our ghostty-web fork, so that's libghostty embedding another libghostty. The source cells are composited into our TinyHAL device abstraction. The UX is presented using "Booba Actions" which abuses OSC 7501.

This describes the differences between TinyGhostty and go-libghostty [3]. I've run other demos on embedded devices, but not this one yet. The fonts could use some love.

[1] https://nimbleterminal.github.io/TinyBubbles/?demo=tinyghost...

[2] https://github.com/NimbleMarkets/go-booba

[3] https://github.com/NimbleTerminal/TinyBubbles/tree/main/tiny...

This was pretty inspiring -- I have been working on file format rendering for a pager in terminal+browser and totally forgot about Mermaid!

Much of the work uses SVG as an intermediary so this Pele pattern works great. OP is a TypeScript project, seems great for that ecosystem.

Searching found this go-mermaid library [1] that operates similarly with SVG its target. We have a Golang TUI picture/SVG widget and a Golang WASM/browser embedder, so I just forked it and had an LLM add a live Mermaid/SVG demo using them [2]. The demo is intended for go-mermaid so it uses its rasterizer, composited to our widget.

(took <15 minutes since I had worked similarly just days ago and had the components at the ready, plus could point at Pele; these LLMs are ridiculous at forging from patterns)

Cool thing is that same visual experience can be had in a terminal if it supports Kitty graphics protocol.

[1] https://github.com/zkrebbekx/go-mermaid

[2] https://neomantra.github.io/go-mermaid/

Since BubbleTea v2.1 and libghostty both adopted OSC 7501, we sync'd our ghostty-web fork [1] to sync with that and smuggled the UX through the `msg`.

Here's demo of it enabled in booba, which is our Golang TUI remoting tool: https://nimblemarkets.github.io/go-booba/demos/actions/

The browser UX comes as a JSON spec over OSC 7501, that spec generated from the BubbleTea Help model.

[1] an overhaul of the original which uses libghostty-vt bindings instead of a patchset, fixes Bidi fonts, and adds WebGPU/WebGL renderer, but really a placeholder for whatever Ghostty/Superlogical cooks up.

This is important (and TIL OSC 3008, how do we all keep up?!), but I want something adjacent to this... perhaps people can point me in a direction.

This OSC 7501 pushes state from Program to Terminal; with an explicit running/idle/fubar "state" field but also K/V data. Then Terminal can provide interactions thereof, such as display it.

What I want is for the Program to push the terminal some map of "key:command" which is available for the terminal to provide interactions thereof. Maybe that can come through just as a key in this?

Here's the motivation: when using a TUI on a phone or tablet, the keyboarding experience is horrible (unless you have a physical keyboard). It takes up too much real estate and most of the time there's only three keys action you want to hit.

An obvious solution is to put up HTML buttons and other chrome for users to tap. Personally, I've handled that bespoke at the library+application level, where the Golang and HTML+JS container work together. There's some reusability because it can just take a BubbleTea Help Model (holds keybindings), but it is limited.

In the last few weeks, I've started seeing Claude do this unasked for me (creating parallel Web/TUI interfaces), but it was actually building more complicated Web scaffolding, rather than it being deterministically rendered from a specification by the harness.

I'm exploring aspects of these "other ways". I've been pushing Kitty terminal graphics compositing and then layering libraries over that. I've also been working on remoting Golang programs over the network as well as compiling them to WASM and embedding that in browsers. This WebGPU browser shader is an example of that mashed together [1]. Same code for native and browser.

Shout out to TUIOS [2] that is in the article; author has a lot of neat libraries and his `sip` protocol is the basis of that remoting work.

[1] https://nimblemarkets.github.io/ntcharts/demos/shaders/

[2] https://github.com/Gaurav-Gosain/tuios

Good news everybody, I spent a Sunday afternoon on a cloud AMD GPU to work out ROCm builds and ds4go support [1]. I also released the vibe-slop ds4go-apps ;0 [2]

While upstream ds4 only supports Strix, this also handles other AMD GPU architectures (because my cloud MI325X wasn't working at first).

[1] https://github.com/NimbleMarkets/ds4go/blob/main/CHANGELOG.m...

[2] https://github.com/NimbleMarkets/ds4go-apps#running-the-apps

There were ROCM commits to ds4 in late summer, so that's probably related. We include a ROCm build with ds4go (links elsewhere in this comment section), but it is absolutely untested by us whereas the Mac and DGX Spark are very tested.

I just put up videos of some of the ds4go I mentioned. Most of it is long and boring, but it's there.

https://gist.github.com/neomantra/d49df05d6b137b9e6844186499...

I started playing with local LLM+MCP in April 2025... I had to beg Qwen to look at the tool list and try anything.

These ds4 models, will happily call tools and all those harnesses I've made are composed of custom tools.

Once the HuggingFace+OpenAI showed how powerful notes are, I added a scratchpad tool to ds4go to improve self-improvement.

While you can do 64G/96G with the Qwen3.8 model, realistically you need 128G. Also, despite tons of playing with local models, the cloud-hosted models on bigger iron are smarter and faster. I don't truly code with my local models and don't recommend this path right now to replace something like Opus/Astra or full-brain DeepSeek4.

The "frontier-ness" of ds4 is great though! It has vast knowledge and thinking capability. Look at that steering video especially. I'm now exploring using ds4 for high-level thinking to create prompts for denser coding models.

I maintain a fork of ds4 as shared libraries and thus can be used with other languages via FFI, along with public builds/binaries [1]. I made ds4go [2] against ds4 using techniques inspired by yzma.

In addition to the library bindings, we have a small library of tools (workspace for view/edit, scratchpad for persistence) and making your own is registering a Go function. And in recent weeks, I added the Vision and Qwen support, as ds4 added them.

Even if you don't use the Go library, the ds4go binary makes it really easy to download the libraries off of HuggingFace with a TUI available vie Homebrew.

Here's some TUI toy screenshots, sorry I still haven't released that code; it's of different quality than the others. [3]

EDIT: add ds4go TUI screenshot gist [4]

[1] https://github.com/NimbleMarkets/ds4/releases/tag/v0.8.20260...

[2] https://github.com/nimblemarkets/ds4go#install

[3] https://gist.github.com/neomantra/ae47422c8daf7a458212c93992...

[4] https://gist.github.com/neomantra/40180ade13df93290250ce8c6d...

Thanks for referencing that. I'm similarly doing independent research and feel like I "do", but not much more. As I've previously researched in either academic and corporate settings, where there is so much other scaffolding, that helped outline some ways to contextualize and activate.

I love that library -- perfect for multi-user TUIs -- and thought its associated Wish SAAS with multi-key identity and KV store was a fantastic idea.

I hadn’t heard of ASD-STE100 until last month when the TinyGo AGENTS.md added it as a requirement, along with some other tidbits to improve life for maintainers.

It’s been really productive and I’ve been asking my agents to communicate using it more and more. I believe it’s relieved my cognitive load a bit while working with them.

https://github.com/tinygo-org/tinygo/blob/dev/AGENTS.md

That is a good point — alignment training is intrinsically intentional, RL needs goals, etc.

Edited for clarity, thank you. I wasn't trying to muddy the waters (doesn't mean I didn't), it's a term I've used for a long time. I did mistakenly think the quotes would help disambiguate. I don't know what Knight called them; the first S in "SMARS" is Smart.

Thanks for the feedback, I have edited to not confuse.

I considered it relevant as it involves the algorithmic/computing implosion of a 17-year-old market making company, in the young field of electronic trading agents, with heavy regulation Federally (SEC) and industry self-regulation (FINRA), which includes compliance and audits. Mandatory pre-trade rules such as 15(c)3-5 were less than 5 years old then and even more regulation came out of that incident.

The article is calling for embedding, controls, and regulation in LLMs. Understanding how the same processes utterly failed a decade ago might be useful in understanding how to proceed.

[In 2013], "Agents" caused Knight Capital to lose $450M in 45 minutes [1]. Implemented by humans and effected by computers, in the end it was really because of two reasons:

* multiple levels of inappropriate controls and unintended consequences in several complex systems

* the inability, both politically and technically, to turn it off

[1] https://www.sec.gov/files/litigation/admin/2013/34-70694.pdf

EDIT: Comments indicated I was confusing, so I added a date to make clear that this is pre-LLM agents. My apologies, I intended to illustrate parallels and the post-mortem so we can learn from it.

On disposable code, I’m waiting on an Adafruit Feather microcontroller to come in the mail. I asked Astra to make a me web-based Feather simulator, kinda like the iOS simulator with screen and buttons, so I could work on my UX while I waited.

Something like that would have been a multi-month project a year ago, but I did it in twenty minutes rather than pay for expedited shipping.

Noting that qDot already figured all this out, along with a discovery layer. The spec has not been publicly released, can anybody verify if MHS wraps buttplug.io like MCP wraps JSON-RPC?

I am more interested in the question of how Y-Combinator has changed Stanford over the last two decades rather than the question of how Stanford should change to accommodate Y-Combinator.

Notice there is no mention of ethics, philosophy, or human connection, except maybe Zuck being a psych major. Do we really want the future of education to be an incubator pipeline?

That said I wholehearted agree with the second half of this paragraph: "In fact there are only two things universities need to change to be perfect at preparing founders: they need to make students feel that starting a startup is something they can do, and they need to encourage them to work on their own projects."

For the first part, I suspect that money, and the safety net it provides, is a bigger impediment to entrepreneurship than its collegiate advocacy. It's hard to start a company or join a fledgling one when you are staring at an immense debt.

I'm making a LED Camel Totem for Burning Man. I had the idea to make a Koons-style balloon animal.

I explored this idea with ChatGPT, asking it to make some reference images. I also asked for some prompt generation. I have weak sketching abilities (it's on my list to improve), so this is how I "storyboard".

To be cheeky, I asked Claude to make balloon simulator from which I could eventually drop into Fusion360 to muck with and 3D print. CamelKoons was born! [1]

I wanted a Golang backend and web frontend. Fable pretty much one-shotted the step-one scaffolding: Golang physical simulation of a single balloon, streaming geometry to a Web application. Vibed through various issues and then step two was multiple balloons with twists (which were just choke points).

In the world of disposable, hyper-focused software, this tool remained static to Dromedary Camel topologies. A generalized topology feature is left as an exercise for the reader's LLM.

I like empowering my agents to loop [2]. So, I used Claude-in-Chrome to do some loops where Claude positioned the Camel and could screenshot it. I also gave it an HTTP endpoint to position the camera for itself and me.

Eventually, I wanted to push views and comments from the Web page, so I added a comment box. Claude Code used its new-to-me "monitoring" feature to watch for that action and react to it in the session. Claude made itself a "look-at-camel" skill, so cute! [3]

While the balloons were looking interesting, I noted it wasn't very Koons-like and Claude reminded me that Koons was art and we were doing physical simulation. So then we started distorting the physical model. Of course we also added model export, etc.

After tokenmaxxing, I ended up with something that was a cross between a poop emoji and an alien dildo.

I'm now learning the Forms feature in Fusion360 and following a great balloon-dog tutorial on YouTube. I think this guitar approach will win out over my Guitar Hero approach.

[1] https://github.com/cameltopia/CamelKoons

[2] https://github.com/ConAcademy/WeaselToonCadova

[3] https://github.com/Cameltopia/CamelKoons/blob/main/.claude/s...

By this statement, do you mean that LLMs really just know about "Tool Calling Tokens" or something else?

The practice described there is close to shamatha (calm abiding). Just sit and when thoughts arrive, simply label it as “thinking” without prejudice or attachment and carry on.

A common occurrence is the thought that oneself is thinking or labeling too much. This is close to the recursion / self-reference you are referring to. The practice thereof is to simply accept that (and your labeling of inner activity and all wrapped up in that) and carry on abiding. The inner chatter that you are not meditating well enough is a funny one.

To get the hang of this, I used Leanstral (Mistral’s LEAN agent) to vibe-code things like “the game of bridge” and then read the LEAN code.

It is a simple prompt that packs a lot:

* operates an absurd prompt

* involves SVG coding knowledge, generates a source code artifact

* involves world knowledge (what is a pelican? What is a bicycle? What does each do?” How are each constructed?”)

* when rendered, the coding artifact expresses an image that makes sense to us perceptually, including color and spatial relationships

* different models and settings have different output so it can be used as an evaluation scheme

That said I wouldn’t choose a model based on this! Just like some brain teaser shouldn’t determine employment eligibility.

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?

[1] https://news.ycombinator.com/item?id=48889335

[2] https://sourcelibrary.org/librarian?thread=6a56c578a50845441...

I have found and used this organically and it is a cool mapping tool!

I used it to get better perspectives on the history and place names in Connecticut, from the Dutch and Siwanoy to modern times.

neb pointed me to SourceLibrary last month! Congrats on this work, it is very cool and very important -- a great example of AI helping humans.

It is a vast and beautiful collection that I spent hours checking out all sorts of documents, especially the Occult and Alchemy.

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

https://github.com/NimbleMarkets/ntcharts/blob/spec/spec/REA...