aziis98

It is absurd how this kind of anticipated ssd streaming

I started doing a rewatch a few weeks ago xD

Seeing it now the show also has some pretty fun foreshadowing of llm technology like an episode where they anticipate the idea of "ssd streaming" (running a model slower when you don't have enough memory to fit it all at once), at least this is how I interpreted it to make the connection.

And there are many others connections that now can be made thinking about llms vs the machine

Oh and they also anticipated the openai incident where models started using random stuff as external persistent memory across "sessions"

Ok the custom rich text latex editor is really cool. But I'm on a tablet and stuff like selecting text is a bit awkward (the up down auto scroll is not exactly the same as the native one and isn't as precise as the native one).

But still this is an awesome project!

Exactly the same for me! I love it for the terminal especially

Just tried this on my Intel Ultra 7 255H, I also only have an iGPU. This does ~22tps! Love this.

I just had to do a little patch to support my iGPU device that is a bit newer than Intel Xe-LP, maybe I'll do a PR.

On a side note the other day I was experimenting with Sonnet 5.5. I gave it the llama cpp repo and told it to extract in a single file inference for a single model + backend (qwen3.5 4b mtp + sycl) and (after a long time) it actually worked! It produced a ~1400 lines file with no deps. I need to check the quality of inference yet but I think this is still a great achievement.

I'm pretty sure 2027 will be a very interesting year for local models and inference.

When for the training part you have to consider brains had like billions of years to develop. Maybe one of the reasons llms seem to be so expensive to train is because we are "compressing" in far less time that learning part

For me, at least for agentic use, you need at least ~40tps. Less might be good only for tasks you could run in the background (like at night maybe).

Instead of coding agents like tool for local models I would like to see more "docker ps" like tools where you can queue up tasks that get processes incrementally (maybe when the pc i idle) and are specialized for doing retries and caching as much work as possible to work decently with slow local models.

I also made my own variant recently. I really liked the idea of litmaps but I didn't really like the UI/UX or "graph expand" feature (it uses some internal heuristic that is not very clear).

https://paper-explorer.aziis98.com/ (also on github https://github.com/aziis98/paper-explorer)

This uses OpenAlex as a source of articles and to let you explore the citation graph of papers. This is still a prototype mostly made to test out how far I could go with vibecoding (well I still checked the code now and then) something without a js framework. Someday I think I will add more features to it, but now there is already a somewhat working version of import/export so I'm fine with it.

This would be nice as an Astro (or generic meta-framework plugin) that automatically parses all generated html files and generates a small db of embeddings.

This way on the frontend you can lazily load this. Maybe you could even store the HNSW in chunks and just load the pieces you need for your specific search query.

i.e. like https://pagefind.app/ but to get fully static vector search.

Is this GUI only?

Love it!

I also did some experiments some time ago. The thing this is missing for me is the ability to also run arbitrary commands other that just using a few premade apps. In fact I think this stuff becomes really interesting when you put a real "shell" on top of this.

And I don't mean a classical posix shell, something that can be used to leverage the full power of the custom ui and frontend. Also a must have is "nestable connections".

The experiment I was doing was with a web interface and a statically compiled Go backend (for easy deployment via ssh). Maybe some day I will finish it xD

Wow, awesome project! I gave a look a bit at the code (before realizing this was made with coding agents as said below on the website) and this seems really well made.

Still, I would really like to know how you approached this from an architecture perspective. I'm also curious to how much coding agents structured the code like so by themselves or if you had to steer them heavily (I've just tried a bit gemini flash from antigravity cli so I'm a bit behind on this).

Also how did you approach the rendering correspondence with actual tikz code? Do you have some tests that like render the tikz using latex and your js pipeline and compare the result for differences?

> I was able to get I think 20 or 30 tokens per second on CPU (DDR4 ram) alone

What are you using for inference? I have a recent intel laptop with 32GB of DDR5 and I am getting at most 25tps with the llama cpp vulkan backend (that is the fastest, I also tried sycl but it is a bit slower)

