MurphyA/hacker-news huggingface dataset:
by bunnie | 2026-01-18 06:29:11+00:00
I am a maintainer. I think what you're referring to is the problem where `std` is actually a veneer on C - so for example, when Rust allocates memory on an x86-class desktop, it actually invokes a C library (jemalloc, or whatever the OS is using) and that networking is all built on top of libc. Thus a bunch of nice things like threads, time, filesystem, allocators are all actually the same old C libraries that everything else uses underneath a patina of Rust.

In Xous, considerable effort went in to build the entire `std` in Rust as well, so no C compilers are required to build the OS, including `std`. You can see some of the bindings here in the Rust fork that we maintain: https://github.com/betrusted-io/rust/tree/1.92.0-xous/librar...

Thus to boot the OS, a few lines of assembly are required to set up the stack pointer and some default exception handler state, and from there we jump into Rust and stay in Rust. Even the bootloaders are written in Rust using the small assembly shim then jump to Rust trick.

Xous is Tier-3 Rust OS, so we are listed as a stable Rust target. We build and host the binaries for our `std` library, which native rustc knows how to link against.
by utopiah | 2026-01-18 06:29:55+00:00
Is there though? If they are "solved" (as in the tickbox mark them as such, through a validation process, e.g. another model confirming, formal proof passing, etc) but there is no human actually learning from them, what's the benefit? Completing a list?

I believe the ones that are NOT studied are precisely because they are seen as uninteresting. Even if they were to be solved in an interesting way, if nobody sees the proof because they are just too many and they are again not considered valuable then I don't see what is gained.
by cik | 2026-01-18 06:34:07+00:00
I don't think the dream of replacing developers, in particular exists. Specialization of labour leads to increased costs, due to value placed on said specialized labour. Software development, is one form of specialized manufacturing, and hence is more costly. Within software development, similar strata exists, leading to increased value on increased specialization, and hence the pyramid effect. The same is true within any field.

Similarly, one might argue as increased capital finds its way to a given field, due to increased outcomes, labour in turn helps pressure pricing. Increased "sales" opportunity within said field (i.e people being skilled enough to be employed, or specialized therein) will similarly lead to pricing pressure - on both ends.
by fc417fc802 | 2026-01-18 06:35:14+00:00
The login page example was actually perfect for illustrating this. Meshing polygons? Centering a div? Go ahead and turn the LLM loose. If you miss any bugs you can just fix them when they get reported.

But if it's security critical? You'd better be touching every single line of code and you'd better fully understand what each one does, what could go wrong in the wild, how the approach taken compares to best practices, and how an attacker might go about trying to exploit what you've authored. Anything less is negligence on your part.
by Animats | 2026-01-18 06:37:02+00:00
That's a neat little system.

Two surprising design decisions:

- One-way messages. You send, then, in a separate operation, you wait for a reply. This happens at each end. That means two extra trips through the scheduler and more time jitter. QNX has a blocking "MsgSend" which sends and waits for a reply. The scheduler transfers control to the receiving thread in the common case where the receiver is waiting, which behaves like a coroutine with bounded latency. It's a subtle point, but one of the reasons QNX is so well behaved about jitter.

- Interprocess communication by memory remapping instead of copying. This is high overhead for small messages, and at some fairly large size, becomes a win. Remapping pages means a lot of MMU and cache churn. Cost varies with the CPU and memory architecture. Mach worked that way, and the overhead was high. Not sure how expensive it is with modern MMUs. Do you have to stop other threads that might have access to the page about to be unmapped?
by VorpalWay | 2026-01-18 06:37:25+00:00
You need to ring when you are still some way away, so they have time to react, and if they don't you can slow down and ring a second time. And travel at an appropriate speed for the location.

(I have an ebike, so this is especially important. Mine is a legal one: 25 km/h max, 250 W, etc. If yours is faster, this is even more important.)
Show HN: I Replaced Vector DBs with Optimal Transport (Open Source Project))
by MohskiBroskiAI | 2026-01-18 06:37:34+00:00
I spent the last few months frustrated with RAG hallucinations and the cost of vector databases ($2k/mo for Pinecone).

I realized that Cosine Similarity is often a weak proxy for semantic truth, so I built a memory protocol based on Wasserstein-2 Distance (Optimal Transport) instead.

