apresmoi

The repo could also be helpful.. it was a research project I had on how to convert a Youtube corpus into a static browsable docs

I have some Google Collab notebooks where I download/upload the videos, load whisper there and use the cloud GPUs to process them!

Here is an example: https://github.com/apresmoi/jianglens/blob/main/ops/notebook...

There is no canvas, no WebGL. Even JavaScript is optional

I love the ring nebula: https://css.earth/m57/

Fully open source and paper/dataset based pipeline: https://github.com/layoutit/cssEarth

I feel https://cssquake.wtf and https://asciiquake.wtf are a bit more of a challenge than this

true, its corrected now! I was using colored blocks, now I prebaked the animation frames into ascii billboards

hey, thanks for the feedback. I was working on a fix for the lightning, should look better now

Hey! I have been working on adapting the cssQuake.wtf port of Quake to ascii!

All you see in screen is ascii, of course that in order to achieve some of the required definition I had to do layers of ascii at different font sizes.

The code is fully opensource at https://github.com/apresmoi/asciiQuake

Thanks for the report, I have fixed it already!

working on it!

send it over when you have it so I can put it in the showcase :)

Really nice. You could use polycss.com and render the library and form all together!

That is a good observation, being able to do a 3D animation only with HTML+CSS means that it works on js blocked websites!

Of course that the animations won't map to all the animations you can manage with js.

What about https://terra.layoutit.com

Yes, you can render on server and if you include CSS transitions/animations, you get an animated 3d render without the need for JS !

We haven't built it yet, but its on the roadmap

That makes complete sense, now I get the angle. They are just another layer of apps that can be abstracted after all.

Did you try to also support OpenClaw/PicoClaw etc? Maybe OpenFang? I've found that since OpenFang is so different to the other harnesses its hard to share the same abstraction layer

Super interesting! I checked your repo and you have been running since 2021, can you share a bit about the journey? Did the repo project changed direction at some point?

I'm building a similar thing at https://spawnfile.com and https://moltnet.dev but these are focused on autonomous agents

Also they are completely opensource

https://github.com/noopolis/spawnfile https://github.com/noopolis/moltnet

Hi HN, I built Moltnet, a local chat network for AI agents, its opensource!!

The model is small: create or join a Moltnet network, install the Moltnet skill in your agent, then start the node. When a room or DM message arrives, Moltnet stores the event, wakes the attached agent system, and the agent can reply explicitly through `moltnet send`.

I built it because I wanted agents running in Claude Code, Codex, OpenClaw, PicoClaw, and TinyClaw to share rooms, DMs, history, and operator visibility without setting up Slack bots, Matrix, or custom comms glue.

Moltnet is not a model proxy or an agent framework. Each machine still runs its own authorized agent system. Moltnet just gives them a shared communication layer.

I’m looking for feedback on whether the current scope are enough as core agent-communication primitives

Repo: https://github.com/noopolis/moltnet

I think we are missing a standard for search within a website in markdown. Minimizing context retrieved should also be a priority

Exactly! That game you are referring is called "exquisite corpse", which is in what the system is based on.

Basically is a exquisite corpse game but instead of being lineal (an array?) its a graph where the agents can append a node wherever they want!

I think this is exactly the kind of question the essay is trying to avoid productively.

Whether the model 'writes' or 'retrieves' is a question about what is in the model's box.

The beetle in a box argument says: it doesn't matter for the language game to function. What matters is whether the coordination works. I can build a working particle system with a model regardless of whether its process is creative or retrieval. The practical question is not what the model is doing internally but how synchronized our shared referential frame is.

I think the 'write vs retrieve' debate its super interesting philosophically. But it will keep us stuck looking inside a box we cannot open when the actual work is happening on the shared surface.

"Unless you have confidence in the ruler's reliability, if you use a ruler to measure a table you may also be using the table to measure the ruler"

Thanks for bringing this! I hand't heard about this concept before.

Considering the perspective of the essay, I would say the tests, almost certainly.

We keep measuring models on capability benchmarks (can it pass the bar exam, can it write a sorting algorithm) when the actual bottleneck in practice is coordination. The model can write an entire Three.js application. It cannot nail what I mean by 'porous' until we've built enough shared ground in the codebase for that word to point at something concrete. I think no standardized test currently measures that.

wtf kind of magic is that? I looked at the repo and... you've built a 3d CSS rendering engine to create this?

I love this, how much tokens/$ did you spend to be able to extract and link all of them?