I just tried the Q4_K_M variant of this [] and this is one of the first models that run at ~20tps on my laptop. I also tried it with some "hard" maths questions and it clearly knows much. Can't wait to try some local coding agent harnesses with it (I recently discovered kon [1] and dirac [2] and wanted to try them out)

The only thing I'm not sure about is if this model supports thinking or not.

[1]: https://github.com/0xku/kon

[2]: https://github.com/dirac-run/dirac

I also did some experiments in this space as I have the same complaints about Tailwind

https://github.com/aziis98/preact-css-extract

I made this as I couldn't stand writing another 2K lines css file and wanted to try the atomic css wagon without having to switch from preact or having to learn tailwind

On Firefox and Chrome the rectangle to make a query is offset wrong relative to the mouse D:

Does anybody know if I can try this online?

> The win? Massive.

But there are benchmark numbers at least, so maybe they only used it for the prose

Why didn't I know about this before

I hope we get to good A1B models as I'm currently GPU poor and can only do inference on CPU for now

This simply solved icons for me

The real problem vdom and more complex frameworks solve for me is dealing with much more complex state i.e. lists.

When dealing with lists there are so many possible ways of updating them (full updates, insertion/removal at an index, update at an index, ...) that manually mounting and unmounting single items by hand gets unbearable. You must then do some kind of diffing at the framework level to get good performance and readable code.

I would like to see "VanillaJS" articles talk both more and more in depth about this problem.

Still the whole world runs on GC-ed languages so it must be an abstraction at least some people like to work with.

And I'm pretty sure using a GC in some cases it's the only option to not go crazy.

I don't get how this would be more "ai friendly" than other frameworks, that kind of propositions should be backed by more concrete proof. I know that this is a kind of open problem but at least show me this can be easily generated with common models without an enormous reference prompt.

Another thing is that this looks like any other framework out there. I think you can map every one of it's features mostly 1-1 to SolidJS. What is the novelty here? The slightly changed js syntax with "component", "@" and "#"?

I would like to see more radical and new ideas in the js space, expecially in this period. Maybe a new take on Elm to get stronger UI stability guarantees. Or even just some very good tooling to reason about very large reactivity graphs at runtime and (maybe also at) compile time.

That said I still appreciate the work and in particular all the effort spent making the new syntax work in all common editors, I see they support vscode, intellij, sublime, ...

Edit: In the actual documentation they provide an llm.txt https://www.ripplejs.com/llms.txt

The erdos problem website tells the theorem is formalized in Lean but on the mathlib project there is just the theorem statement with a sorry. Does someone know where I can find the lean proof? I don't know maybe it's in some random pull request I didn't find.

Edit: Found it here https://github.com/plby/lean-proofs/blob/main/src/v4.24.0/Er...

There are many made with eval-unescape-escape that feel a bit like cheating. Still all very impressive

I didn't know about JBang, it looks awesome. Does it work somewhat like uv?

I would actually merge html and js in a single language and bring the layout part of css too (something like having grid and flexbox be elements themselves instead of display styles, more typst kind of showed this is possible in a nice way) and keep css only for the styling part.

Or maybe just make it all a single lispy language

I know this is a bit out of scope for these image editing models but I always try this experiment [1] of drawing a "random" triangle and then doing some geometric construction and they mess up in very funny ways. These models can't "see" very well. I think [2] is still very relevant.

[1]: https://chatgpt.com/share/6941c96c-c160-8005-bea6-c809e58591...

[2]: https://vlmsareblind.github.io/

> Pointing capability: Gemini 3 has the ability to point at specific locations in images by outputting pixel-precise coordinates. Sequences of 2D points can be strung together to perform complex tasks, such as estimating human poses or reflecting trajectories over time

Does somebody know how to correctly prompt the model for these tasks or even better provide some docs? The pictures with the pretty markers are appreciated but that section is a bit vague and without references