The core idea: Treat memory as a geometry problem. By measuring the transport cost between the "Stored State" and the "Retrieved State," we can mathematically enforce coherence. If the transport cost exceeds a threshold ($W_2 > \epsilon$), the system rejects the memory rather than hallucinating.The Benchmarks (Local CPU):Coherence: 0.96 (vs ~0.67 for standard RAG)Efficiency: 40x compression ratio via state s
ynthesis.Cost: $0 (No external DBs; runs in-process).I’ve packaged the core protocol into a Python library (pip install remember-me-ai). The repo also includes a CLI "Cognitive Shell" I used to test it (with local models/voice), but the real engineering value is in src/rememberme/csnp.py.It’s MIT licensed. I’m looking for feedback on the optimal transport implementation—specifically edge cases where the topological bounds might break.
by O1111OOO | 2026-01-18 06:37:47+00:00
It's not even about preferences for me. I can spend all day in light mode without eyestrain, without issue, very comfortably.

If I encounter a page that's dark mode (GUI), after about a minute or so, I start seeing spots before my eyes that stay with me for quite a while.

To wit... I use these two firefox extensions to convert pages from Dark Mode to Light mode. If one fails, the other usually finds success (I think they work in reverse too):

https://addons.mozilla.org/en-US/firefox/addon/site-color-ch...

https://addons.mozilla.org/en-US/firefox/addon/no-color/

side note: I cannot explain why the terminal (FG/White; BG/Black) feels incredibly comfortable to my eyes. Maybe it's the larger font I use (80 columns = ~2/3rds of my 16" screen width), the right amount of contrast, the fixed spacing...?
by visarga | 2026-01-18 06:40:47+00:00
The "pattern matching" perspective is true if you zoom in close enough, just like "protein reactions in water" is true for brains. But if you zoom out you see both humans and LLMs interact with external environments which provide opportunity for novel exploration. The true source of originality is not inside but in the environment. Making it be all about the model inside is a mistake, what matters more than the model is the data loop and solution space being explored.
by bruce511 | 2026-01-18 06:41:11+00:00
Leaving aside for the moment yesterday advertising and marketing are very different functions (advertising is easy, marketing is hard);

If your target customers are "VC funded companies" then sure, getting in bed with as many VCs as possible is certainly one marketing approach (and probably a good one.)

Certainly you're are a lot of products targeted at businesses who are flush with cash and eager for kit like fancy chairs.

The important part of marketing is knowing who your potential customers are, and the best way for them to get to know you.
Why are websites trying to talk at me?
by LeratoAustini | 2026-01-18 06:41:43+00:00
Why am I seeing this on so many sites recently (in FireFox)? I've seen it half a dozen times in the past month or so, had never noticed it before then.

"You can't use speech synthesis because the speech dispatcher library is missing"

