Dalaran: Robotics-First Observability and Visualization for ROS 2 and Multimodal Time-Series

What Dalaran Adds to the Rerun Foundation

Rerun is a C++ and Rust visualization tool for multimodal time-series data. Dalaran is described as a hard fork: it preserves the storage container format and the recording stream API but adds a layer of robotics-specific tooling that the upstream project does not provide.

The README lists five additions that are described as code in the repository with tests, not roadmap items: the `dalaran.robot` high-level logging API, the ROS 2 bridge and rosbag2 replay pipeline, REP-103/REP-105 axis-convention helpers, occupancy grid and costmap support, and the `dalaran doctor` diagnostic subcommand. Everything else in the README that is marked as not yet built lives in ROADMAP.md.

This distinction matters when evaluating the project. The README is explicit about drawing a line between shipped features and future plans, which is a more honest framing than is typical for early-stage projects.

Installation and Quickstart Across SDKs

The Python SDK installs from PyPI:

pip install dalaran-sdk

A minimal logging example streams 3D points to a spawned viewer process:

import dalaran as dl
import numpy as np

dl.init("dalaran_example_app", spawn=True)

positions = np.random.default_rng(0).normal(size=(1000, 3)).astype(np.float32)
colors = np.random.default_rng(1).integers(0, 255, size=(1000, 3), dtype=np.uint8)

for frame in range(100):
    dl.set_time("frame", sequence=frame)
    dl.log("world/points", dl.Points3D(positions + frame * 0.01, colors=colors))

To write to a file instead of a live viewer, replace `spawn=True` with `dl.save("session.dlr")` and open it later with `dalaran session.dlr`. The Rust SDK installs with `cargo add dalaran`. For C++, the SDK is fetched in CMakeLists.txt and linked against `dalaran_sdk`. The CLI binary ships with the Python wheel or can be installed separately with:

cargo install dalaran-cli --locked

ROS 2 Bridge, rosbag2 Replay, and the Message Registry

The ROS 2 bridge subscribes to live topics and feeds them into Dalaran's recording stream in real time. The rosbag2 replay path reads MCAP files and a set of common ROS message schemas directly, so teams can replay an existing rosbag2 recording into Dalaran without writing a conversion script. The message registry is extensible: teams can register their own `.msg` types without patching the core, which means the bridge does not break when a robot uses custom messages that upstream Rerun would not know about.

Axis conventions are a recurring source of visualization bugs in robotics. Dalaran ships REP-103 and REP-105 helpers that encode `x`-forward, `z`-up, ENU and NED conventions for positions and orientations, along with `map`, `odom`, and `base_link` frame semantics. The README calls silently mismatched axis conventions the most common way a robotics visualization ends up wrong, and these helpers make the direction hard to get backwards at the API level.

Occupancy grids from `nav_msgs/OccupancyGrid`, costmaps from `nav2_msgs/Costmap`, and nav2's `/global_costmap` and `/local_costmap` topics are handled as typed `GridMap` archetypes with proper origin and resolution, not as untyped images. Nav2 cost semantics such as `INSCRIBED_INFLATED_OBSTACLE` and `LETHAL_OBSTACLE` are drawn as distinct categories. A costmap's layers stack as separate entities with their own draw order and opacity, and the rolling local window updates its origin rather than adding new entities.

Compatibility with Existing Rerun Recordings

Dalaran did not change the storage container. The on-disk format still uses the `RRF2` fourcc, and the `dalaran` CLI accepts `.rrd` files directly without renaming or conversion. The README defines compatibility precisely at four levels, which is a clearer statement than most forks provide.

The stream header, framing, and footer are unchanged. The Arrow chunk data is compatible: upstream writes metadata under `rerun:*` and Dalaran writes `dalaran:*`, and readers accept both namespaces, so chunks, entity paths, timelines, and segment IDs resolve out of an upstream file. Blueprint compatibility is partial: some component descriptors from upstream blueprint stores do not yet resolve in Dalaran, so a recording's saved layout may be ignored while its data loads correctly. Very old recordings are subject to the same migration rules that apply upstream.

Live streams and remote catalogs use `dalaran://` URIs. The `dalaran convert` command turns an `.rrd` file into a `.dlr` file when normalization is wanted. This level of backward compatibility removes the migration cost for teams that have accumulated Rerun recordings and want to evaluate Dalaran's robotics features without converting their archive.

Saved blueprints use the `.dbl` extension. The `.dlrpack` portable dataset bundle format carries recordings, the blueprint, referenced assets, and metadata in a single file.

The dalaran.robot API and URDF Integration

The `dalaran.robot` API provides a single handle that knows about the robot's joint states, base pose, sensor frames, and URDF-driven link transforms. Instead of manually constructing entity paths and quaternion conversions for each sensor, a developer calls `robot.log_joint_states(...)` and the API handles the geometry. This removes a class of boilerplate that is otherwise repeated in every robotics logging script.

Pointing the handle at a URDF file causes joint limits, joint axes, and `<mimic>` joints to be respected automatically. This is the practical payoff of the axis-convention work: the `robot` API and the URDF loader agree on the coordinate system, so the default behavior produces correct visualizations without manual frame adjustment. The README notes that URDF-driven link transforms and `<mimic>` joint handling are already in the codebase and tested, not planned.

The viewer's web server mode runs with `dalaran --serve`, which allows remote access to a running recording session without copying files. Live streams use `dalaran://` URIs, and the same CLI handles both local files and remote catalog connections.

Comparison with Upstream Rerun and Limitations

Rerun is the upstream project and has a larger ecosystem, more language bindings, stable releases, and broader community adoption. Rerun supports Python, Rust, C++, and has integrations for computer vision, medical imaging, and general sensor fusion. For teams doing non-ROS embedded systems, the additional layer that Dalaran adds has no value and the fork introduces maintenance uncertainty.

Dalaran's differentiation is specific: it is useful for ROS 2 teams that need a recording and visualization tool with nav2 costmap support, URDF-driven joint visualization, and an axis-convention safety layer built in. The README says that Dalaran is Apache-2.0 throughout with no dual-license ambiguity and no hosted-service dependency, which may matter to teams that were concerned about Rerun's licensing approach. Outside the robotics use case, the additional complexity of a fork without stable releases is a cost without a corresponding benefit.

The current Python workspace version is `0.28.0-alpha.1+dev` according to pyproject.toml, and the Cargo workspace version is `0.1.0`. There are no GitHub releases published, and the Rust minimum version is 1.95. The `dalaran doctor` subcommand inspects the build environment, wgpu adapters, `DALARAN_*` environment variables, headless and ROS 2 setup, and recording integrity. It runs from the viewer binary, meaning it can diagnose problems even when the Python SDK installation is broken. The companion `dalaran-doctor` command covers the Python side, checking interpreter compatibility and SDK-to-viewer version skew from within a working Python environment. This split matters on systems where the viewer and the Python process run as separate installations.

Editorial conclusion

Dalaran is the better choice over upstream Rerun for ROS 2 teams that need axis-convention safety, nav2 costmap visualization, or a high-level `robot` logging API tied to a URDF. Teams doing general sensor fusion, non-ROS embedded systems, or medical imaging should use upstream Rerun, which has a larger community, stable releases, and broader language support. The last push was on 2026-08-12, and the current Python SDK version is `0.28.0-alpha.1+dev` according to pyproject.toml, which means it is still pre-release. Consult ROADMAP.md before committing to a planned feature: the README separates shipped code (with tests) from roadmap items, and only the former is reliable.

Frequently asked questions

Official sources

1. Flaminis/Dalaran on GitHub
2. Issues
3. License: Apache-2.0
4. README