A new ROS2-native, SUPERFAST visualizer written in Rust — `fastviz`
Hi everyone,
I’ve been working on a project called **fastviz**: a Rust-based 3D visualizer that runs as a native ROS2 node, built on `wgpu` and `egui`. RViz has been the workhorse of the community for many years and isn’t going anywhere — fastviz is just an experiment to see how much smoothness and headroom we can get out of a pure-Rust + GPU-native pipeline, and I wanted to share where it’s at in case it’s useful to others.
It’s at a preliminary stage — only a handful of message types are wired up so far — but the core architecture is in place and it already renders things like TurtleBot 4 in Gazebo end-to-end.
**Repo:** GitHub - ksatyaki/fastviz: Rust based HOPEFULLY superfast viz for ROS2 · GitHub
-–
## The bits I’m most excited about
### 1. It IS a ROS2 node
No bridge, no middleware, no separate process. fastviz subscribes directly to topics via `r2r`, so there’s nothing extra to wire up between your robot and the visualizer.
### 2. The render thread never touches ROS2
The `r2r` executor runs on a dedicated thread; the renderer talks to it through an `Arc<RwLock>` with brief, write-only handoffs. The UI never blocks on DDS — frames stay smooth even when a noisy topic is flooding the graph.
### 3. GPU-accelerated via `wgpu`
Vulkan on Linux, Metal on macOS, DX12 on Windows, and WebGPU is on the menu too. Same renderer everywhere.
### 4. Revision-cached render passes
A `revision()` counter on the scene graph drives pass-level caching, so an idle scene costs ~zero CPU. Walking away from the visualizer doesn’t pin a core.
### 5. GPU-side per-entity transforms for point clouds
The point-cloud pipeline is instanced, per-entity transforms happen on the GPU, and the prepare step is revision-cached with buffer reuse. PointCloud2 streams stay cheap.
### 6. TF tree reimplemented in Rust
No `tf2` C++ dependency — TF maintenance lives in pure Rust alongside the rest of the ingestion layer.
### 7. TOML config as the source of truth
Layouts are declared in a TOML file — diff-friendly, version-controllable, and easy to commit alongside your robot’s launch config.
### 8. Polled wildcard topic discovery
Drop `“*”` into a topic list and every matching message type in the ROS graph gets auto-subscribed within about a second. Handy when you’re exploring an unfamiliar bag or sim and don’t want to enumerate topics by hand.
### 9. Per-topic QoS overrides in config
`reliability`, `durability`, and `depth` are all settable per topic from the same TOML file.
### 10. URDF support with STL / OBJ / DAE meshes
URDF parsing via `urdf-rs`; mesh loading covers STL, OBJ, and Collada. `package://` URIs resolve through `AMENT_PREFIX_PATH`, and `JointState` drives the FK.
### 11. Dev container + release Docker image
The `.devcontainer/` ships an Ubuntu 24.04 + ROS2 Jazzy image with `r2r` build deps, the Vulkan loader, and NVIDIA passthrough already wired up. A root `Dockerfile` also builds a release image you can `docker run`.
-–
## What’s supported today (early days!)
This is very preliminary — only a few message types are supported right now:
| Topic kind | Message |
| -------------- | -------------------------------- |
| `[map]` | `nav_msgs/OccupancyGrid` |
| `[poses]` | `geometry_msgs/PoseStamped` |
| `[pose_arrays]`| `geometry_msgs/PoseArray` |
| `[paths]` | `nav_msgs/Path` |
| `[scans]` | `sensor_msgs/LaserScan` |
| `[points]` | `sensor_msgs/PointCloud2` |
| `[tf]` | `tf2_msgs/TFMessage` |
| `[urdf]` | `std_msgs/String` + `JointState` |
`MarkerArray`, `Image`, `Imu`, `Odometry`, and friends are on the near-term roadmap. ROS2 Jazzy is the only distro currently tested.
-–
## Try it
```sh
git clone GitHub - ksatyaki/fastviz: Rust based HOPEFULLY superfast viz for ROS2 · GitHub
cd fastviz
source /opt/ros/jazzy/setup.bash
cargo build --release
cargo run -p app – --config configs/turtlebot4.toml
```
Or via the dev container — open the folder in VS Code / Cursor and pick “Reopen in Container”.
-–
## Help wanted
If you give it a spin, I’d genuinely love to hear:
- which message types you’d want supported next,
- what kinds of bags would make good benchmarks,
- any architectural input on plugins, MCAP playback, or multi-window layouts.
Issues, PRs, and “this completely broke on my robot” reports are all very welcome.
Hopefully this can grow into something useful for the community. Thanks for taking a look!
**GitHub:** GitHub - ksatyaki/fastviz: Rust based HOPEFULLY superfast viz for ROS2 · GitHub