James Logan

Terminal with three panels. Top-left shows "zoo kcl analyze" command output, with a table showing mass, density, volume etc. Bottom-left panel shows "zoo kcl view" displaying four different angles of a model rendered as PNG. Right panel shows the KCL code for the model.

I added a new helpful one-stop-shop for all your physical analysis in Zoo's CLI. Find your model's mass, volume, surface area, etc with "zoo kcl analyze".

I just wish more web ui systems were aware of this. Some like Material and whatever github uses only render svg once, and don't re-render when CSS changes for dark/light mode, so even if you put CSS in your SVG to switch between light and dark mode, it won't actually update until refresh

hey uhhh. I got fired yesterday. if anyone has rust positions in the Netherlands let me know!

> dump firmware from a cheap and _very_ cursed handheld "microscope"
>
> look inside
>
> `NES Game`


$ strings plushlogic.bin
...
NES Game
nesGameSubOpenWin
nesGameInnerWinChildClose
nesGameWinChildClose
nesGameSubCloseWin

screenshot from C11 standard, appendix J.2, specifying that "The behavior is undefined in the following circumstances: — A ‘‘shall’’ or ‘‘shall not’’ requirement that appears outside of a constraint is violated (clause 4). — A nonempty source file does not end in a new-line character which is not immediately preceded by a backslash character or ends in a partial preprocessing token or comment (5.1.1.2). ..."

today i learned that if you don't end a C file with a newline, the compiler is free to steal your apes

Yeah, among other things, they set global flags that clip subnormal numbers to zero

Many of the #rust floating-point math functions have a note:

"The precision of this function is non-deterministic. This means it varies by platform, Rust version, and can even differ within the same execution from one invocation to the next."

When would results vary between invocations?
#rustlang

libm implementations are a little slower sometimes, but imo it is well worth the cost to achieve real cross-platform consistency, especially in scientific computing

I recommend using libm for any functions with that label unless you know they'll get compiled to a single instruction on your target platform (like sqrt() for example)

If you load a C module that uses -ffast-math, or if libc gets hooked and modified, it can change floating-point calculation behavior in your otherwise-separate program. I think there are also some function implementations that don't write all the bits of the float in some cases, so you get some junk

Texas Instruments in advanced talks to buy Silicon Laboratories for about $7 billion, source says Texas Instruments is in advanced talks to buy chip designer Silicon Laboratories for about $7 billion, a source familiar with the matter told Reuters on Tuesday.

> Texas Instruments in advanced talks to buy Silicon Laboratories

We march ever closer to the "silicon vendor singularity"

www.reuters.com/technology/t...

- make the best chips
- every two years get bought by a new big chip or big finance company
- they want to know the secret to making the best chips
- the secret: "get gud"
- get sold again, more like

I can only imagine what silabs would get done without the corporate churn...

Error: entity released

...horrifying message without context, thank you

WhatsApp architect overview and rust

🦀 WhatsApp adopts Rust for media security

> Rust version showed performance and runtime memory usage advantages over the C++

> We anticipate accelerating adoption of Rust over the coming years

engineering.fb.com/2026/01/27/s...

#rustlang #whatsapp

😒

A picture showing an example output of the program on the city of Montréal and the autumn color scheme. You can see a map of the city with all the roads, trains, subways and light rail. At the bottom there the poster is titled MONTRÉAL - QUÉBEC. The latitude and longitude are also written under the title.

A picture showing an example output of the program on the city of Paris and the emerald color scheme. You can see a map of the city with all the roads, trains, subways and light rail. At the bottom there the poster is titled PARIS - FRANCE. The latitude and longitude are also written under the title.

A picture showing an example output of the program on the city of Tokyo and the japanese ink color scheme. You can see a map of the city with all the roads, trains, subways and light rail. At the bottom there the poster is titled TOKYO - JAPAN. The latitude and longitude are also written under the title.

A picture showing an example output of the program on the city of Berlin and the noir color scheme. You can see a map of the city with all the roads, trains, subways and light rail. At the bottom there the poster is titled BERLIN - GERMANY. The latitude and longitude are also written under the title.

