Crate rerun

source ·
Expand description

§Rerun - Visualize streams of multimodal data.

Add the rerun library to your crate with cargo add rerun.

There is also a rerun binary. The binary is required in order to stream log data over the networks, and to open our .rrd data files. If you need it, install the rerun binary with cargo install rerun-cli.

§Feature flags

  • analytics (enabled by default) — Enable telemetry using our analytics SDK.

  • clap — Integration with clap.

  • data_loaders (enabled by default) — Support for using Rerun’s data-loaders directly from the SDK.

    See our log_file example and https://www.rerun.io/docs/reference/data-loaders/overview for more information.

  • demo (enabled by default) — Demo helpers for examples.

  • glam (enabled by default) — Add support for some math operations using glam. Only relevant if feature sdk is enabled.

  • mint — Add support for math type conversions using mint. Only relevant if feature sdk is enabled.

  • image (enabled by default) — Integration with the image crate, plus JPEG support.

  • ecolor — Integration with the ecolor crate.

  • log (enabled by default) — Integration with the log crate.

  • native_viewer — Support spawning a native viewer. This adds a lot of extra dependencies, so only enable this feature if you need it!

  • run — Add support for the [run()] function, which acts like a main-function for a CLI, acting the same as the rerun binary.

  • server (enabled by default) — Support for running a TCP server that listens to incoming log messages from a Rerun SDK.

  • sdk (enabled by default) — Embed the Rerun SDK & built-in types and re-export all of their public symbols.

  • web_viewer — Support serving a web viewer over HTTP.

    Enabling this inflates the binary size quite a bit, since it embeds the viewer wasm.

    For faster & easier builds, a pre-built web-views comes bundled with the crate as a Wasm binary. Enabling this feature will embed this pre-built web viewer.

    However, when building from source in the repository, this feature adds quite a bit to the compile time since it requires compiling and bundling the viewer as wasm.

There are many different ways of sending data to the Rerun Viewer depending on what you’re trying to achieve and whether the viewer is running in the same process as your code, in another process, or even as a separate web application.

Checkout SDK Operating Modes for an overview of what’s possible and how.

If you get stuck on anything, open an issue at https://github.com/rerun-io/rerun/issues. You can also ask questions on the Rerun Discord.

§Using the rerun binary

The rerun binary is required in order to stream log data over the networks, and to open our .rrd data files.

The binary can act either as a server, a viewer, or both, depending on which options you use when you start it.

Install it with cargo install rerun-cli.

Running just rerun will start the viewer, waiting for the logging library to connect using RecordingStreamBuilder::connect (see below).

You can run rerun --help for more info.

§Using the rerun library

§Logging

You first create a RecordingStream using RecordingStreamBuilder. You then use it to log some archetypes to a given EntityPath using RecordingStream::log:

// Stream log data to an awaiting `rerun` process.
let rec = rerun::RecordingStreamBuilder::new("rerun_example_app").connect()?;

let points: Vec<rerun::Position3D> = positions();
let colors: Vec<rerun::Color> = colors();
let image: image::DynamicImage = capture_image();

rec.set_time_sequence("frame", 42);
rec.log("path/to/points", &rerun::Points3D::new(points).with_colors(colors))?;
rec.log("path/to/image", &rerun::Image::try_from(image)?)?;
§Streaming to disk

Streaming data to a file on disk using the .rrd format:

let rec = rerun::RecordingStreamBuilder::new("rerun_example_app").save("my_data.rrd")?;
§Buffering

You can buffer the log messages in memory and then show them in an embedded viewer:

let (rec, storage) = rerun::RecordingStreamBuilder::new("rerun_example_app").memory()?;
log_to(&rec);

// Will block program execution!
rerun::native_viewer::show(storage.take());
ⓘ
cargo install rerun
rerun --help

§Forwarding text log events to Rerun

See [Logger].

Modules§

Macros§

