HNHacker News
TopNewBestAskShowJobs

DarkUranium

229 karma · joined March 18, 2015

submissionscomments
DarkUranium··on Sales and Dungeons: Thermal printer TTRPG utility
It's actually the reason as to why I wanted to get a thermal printer a few years ago. To be honest, I'm surprised someone else had this idea, too.

Alas, that never materialized as the in-person campaign I was DMing fizzled out.

DarkUranium··on Saying goodbye to asm.js
To be honest, with how bad a target WASM is for any existing compiler, I feel like what killed that possibility was WASM itself.

Its IR design is horrendeous.

DarkUranium··on Iran starts Bitcoin-backed ship insurance for Hormuz strait
You don't need a truthful reason to have an excuse. Remember the whole Iraq WMD debacle?

Or, for that matter, Ukraine giving up its nuclear capabilities.

DarkUranium··on Show HN: Files.md – Open-source alternative to Obsidian
Considering Microsoft's been making more and more of VSCode non-FOSS, I'm pretty sure using it as your base is at odds with your goals.
DarkUranium··on Ask HN: We just had an actual UUID v4 collision...
I mean ... rand() is notoriously bad, plenty of actually good options out there. Even back in 1990s.
DarkUranium··on Ask HN: We just had an actual UUID v4 collision...
No need for this dance in a modern browser: `crypto.randomUUID()` is a thing nowadays.
DarkUranium··on Ask HN: We just had an actual UUID v4 collision...
AWS as well, and I've done this myself, too.

It really helps debugging.

DarkUranium··on Linux gaming is faster because Windows APIs are becoming Linux kernel features
It's definitely not. Completely bespoke OS.
DarkUranium··on Google Chrome silently installs a 4 GB AI model on your device without consent
FWIW: https://news.ycombinator.com/item?id=48020960

Plus there's the Wikipedia link another user posted.

DarkUranium··on Google Chrome silently installs a 4 GB AI model on your device without consent
To avoid repeating myself: https://news.ycombinator.com/item?id=48020960
DarkUranium··on Google Chrome silently installs a 4 GB AI model on your device without consent
I apologize; my comment is vague because I wrote it on my phone, and didn't feel like writing super-long text there. I hate typing on a phone.

Anyway, for a browser that keeps touting how it's privacy-centered, they sure as hell love doing horrible things.

Cliqz is a great example; here's a direct quote from Mozilla (emphasis mine):

> "Users who receive a version of Firefox with Cliqz will have their browsing activity sent to Cliqz servers, including the URLs of pages they visit."

This was not opt-in. It was automatically enabled for a percentage of users in (I believe) Germany. Not only is it a blatant breach of the privacy promise, it's such a massive breach it's almost on the cartoon villainy level.

But for me personally, the final straw was the yet-another-pointless-UI-change at or around v103 (or thereabouts, I don't recall the exact version). When they removed icons from a bunch of menus and went with the rounded style. That version's UI redesign worsened accessibility in so many ways, and complaints by visually-impaired users were simply ignored. All for the sake of a UI redesign yet again.

I consider myself an advanced user, and even I get annoyed by the changes. Now imagine someone not tech savvy, e.g. my mother, trying to use Firefox, when the UI suddenly changes between versions. I can adapt to changes far more easily than them (not that I want to, but Mozilla keeps wanting to force it), but for some, it's going to be a struggle. For that reason alone, I can no longer recommend Firefox to non-tech-savvy people (and I used to!).

Meanwhile, Chrome, although I dislike its UI, has kept it relatively stable throughout. People get used to it, and it stays that way. They don't have to learn new things or change their habits. Now, there are a myriad of issues with Chrome, but constant UI rug-pulls aren't one of them.

That's why I'm comparing Mozilla to Microsoft. They ignore users, and shove changes nobody asked for down their throats --- even if it makes things worse for everyone. The UI change, for example, is kind of like the new context menu in Windows Explorer. On top of that, they tout being privacy-focused everywhere in the marketing, but then their actions show the exact opposite.

DarkUranium··on Google Chrome silently installs a 4 GB AI model on your device without consent
There are far more Google Chrome users than probably PlayStation & Steam users combined.

Also, someone installing Steam is going to expect large downloads, hell, the platform tells you the size as you're about to start the download.

I don't think anyone expects a browser to suddenly download 4GB, let alone behind their backs!

DarkUranium··on Google Chrome silently installs a 4 GB AI model on your device without consent
I'd recommend checking out WaterFox. It's what I switched to when I finally got sick & tired of Mozilla's shit.
DarkUranium··on Google Chrome silently installs a 4 GB AI model on your device without consent
I mean ... frankly, and I say this as a guy who's used solely Firefox since before it was Firefox all the way until 2025 when I finally got sick & tired of their shit... (now on WaterFox because I refuse to submit to the Google browser monopoly)

... Mozilla absolutely did this to themselves. Come think of it, they really remind me of what Microsift's been doing with Windows.

DarkUranium··on CVE-2026-31431: Copy Fail vs. rootless containers
1000x less eyes is true, but also: Linux, even in the kernel, has a long history of "move fast and break things".

Yes, the syscall API is (famously) stable, but the drivers, for example, are such a mess that many non-Linux projects prefer to take BSD drivers for e.g. WiFi despite them supporting far fewer devices (even if the Linux ones would be license compatible).

DarkUranium··on Windows quality update: Progress we've made since March
Considering Win11 being, well, Win11, I wouldn't be surprised if they were sending partition tables of hard drives to detect other OSes.

They won't be able to detect which Linux distro it is that way, but they'd definitely know it's ext4 or whatnot, which heavily implies Linux.

DarkUranium··on For Linux kernel vulnerabilities, there is no heads-up to distributions
The Linux Foundation hasn't been about Linux (except marginally) in a long while, if ever.

The name is a misnomer.

DarkUranium··on The woes of sanitizing SVGs
Wrapping text is a bit tricky because of differences in text wrapping algorithms. Though I suppose an "easy" fix would be to be able to specify a very specific algorithm (to ensure equal representation across systems), or allowing custom (possibly better-quality) wrapping.

But for the most part, I 100% agree, and I've been considering making a format for my own use-cases. I think the biggest issue is in agreeing as to what subset is necessary; plus, of course, getting any level of adoption (though the latter isn't a factor for my own use ... except in the sense that there are no tools to help).

