-
Apple security releases, https://support.apple.com/100100.
Nothing interesting here apart from the 100100 in the URL. The binary number is a nice touch ^^.
-
Bugs Rust Won't Catch, https://corrode.dev/blog/bugs-rust-wont-catch/.
Canonical has disclosed 44 CVE in uutils. The author explains a couple of them.
It’s interesting to learn about these attack vectors. The author insists Rust doesn’t catch these bugs at compile-time nor via Clippy, even if fixes are straightforward.
The author quickly compares uutils to GNU coreutils that has received many CVE related to, e.g. memory management, which are not possible in safe Rust.
-
dav2d, https://code.videolan.org/videolan/dav2d.
dav2d is an AV2 cross-platform decoder, open-source, and focused on speed and correctness. It is based on the popular dav1d decoder.
The goal of this project is to provide a decoder for most platforms, and achieve the highest speed possible to overcome the temporary lack of AV2 hardware decoder.
Made by VideoLAN.
-
Which Mastodon client are you using on iOS?
I’m using Mona since a long time. I tried the official app: it’s (very) beautiful but buggy and lacks a couple of features. I’m back on Mona.
What about you?
-
The fastest way to match characters on ARM processors?, https://lemire.me/blog/2026/04/19/the-fastest-way-to-match-characters-on-arm-processors/.
In this article, Lemir talks about two SIMD ARM SVE/SVE2 instructions: `match` and `nmatch`, which fit nicely in the _vectorized classification_ step of `simdjson`. These instructions improve the performance of `simdjson` from 11.4Gb/s to 14.4Gb/s.
-
Throughput of the crate I'm trying to replace: 12.73Melem/s
My crate: 70.1Melem/s.👀 I think I'm on something.
-
-
Futurelock, https://rfd.shared.oxide.computer/rfd/0609.
Discussion and concrete examples about “a type of deadlock where a resource owned by Future A is required for another Future B to proceed, while the Task responsible for both Futures is no longer polling A. Futurelock is a particularly subtle risk in writing asynchronous Rust.”
Well written! Once again, async code is hard.
-
📣 New blog post
About memory pressure, lock contention, and Data-oriented Design, https://mnt.io/articles/about-memory-pressure-lock-contention-and-data-oriented-design/.
I illustrate how Data-oriented Design helped to remove annoying memory pressure and lock contention in multiple sorters used in the Matrix Rust SDK. It has improved the execution by 98.7% (53ms to 676µs) and the throughput by 7718.5% (from 18Kelem/s to 1.4Melem/s)!
-
-
Making the rav1d Video Decoder 1% Faster, https://ohadravid.github.io/posts/2025-05-rav1d-faster/.
The author explains the approach: how to measure, to profile, and how to improve the code. Really great writing and excellent findings!
-
• -14°C this morning, -4°C now.
• air enters the ventilation at 5°C thanks to the passive ground-coupled heat exchanger (+9°C)
• supplied air is at 21°C thanks to the air-to-air heat exchanger (+16°C)
• extracted air is at 24°C
• discharged air is at 8°CIt consumes around 300W of electricity.
The ventilation maintains the temperature whilst renewing air. The greenhouse heats the house. It's currently at 32°C.
-
What We Learned from the Recent Mandrill Outage, https://mailchimp.com/what-we-learned-from-the-recent-mandrill-outage/.
Mailchimp encountered a database failure. This is the story of how they have fixed it.
-
Looking for LED bulbs with white colour (daylight, 5000-6500K) and with a high CRI (>90). Any recommendations?
-
Faster linking times with 1.90.0 stable on Linux using the LLD linker, https://blog.rust-lang.org/2025/09/01/rust-lld-on-1.90.0-stable/.
tl;dr: rustc will start using the LLD linker by default on the `x86_64-unknown-linux-gnu` target starting with the next stable release (1.90.0, scheduled for 2025-09-18), which should significantly reduce linking times.
-
Sunsetting the `rustwasm` Github org, https://blog.rust-lang.org/inside-rust/2025/07/21/sunsetting-the-rustwasm-github-org/.
Active and important projects like `wasm-bindgen`, `walrus`, `weedle`, `wasm-pack`, `twiggy` etc. are moved into either their own organisation, or the maintainer's account, e.g.:
* https://github.com/wasm-bindgen/wasm-bindgen
* https://github.com/drager/wasm-pack
* https://github.com/AlexEne/twiggy -
Ordering Numbers, How Hard Can It Be?, https://orlp.net/blog/ordering-numbers/.
Well. Ordering numbers from different types (like i32 and u32) can be error-prone and not that trivial.
-
A valid HTML zip bomb, https://ache.one/notes/html_zip_bomb by @ache
The article shows how to create an HTML zip bomb for AI crawlers not respecting the `robots.txt` file.
A zip bomb is a huge file (like 10Gib), that once compressed, has a reasonable size like 10Mib. An AI crawler will uncompressed it and will see all its memory being consumed, leading to a possible crash.
That’s an effective way to counter-attack disrespectful AI crawlers.
-
`uutils/coreutils` 0.1.0 has been released, https://github.com/uutils/coreutils/releases/tag/0.1.0.
It took me a moment to share the news but it’s a good news!
`uutils/coreutils` is a cross-platform reimplementation of the GNU `coreutils` in Rust.
> This release brings major performance gains, SELinux support, and expanded GNU compatibility.
-
`vello_svg`, https://github.com/linebender/vello_svg.
An integration to render SVG files with Vello.
Play with it in the browser, https://linebender.org/vello_svg/.
-
`cargo-sort`, https://crates.io/crates/cargo-sort.
Check if tables and items in a `.toml` file are lexically sorted.
Pretty handy to get nice `Cargo.toml` files for example!
-
Received 21.7 tonnes of rocks for dry stone walls, an “amphitheatre”, and other projects in the garden. Wish me luck.
5 more tonnes are missing, but will join the party soon.
-
I wrote another higher-stream stream, `Skip`, inside `eyeball`, https://github.com/jplatte/eyeball/pull/72. It provides a limited view over an `ObservableVector` where the first values are skipped.
This one was funny to write!
Oh, `Limit` has been renamed to `Head`, and `RLimit` to `Tail`, it makes things clearer.
#RustLang #ReactiveProgramming #Observability #stream #asynchronous
-
I wrote a new higher-order stream, `RLimit`, inside `eyeball`, https://github.com/jplatte/eyeball/pull/69. It provides a limit over an `ObservableVector` starting from the end of the vector.
This one was fun.
#RustLang #ReactiveProgramming #observability #stream #asynchronous
-
Okay, the last album of Rilès, SURVIVAL MODE, is excellent. The lyrics, the production, the variety of styles, the composition… what a great artist.
-
Practical Data-oriented Design, https://www.youtube.com/watch?v=IroPQ150F6c by @andrewrk. That's an amazing talk, with concrete examples on the Zig compiler.
-
Why an Elf file with a single small segment produces an error?, https://stackoverflow.com/questions/79181029/why-an-elf-file-with-a-single-small-segment-produces-an-error
If someone has an answer to my question, that would be lovely!
-
A Whirlwind Tutorial on Creating Really Teensy ELF Executables for Linux, (or Size Is Everything), https://www.muppetlabs.com/~breadbox/software/tiny/teensy.html
An excellent article! The author tries to produce the smallest Elf32 executable file possible. It's well written, it's fun, and particularly impressive. Well done!
-
Finally been able to produce a tiny executable:
```
$ cat exit.s
section .text
global _start_start:
mov edi, 42 ; return code 42
mov eax, 60 ; `_exit` syscall
syscall
$ nasm -f elf64 exit.s -o exit.o
$ cargo run -- --target x86_64-unknown-unknown exit.o -o a.out$ [go on a x86-64 Linux machine]
$ chmod u+x a.out
$ ./a.out
$ echo $?
42
```That's a first step! Patches are coming.
-
OpenHCL: the new, open source paravisor, https://techcommunity.microsoft.com/t5/windows-os-platform-blog/openhcl-the-new-open-source-paravisor/ba-p/4273172.
Learn more at https://openvmm.dev/ or https://github.com/microsoft/openvmm.
Bonus: it’s fully written in Rust!
-
Designing A Fast Concurrent Hash Table, https://ibraheem.ca/posts/designing-papaya/.
The author presents a novel Rust library called papaya, that is a (really) fast concurrent hash table. The article explains the inspirations, the differences with other libraries, the new techniques etc. A really instructive article.
-
📣 New blog post
✨ Building a new site! — https://mnt.io/articles/building-a-new-site/ ✨
It's time to rewrite my site from scratch. I'm nostalgic of the good old Web. This site is hand-written, and promotes smallness, speed, simplicity and fun. Let's discover the new lore (!), and let's talk about series a little bit.
-
📣 New series on https://mnt.io named ✨ Reactive programming in Rust ✨.
https://mnt.io/series/reactive-programming-in-rust/
👉 Episode 1 — Observability
I'm trying a new style. Feel free to give any feedback (preferably with the new Discuss link in the menu). I hope you'll enjoy the new character: Le Comte. Its friends are not in this episode; maybe in the next ones 😉.
-
The first episode of the new series I’m preparing for https://mnt.io/series is finally mentioning the type I wanted to talk about. After 17mn reading time. Now I understand @fasterthanlime.
-
wide, https://github.com/Lokathor/wide.
> [it] has portable "wide" data types that do their best to be SIMD when possible.
> On x86, x86_64, wasm32 and aarch64 neon this is done with explicit intrinsic usage (via safe_arch), and on other architectures this is done by carefully writing functions so that LLVM hopefully does the right thing. When Rust stabilizes more explicit intrinsics then they can go into safe_arch and then they can get used here.
-
A Practical Approach for Model Checking C/C++11 code, http://plrg.eecs.uci.edu/publications/toplas16.pdf.
-
It brings the following interesting features:
• Generally faster and/or more memory efficient than alternatives
• Scales better to multiple cores for some workloads than alternatives
• Custom Out-Of-Memory handlers for just-in-time heap management and recovery
• Supports creating and resizing arbitrarily many heaps
• Optional allocation statistics
• Partial validation in debug -
Talc, https://github.com/SFBdragon/talc.
A memory allocator built in Rust, for Rust. It is for embedded system, OS kernels or other no_std environments. It is also for WebAssembly.
-
Tock Compiles on Stable Rust, https://tockos.org/blog/2024/talking-tock-55/.
Tock is an embedded operating system designed for running multiple concurrent, mutually distrustful applications on low-memory and low-power microcontrollers. It’s written in Rust. And now it can be compiled with the stable Rust versions.
-
Optimizing Rust programs with PGO and BOLT using cargo-pgo, https://kobzol.github.io/rust/cargo/2023/07/28/rust-cargo-pgo.html.
Feedback-directed optimisations made easy with `cargo-pgo`! Neat.
-
Do you know how to create a Unity plugin?
Coqui awesome Text-to-Speech project needs you, https://github.com/coqui-ai/TTS/issues/2589. Imagine being able to create any speech from a simple text, in multiple languages, with any voices (including voice cloning), based on open source technologies and state-of-the-art algorithms? You can make it real.
-
Orogene, https://orogene.dev/.
> Orogene is a next-generation package manager for tools that use node_modules/, such as bundlers, CLI tools, and Node.js-based applications. It's fast, robust, and meant to be easily integrated into your workflows such that you never have to worry about whether your node_modules/ is up to date.
It’s really faster than other tools, check the benchmarks, https://github.com/orogene/orogene/blob/main/BENCHMARKS.md.
#JavaScript #RustLang #npm #node_modules #PackageManager #performance
-
XUL Layout is gone, https://crisal.io/words/2023/03/30/xul-layout-is-gone.html.
XUL is (was) a Mozilla technology. Most of it can be replaced by current HTML/CSS features today. It’s being removed from Firefox, and that’s a good thing.
-
An aperiodic monotile, https://arxiv.org/abs/2303.10798.
This is so awesome.
-
First 10 patches to add Xtensa support inside LLVM have been merged upstream, https://github.com/search?q=repo%3Allvm%2Fllvm-project+Xtensa&type=commits \o/.
-
Flume, https://github.com/zesterer/flume.
A blazingly fast multi-producer, multi-consumer channel. It can be sync or async, which is pretty neat!
No unsafe code too.
-
St³, https://github.com/asynchronics/st3.
The Stealing Static Stack. Very fast lock-free, bounded, work-stealing queues with FIFO stealing and LIFO or FIFO semantic for the worker thread.
-
Souper, https://github.com/google/souper.
Souper is a superoptimizer for LLVM IR. It uses an SMT solver to help identify missing peephole optimizations in LLVM's midend optimizers.
-
Falsehoods programmers believe about undefined behaviour, https://predr.ag/blog/falsehoods-programmers-believe-about-undefined-behavior/.
The article explains what is an undefined behaviour exactly. It’s funny.