I really think I should go back to Java.

Writing programs in Python is so exhausting. I want a compiler and I want static typing. No, linters and type checkers and IDEs are not good enough. Compilers catch way more errors in advance.

Rust is also exhausting. They’re constantly adding language features and, at the same time, the runtime library remains tiny and you need 3rd party libraries for everything. Many of those are still at version 0.x (SemVer!) and you can’t rely on anything. Often times, you need the latest Rust nightly compiler.

Go is … I don’t like it. And huge binaries.

I like C as a language, but it’s too fragile. I want to have a proper HashMap every now and then.

None of the above have good GUI libraries, at least not on Linux.

And then there’s Java. This is my fractal renderer that I wrote over 17 years ago:

https://movq.de/v/fcd3c4e557/vid-1784121825.mp4

It’s fast. It has a GUI with custom widgets and those weren’t even hard to make. It still works without changing a single line of code. The source code files have timestamps from 2009 and I just noticed that the JAR file I’m using in the video was compiled in 2010.

Java as a language is relatively easy to learn and to master. There are few surprises. The source code organization with packages is good. Java API docs are clear and well written.

The JVM ramp-up times have improved considerably:

https://movq.de/v/e7314e521e/vid-1784121998.mp4

This isn’t like the Dark Ages anymore. Might even be usable for some CLI tools.

The only thing where Java really sucks is anything close-ish to the kernel. Try issuing an ioctl() … I couldn’t have made my TUI framework in Java, but then again, I wouldn’t have needed to because Swing already exists and it just works.

Linux 0.11 rewritten in idiomatic Rust, boots in QEMU | Hacker News Fark’n hell, this is some ~50k SLOC of Rust code compared to the original ~8k SLOC of C of the original this was based off of. No doubt this was “vibe coded” for sure, there is no way a human can write 50k SLOC, not in a reasonable timeframe anyway 😅

I want to check this at some point…

«spyrrow
 Python wrapper of Sparrow, State-of-the-art Nesting for 2D irregular strip packing»

#python #rust #nesting #2DirregularPacking

@prologic@twtxt.net Yeah, Rust is quite popular in the Wayland scene, it seems.

In image viewer in 170 lines? Show me. 😅

@movq@www.uninformativ.de I looked into swagimg. That’s the thing, The latest version pulls in fark’n C++ (geez fuck) and luajit. Anything else I’ve round for Wayland depdns on Rust (wtf?!) – So I built my own in Pure Go. It’s wonderful, so simple, only ~170 lines of Go 🤣

Hmmm are there really no decent Wayland (desktop) compatible image viewers that don’t drag in Mesa and all it’s hundreds of dependences or GCC and libgcc and it’s multi-hour long build time or Rust? geez

Zinnia: A modular 64-bit Unix-like kernel written in Rust
Article URL: https://zinnia-os.org/

Comments URL: https://news.ycombinator.com/item?id=48532705

Points: 5

# Comments: 0 ⌘ Read more

Port React Compiler to Rust
Article URL: https://github.com/react/react/pull/36173

Comments URL: https://news.ycombinator.com/item?id=48473662

Points: 5

# Comments: 0 ⌘ Read more

Show HN: Mnemo – local-first AI memory layer for any LLM (Rust, SQLite,petgraph)
Article URL: https://github.com/zaydmulani09/mnemo

Comments URL: https://news.ycombinator.com/item?id=48389586

Points: 4

# Comments: 0 ⌘ Read more

Bun Has Been Converted to Rust. Now What?
Article URL: https://bytecode.news/posts/2026/06/bun-has-been-converted-to-rust-now-what

Comments URL: https://news.ycombinator.com/item?id=48383018

Points: 26

# Comments: 16 ⌘ Read more

Custom Errors Are Non-Negotiable in My Rust Applications
Article URL: https://tristonarmstrong.com/blog/custom-errors-are-non-negotiable-in-my-rust-applications

Comments URL: https://news.ycombinator.com/item?id=48341505

Points: 3

# Comments: 0 ⌘ Read more

Creusot helps you prove your Rust code is correct
Article URL: https://github.com/creusot-rs/creusot/tree/master

Comments URL: https://news.ycombinator.com/item?id=48309645

Points: 5

# Comments: 0 ⌘ Read more

