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

> Explore DimOS viewer backends like rerun, foxglove, and none. Learn how to configure visualization rendering with GlobalConfig settings in this technical guide.

- Repository: [Dimensional/dimos](https://github.com/dimensionalOS/dimos)
- Tags: tutorial
- Published: 2026-03-15

---

**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`](https://github.com/dimensionalOS/dimos/blob/main/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`](https://github.com/dimensionalOS/dimos/blob/main/dimos/visualization/rerun/bridge.py). The `_BACKEND_TO_MODE` dictionary resolves user-facing strings to internal `ViewerMode` constants:

```python
_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`](https://github.com/dimensionalOS/dimos/blob/main/dimos/robot/unitree/go2/blueprints/basic/unitree_go2_basic.py), the selection logic branches as follows:

```python
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`](https://github.com/dimensionalOS/dimos/blob/main/dimos/core/global_config.py):

```python
global_config.viewer: ViewerBackend = "rerun"

```

## Practical Usage Examples

### Launch with Native Rerun (Default)

```bash
dimos run unitree-go2-agentic

```

### Serve Web Viewer for Containerized Environments

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

```

### Connect to External Rerun Server

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

```

### Use Foxglove Dashboard

```bash
dimos run unitree-go2-agentic --viewer foxglove

```

### Disable Visualization for Headless Operation

```bash
dimos run unitree-go2-agentic --viewer none

```

### Runtime Configuration in Python

```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`](https://github.com/dimensionalOS/dimos/blob/main/dimos/core/global_config.py): `rerun`, `rerun-web`, `rerun-connect`, `foxglove`, and `none`.
- The `RerunBridgeModule` in [`dimos/visualization/rerun/bridge.py`](https://github.com/dimensionalOS/dimos/blob/main/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`](https://github.com/dimensionalOS/dimos/blob/main/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.