dochtman

Wild is a decent bit faster than mold at this point:

https://github.com/wild-linker/wild

(Benchmarks in the README.)

Pretty obviously LLM-generated.

I don’t think it’s completely unfair to say that the Neo is based on a chip that was first announced in Sep 2024 while the Intel chip is from Apr 2026.

Also, I think the battery life most people are practically interested in is more like running (close to) idle and less like the number of Watts spent when running maxed out, and I wouldn’t be surprised if Arm chips still win on that metric…

> I wonder if someone could create a GitHub account using my name and claim ownership of them...

AIUI the crates are actually linked to the account via a different identifier, not directly to the username.

GitButler now employs/has hired the gitoxide maintainer, I think? So no doubt they’re aware.

I guess they found that gitoxide isn’t good enough and/or to expensive to extend/improve for their use cases?

A lot of Let’s Encrypt is not the software but a bunch of auditing and process that ensure compliance and make it legible to the required auditors.

That's the policy, but we've been a bit more conservative in practice. `main` currently targets 1.88, but that's only because a security issue in the time crate has forced our hand (one reason I don't like the time crate all that much). Before that, it was 1.83 (from November 2024). Our last release targets 1.71 (from July 2023).

I'd bet a supermajority of Swift commits comes from Apple developers. Pretty sure the rust-lang/rust commit authors would be much less centralized.

See also:

https://github.com/1jehuang/mermaid-rs-renderer

Just submitted a HN thread about it:

https://news.ycombinator.com/edit?id=46807750

I think the way Rust checks borrows also makes it a lot more feasible to avoid allocations/copies; not because it is impossible to do in C, but because doing it in C requires writing very careful documentation and the caller to actually read that documentation. In (safe) Rust this is all checked by the compiler such that libraries can leverage it without blowing their complexity budget.

There’s also a compounding effect: I’ve heard from a hardware vendor that they spend a lot of time optimizing OpenSSL to get the most out of their silicon, so for their customers they suggest using OpenSSL to get the most out of the hardware.

How is the HiDPI situation, and font rendering? Last time I tried it on my M1 Max with Asahi it still looked substantially worse.

I'm pretty sure private PKIs are an option that is pretty straightforward to use.

Security is still a lot better because the root is communicated out of band.

When I asked about financial support, the Senior Principal Software Engineer from Mozilla I talked to said "Mozilla has no money".

To be fair, we've gotten a great amount of code contributions from the Mozilla folks, so it's not like they haven't contributed anything.

(I am one of the Quinn maintainers.)

I would argue that regexes are often more complex than simple parsers.

(2021)

CRLite is awesome, and it deserves more usage; notably most non-browser clients on Linux machines don’t get any revocation handling at all.

Tauri seems interesting. It combines a Rust core with the platform-native browser engine for presentation. Of course a potential downside is rendering incompatibilities between engines/platforms.

No, they don’t.

Selling support contracts is actually hard.

GPL/AGPL preclude widespread adoption (these days) — the grandparent explicitly mentioned “permissive” licenses.

IIRC derive and attribute macros via declarative macro definitions are coming soon, which probably obviates this?

https://github.com/rust-lang/rust/issues/143549

Does this work on macOS?

On mobile (Firefox on iOS) why does this site keep putting animations in my face?

We tried this when we were benchmarking and it was not significantly better than the Arc<RwLock<_>> that we're using now.

Did you file an issue or ask in the rustls Discord channel? We're happy to help.

Curious what this would look like written in Rust, using the windows-rs bindings.

Typst is the modern LaTeX.

https://typst.app/

Async is a language feature to enable scalability, but an alternative approach is just to spawn a bunch of threads and block threads when waiting for I/O to happen. That is the approach used by this framework.

Part of the fingerprint is stuff like the ordering of extensions, which Chrome could easily do but AFAIK doesn’t.

(AIUI Google’s Play Store is one of the biggest TLS fingerprinting culprits.)

But the difference is that Signal has been architected from the start to retain much less (meta)data on the server, so that even if the Signal Foundation is compelled to share the data they have, that data will be extremely limited to the point of being mostly useless.

How does performance compare to running native code?

zlib-rs is faster than C:

https://trifectatech.org/blog/zlib-rs-is-faster-than-c/