Available Viewer Backends in DimOS: Rerun, Foxglove, and None Explained

DimOS supports five distinct viewer backends—rerun, rerun-web, rerun-connect, foxglove, and none—configured via the viewer setting in GlobalConfig to control how visualization data is rendered.

The dimensionalOS/dimos repository provides flexible visualization capabilities for robotics applications through pluggable viewer backends. Understanding the available DimOS viewer backends allows you to optimize your workflow for local debugging, remote monitoring, or headless deployment.

Supported Viewer Backends

DimOS defines supported backends as a typed literal in dimos/core/global_config.py. The system recognizes five distinct values that determine how sensor data and telemetry are displayed.

Rerun Native ("rerun")

The default backend launches a local dimos-viewer process using the standard Rerun UI. When selected, the RerunBridgeModule spawns the native viewer binary and logs all messages implementing the to_rerun() protocol.

This mode requires a display server (X11 or Wayland) and is ideal for workstation-based debugging.

Rerun Web ("rerun-web")

This backend runs the Rerun web server (rr.serve_web_viewer) without requiring a separate binary installation. The bridge serves HTML and JavaScript content directly, making it suitable for containerized environments or systems without display servers.

Rerun Connect ("rerun-connect")

Use this mode to connect to a remote Rerun server (e.g., rerun+http://127.0.0.1:9877/proxy). The bridge forwards data to an external viewer instance without spawning a local process, enabling distributed visualization architectures.

Foxglove ("foxglove")

The Foxglove bridge (foxglove_bridge) translates LCM messages to the Foxglove dashboard format. This backend completely bypasses Rerun components and integrates with existing Foxglove infrastructure for web-based robotics visualization.

None ("none")

Disables all visualization processes while maintaining data publication. Use this for headless batch processing, automated testing, or when external tools handle visualization independently.

Backend Architecture and Mapping

The internal mapping from configuration strings to runtime modes lives in dimos/visualization/rerun/bridge.py. The _BACKEND_TO_MODE dictionary resolves user-facing strings to internal ViewerMode constants:

_BACKEND_TO_MODE: dict[str, ViewerMode] = {
    "rerun": "native",
    "rerun-web": "web",
    "rerun-connect": "connect",
    "none": "none",
}

When a blueprint initializes, DimOS checks global_config.viewer and wires the appropriate bridge module. In dimos/robot/unitree/go2/blueprints/basic/unitree_go2_basic.py, the selection logic branches as follows:

if global_config.viewer == "foxglove":
    # Foxglove bridge (LCM → Foxglove)

    with_vis = autoconnect(_transports_base,
                           foxglove_bridge(shm_channels=[...]))
elif global_config.viewer.startswith("rerun"):
    # Rerun bridge – mode resolved from the mapping above

    from dimos.visualization.rerun.bridge import _resolve_viewer_mode, rerun_bridge
    with_vis = autoconnect(_transports_base,
                           rerun_bridge(viewer_mode=_resolve_viewer_mode(),
                                        **rerun_config))
else:
    # No visualiser

    with_vis = _transports_base

Configuration Methods

Set your preferred backend through three mechanisms, processed in order of precedence:

1. Environment Variable: Export DIMOS_VIEWER (or add to .env files)
2. CLI Flag: Pass --viewer to the run command: dimos run <blueprint> --viewer rerun-web
3. Programmatic: Modify global_config.viewer directly in Python code

The default value is "rerun" as defined in dimos/core/global_config.py:

global_config.viewer: ViewerBackend = "rerun"

Practical Usage Examples

Launch with Native Rerun (Default)

dimos run unitree-go2-agentic

Serve Web Viewer for Containerized Environments

dimos run unitree-go2-agentic --viewer rerun-web

Connect to External Rerun Server

dimos run unitree-go2-agentic --viewer rerun-connect

Use Foxglove Dashboard

dimos run unitree-go2-agentic --viewer foxglove

Disable Visualization for Headless Operation

dimos run unitree-go2-agentic --viewer none

Runtime Configuration in Python

from dimos.core.global_config import global_config

global_config.viewer = "foxglove"  # Switch backends programmatically

Summary

• DimOS provides five viewer backends defined in dimos/core/global_config.py: rerun, rerun-web, rerun-connect, foxglove, and none.
• The RerunBridgeModule in dimos/visualization/rerun/bridge.py handles Rerun-specific modes through the _BACKEND_TO_MODE mapping.
• Foxglove integration bypasses Rerun entirely, using foxglove_bridge for LCM-to-dashboard translation.
• Configure via environment variables (DIMOS_VIEWER), CLI flags (--viewer), or direct GlobalConfig modification.
• Select backends based on infrastructure: native for local workstations, web for containers, connect for remote servers, foxglove for existing dashboards, and none for automated pipelines.

Frequently Asked Questions

How do I run DimOS without a display server?

Use the rerun-web backend. It serves the Rerun interface via HTTP without requiring X11 or Wayland, making it ideal for Docker containers and remote servers. Execute: dimos run <blueprint> --viewer rerun-web.

What is the difference between rerun and rerun-connect?

The rerun backend spawns a local viewer process on your machine, while rerun-connect forwards data to an already-running Rerun server at a specified URL. Use rerun-connect when the viewer runs on a different machine or when you want to consolidate multiple data sources into one remote instance.

Can I switch viewer backends without restarting my application?

Yes. Modify global_config.viewer programmatically before initializing your blueprint. However, once the visualization bridge is initialized (when autoconnect is called), the backend is fixed for that session. For CLI usage, you must specify the flag at launch time.

Where does Foxglove visualization data originate?

The Foxglove bridge in dimos/robot/foxglove_bridge.py subscribes to LCM channels and translates messages into Foxglove-compatible formats. It does not use Rerun logging functions; instead, it maintains separate transport connections for the Foxglove dashboard protocol.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}