neomantra

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

I tried making a port of buttplug-mcp called a2a4a2a.

Really nice exploration, and their other posts are interesting too!

We used Perlin noise for demos of our Golang/BubbleTea terminal Glyph heatmap widget and then later with our Picture widget.

Live WASM demos of the Golang terminal programs:

https://nimblemarkets.github.io/ntcharts/demos/heatmap-perli...

https://nimblemarkets.github.io/ntcharts/demos/heatpicture-p... Press 't' to switch between glyph/image modes

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

https://antirez.com/news/164

https://github.com/redis/redis/pull/15162

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

https://nimblemarkets.github.io/ntcharts/demos/heatpicture-p...

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

I've recently made SVG, PDF, SVG, and OpenStreetMap widgets.... https://github.com/NimbleMarkets/ntcharts-svg https://github.com/NimbleMarkets/ntcharts-pdf https://github.com/NimbleMarkets/ntcharts-osm

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:

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

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

Literal #showerthought: "why don't you just make the same thing for ds4, it will be awesome"

Toweled off and got to work:

https://github.com/NimbleMarkets/ds4-go

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

https://github.com/hybridgroup/yzma

And thank you antirez for using your rep and quality output to push this line of evangelism; it is even more important than the software itself.

The official F5 page is here: https://my.f5.com/manage/s/article/K000161019

As noted elsewhere, ASLR protects you. While you are waiting for your affected platform to get the fix, they note the mitigation:

"use named captures instead of unnamed captures in rewrite definition"

"To mitigate this vulnerability for this example, replace $1 and $2 with the appropriate named captures, $user_id and $section"

F5 patched 1.31.0 and 1.30.1.

OpenResty has a patch for 1.27 and 1.29: https://github.com/openresty/openresty/commit/ee60fb9cf645c9...

You can track OpenResty's (a Lua application server based on Nginx) progress here: https://github.com/openresty/openresty/issues/1119

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]