For example, do we need animations? Gradients? If so on the latter, what kind?

DarkUranium··on Writing a C Compiler, in Zig (2025)
I feel like Zig is to C what Rust is to C++, kind of.
DarkUranium··on What async promised and what it delivered
Also with the exception of trace/debug print. At least I'd consider it a fair exception.

(it's what I'm planning for my own lang, having `trace` be "blessed" to not make a function unpure despite I/O)

DarkUranium··on Bitwarden CLI compromised in ongoing Checkmarx supply chain campaign
I think there's actually a decent compromise one could make here (not that Rust did, mind), and it's what I'm planning for my own language, in big part to avoid the Rust/NPM/etc situation.

TL;DR, the official libraries are going to be split into three parts:

---

1) `core.*` (or maybe `lang.*` or `$MYLANGUAGE.*` or w/e, you get the point) this is the only part that's "blessed" to be known by the compiler, and in a sense, part of the compiler, not a library. It's stuff like core type definitions, interfaces, that sort of stuff. I may or may not put various intrinsics here too (e.g. bit count or ilog2), but I don't know yet.

Reserved by the compiler; it will not allow you to add custom stuff to it.

There is technically also a "pseudo-package" of `debug.*` ("pseudo" in the sense that you must always use it in the full prefixed form, you can't import it), which is just going to be my version of `__LINE__` and similar. Obviously blessed by compiler by necessity, but think stuff like `debug.file` (`__FILE__`), `debug.line` (`__LINE__`), `debug.compiler.{vendor,version}` (`__GNUC__`, `_MSC_VER`, and friends). `debug` is a keyword, which makes it de-facto non-overridable by users (and also easy for both IDEs and compiler to reason about). Of course I'll provide ways of overriding these, as to not leak file paths to end users in release builds, etc.

(side-note: since I want reproducible builds to be the default, I'm internally debating even having a `debug.build.datetime` or similar ... one idea would be to allow it but require explicitly specifying a datetime [as build option] in such cases, lest it either errors out, or defaults to e.g. 1970-01-01 or 2000-01-01 or whatever for reproducibility)

---

2) `std.*`, which is minimal, 100% portable (to the point where it'd probably even work in embedded [in the microcontroller sense, not "embedded Linux" sense] systems and such --- though those targets are, at least for now, not a primary goal), and basically provides some core tooling.

Unlike #1, this is not special to the compiler ... the `std.*` package is de jure reserved, but that's not actually enforced at a technical level. It's bundled with the language, and included/compiled by default.

As a rule (of thumb, admittedly), code in it needs to be inherently portable, with maybe a few exceptions here or there (e.g. for some very basic I/O, which you kind of need for debugging). Code is also required to have no external (read: native/upstream) dependencies whatsoever (other than maybe libc, libdl, libm, and similar things that are really more part of the OS than any particular library).

All of `std.*` also needs to be trivially sandboxable --- a program using only `core.*` & `std.*` should not be able to, in any way, affect anything outside of whatever the host/parent system told it that it can.

---

3) `etc.*`, which actually work a lot like Rust/Cargo crates or npm packages in the sense that they're not installed by default ..... except that they're officially blessed. They likely will be part of a default source distribution, but not linked to by default (in other words: included with your source download, but you can't use them unless you explicitly specify).

This is much wider in scope, and I'm expecting it to have things like sockets, file I/O (hopefully async, though it's still a bit of a nightmare to make it portable), downloads, etc. External dependencies are allowed here --- to that end, a downloads API could link to libcurl, async I/O could link to libuv, etc.

---

Essentially, `core.*` is the "minimal runtime", `std.*` is roughly a C-esque (in terms of feature count, or at least dependencies) stdlib, and `etc.*` are the Python-esque batteries.

Or to put it differently: `core.*` is the minimum to make the language run/compile, `std.*` is the minimum to make it do something useful, and `etc.*` is the stuff to make common things faster to make. (roughly speaking, since you can always technically reimplement `std.*` and such)

I figured keeping them separate allows me to provide for a "batteries included, but you have to put them in yourself" approach, plus clearly signaling which parts are dependency-free & ultra-sandbox-friendly (which is important for embedding in the Lua/JavaScript sense), plus it allows me to version them independently in cases of security issues (which I expect there to be more of, given the nature of sockets, HTTP downloads, maybe XML handling, etc).

DarkUranium··on Windows Server 2025 Runs Better on ARM
Isn't that basically a heavier version of a unikernel?
DarkUranium··on FSF trying to contact Google about spammer sending 10k+ mails from Gmail account
I'm curious, what about Microsoft/Outlook?

I also have my own MTA. No problems with anyone ..... except Microsoft, who (silently) never delivers the mail.

DarkUranium··on European civil servants are being forced off WhatsApp
I hope they don't, considering Matrix's handling of security is on the level of a bumbling toddler.
DarkUranium··on Backblaze has stopped backing up OneDrive and Dropbox folders and maybe others
To an extent. WinAPI's file watching has a race condition in it, and there's no simple workaround (just complex & error-prone ones).

Well, for backups the workaround is a bit easier (as they strictly only ever read files), but still.

DarkUranium··on Someone bought 30 WordPress plugins and planted a backdoor in all of them
I know a lot of security researchers will disagree with this notion, but I personally think that security (& privacy, I'm going to refer to both as "security" for brevity here) are an overhead. I think that's why it needs to exist *and be discussed* as a sliding scale. I do find a lot of people in this space chase some ideal without a consideration for practicality.

Mind, I'm not talking about financial overhead for the company/developer(s), but rather an UX overhead for the user. It often increases friction and might even need education/training to even make use the software it's attached to. It's much like how body armor increases the weight one has to carry and decreases mobility, security has (conceptually) very similar tradeoffs (cognitive instead of physical overhead, and time/interactions/hoops instead of mobility). Likewise, sometimes one might pick a lighter Kevlar suit, whereas othertimes a ceramic plate is appropriate.

Now, body armor is still a very good idea if you're expecting to be engaged in a fight, but I think we can all agree that not everyone on the street in, say, a random village in Austria, needs to wear ceramic plates all the time.

The analogy does have its limits, of course ... for example, one issue with security (which firmly slides it towards erring on the safe side) as compared to warfare is that you generally know if someone shot at you and body armor saved you; with security (and, again, privacy), you often won't even know you needed it even if it helped you. And both share the trait that if you needed it and didn't have it, it's often too late.

Nevertheless, whether worth it or not (and to be clear, I think it's very worth it), I think it's important that people don't forget that this is not free. There's no free lunch --- security & privacy are no exception.

Ultimately, you can have a super-secure system with an explicit trust system that will be too much for most people to use daily; or something simpler (e.g. Signal) that sacrifices a few guarantees to make it easier to use ... but the lower barrier to entry ensuring more people have at least a baseline of security&privacy in their chats.

Both have value and both should exist, but we shouldn't pretend the latter is worthless because there are more secure systems out there.

DarkUranium··on What is a property?
I'd also like to add that, since immediate-operand instructions exist, constants are absolutely not the same as variables at the machine level, since immediates will never be stored in a register (typically, e.g. "move immediate" will obviously store it in one, and I'm sure there are architectures that use an internal/hidden register that's populated during instruction decode).

Also, in Harvard-architecture systems, the constants, being part of the instruction itself, might not even be in the same memory or even address space as variables ([EEP]ROM/Flash vs RAM).

DarkUranium··on CPU-Z and HWMonitor compromised
Well, they got one half of that label right...
DarkUranium··on CPU-Z and HWMonitor compromised
You mean DVD-R? DVD-RW is rewritable, which means it's not really RO. The semi-obscure DVD-RAM takes this a step further by making it work a lot like a hard/flash drive (at the user level, not technical).
DarkUranium··on CPU-Z and HWMonitor compromised
Why not a simple switch, not unlike on SD cards (but implemented on the device, not host/reader, and enforced by said device)?

Though yes, two USB ports would definitely work; it's just that the concept might be better served by providing two different connectors (e.g. USB-A & USB-C), as is common nowadays.

← PreviousPage 3 of 5Next →