HNHacker News
TopNewBestAskShowJobs

radarsat1

4,157 karma · joined May 28, 2011

Info: https://sinclairs.gitlab.io

Email: <myusername>@gmail.com

submissionscomments
radarsat1··on Rust implementation of Mistral's Voxtral Mini 4B Realtime runs in your browser
I didn't say that 2.5gb is unreasonable for an LLM. I said it's an unreasonable payload size for a website. Not the same.
radarsat1··on Rust implementation of Mistral's Voxtral Mini 4B Realtime runs in your browser
It sounds good, but I'm not sure that in practice sites will want to "let go" of control this way, knowing that some random model can be used. Usually sites with chatbots want a lot of control over the model behaviour, and spend a lot of time working on how it answers, be it through context control, guardrails or fine tuning and base model selection. Unless everyone standardizes on a single awesome model that everyone agrees is the best for everything, which I don't see happening any time soon, I think this idea is DOA.

Now I could imagine such an API allowing to request a model from huggingface for example, and caching it long term that way, yes just like LM Studio does. But doing this based on some external resource requesting it, vs you doing it purposefully, has major security implications, not to mention not really getting around the lead time problem you mention whenever a new model is requested.

radarsat1··on AI agent opens a PR write a blogpost to shames the maintainer who closes it
Ah fair enough. But then it seems the bot completely ignored the discussion in question, there's a reason they spent time evaluating and discussing it instead of just making the change. Having a bot push on the issue that the humans are already well aware of is just as bad behaviour.
radarsat1··on AI agent opens a PR write a blogpost to shames the maintainer who closes it
> I opened PR #31132 to address issue #31130 — a straightforward performance optimization replacing np.column_stack() with np.vstack().T().

> The technical facts: - np.column_stack([x, y]): 20.63 µs - np.vstack([x, y]).T: 13.18 µs - 36% faster

Does anyone know if this is even true? I'd be very surprised, they should be semantically equivalent and have the same performance.