Here is what I've been doing this past week: git.olaren.dev/Olaren/mapto...
A little python program that generates poster for cities! You might have seen stuff like this around lately, but I modified it to put an emphasis on rail infrastructure :3

logic analyzer output

⚡️Using a Cheap USB Logic Analyzer for Embedded Rust Debugging

- A beginner-friendly post on logic analyzers (Rust is a small part of the post).

> Focuses on understanding samples, capture duration, and reading waveforms with PulseView.

blog.implrust.com/posts/2026/0...

#rustlang #embedded

Scientific Computing in Rust the Scientific Computing in Rust annual workshop and monthly newsletter.

First Scientific Computing in Rust monthly newsletter of 2026 is out. Enjoy!

scientificcomputing.rs/monthly/2026...

We are excited to announce that we can successfully use Rust's standard library from the GPU. This has never been done before.

www.vectorware.com/blog/rust-st...

Supporting Rust's standard library enables existing Rust code to work on the GPU and makes GPU programming feel normal.

GitHub - jlogan03/interpn: N-dimensional interpolation methods in Rust and Python, no-std compatible N-dimensional interpolation methods in Rust and Python, no-std compatible - jlogan03/interpn

The library is available as a Rust crate and Python library at:
* Github: github.com/jlogan03/int...
* crates.io: crates.io/crates/interpn
* PyPI: pypi.org/project/inte...

Plot showing up to 320x speedup compared to scipy

Snip showing +460/-3064 lines changed

InterpN is now 100% statically-analyzable and about 30% faster by eliminating the need for recursive methods.

In addition to a nice speedup, this change shrinks the repo by about 45%, removing about 2600 lines of code!

Exponential growth continued — cargo-semver-checks 2025 Year in Review More than twice as many lints as last year, and that's just the start!

cargo-semver-checks is growing faster than ever:
- 7 new releases, from v0.39 to v0.45
- 122 new lints, more than double last year's count
- 4x reduction in lint execution time — some lints became up to 10x faster
- across 26 (!!) rustdoc format versions

predr.ag/blog/cargo-s...

crates.io: Rust Package Registry

If you need fast interpolation, give it a look on the package repos ~
* crates.io/crates/interpn
* pypi.org/project/inte...

...and check out the writeup at jlogan.dev/blog/2025/11... !

Plot showing linear speedup with number of cores for different interpn calc methods.

The `interpn` library for Rust and Python has the fastest interpolation algorithms I'm aware of - up to 250x faster than Scipy - and today it got faster!

After years of focusing on single-thread performance, I finally called it good gave it more cores - and the parallel speedup is nearly linear!

alaska, the ◼️◼️◼️◼️◼️

but at least they didn't make us an island this time?

Screenshot from the cargo-semver-checks 2024 year in review post featuring a diagram of the number of lints at the end of each calendar year. 2022 ended with 30 lints, 2023 ended with 57, 2024 ended with 120 lints. Link to the post: https://predr.ag/blog/cargo-semver-checks-2024-year-in-review/

SemVer is tricky in all languages. But in #rustlang it's easier than ever before!

By the end of 2024, cargo-semver-checks' capabilities were growing exponentially: 30 -> 57 -> 120 lints. We now end 2025 with 242 lints — 122 new lints were merged this calendar year 🎉

The exponential continues!

I've been wanting to try and start brain dumping some thoughts on (embedded) rust, how I approach problems, write HAL/device drivers, tools I use, etc.

But, I'm terrible at starting to write unless I have specific questions to answer.

So: ask me anything re: embedded/rust/hardware!

Day 18: Function with fast & slow paths. Inline = code bloat. Don't inline = slow fast path. Can't have both—or can you? The compiler finds a surprising way out of this dilemma.

xania.org/202512/18-pa...
youtu.be/STZb5K5sPDs
#AoCO2025

Any rust friends have some good resources / insights into doing input fuzzing?

Chip was written in Spade HDL (spade-lang.org), which transpiles down to SystemVerilog. That's then fed into a LibreLane build process that turns the verilog into transistors. All open source!