Structs§

  • AnnotationContext
    Archetype: The AnnotationContext provides additional information on how to display entities.
  • AnnotationInfo
    Datatype: Annotation info annotating a class id or key-point id.
  • ApplicationId
    The user-chosen name of the application doing the logging.
  • ArchetypeName
    The fully-qualified name of an Archetype, e.g. rerun.archetypes.Points3D.
  • Arrows2D
    Archetype: 2D arrows with optional colors, radii, labels, etc.
  • Arrows3D
    Archetype: 3D arrows with optional colors, radii, labels, etc.
  • Asset3D
    Archetype: A prepacked 3D asset (.gltf, .glb, .obj, .stl, etc.).
  • BarChart
    Archetype: A bar chart.
  • Boxes2D
    Archetype: 2D boxes with half-extents and optional center, rotations, rotations, colors etc.
  • Boxes3D
    Archetype: 3D boxes with half-extents and optional center, rotations, rotations, colors etc.
  • ClassDescription
    Datatype: The description of a semantic Class.
  • Clear
    Archetype: Empties all the components of an entity.
  • Color
    Component: An RGBA color with unmultiplied/separate alpha, in sRGB gamma space with linear alpha.
  • ComponentName
    The fully-qualified name of a Component, e.g. rerun.components.Position2D.
  • DataStore
    Everything needed to build custom StoreSubscribers. A complete data store: covers all timelines, all entities, everything.
  • DatatypeName
    The fully-qualified name of a Datatype, e.g. rerun.datatypes.Vec2D.
  • DepthImage
    Archetype: A depth image.
  • DisconnectedSpace
    Archetype: Spatially disconnect this entity from its parent.
  • EntityPath
    The unique identifier of an entity, e.g. camera/3/points
  • EntityPathPart
    The different parts that make up an EntityPath.
  • Float32
    Datatype: A single-precision 32-bit IEEE 754 floating point number.
  • GenericIndicatorComponent
    A generic indicator component that can be specialized for any Archetype.
  • HalfSizes2D
    Component: Half-sizes (extents) of a 2D box along its local axis, starting at its local origin/center.
  • HalfSizes3D
    Component: Half-sizes (extents) of a 3D box along its local axis, starting at its local origin/center.
  • Image
    Archetype: A monochrome or color image.
  • Instance
    A unique numeric index for each individual instance within a batch.
  • KeypointPair
    Datatype: A connection between two Keypoints.
  • LineStrip2D
    Component: A line strip in 2D space.
  • LineStrip3D
    Component: A line strip in 3D space.
  • LineStrips2D
    Archetype: 2D line strips with positions and optional colors, radii, labels, etc.
  • LineStrips3D
    Archetype: 3D line strips with positions and optional colors, radii, labels, etc.
  • Mat3x3
    Datatype: A 3x3 Matrix.
  • Material
    Component: Material properties of a mesh.
  • MediaType
    Component: A standardized media type (RFC2046, formerly known as MIME types), encoded as a utf8 string.
  • MemoryLimit
    Represents a limit in how much RAM to use for the entire process.
  • Mesh3D
    Archetype: A 3D triangle mesh as specified by its per-mesh and per-vertex properties.
  • NamedIndicatorComponent
    An arbitrary named indicator component.
  • OutOfTreeTransform3D
    Component: An out-of-tree affine transform between two 3D spaces, represented in a given direction.
  • Pinhole
    Archetype: Camera perspective projection (a.k.a. intrinsics).
  • Points2D
    Archetype: A 2D point cloud with positions and optional colors, radii, labels, etc.
  • Points3D
    Archetype: A 3D point cloud with positions and optional colors, radii, labels, etc.
  • Position2D
    Component: A position in 2D space.
  • Position3D
    Component: A position in 3D space.
  • Quaternion
    Datatype: A Quaternion represented by 4 real numbers.
  • Radius
    Component: A Radius component.
  • RecordingStream
    A RecordingStream handles everything related to logging data into Rerun.
  • RecordingStreamBuilder
    Construct a RecordingStream.
  • Rgba32
    Datatype: An RGBA color with unmultiplied/separate alpha, in sRGB gamma space with linear alpha.
  • RotationAxisAngle
    Datatype: 3D rotation represented by a rotation around a given axis.
  • Scalar
    Archetype: Log a double-precision scalar.
  • SegmentationImage
    Archetype: An image made up of integer class-ids.
  • SeriesLine
    Archetype: Define the style properties for a line series in a chart.
  • SeriesPoint
    Archetype: Define the style properties for a point series in a chart.
  • SpawnOptions
    Options to control the behavior of spawn.
  • StoreDiff
    Everything needed to build custom StoreSubscribers. Describes an atomic change in the Rerun DataStore: a row has been added or deleted.
  • StoreEvent
    Everything needed to build custom StoreSubscribers. The atomic unit of change in the Rerun DataStore.
  • StoreGeneration
    Everything needed to build custom StoreSubscribers. Incremented on each edit.
  • StoreId
    A unique id per store.
  • Tensor
    Archetype: A generic n-dimensional Tensor.
  • TensorData
    Datatype: A multi-dimensional Tensor of data.
  • TensorDimension
    Datatype: A single dimension within a multi-dimensional tensor.
  • Text
    Component: A string of text, e.g. for labels and text documents.
  • TextDocument
    Archetype: A text element intended to be displayed in its own text-box.
  • TextLog
    Archetype: A log entry in a text log, comprised of a text body and its log level.
  • TextLogLevel
    Component: The severity level of a text log message.
  • Time
    A date-time represented as nanoseconds since unix epoch
  • TimePoint
    A point in time on any number of Timelines.
  • Timeline
    A time frame/space, e.g. log_time or frame_nr, coupled with the type of time it keeps.
  • Transform3D
    Archetype: A 3D transform.
  • TranslationAndMat3x3
    Datatype: Representation of an affine transform via a 3x3 affine matrix paired with a translation.
  • TranslationRotationScale3D
    Datatype: Representation of an affine transform via separate translation, rotation & scale.
  • TriangleIndices
    Component: The three indices of a triangle mesh.
  • Vec2D
    Datatype: A vector in 2D space.
  • Vec3D
    Datatype: A vector in 3D space.
  • Vec4D
    Datatype: A vector in 4D space.
  • Vector2D
    Component: A vector in 2D space.
  • Vector3D
    Component: A vector in 3D space.
  • ViewCoordinates
    Archetype: How we interpret the coordinate system of an entity/space.

Enums§

Constants§

Traits§

Functions§

Type Aliases§