There's a 'learn more' link, but it just talks about getting speech synthesis working in my browser. Searching for the error string returns similar discussions. I don't want to do that (especially if it's some new marketing fad). Obviously it's speech synthesis but *what is it saying?*

The most recent instance was a dell.com product page posted here on HN:

https://www.dell.com/en-us/shop/dell-ultrasharp-52-thunderbolt-hub-monitor-u5226kw/apd/210-bthw/monitors-monitor-accessories

As lots of people on HN will have visited that link I thought somebody might be able to tell me what they heard?
by LargoLasskhyfv | 2026-01-18 06:42:22+00:00
Return In Power...err I mean the liberty to stalk.

They cheaped out though, should have gone for https://en.wikipedia.org/wiki/Gorgon_Stare instead. But maybe it's equivalent, considering the advances in miniaturization, wireless bandwith/latency/cost.

Think of all the porch piracy!1!!
by bunnie | 2026-01-18 06:42:26+00:00
It is true that hardware, by definition, is a big ball of globally mutable state with no guarantees about concurrency, data types, or anything else. However, one could take the view that it's the role of the OS to restrict & refine that raw power into a set of APIs that are safe, through a set of disciplines, such as reasoning through why an unsafe block might actually be sound.

unsafe means that the compiler can't provide any guarantees about what happens inside the unsafe block. However, it is possible to manually ensure those guarantees.

Thus as a matter of discipline every time an unsafe block is used there's a comment next to it recanting the mantra of safety: This `unsafe` is sound because ... all data types are representable, the region is aligned & initialized with valid data, the lifetime is static, we structurally guarantee only one owner at a time (no concurrency issues)...often times in writing that comment, I'll be like, "oh, right. I didn't actually think about concurrency, we're going to need an Atomic somewhere around this to guarantee that" - and that saves me a really hard-to-find concurrency bug down the road.

So while this is a very manual process, I have found the process of documenting safety to be pretty helpful in improving code quality.

Once you've established safety, then you do get some nice things in your life, like Mutexes, Refcells, Arcs, and the whole collections library to build an OS on top of, which saves us a lot of bugs. It is kind of nice to have a situation where if the code compiles, it often just works.
by utopiah | 2026-01-18 06:42:56+00:00
Nothing I can see on https://github.com/bpodgursky/ nor https://bpodgursky.com/projects/ but I'd be curious.

Honestly it's a pattern when arguing about the topic :

- wow AI is amazing!

- OK, why?

- because it can do so much stuff! I'm making so much projects and earning a lot!

- cool, care to share a link to anything?

- ... radio silence or yet another NES emulator or something that is clearly so curated it might have taken more work than without any "AI assistance"
by xobs | 2026-01-18 06:43:07+00:00
> One-way messages

Messages are either one-way (Send or Scalar), or are two-way (BlockingScalar, Lend, or MutableLend). For two-way messages, the calling process inherits the quantum of the sending process, so the only penalty is the cost of two context switches.

> Interprocess communication by memory remapping instead of copying

This is true for Send, Lend, and MutableLend, but for Scalar or BlockingScalar you get 5xusize values instead, which is used for things like `msleep` or `uptime`.

You would have to stop access to other threads that might have access to the page about to be unmapped, but Rust guarantees that if you have a mutable reference, you're the only one with access to the page.
by wincy | 2026-01-18 06:43:27+00:00
I think before heating without smoke, it was perfectly sensible to smoke tobacco because it was the least bad thing you were inhaling on a daily basis, and you were likely going to die of lung cancer regardless. Makes sense we didn’t really discover the risk until after we stopped using wood burning stoves (or burning coal, like Laura Ingalls Wilder’s mother would to in Little House when it was available)
by GCUMstlyHarmls | 2026-01-18 06:43:31+00:00
I've used podman for number of years, possibly too long to really give a good comparison but for the most part it is exactly s/docker/podman. Can't think of anything I've read on the internet that I couldn't just copy the tail of and stick podman in front of it. Any run/build/inspect/volumes/secrets/etc all work like for like by design afaik. There may be additional flags on podmans end for other things it supports (eg: selinux labels).

EDIT: Actually the biggest might be that containers often need a fully qualified name, so instead of `run name/container:latest` you need `run docker.io/name/container:latest`. You can configure default search domains though.

The biggest thing people will (did?) miss is docker-compose. There was a third party `podman-compose` but now it seems that's actually been folded under the official umbrella, along with a `podman compose` command that will "Run compose workloads via an external provider such as docker-compose or podman-compose" so even that gap might be closed up now. Honestly I swapped to just scripting it myself when I swapped to podman - before even the third party podman compose existed, either using sh, .kube files or now systemd units. If you're used to using big 5-10+ container compose files you might have some friction there, might not.

There are differences internally, ex: docker primarily runs as root and has a different networking stack compared to podman, but for most usage on a dev machine it doesn't matter, and matters maybe in a deployment, maybe not.

Unsolicited opinion, I originally found Podman much less intrusive, dockers iptable muckery always rubbed me the wrong way, so it defaulting to userspace and just letting me do any nftable routing I wanted felt much nicer. It also just fees less icky when using it where its default or configuration options were less funnel-you-into-docker.com.

https://github.com/containers/podman-compose
by fc417fc802 | 2026-01-18 06:44:09+00:00
Wasn't transformer 2017? There's been constant AI hype since at least that far back and it's only gotten worse.

If I release a claim once a month that armageddon will happen next month, and then after 20 years it finally does, are all of my past claims vindicated? Or was I spewing nonsense the entire time? What if my claim was the next big pandemic? The next 9.0 earthquake?
by chopratejas | 2026-01-18 06:44:40+00:00
Some results from real world data so far:

┌─────────────────┬─────────────┬──────────────────────────────┐
│ Data Type │ Compression │ Why │
├─────────────────┼─────────────┼──────────────────────────────┤
│ Server logs │ 90%+ │ Highly repetitive patterns │
├─────────────────┼─────────────┼──────────────────────────────┤
│ MCP tool output │ 70%+ │ JSON structure overhead │
├─────────────────┼─────────────┼──────────────────────────────┤
│ Database rows │ 50-70% │ Same schema, many records │
├─────────────────┼─────────────┼──────────────────────────────┤
│ File trees │ 40-50% │ Repeated metadata │
├─────────────────┼─────────────┼──────────────────────────────┤
│ Code diffs │ 0% │ Every line unique │
├─────────────────┼─────────────┼──────────────────────────────┤
│ Dense prose │ -0.3% │ No patterns, slight overhead │
├─────────────────┼─────────────┼──────────────────────────────┤
│ Encrypted │ 0% │ Incompressible │
└─────────────────┴─────────────┴──────────────────────────────┘
by MohskiBroskiAI | 2026-01-18 06:47:11+00:00
The issue isn't the LLM's reasoning; it's the retrieval layer.

Most "Enterprise AI" is just a wrapper around a Vector DB doing cosine similarity. That’s probabilistic. It works 80% of the time, but for an enterprise product, the 20% hallucination rate on edge cases is a dealbreaker.

I spent the last 6 months trying to replace a legacy system with agents, and I hit this exact wall. I eventually had to rip out the Vector DB and replace it with a custom memory protocol using Optimal Transport (Wasserstein Distance) just to get deterministic retrieval.

If you treat memory as 'Geometry' (strict topology) instead of 'Search' (fuzzy matching), you can actually bound the hallucination error mathematically. It’s the only way I could sleep at night deploying this to production.

TL;DR: Yes, it’s realistic, but not if you use the standard RAG stack. You need stricter constraints on the context window.
Show HN: GibRAM an in-memory ephemeral GraphRAG runtime for retrieval
by ktyptorio | 2026-01-18 06:47:17+00:00
Hi HN,

I have been working with regulation-heavy documents lately, and one thing kept bothering me. Flat RAG pipelines often fail to retrieve related articles together, even when they are clearly connected through references, definitions, or clauses.

After trying several RAG setups, I subjectively felt that GraphRAG was a better mental model for this kind of data. The Microsoft GraphRAG paper and reference implementation were helpful starting points. However, in practice, I found one recurring friction point: graph storage and vector indexing are usually handled by separate systems, which felt unnecessarily heavy for short-lived analysis tasks.

To explore this tradeoff, I built GibRAM (Graph in-buffer Retrieval and Associative Memory). It is an experimental, in-memory GraphRAG runtime where entities, relationships, text units, and embeddings live side by side in a single process.

GibRAM is intentionally ephemeral. It is designed for exploratory tasks like summarization or conversational querying over a bounded document set. Data lives in memory, scoped by session, and is automatically cleaned up via TTL. There are no durability guarantees, and recomputation is considered cheaper than persistence for the intended use cases.

This is not a database and not a production-ready system. It is a casual project, largely vibe-coded, meant to explore what GraphRAG looks like when memory is the primary constraint instead of storage. Technical debt exists, and many tradeoffs are explicit.

The project is open source, and I would really appreciate feedback, especially from people working on RAG, search infrastructure, or graph-based retrieval.

GitHub: https://github.com/gibram-io/gibram

Happy to answer questions or hear why this approach might be flawed.
by fc417fc802 | 2026-01-18 06:47:31+00:00
I don't dispute that the situation is rapidly evolving. It is certainly possible that we could achieve AGI in the near future. It is also entirely possible that we might not. Claims such as that AGI is close or that we will soon be replacing developers entirely are pure hype.

When someone says something to the effect of "LLMs are on the verge of replacing developers any day now" it is perfectly reasonable to respond "I tried it and it came up with crap". If we were actually near that point you wouldn't have gotten crap back when you tried it for yourself.
by Instantnoodl | 2026-01-18 06:49:37+00:00
In the "Image to Terminal character" space this is also a known solution. Map characters to their shape and then pick the one with the lowest diff to the real chunk in the image. If you consider that you have a foreground and a background colour you can get a pretty close image in the terminal :D

https://hpjansson.org/chafa/

My go version:
https://github.com/BigJk/imeji
by utopiah | 2026-01-18 06:49:58+00:00
> the dream underneath this dream is about being able to manifest things into reality without having to get into the details.

Yes, it has nothing to do with dev specifically, dev "just" happens to be how to do so while being text based, which is the medium of LLMs. What also "just" happens to be convenient is that dev is expensive, so if a new technology might help to make something possible and/or make it unexpensive, it's potentially a market.

Now pesky details like actual implementation, who got time for that, it's just few more trillions away.
by danielbln | 2026-01-18 06:50:14+00:00
Transformers was 2017 and it had some implications on translation (which were in no way overstated), but it took GPT-2 and 3 to kick it off in earnest and the real hype machine started with ChatGPT.

What you are doing however is dismissing the outrageous progress on NLP and by extension code generation of the last few years just because people over hype it.

People over hyped the Internet in the early 2000s, yet here we are.
by MohskiBroskiAI | 2026-01-18 06:50:31+00:00
This is the inevitable result of probabilistic coding.

The current wave of "AI Coding Agents" are just wrappers around Vector DBs that fetch fuzzy context. They don't "understand" the codebase; they statistically guess the next token based on a cosine similarity match.

Of course they generate subtle bugs. They have no concept of topological consistency.

I realized this 3 months ago and stopped using standard agents. I built a local memory protocol (Remember-Me) that uses Wasserstein Distance to enforce strict consistency before the AI is allowed to write a line of code. If the memory doesn't mathematically fit the context topology, it rejects the edit.

We need to move from "Generative" coding to "Verifiable" coding, or this slop will drown every OSS maintainer.
by utopiah | 2026-01-18 06:52:25+00:00
It's not directly funded by the EU, it's funded by NLNet which is only in part funded by the EU. The goal is to collect money from large sources (e.g. EU) from relatively complex subsidiaries that are too big for small projects then dispatch and evaluate.

Source : I have an NLNet funded project, so like Xous https://github.com/betrusted-io/xous-core?tab=readme-ov-file... I have such banners at the bottom of my repository.
by concinds | 2026-01-18 06:53:08+00:00
I think that is the flawed conscious reason for these icons getting excessively oversimplified and minimalistic. And some higher-up at Apple's severe untreated OCD is the reason for the excessive uniformity (squircle jail, one saturated dominant color, the geometric "grid system" they keep bragging about at keynotes), so that every icon looks visually balanced with each other when put on the same screen and nothing stands out much. Removing individuality, expressiveness and creativity "worked".

I showed this timeline to non-technical people around me and they prefer... the original pen pot.
by MohskiBroskiAI | 2026-01-18 06:53:52+00:00
I stopped using Vector DBs locally entirely.

I found that for local setups (running on my MacBook), the overhead of managing a vector index wasn't worth the hallucinations. Cosine similarity is just too fuzzy for code/tech docs.

I switched to using *Optimal Transport (Wasserstein Distance)* in-process. It essentially treats the memory as a geometry problem. If the "transport cost" from the query to the memory chunk is too high, it rejects it mathematically.

It’s way lighter than running a local Chroma/LanceDB instance, and the coherence is ~0.96 vs ~0.67 for standard embeddings.

It's free (MIT license) and open-source btw.

https://github.com/merchantmoh-debug/Remember-Me-AI
Ask HN: Why is Google tolerating impersonation of Gmail from it's own domain?
by dvh | 2026-01-18 06:53:55+00:00
For several weeks now I've been receiving spam impersonating Gmail. It always contain link to https://storage.googleapis.com/rightsmoves/... The email looks like this:

https://imgur.com/xyXfPI8

Even Google's own Gemini knows it's a scam:

> The URL https://storage.googleapis.com/rightsmoves/ points to a specific Google Cloud Storage bucket named "rightsmoves". Based on recent security data and web scans, this particular bucket has been associated with malicious activity, specifically phishing and "traffic stealing" schemes.

I've reported it several times via Google Cloud Platform abuse form and they ignore it.

Is it Google's total incompetence? Why are they allowing scams from their own domain?