Open any file
The Rerun Viewer has built-in support for opening many kinds of files, and can be extended to open any other file type without needing to modify the Rerun codebase itself.
The viewer can load files in 3 different ways:
- via CLI arguments (e.g.
- using drag-and-drop,
- using the open dialog in the Rerun Viewer.
All these file loading methods support loading a single file, many files at once (e.g.
rerun myfiles/*), or even folders.
⚠ Drag-and-drop of folders does not yet work on the web version of the Rerun Viewer ⚠
The following file types have built-in support in the Rerun Viewer:
- Native Rerun files:
- 3D models:
- Point clouds:
- Text files:
With the exception of
rrd files that can be streamed from an HTTP URL (e.g.
rerun https://demo.rerun.io/version/latest/examples/dna/data.rrd), we only support loading files from the local filesystem for now, with plans to make this generic over any URI and protocol in the future.
DataLoader trait takes care of loading files into the Viewer.
There are 3 broad kinds of
DataLoaders: builtin, external and custom.
External and custom are the two ways of extending the file loading system that we'll describe below.
When a user attempts to open a file in the Viewer, all known
DataLoaders are notified of the path to be opened, unconditionally.
DataLoaders maximum flexibility to decide what files they are interested in, as opposed to e.g. only being able to look at a file's extension.
Once notified, a
DataLoader can return a
DataLoaderError::Incompatible error to indicate that it doesn't support a given file type.
If, and only if, all loaders known to the Viewer return an
Incompatible error code, then an error message is shown to the user indicating that this file type is not (yet) supported.
In these instances of unsupported files, we expose two ways of implementing and registering your
DataLoaders, explained below.
The easiest way to create your own
DataLoader is by implementing what we call an "external loader": a stand alone executable written in any language that the Rerun SDK ships for. Any executable on your
$PATH with a name that starts with
rerun-loader- will be treated as a
This executable takes a file path as a command line argument and outputs Rerun logs on
It will be called by the Rerun Viewer when the user opens a file, and be passed the path to that file.
From there, it can log data as usual, using the
stdout logging sink.
The Rerun Viewer will then automatically load the data streamed to the external loader's standard output.
Like any other
DataLoader, an external loader will be notified of all file openings, unconditionally.
To indicate that it does not support a given file, the loader has to exit with a dedicated status code.
Another Rust-specific approach is to implement the
DataLoader trait yourself and register it in the Rerun Viewer.
To do so, you'll need to import
rerun as a library, register your
DataLoader and then start the viewer from code.
Check out our example that cover all these steps in details.