ultraviolet VS r2r

This one has some more traction: https://github.com/fu5ha/ultraviolet

Some other good places to look would be the source code for the ultraviolet crate and for wide.

2. Using macros for codegen, as seen in almost all other linear algebra crates, e.g. ultraviolet (https://crates.io/crates/ultraviolet)

The drawback of (1) is that it's hard to understand or extend, and the type errors are insane, and put Boost to shame. The drawback of (2) is that's just a macro. Of course (1) and (2) are not interoperable.

C++ templates are really underappreciated, because they are a single mechanism that gives you both powerful generics and macro-like codegen, while being easy to adopt gradually. (E.g. you can add concepts when it gets unwieldy, but you don't have to rewrite the whole thing.)

You can also check https://github.com/sequenceplanner/r2r for ROS2 bindings (using in production at work for a couple of ROS nodes).

But TBH, in a Rust world, it’s worth revisiting the assumptions behind the ROS node architecture, since Rust is so strong at scaling to large monolithic applications (due to the strict hierarchical code patterns it encourages).

A transitional Rust approach, that doesn't try to reimplement everything from scratch, could do something like a strangler pattern: Take each ROS node, run them separately in “jails” with a Rust API around each one, then implement the plumbing/management logic in pure Rust.

Nice to see async support! I've been following along with r2r which seems further along (action, parameter support), which has been converted to async-only a while ago. However, it hasn't seen activity since February,

ros2 bindings (not the one you get as the first search result, ros2_rust) are far nicer than ros1 ones, mostly because ros2's design of having one library (rcl) designed for bindings is far better. This one even has full async/await support, and because of Rust's flexible design for that, rcl's runtime is plugged into Rust's so it's really efficient.