Ask HN: Pregunta para los devs hispanohablantes
¿Cómo les caería un lenguaje de programación de sistemas pero completamente en español?
imagino algo con el minimalismo y la concurrencia de Go, el bonito sistema de errores de Rust, no compartir estados mutuos como en Pony (no race conditions)

¿Qué opinan?

Comments URL: https://news.ycombinator.com/item?id=48275005

Points: 5

# Comments: 0 ⌘ Read more

Cada edição começa com o “State of Libre Graphics”, um momento para rever as novidades de cada projeto ao longo do ano que passou. Alguns que não estava a acompanhar e/ou não conhecia, e que agora quero:

• Blockbench - modelação 3D low-poly
  
• Coollab - animação em tempo real (tipo TouchDesigner)
  
• Friction - motion graphics
  
• Glaxnimate - animação vetorial
  
• Graphite - motor de animação 2D e etc
  
• Hyper8 - publicar vídeos na web
  
• L5 - Processing + Lua
  
• Makepad - IDE pra shaders em Rust
  
• Openrndr - creative coding
  
• Ossia Score - sequenciador intermedia
  
• OurPaint - pintura com pigmentos digitais
  
• PixiEditor - editor 2D à base de nós (nodes)
  
• TiXL - motion graphics em tempo real e VJ

Since I used so much Rust during the holidays, I got totally used to rustfmt. I now use similar tools for Python (black and isort).

What have I been doing all these years?! I never want to format code manually again. 🤣😅

Vacation: Doing crazy things like C on DOS, lots of Rust, bare-metal assembly code, everything is fine.

Back at work: How the fuck do I move an email in this web mail program? Am I stupid? 😮‍💨

I came across this on “Why Is SQLite Coded In C”, which I found interesting:

“There has lately been a lot of interest in “safe” programming languages like Rust or Go in which it is impossible, or is at least difficult, to make common programming errors like memory leaks or array overruns.”

If that’s true, then encountering those issues means the programmer is, simply, horrible?

My little toy operating system from last year runs in 16-bit Real Mode (like DOS). Since I’ve recently figured out how to switch to 64-bit Long Mode right after BIOS boot, I now have a little program that performs this switch on my toy OS. It will load and run any x86-64 program, assuming it’s freestanding, a flat binary, and small enough (< 128 KiB code, only uses the first 2 MiB of memory).

Here I’m running a little C program (compiled using normal GCC, no Watcom trickery):

https://movq.de/v/b27ced6dcb/los86%2D64.mp4

Image

Next steps could include:

• Use Rust instead of C for that 64-bit program?
  
• Provide interrupt service routines. (At the moment, it just keeps interrupts disabled.)

This feels useful: Rust’s Block Pattern

I rewrote all my solutions in Rust (except for day 10 part 2) and these are the runtimes on my i7-3770 from 2013 (this measures CLOCK_PROCESS_CPUTIME_ID, not wallclock):

day01/1 [      00.000501311] Result: 1066
day01/2 [      00.000400298] Result: 6223
day02/1 [      00.000358848] Result: 12586854255
day02/2 [      00.000750711] Result: 17298174201
day03/1 [      00.000106537] Result: 17405
day03/2 [      00.000404632] Result: 171990312704598
day04/1 [      00.000257517] Result: 1626
day04/2 [      00.007495342] Result: 9173
day05/1 [      00.000237212] Result: 505
day05/2 [      00.000142731] Result: 344423158480189
day06/1 [      00.000229629] Result: 4076006202939
day06/2 [      00.000279552] Result: 7903168391557
day07/1 [      00.000204422] Result: 1622
day07/2 [      00.000283816] Result: 10357305916520
day08/1 [      00.029427421] Result: 84968
day08/2 [      00.028089859] Result: 8663467782
day09/1 [      00.000310304] Result: 4764078684
day09/2 [      00.015512554] Result: 1652344888
day10/1 [      00.000796663] Result: 375
day10/2 [      --.---------] Result: 15377 (Z3)
day11/1 [      00.000416804] Result: 753
day11/2 [      00.000660528] Result: 450854305019580
day12/1 [      00.000336081] Result: 577
day12/2 [      00.000000695] Result: no part 2

A little under 90 ms total.