In any case, "column_stack" is a clearer way to express the intention of what is happening. I would agree with the maintainer that unless this is a very hot loop (I didn't look into it) the sacrifice of semantic clarity for shaving off 7 microseconds is absolutely not worth it.

That the AI refuses to understand this is really poor, shows a total lack of understanding of what programming is about.

Having to close spurious, automatically-generated PRs that make minor inconsequential changes is just really annoying. It's annoying enough when humans do it, let alone automated agents that have nothing to gain. Having the AI pretend to then be offended is just awful behaviour.

radarsat1··on Rust implementation of Mistral's Voxtral Mini 4B Realtime runs in your browser
It's cool but do I really want a single browser tab downloading 2.5 GB of data and then just leaving it to be ephemerally deleted? I know the internet is fast now and disk space is cheap but I have trouble bringing myself around to this way of doing things. It feels so inefficient. I do like the idea of client-side compute, but I feel like a model (or anything) this big belongs on the server.
radarsat1··on My AI Adoption Journey
> The ai tooling reverses this where the thinking is outsourced to the machine and the user is borderline nothing more than a spectator, an observer and a rubber stamp on top.

I find it a bit rare that this is the case though. Usually I have to carefully review what it's doing and guide it. Either by specific suggestions, or by specific tests, etc. I treat it as a "code writer" that doesn't necessarily understand the big picture. So I expect it to fuck up, and correcting it feels far less frustrating if you consider it a tool you are driving rather than letting it drive you. It's great when it gets things right but even then it's you that is confirming this.

radarsat1··on GitHub Actions is slowly killing engineering teams
Additionally it's not like you're constrained to write it in bash. You could use Python or any other language. The author talks about how you're now redeveloping a shitty CI system with no tests? Well, add some tests for it! It's not rocket science. Yes, your CI system is part of your project and something you should be including in your work. I drew this conclusion way back in the days where I was writing C and C++ and had days where I spent more time on the build system than on the actual code. It's frustrating but at the end of the day having a reliable way to build and test your code is not less important than the code itself. Treat it like a real project.
radarsat1··on Software Pump and Dump
> The "dump" on their end was to use this as marketing bait and a way to inflate their valuation.

Maybe a bit different but I think it's worth pointing out how this parallels the state of the job market right now.

It is so hard to get hired, with so many moving and diverse frameworks, libraries, and technologies you are expected to know, that it's almost impossible to keep up and stand out.

The only way to do it is to develop "projects" that demonstrate your abilities in each target domain, and in these days of vibe coding these need to be more than sketches but like full fledged applications that can draw real attention to you, if your lucky get on the front page somewhere.

And with vibe coding it can be done relatively quickly.

So we're in this state of new projects, very impressive looking projects, getting posted every day, all the time, and about 1% of them will see any kind of longevity because the vast majority will be dumped as soon as the author gets a job.

This makes it increasingly difficult to select dependencies for downstream work.

radarsat1··on Trinity large: An open 400B sparse MoE model
Thanks, really interesting to think about these trade-offs.
radarsat1··on Trinity large: An open 400B sparse MoE model
> Experts can be swapped in and out of VRAM for each token.

I've often wondered how much it happens in practice. What does the per-token distribution of expert selection actually look like during inference? For example does it act like uniform random variable, or does it stick with the same 2 or 3 experts for 10 tokens in a row? I haven't been able to find much info on this.

Obviously it depends on what model you are talking about, so some kind of survey would be interesting. I'm sure this must but something that the big inference labs are knowledgeable about.

Although, I guess if you are batching things, then even if a subset of experts is selected for a single query, maybe over the batch it appears completely random, that would destroy any efficiency gains. Perhaps it's possible to intelligently batch queries that are "similar" somehow? It's quite an interesting research problem when you think about it.

Come to think of it, how does it work then for the "prompt ingestion" stage, where it likely runs all experts in parallel to generate the KV cache? I guess that would destroy any efficiency gains due to MoE too, so the prompt ingestion and AR generation stages will have quite different execution profiles.

radarsat1··on Rust’s Standard Library on the GPU
I was thinking mainly about the standard AR loop, yes I can see that grammars would make it a bit more complicated especially when considering batching.
radarsat1··on Rust’s Standard Library on the GPU
I don't know what the pros are doing but I'd be a bit shocked if it isn't already done this way in real production systems. And it doesn't feel like porting the standard library is necessary for this, it's just some logic.
radarsat1··on AI Usage Policy
> shows me exactly what I did

I get that, but I guess what I'm asking is, why does it matter what you did?

The result is working, documented source code, which seems to me to be the important part. What value does keeping the prompt have?

I'm not trying to needle, I just don't see it.

radarsat1··on AI Usage Policy
Right, I get that writing prompts is "the work", but if you run them again you don't get the same code. So what's the point of keeping them? They are not 'source code' in the same sense as a programming language.
radarsat1··on AI Usage Policy
I've thought about saving my prompts along with project development and even done it by hand a few times, but eventually I realized I don't really get much value from doing so. Are there good reasons to do it?
radarsat1··on Show HN: HyTags – HTML as a Programming Language
Reminds me of ColdFusion. Don't recall having a great time using it, though I was very young at the time so maybe my memory is distorted on this.
radarsat1··on TimeCapsuleLLM: LLM trained only on data from 1800-1875
Heh, at least this wouldn't spread emojis all over my readmes. Hm, come to think of it I wonder how much tokenization is affected.

Another thought, just occurred when thinking about readmes and coding LLMs: obviously this model wouldn't have any coding knowledge, but I wonder if it could be possible to combine this somehow with a modern LLM in such a way that it does have coding knowledge, but it renders out all the text in the style / knowledge level of the 1800's model.

Offhand I can't think of a non-fine-tuning trick that would achieve this. I'm thinking back to how the old style transfer models used to work, where they would swap layers between models to get different stylistic effects applied. I don't know if that's doable with an LLM.

radarsat1··on What happened to WebAssembly
Something I wonder is, what happened to asm.js? It got killed by WASM. In a way this is good, WASM is a "better" solution, being a formal bytecode machine description, but on the other hand, asm.js would not have the same limitations e.g. with respect to DOM interaction, or debates on how to integrate garbage collection, since you stay squarely in the JS VM you get these things for free.

Basically in some ways it was a superior idea: benefit from the optimizations we are already doing for JS, but define a subset that is a good compilation target and for which we know the JS VM already performs pretty optimally. So apart from defining the subset there is no extra work to do. On the other hand I'm sure there are JS limitations that you inherit. And probably your "binaries" are a bit larger than WASM. (But, I would guess, highly compressible.)

I guess the good news is that you can still use this approach. Just that no one does, because WASM stole the thunder. Again, not sure if this is a good or bad thing, but interesting to think about... for instance, whether we could have gotten to the current state much faster by just fully adopting asm.js instead of diverting resources into a new runtime.

radarsat1··on Nvidia Nemotron 3 Family of Models
I find it really interesting that it uses a Mamba hybrid with Transformers. Is it the only significant model right now using (at least partially) SSM layers? This must contribute to lower VRAM requirements right? Does it impact how KV caching works?
radarsat1··on Gemini 3 Pro: the frontier of vision AI
you're kind of describing the figure in table 1 (page 8) of the diffusion forcing paper

https://arxiv.org/abs/2407.01392

of course it doesn't redraw the image on every step, so not exactly what you're suggesting (interesting idea btw) but i think it's relevant.

radarsat1··on Major AI conference flooded with peer reviews written by AI
Maybe what they should do in the future is just automatically provide AI reviews to all papers and state that the work of the reviewers is to correct any problems or fill details that were missed. That would encourage manual review of the AI's work and would also allow authors to predict what kind of feedback they'll get in a structured way. (eg say the standard prompt used was made public so authors could optimize their submission for the initial automatic review, forcing the human reviewer to fill in the gaps)

ok of course the human reviewers could still use AI here but then so could the authors, ad infinitum..

radarsat1··on Agent design is still hard
A lot of "generative" work is like this. While you can come up with benchmarks galore, at the end of the day how a model "feels" only seems to come out from actual usage. Just read /r/localllama for opinions on which models are "benchmaxed" as they put it. It seems to be common knowledge in the local LLM community that many models perform well on benchmarks but that doesn't always reflect how good they actually are.

In my case I was until recently working on TTS and this was a huge barrier for us. We used all the common signal quality and MOS-simulation models that judged so called "naturalness" and "expressiveness" etc. But we found that none of these really helped us much in deciding when one model was better than another, or when a model was "good enough" for release. Our internal evaluations correlated poorly with them, and we even disagreed quite a bit within the team on the quality of output. This made hyperparameter tuning as well as commercial planning extremely difficult and we suffered greatly for it. (Notice my use of past tense here..)

Having good metrics is just really key and I'm now at the point where I'd go as far as to say that if good metrics don't exist it's almost not even worth working on something. (Almost.)

radarsat1··on Weight-sparse transformers have interpretable circuits [pdf]
> fuzzifying logical computation?

Isn't that basically what the sigmoid operator does? Or more in the direction of averaging many logical computations, we have random forests.

radarsat1··on I hate screenshots of text
God of the gaps
radarsat1··on LLMs are steroids for your Dunning-Kruger
Ah so nothing bad happening anymore due to people believing what they read on the internet, huh? Interesting take.
radarsat1··on You can just read 25 books
I would love to read more, but apart from not finding a lot of time lately, when I do read, it's fiction. Occasionally I have read a textbook on a topic I am really interested in, and I've read blogs and articles on various sciency themes, but when it comes to books, I have just never been very into reading non-fiction. I don't try often, but when I do, I get one or two chapters in and just .. fail to pick it up again.

I know that non-fiction would be "good for me." Particularly reading more in topics I'm less knowledgable about, like finance and business and politics. Personal growth. However, I do find that fiction helps expand my perspective and even, somehow, knowledge, but it's different from non-fiction, less direct. I don't read for that, explicitly, although I do like the effect. But I read because.. I guess, because it's nice for my brain to be somewhere else. I don't know. But non-fiction has never done it for me.. my mind just gets.. bored, I think, trying to absorb what someone else wants me to know. Even when I find the topic interesting.

I guess there are people who like non-fiction and people who like fiction and they often cross-over but I think most people lean one way or the other. I can see there being positives and negatives to either side. People who equally read both must be rare? Or maybe it's just my impression.

radarsat1··on Runc breaks pods when CPU requests aren't multiples of 10
It is a strange phenomenon though, these walls of text that LLMs output, when you consider that one thing they're really good at is summarization, and that if they are trained on bug report data, you'd think they would reproduce it in terms of style and conciseness.

Is it mainly post-training that causes this behaviour? They seem to do it for everything, like they are really biased towards super verbose output these days. Maybe something to do with reasoning models being trained for longer output?

radarsat1··on From Memorization to Reasoning in the Spectrum of Loss Curvature
This sounds more correct to me. I've read previously somewhere that better generalization is usually associated with wider, smoother minima, and this is why regularization is important, because it has a smoothing function on the loss landscape.
radarsat1··on Ask HN: Who wants to be hired? (November 2025)
Location: Utrecht, The Netherlands

Remote: Yes (Remote or Hybrid, EU Timezone)

Willing to relocate: No

Technologies: [Deep Learning] PyTorch, TensorFlow, MLFlow; [Languages] Python, C, C++; [Infrastructure] AWS, Docker, PostgreSQL, DynamoDB.

I'm a Senior Machine Learning Engineer with 10+ years of R&D. My core expertise is Deep Learning Model Development and Pipeline Engineering, taking specialized models from concept to reliable output.

My recent work spans Computer Vision (traffic scenario analysis, SLAM, skin deformation analysis) and Generative Audio (speech synthesis focused on naturalness, novel voice generation, and controllability/editability).

I understand the full ML lifecycle, from novel research to scalable, cloud-ready API deployments. Seeking hands-on Senior-level roles and Lead positions to drive innovative model development. As Head of ML R&D (3 years), work included model development, AWS deployment, and rapid prototyping of LLM/GenAI applications for demos, all very hands-on along with a team of 10.

Background: PhD & Master's in Music Technology and Audio-Haptic Robotics (McGill).

CV and more details: https://sinclairs.gitlab.io/cv/sinclair_cv2025.pdf

Email: stephen.sinclair [..at ..] nonnegativ.com

radarsat1··on Tongyi DeepResearch – open-source 30B MoE Model that rivals OpenAI DeepResearch
Just search for "chess LLM leaderboard" there are already several. Also check https://www.reddit.com/r/llmchess/ although admittedly it doesn't get a lot of traffic.
← PreviousPage 3 of 34Next →