On my Samsung NC10 netbook from 2011 with its Intel Atom N455 at 1.6 GHz:

day01/1 [      00.003771326] Result: 1066
day01/2 [      00.003267317] Result: 6223
day02/1 [      00.003902698] Result: 12586854255
day02/2 [      00.006659479] Result: 17298174201
day03/1 [      00.000747544] Result: 17405
day03/2 [      00.002737587] Result: 171990312704598
day04/1 [      00.001263892] Result: 1626
day04/2 [      00.044985301] Result: 9173
day05/1 [      00.001696761] Result: 505
day05/2 [      00.000978962] Result: 344423158480189
day06/1 [      00.001387660] Result: 4076006202939
day06/2 [      00.001734248] Result: 7903168391557
day07/1 [      00.001295528] Result: 1622
day07/2 [      00.001809659] Result: 10357305916520
day08/1 [      00.277251443] Result: 84968
day08/2 [      00.284359332] Result: 8663467782
day09/1 [      00.003152407] Result: 4764078684
day09/2 [      00.071123459] Result: 1652344888
day10/1 [      00.005279527] Result: 375
day10/2 [      --.---------] Result: 15377 (Z3)
day11/1 [      00.003273342] Result: 753
day11/2 [      00.005139719] Result: 450854305019580
day12/1 [      00.002857552] Result: 577
day12/2 [      00.000004421] Result: no part 2

A little over 700 ms total.

I like this. You get performance that’s more or less in the ballpark of C, but without the footguns.

I’m seeing crashes in the 3D subsystem. (Gallium? Glamor? Whatever other Mesa thing they have? No idea.) In the logs I find this:

malloc(): unaligned tcache chunk detected

And that’s why I still care about Rust and want to learn more about it, even though it’s giving me so much headache and I’ve given up so many times. Because Rust currently seems to be the only popular systems programming language that tries to eliminate these error classes.

And of course “the Rust experiment” in the Linux kernel has recently been concluded as “successful”, so that alone is reason enough for me:

https://lwn.net/Articles/1049831/

Cloudflare Rewrote Their Core in Rust, Then Half of the Internet Went Down
53 days after Cloudflare announced that their service was now “more secure” because they had ported it to Rust… ⌘ Read more

Multiple Vulnerabilities Found in Rust Sudo Clone in Ubuntu
Ubuntu is now shipping with Rust based replacements of core utilities (sudo, date, du, etc.). ⌘ Read more

Can We Trust Rust?
Debian Linux and Ubuntu are forcing adoption of Rust at core levels of the system. ⌘ Read more

Debian Adding “Hard Dependency” on Rust, May Abandon Some PC Architectures
APT, Debian’s package manager also used by Ubuntu, to have a hard Rust requirement. ⌘ Read more

@lyse@lyse.isobeef.org Hmmmmmmmmmmmm … guess I should take a look at Qt. 🤔 That’s the one popular toolkit that I’ve never really tried for some reason. I really don’t like C++ (might as well use Rust), so I’ll also use Python.

Rust Clone of Core Utils Breaks Ubuntu Updates
Ubuntu 25.10 dropped the battle tested GNU Core Utils, in favor of the untested, incomplete “uutils”. ⌘ Read more

Rust Changes from “Master” to “Main”
Two weeks ago, The Lunduke Journal pointed out how many Leftist Open Source organizations (Rust, NixOS, Linux Kernel, etc.) still used the “Master” branch naming (against their “inclusive naming” rules). ⌘ Read more

C2BF: A C-to-Brainfuck compiler written in Rust
Comments ⌘ Read more

Async Rust with Tokio I/O Streams: Backpressure, Concurrency, and Ergonomics
Comments ⌘ Read more

[$] Gccrs after libcore
Despite its increasing popularity, the Rust programming language is still
supported by a single compiler, the LLVM-based rustc. At the 2025 GNU Tools\
Cauldron, Pierre-Emmanuel Patry said that a lot of people are waiting
for a GCC-based Rust compiler before jumping into the language. Patry, who
is working on just that compiler (known as “gccrs”), provided an update on
the status of that project and what is coming next. ⌘ Read more

Ubuntu 25.10 released
Ubuntu\
25.10, “Questing Quokka”, has been released. This release includes
Linux 6.17, GNOME 49, GCC 15, Python 3.13.7,
Rust 1.85, and more. This release also features Rust-based
implementations of sudo and coreutils; LWN covered the switch to the
Rust-based tools in March. The 25.10 version of Ubuntu flavors
Edubuntu, Kubuntu, Lubuntu, Ubuntu Budgie, Ubuntu Cinnamon, Ubuntu
Kylin, Ubuntu MATE, Ubun … ⌘ Read more

Security updates for Thursday
Security updates have been issued by AlmaLinux (gnutls, kernel, kernel-rt, and open-vm-tools), Debian (chromium, python-django, and redis), Fedora (chromium, insight, mirrorlist-server, oci-seccomp-bpf-hook, rust-maxminddb, rust-prometheus, rust-prometheus_exporter, rust-protobuf, rust-protobuf-codegen, rust-protobuf-parse, rust-protobuf-support, turbo-attack, and yarnpkg), Oracle (iputils, kernel, open-vm-tools, redis, and valkey), Red Hat (perl-File-Find-Rule and perl-File-Find-Rul … ⌘ Read more

[$] LWN.net Weekly Edition for October 9, 2025
Inside this week’s LWN.net Weekly Edition:

• Front: Kernel Rust features; systemd v258, part 2; Cauldron kernel hackers; BPF for GNU tools; 6.18 merge window, part 1; Lifetime-end pointer zapping; Robot Operating System.

• Briefs: OpenSSH 10.1; Firefox profiles; Python 3.14; U-Boot v2025.10; FSF presidency; Quotes; …

• Announcements: Newsletters, conferences, security upda … ⌘ Read more

[$] Upcoming Rust language features for kernel development
The
Rust for Linux project has been good for Rust, Tyler Mandry, one of the
co-leads of Rust’s language-design team, said. He
gave a talk at
Kangrejos 2025 covering upcoming Rust language features and thanking
the Rust for Linux developers for helping drive them forward. Afterward, Benno Lossin and Xiangfei Ding
went into more detail about their work on the three most important language
features for kernel development: … ⌘ Read more

Why we didn’t rewrite our feed handler in Rust
Comments ⌘ Read more

[$] Progress on defeating lifetime-end pointer zapping
Paul McKenney gave a remote presentation at
Kangrejos 2025 following up on the
talk he gave last year about the
lifetime-end-pointer-zapping problem: certain common patterns for multithreaded code are
technically undefined behavior, and changes to the C and C++ specifications
will be needed to correct that. Those changes could also impact code that uses
unsafe Rust, such as the kernel’s Rust bindings. Progress on the p … ⌘ Read more

Linus Says Rust Formatting is “Bass-Ackwards Garbage”
“[Rustfmtcheck] is just ANNOYING. ⌘ Read more

Notes from the 2025 Git Contributor’s Summit
Taylor Blau has posted an\
extensive set of notes from the recently concluded Git Contributor’s
Summit. Covered topics include the SHA-256 transition, Rust, Change-ID
headers, Git 3.0, and many more. The note are also available on\
Google Docs for those who prefer that format. ⌘ Read more

BBC finds Russian guards, Iranian trucks and rusting railway on Trump’s Caucasus peace route
The planned Trump Route in the South Caucasus could reshape the geopolitics of a region that borders Russia and Iran. ⌘ Read more

cargo-subspace: Make rust-analyzer work better with very large cargo workspaces
Let me preface all of this by saying that rust-analyzer is an amazing project, and I am eternally grateful for the many people who contribute to it! It makes developing rust code a breeze, and it has surely significantly contributed to Rust’s widespread adoption.

If you’ve ever worked with a very large cargo workspace (think hundreds of crates), you know that rust-analyzer eagerly builds compile time dependencies (e.g. proc macros) and index … ⌘ Read more

Security updates for Friday
Security updates have been issued by AlmaLinux (idm:DL1), Debian (gegl and haproxy), Fedora (ffmpeg, firefox, freeipa, python-pip, rust-astral-tokio-tar, sqlite, uv, webkitgtk, and xen), Oracle (idm:DL1, ipa, kernel, perl-JSON-XS, and python3), Red Hat (git), SUSE (curl, frr, jupyter-jupyterlab, and libsuricata8_0_1), and Ubuntu (linux-aws, linux-lts-xenial, linux-aws-fips, linux-fips, linux-gcp-fips, linux-azure, linux-azure, linux-azure-6.8, linux-fips, linux-gcp-fips, and l … ⌘ Read more

[$] Kernel hackers at Cauldron, 2025 edition
The GNU Tools Cauldron is almost entirely focused on user-space tools, but
kernel developers need a solid toolchain too. In what appears to be a
developing tradition ( started in 2024),
some kernel developers attended the 2025 Cauldron for the
second year in a row to discuss their needs with the assembled toolchain
developers. Topics covered in this year’s gathering include Rust, better
[BPF type\
format (BTF … ⌘ Read more

Security updates for Thursday
Security updates have been issued by AlmaLinux (perl-JSON-XS), Debian (chromium and openssl), Fedora (bird, dnsdist, firefox, mapserver, ntpd-rs, python-nh3, rust-ammonia, skopeo, sqlite, thunderbird, and xen), Oracle (perl-JSON-XS), Red Hat (kernel, kernel-rt, and libvpx), SUSE (afterburn, cairo, docker-stable, firefox, nginx, python-Django, snpguest, and warewulf4), and Ubuntu (libmspack, libxslt, linux, linux-aws, linux-aws-5.15, linux-gcp, linux-gcp-5.15, linux-gkeop, linu … ⌘ Read more

Linux, Rust, & NixOS Use Master Branch, Support Human Slavery
Using the term “Master” in our software projects is racist, right? ⌘ Read more

[$] LWN.net Weekly Edition for October 2, 2025
Inside this week’s LWN.net Weekly Edition:

• Front: Fedora and AI; Linting kernel Rust; openSUSE Leap 16; mmap() file operation; 6.17 statistics; dirlock.

• Briefs: Bcachefs removal; Alpine /usr merge; F-Droid; Fedora AI policy; OpenSUSE Leap 16; PostgreSQL 18; Radicle 1.5.0; Quotes; …

• Announcements: Newsletters, conferences, security updates, patches, and more. ⌘ Read more

Security updates for Wednesday
Security updates have been issued by AlmaLinux (kernel, kernel-rt, mysql:8.0, and openssh), Debian (libcommons-lang-java, libcommons-lang3-java, libcpanel-json-xs-perl, libjson-xs-perl, libxml2, open-vm-tools, and u-boot), Fedora (bird, dnsdist, mapserver, ntpd-rs, python-nh3, and rust-ammonia), Oracle (kernel and mysql:8.0), Red Hat (cups, postgresql:12, and postgresql:13), SUSE (cJSON-devel, gimp, kernel-devel, kubecolor, open-vm-tools, openssl-1_1, openssl-3, and ruby3.4-ruby … ⌘ Read more

[$] Linting Rust code in the kernel
Klint is a Rust compiler extension
developed by Gary Guo to run some
kernel-specific lint rules, which may also be useful for embedded system
development. He spoke about his
recent work on the project at
Kangrejos 2025. The next day, Alejandra González
led a discussion about Rust’s normal linter,
Clippy. The two tools … ⌘ Read more

Ubuntu’s Rust GNU Utils Replacement 17x Slower & Buggy
Canonical plans to replace the battle tested GNU Coreutils with new, untested, Rust-based replacements. ⌘ Read more

Mathieu Pasquet: slixmpp v1.11
This new version includes a few new XEP plugins as well as fixes, notably
for some leftover issues in our rust JID code, as well as one for a bug that
caused issues in Home Assistant.

Thanks to everyone who contributed with code, issues, suggestions, and reviews!

Nicoco put in a lot of work in order to get all possible wheels built in CI. We now have manylinux and musl builds of everything doable within codeberg,
published to the codeberg pypi repo, and published on pypi. … ⌘ Read more

Okay, now this is a very interesting Rust feature:

https://blog.rust-lang.org/2025/07/03/stabilizing-naked-functions/

This (and inline assembly) makes Rust really interesting for very low-level stuff. 🥳

@lyse@lyse.isobeef.org lol – I explicitly kept them in there so that the code is easier to understand for non-Rust people 🤪😂

@movq@www.uninformativ.de All the returns tell me that you’re not a real Rust programmer. :-D Personally, I would never omit them either. They make code 100 times more readable.

Okay, here’s a thing I like about Rust: Returning things as Option and error handling. (Or the more complex Result, but it’s easier to explain with Option.)

fn mydiv(num: f64, denom: f64) -> Option<f64> {
    // (Let’s ignore precision issues for a second.)
    if denom == 0.0 {
        return None;
    } else {
        return Some(num / denom);
    }
}

fn main() {
    // Explicit, verbose version:
    let num: f64 = 123.0;
    let denom: f64 = 456.0;
    let wrapped_res = mydiv(num, denom);
    if wrapped_res.is_some() {
        println!("Unwrapped result: {}", wrapped_res.unwrap());
    }

    // Shorter version using "if let":
    if let Some(res) = mydiv(123.0, 456.0) {
        println!("Here’s a result: {}", res);
    }

    if let Some(res) = mydiv(123.0, 0.0) {
        println!("Huh, we divided by zero? This never happens. {}", res);
    }
}

You can’t divide by zero, so the function returns an “error” in that case. (Option isn’t really used for errors, IIUC, but the basic idea is the same for Result.)

Option is an enum. It can have the value Some or None. In the case of Some, you can attach additional data to the enum. In this case, we are attaching a floating point value.

The caller then has to decide: Is the value None or Some? Did the function succeed or not? If it is Some, the caller can do .unwrap() on this enum to get the inner value (the floating point value). If you do .unwrap() on a None value, the program will panic and die.

The if let version using destructuring is much shorter and, once you got used to it, actually quite nice.

Now the trick is that you must somehow handle these two cases. You must either call something like .unwrap() or do destructuring or something, otherwise you can’t access the attached value at all. As I understand it, it is impossible to just completely ignore error cases. And the compiler enforces it.

(In case of Result, the compiler would warn you if you ignore the return value entirely. So something like doing write() and then ignoring the return value would be caught as well.)

@prologic@twtxt.net I’m trying to call some libc functions (because the Rust stdlib does not have an equivalent for getpeername(), for example, so I don’t have a choice), so I have to do some FFI stuff and deal with raw pointers and all that, which is very gnarly in Rust – because you’re not supposed to do this. Things like that are trivial in C or even Assembler, but I have not yet understood what Rust does under the hood. How and when does it allocate or free memory … is the pointer that I get even still valid by the time I do the libc call? Stuff like that.

I hope that I eventually learn this over time … but I get slapped in the face at every step. It’s very frustrating and I’m always this 🤏 close to giving up (only to try again a year later).

Oh, yeah, yeah, I guess I could “just” use some 3rd party library for this. socket2 gets mentioned a lot in this context. But I don’t want to. I literally need one getpeername() call during the lifetime of my program, I don’t even do the socket(), bind(), listen(), accept() dance, I already have a fully functional file descriptor. Using a library for that is total overkill and I’d rather do it myself. (And look at the version number: 0.5.10. The library is 6 years old but they’re still saying: “Nah, we’re not 1.0 yet, we reserve the right to make breaking changes with every new release.” So many Rust libs are still unstable …)

… and I could go on and on and on … 🤣

@movq@www.uninformativ.de Hahaha 😂 This is gold! I’ve been following along with our ramblings on Rust. What’s it gone and done to you now? 🤔 I don’t think I can ever be friends personally, I feel “too stupid” to learn Rust 🤣

Fuck me sideways, Rust is so hard. Will we ever be friends?

fn sub(foo: &String) {
    println!("We got this string: [{}]", foo);
}

fn main() {
    // "Hello", 0x00, 0x00, "!"
    let buf: [u8; 8] = [0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x00, 0x00, 0x21];

    // Create a string from the byte array above, interpret as UTF-8, ignore decoding errors.
    let lossy_unicode = String::from_utf8_lossy(&buf).to_string();

    sub(&lossy_unicode);
}

Create a string from a byte array, but the result isn’t a string, it’s a cow 🐮, so you need another to_string() to convert your “string” into a string.

• https://doc.rust-lang.org/std/string/struct.String.html#method.from_utf8_lossy
  
• https://doc.rust-lang.org/std/borrow/enum.Cow.html
  

I still have a lot to learn.

(into_owned() instead of to_string() also works and makes more sense to me, it’s just that the compiler suggested to_string() first, which led to this funny example.)

@lyse@lyse.isobeef.org Rust is so different and, at the same time, so complex – it’s not far fetched to assume that I simply don’t understand what’s going on here. The docs appear to be clear, but alas … is it a bugs in the docs? Is it a lack of experience on my part? Who knows.

By the way, looks like there was a bit of a discussion regarding that name:

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

@movq@www.uninformativ.de Lol, what the hell!? Reports like that turn me away even more from iron oxide. Also, great naming choice on the method they made there. display() doesn’t actually display it. But it’s a Rust thing.

So I was using this function in Rust:

https://doc.rust-lang.org/std/path/struct.Path.html#method.display

Note the little 1.0.0 in the top right corner, which means that this function has been “stable since Rust version 1.0.0”. We’re at 1.87 now, so we’re good.

Then I compiled my program on OpenBSD with Rust 1.86, i.e. just one version behind, but well ahead of 1.0.0.

The compiler said that I was using an unstable library feature.

Turns out, that function internally uses this:

https://doc.rust-lang.org/std/ffi/struct.OsStr.html#method.display

And that is only available since Rust 1.87.

How was I supposed to know this? 🤨🫩

@prologic@twtxt.net Yeah, it’s difficult, you often don’t get what you’d expect. They also make heavy use of 3rd party libraries. IIUC, for random numbers, they refer to this library. I’ve read many times that the Rust stdlib is intentionally minimalistic (to make it easier to maintain and port and all that).

I’m struggling with this, using 3rd party libs for so many things isn’t really my cup of tea. I’ll probably make my own tiny little “standard library”. It’s silly, but I don’t see any other options. 🤷

@movq@www.uninformativ.de LOL 🤣 I don’t think I could ever take Rust seriaujly 🤦‍♂️

淺析 rust 大明星 Tokio
Tokio 可以說是 rust 中最熱門的庫，對於異步與併發進行了很好的支持。大多數基於 rust 的開源框架都使用到了 Tokio，因此在介紹這些實現開源框架時經常會被問到：底層的異步和併發是怎麼實現的？我只能回答：底層的異步和併發都是由 Tokio 控制的。這顯然不是一個令人滿意的回答。因此本文章將對於 Tokio 的基本方法和底層邏輯進行分析。概述一句話概括 Tokio 可以理解成一個 “ ⌘ Read more

Why doesn’t Rust care more about compiler performance?
Comments ⌘ Read more

Is Rust faster than C?
Comments ⌘ Read more

深入 Biome — 現代 Rust 前端工具鏈
Biome 簡介Biome 是一個基於 Rust 開發的前端工具鏈工具，它提供了完善的 Analyzer / Linter / Formatter 的能力支持。目前 Biome 提供了 JS、TS 、JSON/JSONC 以及 CSS 和 GriftQL 等語言的支持。在 Linter 方面，目前 Biome 內置支持了約 320 條以上規則支持 (參考: https://next.biomejs ⌘ Read more

Training a Rust 1.5B Coder LM with Reinforcement Learning (GRPO) | Oxen.ai
Comments ⌘ Read more

I wanted to port this to Rust as an excercise, but they still have no random number generator in the core library: https://github.com/rust-lang/rust/issues/130703

Thank You, DataFusion: Queries in Rust, Without the Pain
Comments ⌘ Read more

I Learned Rust In 24 Hours To Eat Free Pizza Morally
This is a satirical tech story. For readers who prefer the text version, it’s provided below.

I Learned Rust in 24 Hours to Eat Free Pizza Morally

This is not just a story about pizza. As a recent Phoronix article explains,
the Linux Rust subsystem got into major drama because of my humble quest.

Well, here’s my side of the story, with every kernel of truth exposed.

A Moral Quest for Pizza

Des … ⌘ Read more

Introducing facet: Reflection for Rust
Comments ⌘ Read more

Days since last Rust Minecraft server
Comments ⌘ Read more

How to deal with Rust dependencies
Comments ⌘ Read more

Faster route propagation by rewriting our Traefik gateway in Rust
Comments ⌘ Read more

Reducing Cargo target directory size with -Zno-embed-metadata
Comments ⌘ Read more

Designing Error Types in Rust Libraries
Comments ⌘ Read more

Why Use Structured Errors in Rust Applications?
Comments ⌘ Read more

Hey Rust, I think I know just what the feeling is
Comments ⌘ Read more

C++ to Rust Phrasebook
Comments ⌘ Read more

Security updates for Friday
Security updates have been issued by AlmaLinux (.NET 8.0, .NET 9.0, firefox, ghostscript, gstreamer1-plugins-bad-free, libsoup3, mingw-freetype, perl, ruby, sqlite, thunderbird, unbound, valkey, and xz), Debian (chromium, firefox-esr, libavif, linux-6.1, modsecurity-apache, mydumper, systemd, and thunderbird), Fedora (coreutils, dnsdist, docker-buildx, maturin, mingw-python-flask, mingw-python-flit-core, ruff, rust-hashlink, rust-rusqlite, and thunderbird), Red Hat (pcs), SUSE (augeas, … ⌘ Read more

The Linux 6.15 kernel arrives and it’s big a victory for Rust fans
Comments ⌘ Read more

Revisiting Loop Recognition in C++… in Rust
Comments ⌘ Read more

Redesigning the Initial Bootstrap Sequence
Comments ⌘ Read more

Pyrefly vs. ty: Comparing Python’s Two New Rust-Based Type Checkers
Comments ⌘ Read more

Rust streams and timeouts gotcha
Comments ⌘ Read more

Type-level Bounded Recursion in Rust
Comments ⌘ Read more

@kat@yarn.girlonthemoon.xyz Ah, I see. I would assume that you’ll get used to it at some point. 🤔 But yeah, a lot of meaning is packed into these symbols. (It’s much, much worse with languages like Rust. 😅)

10 Ancient “Smart” Materials Scientists Still Can’t Reproduce
As civilizations from Rome to the Maya harnessed empirical ingenuity to create materials with built-in healing, color-shifting, or structural resilience, they left behind recipes that modern science is only now decoding. From rust-proof iron pillars and self-repairing concrete to nanotech-level glass and ancient vulcanized rubber, these ten remarkable “smart” materials demonstrate how our ancestors engineered […] … ⌘ Read more

Microsoft Creates MS-DOS EDIT.COM Clone in Rust
The classic DOS text editor has returned! ⌘ Read more

A Tale of Testability and Sending Non-Send Types in Rust
Comments ⌘ Read more

The GCC compiler backend can now fully bootstrap the Rust compiler
Comments ⌘ Read more

tokio-mpmc：高性能異步多生產者多消費者隊列
tokio-mpmc 是一個基於 Tokio 異步運行時的高性能多生產者多消費者隊列實現，專爲異步 Rust 應用提供高效的數據傳遞機制。本文將深入淺出地介紹其架構設計、工作原理和使用方法。設計背景在異步編程中，特別是構建高性能併發系統時，任務間的數據傳遞是核心問題。雖然 Rust 生態中已有多種隊列實現（如 std::sync::mpsc、tokio::sync::mpsc、tokio::syn ⌘ Read more

Fork Union: Beyond OpenMP in C++ and Rust?
Comments ⌘ Read more

[$] LWN.net Weekly Edition for May 22, 2025
Inside this week’s LWN.net Weekly Edition:

• Front: Home Assistant; Setuptools; Debian AI GR; DMA-mapping API; BPF CI; OSPM 2025

• Briefs: Go audit; Oniux; Asahi progress; Rust in FreeBSD; RHEL 10; Rust 1.87.0; RIP John L. Young; Quote; …

• Announcements: Newsletters, conferences, security updates, patches, and more. ⌘ Read more

Status report on optional Rust in FreeBSD support
Shawn Webb has published a status\
report on work to provide basic support in FreeBSD for userland components
written in Rust.

We introduced a new BSD makefile, located at share/mk/bsd.rust.mk,
that enables building a Rust application during buildworld. As of … ⌘ Read more

Introducing Roto: A Compiled Scripting Language for Rust
Comments ⌘ Read more

Building a fast website with the MASH stack in Rust
Comments ⌘ Read more

Writing into uninitialized buffers in Rust
Comments ⌘ Read more

Optional Rust-In-FreeBSD Support May 2025 Status Report
Comments ⌘ Read more