rerun-io/rerun

This system is a multi-language data logging and visualization platform designed for recording, storing, and inspecting complex datasets such as 3D scenes, time-series metrics, and media. It provides a comprehensive SDK for capturing structured data via a high-performance Arrow-based storage format, supporting a wide variety of input sources including local files, cloud streams, and robotics protocols like ROS 2 and MCAP. The platform features a powerful viewer with declarative blueprint configuration, enabling users to programmatically define and persist custom UI layouts for analyzing logged information across spatial, temporal, and tabular dimensions.

78 changes.

This period focused on a comprehensive architectural rewrite of the Rerun SDK, replacing legacy components with a new gRPC-based communication layer, a modular chunk store, and a modernized code generation pipeline. The work established robust build tooling, CI/CD automation, and extensive benchmarking infrastructure while expanding language support through new C, C++, and JavaScript SDKs. Additionally, the era introduced advanced data handling features like sequence indices, blueprint support, and unified video decoding to enhance performance and developer experience.

130 changes.

This period focused on establishing a robust, code-generated type system for the SDK and implementing a comprehensive blueprint architecture for the viewer. It introduced the \re\_sdk\_types\ crate for auto-generated data definitions and the \re\_lenses\ API for declarative data transformation, while restructuring the viewer to support modular views, agent integration, and unified state management.

The Rust DNA example now includes a visualization of a DNA double helix structure. It logs static 3D points and line strips to represent the DNA backbone and scaffolding, and animates beads along the strands using a stable timeline. The example also demonstrates rotating the entire structure using the Transform3D archetype.

examples/rust/dna · high confidence

The \examples/rust/viewer\_callbacks\ directory now contains a Rust example demonstrating how to wrap the Rerun Viewer in a custom GUI. This example shows how to register event listeners for viewer state changes (such as timeline updates and selection changes) and integrate the viewer into a custom \eframe\ application with a side panel.

_examples/rust/viewer\callbacks · high confidence

A new Rust example template has been added to the examples directory, providing a starting point for users to build applications using the Rerun SDK. The template demonstrates basic initialization by creating a \RecordingStream\ with a specific app ID prefix.

_examples/rust/graph\lattice, examples/rust/template · high confidence

A new Rust example has been added to demonstrate how to read data from standard input and log it as a text document using the Rerun SDK. Users can now pipe input into the application (e.g., via \echo 'hello from stdin!' \| cargo run\) and visualize the captured text in the Rerun Viewer.

examples/rust/stdio · high confidence

A new minimal Rust example has been added to the examples directory, showcasing the most basic usage of the Rerun SDK. The example initializes a recording stream with the app ID 'rerun\_example\_minimal' and logs a 10x10 grid of 3D points with associated RGB colors and a fixed radius of 0.5, providing a quick starting point for users to understand the core logging API.

examples/rust/minimal · high confidence

A new Rust example, \minimal\_options\, has been added to demonstrate how to accept command-line arguments and connect to running Rerun servers. It utilizes the \RerunArgs\ struct for standard Rerun connection options and introduces custom arguments for point grid configuration, such as \num\_points\_per\_axis\ and \radius\, while logging a 3D point cloud with specific colors and radii.

_examples/rust/minimal\options · high confidence

Users can now deserialize ROS2 messages from MCAP files using reflection. This change introduces a new \deserialize\ module in \crates/utils/re\_ros\_msg\ that decodes CDR-encoded data into a generic \Value\ type by walking a \MessageSpecification\. It supports built-in types, arrays, sequences, nested messages, and resolves complex types via a \TypeResolver\, enabling the system to handle message schemas dynamically without hard-coded structs.

_crates/utils/re\_ros\msg/src/deserialize · high confidence

The \re\_ros\_msg\ crate now includes a minimal ROS 2 \.msg\ reflection parser that parses message definitions into a typed representation, supporting fields, constants, and dependent message types. It also introduces a \dds\ module that defines DDS-RTPS representation identifiers (such as CDR v1/v2, Parameter Lists, and XML) and their endianness handling, enabling the system to correctly interpret ROS 2 message wire formats.

_crates/utils/re\_ros\msg/src · high confidence

A new \SizeBytes\ derive macro is now available in \crates/utils/re\_byte\_size\_derive\, allowing structs and enums to automatically implement the \SizeBytes\ trait. This enables automatic calculation of heap memory usage via the \heap\_size\_bytes\ method and a compile-time \IS\_POD\ flag. Users can customize behavior using attributes like \\#\[size\_bytes(ignore)\]\ to exclude specific fields from size calculations or \\#\[size\_bytes(profile)\]\ to enable profiling instrumentation.

_crates/utils/re\_byte\_size\derive · high confidence

A new binary, build\_re\_remote\_store\_types.rs, has been added to the re\_protos\_builder crate to manually trigger the code generation of Rust types for the remote store gRPC service. This tool reads .proto definitions from the v1alpha1 directory and outputs the generated Rust code, facilitating the development and maintenance of the remote store protocol's type definitions.

_crates/build/re\_protos\builder/src/bin · high confidence

A new \run\_wasm\ tool has been added to simplify running web-based examples. It acts as an xtask that leverages \cargo-run-wasm\ to handle wasm-bindgen machinery and HTML generation. The tool provides a simple CLI interface, allowing users to run examples (such as the \re\_renderer\ 2D demo) via \cargo run-wasm --example 2d\, with support for custom host/port arguments and automatic browser launching.

_run\wasm · high confidence

The \re\_sdk\_types\ crate now includes an auto-generated \reflection\ module that provides runtime metadata about all known Rerun components, archetypes, and views. This generated code enables the viewer to introspect type definitions, handle serialization, and manage UI configurations dynamically without hardcoding type information.

_crates/store/re\_sdk\types/src/reflection · high confidence

The blueprint type definitions for all built-in views (Audio, BarChart, Dataframe, Graph, Map, Spatial2D/3D, StateTimeline, Tensor, TextDocument, TextLog, and TimeSeries) have been replaced with new \.def.rs\ files. These definitions explicitly declare the configuration properties available for each view in the blueprint, such as \AudioView.playback\, \GraphView.force\_link\, \Spatial2DView.time\_ranges\, and \TimeSeriesView.interaction\, enabling the SDK to generate the corresponding Rust, Python, and C++ bindings.

_crates/build/re\_type\definitions/rerun/blueprint/views · high confidence

The \re\_sdk\_types\ crate now exposes the Rust type definitions for all blueprint views (Audio, BarChart, Dataframe, Graph, Map, Spatial2D/3D, StateTimeline, Tensor, TextDocument, TextLog, and TimeSeries). These generated structs define the configurable properties for each view—such as playback settings, visual bounds, time ranges, and plot legends—allowing users to programmatically configure and persist view layouts via the blueprint system.

_crates/store/re\_sdk\types/src/blueprint/views · high confidence

The \re\_ros\_msg\ crate now includes a reflection-based decoder that converts ROS 2 CDR-encoded messages directly into Arrow arrays. This new capability in \crates/utils/re\_ros\_msg/src/reflection\ introduces a \MessageDecodePlan\ that resolves schema types at runtime and a \CdrArrowDecoder\ that maps CDR streams straight to Arrow builders, bypassing intermediate value trees. The module also handles conventional ROS timestamp extraction (from \header.stamp\ or top-level \stamp\) by resolving field locations during plan creation, allowing timestamps to be read directly from the decoded Arrow columns.

_crates/utils/re\_ros\msg/src/reflection · high confidence

The \re\_sdk\_types/src/components\ directory now contains the auto-generated Rust source files for the SDK's component and encoding types. This includes definitions for core data structures such as \Color\, \Blob\, \ClassId\, and \AnnotationContext\, as well as specialized components like \AggregationPolicy\ for plot rendering and \Colormap\ (featuring new \RvizMap\ and \RvizCostmap\ options) for grid maps. These generated files provide the serialization, deserialization, and reflection logic required for the Rerun SDK to store and transmit data.

_crates/store/re\_sdk\types/src/components · high confidence

The \re\_log\_types\ crate now includes \EntryName\ and \EntryId\ types to manage catalog entries (datasets and tables). \EntryName\ is a validated, non-empty ASCII string (max 180 characters) used for user-facing labels and lookups, while \EntryId\ is an immutable, randomly generated identifier (backed by \re\_tuid::Tuid\) used for storage and indexing. This separation ensures that mutable names do not affect stable references. The module also introduces \EntryIdOrName\ for APIs that accept either form, and \ApplicationId\ is now backed by \EntryName\ with migration logic for legacy IDs.

_crates/store/re\_log\types/src · high confidence

Users can now use Lenses to extract, transform, and restructure component data before it is logged. This location provides the \LensesSink\, a log sink wrapper that applies defined \Lenses\ to incoming \ArrowMsg\ chunks, forwarding the transformed results to the underlying sink. The implementation supports a \strict\ mode to prevent partial chunks from being emitted when lens errors occur, and re-exports core lens types and operations from the \re\_lenses\ crate.

_crates/top/re\sdk/src/lenses · high confidence

The re\_capabilities crate now provides a MainThreadToken type that enforces, at compile time, that specific operations (such as file dialogs) are only executed on the main thread. This token is non-Send and non-Sync, preventing it from being transferred to background threads, and can be constructed explicitly in the main function or implicitly from an egui UI context to guarantee thread safety for UI-bound operations.

_crates/utils/re\capabilities · high confidence

The Rust SDK now exposes a new \blueprint\ module that allows users to programmatically define and send viewer layouts, including root containers (horizontal, vertical, grid, tabs), specific view types (such as TimeSeries, Spatial2D/3D, Graph, and Map views), and panel configurations (blueprint, selection, and time panels). This API enables declarative control over the viewer's initial state, including automatic layout settings, panel visibility, and playback properties, by serializing these configurations into blueprint log messages sent to the recording stream.

_crates/top/re\sdk/src/blueprint · high confidence

Added two new build-time crates: \re\_types\_builder\_macros\ provides the \\#\[rerun\_type\]\ attribute macro, which strips Rerun-specific IDL annotations (such as \\#\[rerun(...)\]\, \\#\[arrow(...)\]\, and \\#\[rust(...)\]\) from Rust structs and enums so they compile cleanly, and \re\_types\_builder\_prelude\ re-exports this macro along with special types like \f16\ and \Binary\ to support the new IDL syntax. This enables type definitions to be written in a Rust subset that is both parsed by the IDL builder and validated by the Rust compiler for name resolution and typos.

_crates/build/re\_types\_builder\_macros, crates/build/re\_types\_builder\prelude · high confidence

The store now uses a new Sorbet schema and batch representation (ChunkBatch, ChunkSchema, ChunkColumnDescriptors) to manage logging data as Arrow RecordBatches. This change introduces a structured column model (RowId, Index/timeline, and Component columns) with strict ordering and metadata handling, enabling the SDK to interpret arbitrary Arrow record batches as Rerun chunks via the new dataframe-to-chunks API. It also adds latency tracking metadata to monitor pipeline performance from SDK to viewer and standardizes Arrow IPC serialization for schema exchange.

_crates/store/re\sorbet/src · high confidence

A new \Span\ type has been added to the \re\_span\ utility crate to represent integer ranges that are guaranteed to have a non-negative length. Unlike standard Rust ranges, which can be invalid if the start is greater than the end, \Span\ enforces this invariant at the type level, simplifying logic for callers by eliminating the need to check for negative lengths or handle invalid range states. The type provides constructors for creating spans from start/end points or start/length pairs, along with utility methods for checking containment, intersection, union, and clamping.

_crates/utils/re\span/src · high confidence

The \rerun-notebook\ package is introduced as a support package for the Rerun SDK's Jupyter integration, bundling the web-viewer widget and its assets. It provides a \Viewer\ widget that supports configuration of width, height, theme, and panel states, and exposes APIs to control time playback, send RRD data and tables, and manage recording IDs. To address memory leaks and improve startup performance, the package allows users to configure how widget assets are loaded via the \RERUN\_NOTEBOOK\_ASSET\ environment variable, supporting remote URLs, inlined assets, or a local asset server.

_rerun\notebook · high confidence

A new synchronous channel implementation (\re\_quota\_channel\) has been added to the codebase, wrapping \crossbeam::channel\ with byte-based capacity limits. This change introduces backpressure: on native platforms, senders block when the byte budget is exceeded, preventing unbounded memory growth and deadlocks in components like the video decoder and gRPC proxy. On WebAssembly (wasm32), where blocking is not allowed, the channel logs warnings instead of blocking. The module also includes a \select\ macro and utilities for handling multiple receivers while maintaining correct byte accounting.

_crates/utils/re\_quota\channel/src/sync · high confidence

The \re\_lenses\_core\ crate now provides the foundational types and builders for Lenses, enabling users to define transformations that modify existing component columns in-place (mutate) or derive new columns from existing data (derive). This new API supports outputting derived data to either the same entity or a different target entity, and allows for 1-to-1 or 1-to-many (scatter) row mappings. Users can now construct these transformations using the \DeriveLensBuilder\ and \MutateLensBuilder\, with built-in support for casting output types and handling timeline extraction, while the system automatically manages chunk execution plans and error reporting.

_crates/store/re\_lenses\core/src · high confidence

A new \re\_grpc\_client\ crate has been added to handle client-side communication with the legacy StoreHub API. This crate provides a \stream\ function for reading log messages in the viewer and a \Client\ for sending log messages from the SDK, supporting both native (via \tonic\) and WebAssembly (via \tonic\_web\_wasm\_client\) targets. It includes specific error handling via \TonicStatusError\ and \StreamError\, manages connection states, and implements latency tracking for IPC decoding to support end-to-end latency measurements.

_crates/data\_flow/re\_grpc\client · high confidence

Adds a new \re\_grpc\_server\ crate that implements a gRPC proxy server for the legacy StoreHub API. The server listens on port 9876 by default and supports configurable playback behavior (OldestFirst or NewestFirst) and memory limits. It exposes a \ViewerControl\ service that allows clients to send commands to a running viewer and inspect UI state via an \egui\_inspect\ endpoint, with a 10-second request timeout. The implementation includes CORS handling for localhost and rerun.io origins, priority-based message merging, and graceful shutdown support.

_crates/data\_flow/re\_grpc\server · high confidence

The new \re\_agent\ crate provides the core logic for connecting to and managing coding agents (such as Claude Code, Codex, and Gemini CLI) via the Agent Client Protocol. It handles spawning agent subprocesses, managing session lifecycles, and processing events like permission requests and tool calls. This library serves as the backend foundation for the \re\_agent\_ui\ component, which provides the corresponding egui-based chat panel in the viewer.

_crates/utils/re\agent · high confidence

The new \re\_byte\_size\ crate provides a \SizeBytes\ trait and derive macro to calculate the heap-allocated size of values at runtime, enabling accurate memory profiling and garbage collection triggers. It includes implementations for standard collections (HashMap, BTreeMap, Vec), Arrow data structures, and egui types, along with a \BookkeepingBTreeMap\ for O(1) size queries and a \MemUsageTree\ for detailed memory breakdowns.

_crates/utils/re\_byte\size/src · high confidence

The new \re\_case\ utility crate provides case conversion functions (\to\_snake\_case\, \to\_pascal\_case\, \to\_human\_case\) tailored to Rerun's naming conventions. It handles specific type prefixes like \UVec\, \IVec\, \DVec\, and \UInt\, as well as dimension suffixes like \2D\ and \3D\, ensuring consistent formatting for component, archetype, and encoding names across the platform.

_crates/utils/re\case · high confidence

Added the new \re\_web\ crate to provide shared utilities for WebAssembly and browser environments. This includes browser detection helpers (Safari, Firefox) and URL manipulation in \browser.rs\, a standardized error type for converting JavaScript values to Rust errors in \error.rs\, and a filesystem abstraction in \fs.rs\ that mirrors \tokio::fs\ using the Origin Private File System (OPFS) with support for positional reads via \AsyncReadAt\.

_crates/utils/re\web · high confidence

The \re\_lenses\_core\ crate now provides a set of composable transformation combinators for Arrow arrays, enabling users to build data processing pipelines. This includes type casting (\PrimitiveCast\, \ListToFixedSizeList\), element extraction (\GetIndexList\), structural reshaping (\GetField\, \Flatten\, \Explode\), and element-wise mapping (\MapList\, \MapPrimitive\, \ReplaceNull\). These transformations are unified under a \Transform\ trait that supports chaining via a \then\ method, allowing complex data manipulations to be composed into single, efficient operations.

_crates/store/re\_lenses\core/src/combinators · high confidence

Users can now explicitly configure whether a clear operation affects only the target entity or also its recursive children via the new \ClearIsRecursive\ component. This generated component wraps a boolean encoding (renamed from \datatypes\ to \encodings\ in the diff) and defaults to \false\ (non-recursive) to minimize intrusion, while still allowing recursive clearing when needed.

_crates/store/re\_types\core/src/components · high confidence

A new pre-push git hook has been added to the repository, acting as a shim that delegates execution to the main script located at scripts/pre-push.sh. The change includes a README file providing installation instructions, allowing users to either copy the hook into their .git/hooks directory or configure Git to use the hooks folder directly via core.hooksPath.

hooks · high confidence

A new \rerun\_c\ crate has been added to provide C bindings for the Rerun library. The build system is configured via CMake to compile the Rust sources into a static library (\librerun\_c.a\ or \rerun\_c.lib\), respecting the \CMAKE\_BUILD\_TYPE\ for Debug or Release configurations and locating the output in the Cargo target directory. This allows C/C++ projects to link against the Rerun functionality through standard C interfaces.

_crates/top/rerun\c · high confidence

The \re\_auth\ service module now provides client-side and server-side authentication layers for gRPC communication. On the client side, the new \AuthDecorator\ acts as a Tower layer that automatically attaches a Bearer token to outgoing requests using a \CredentialsProvider\. On the server side, the \Authenticator\ interceptor validates incoming JWTs, verifies their signatures, and injects a \UserContext\ containing the user ID and permissions into the request extensions, enabling downstream services to enforce access control.

_crates/utils/re\auth/src/service · high confidence

The MCAP importer now includes a new lens system that transforms third-party data formats into Rerun components. Specifically, it adds support for Foxglove lenses (handling topics like camera calibration, compressed images/video, frame transforms, point clouds, and voxel grids) and ROS 2 message lenses (handling topics like camera info, images, logs, and sensor data). The importer also gains the ability to extract URDF robot descriptions from MCAP files and emit 3D visualization chunks, with recovery support for truncated files.

_crates/data\_flow/re\_importer/src/importer\mcap · high confidence

A new \re\_agent\_ui\ crate introduces a chat panel that lets users interact with coding agents (such as Claude Code, Codex, and Gemini CLI) directly within the viewer. The panel features a setup screen for configuring the agent, working directory, and MCP servers, followed by a chat interface that displays the agent's transcript, tool calls, and thinking process. It supports session modes to control agent permissions, handles authentication prompts, and allows the agent to drive the viewer via the Rerun MCP server.

crates/panels · high confidence

The \re\_sdk\_types\ crate now exposes an \AnyValues\ helper that lets users log arbitrary data by adding existing Rerun components or raw Arrow arrays to a dynamic archetype, including the ability to override component types. Additionally, new \ColormapCategory\ and \ColormapSelection\ types have been added to classify colormaps, introducing a \GridMap\ category that includes RViz-style \RvizMap\, \RvizCostmap\, and \Costmap\ options alongside the standard sequential, diverging, and cyclic categories.

_crates/store/re\_sdk\types/src · high confidence

The examples directory now includes a new C SDK example (\examples/c/minimal\) demonstrating how to create a recording stream and spawn a viewer using the C API, alongside a \spawn\_viewer\ example. Additionally, several new C++ examples have been added, including \clock\ (animated 3D primitives), \custom\_collection\_adapter\ (zero-copy logging of custom C++ containers), and \dna\ (3D helix visualization). These additions expand the available reference implementations for users integrating Rerun with C and C++ applications.

examples · high confidence

The C SDK implementation in \rerun\_c\ has been rewritten, introducing a new component type registry and robust error handling with UTF-8 safe message truncation. It now supports importing Arrow arrays via FFI and provides a new C API function to read video frame timestamps, enabling C++ and other languages to access video timing data directly.

_crates/top/rerun\c/src · high confidence

The C++ SDK now includes a complete CMake build system (CMakeLists.txt) and installation configuration (Config.cmake.in) that automatically downloads and builds the Apache Arrow C++ library by default, while also supporting system-installed Arrow. The SDK links against pre-built rerun\_c static libraries for Linux, macOS, and Windows, and provides comprehensive documentation (README.md, arrow\_cpp\_install.md, cmake\_setup\_in\_detail.md) for integration via FetchContent, conda-forge, or vcpkg. A new .clang-tidy configuration enforces security-focused linting on the SDK source code.

_rerun\cpp · high confidence

This change introduces a suite of new scripts to the \scripts/\ directory to support the build, release, and quality assurance pipelines. Key additions include \append\_web\_viewer.py\ to embed web viewer assets into CLI binaries, \check\_crate\_layers.py\ and \check\_forbidden\_dependencies.py\ to enforce architectural constraints and prevent unwanted dependencies, and \check\_env.py\ to validate developer tool versions. CI-specific scripts such as \build\_and\_upload\_wheels.py\, \build\_and\_upload\_rerun\_notebook.py\, and \bundle\_and\_upload\_rerun\_cpp.py\ automate the creation and distribution of Python wheels, notebook assets, and C++ SDK bundles to Google Cloud Storage. Additional utilities like \accept\_snapshots.sh\ for managing UI test snapshots, \approve\_workflow\_runs.py\ for automating GitHub Actions approvals, and \check\_example\_manifest\_coverage.py\ for ensuring example consistency are also included.

scripts · high confidence

The Rerun CLI now includes dedicated subcommands for managing access and inspecting data. Users can authenticate with Rerun Hub using \rerun auth login\, \rerun auth logout\, and \rerun auth token\, or generate revocable API-style tokens via \rerun auth generate-token\. A new \rerun download\ command allows saving recordings from gRPC or HTTP sources as local \.rrd\ files, complete with progress reporting and automatic credential refresh. Additionally, \rerun dump-puffin\ enables exporting \.puffin\ profiler recordings to JSON for external analysis.

crates/top/rerun/src/commands · high confidence

The \rerun rrd\ subcommand suite now includes \compare\, \filter\, \merge\, \migrate\, \optimize\, \print\, \route\, \split\, \stats\, and \verify\. Users can compare recordings semantically (ignoring order or specific timelines), filter out entities or timelines, merge multiple files, migrate legacy data to the current protocol, optimize chunk compaction, print detailed file contents, manipulate metadata at the transport level, split recordings by time, and verify file integrity.

crates/top/rerun/src/commands/rrd · high confidence

Added a new command-line example (\optimize\_rrd\) that allows users to optimize Record Replay Data (RRD) files by merging and splitting chunks according to configurable profiles (defaulting to \OBJECT\_STORE\). The tool supports specifying input/output paths, customizing maximum chunk sizes and target timelines, and running in dry-run mode. It also includes built-in profiling capabilities using \puffin\ scopes and memory reporting, enabling users to benchmark and analyze the performance of the optimization process.

_crates/store/re\_chunk\optimizer/examples · high confidence

Two new view types are now available: the Dataframe view displays entity data in a tabular format with configurable column visibility, time-range filtering, and row expansion, while the Bar Chart view renders single bar charts with support for background and legend customization. Both views are implemented as independent crates with their own visualizer systems and selection panel UIs.

_crates/views/re\_view\dataframe · high confidence

The \gpu\_bridge\ module has been introduced to handle the translation of image data to GPU textures and the rendering of colormap selection interfaces. This includes logic for uploading color, depth, and segmentation images to \re\_renderer\, applying colormaps to scalar data, and providing a UI for selecting and previewing colormap categories. The module also manages the integration between egui and the GPU renderer via custom paint callbacks, ensuring correct viewport handling and texture filtering.

_crates/viewer\_support/re\_viewer\_context/src/gpu\bridge · high confidence

A new Graph View has been added to the product, allowing users to visualize node-link diagrams. This view features a force-directed layout engine (powered by the \fjadra\ library) that automatically positions nodes and edges, with configurable parameters for link distance, collision, and centering forces exposed in the view's selection panel. It supports both explicit nodes (defined via \GraphNodes\) and implicit nodes (inferred from \GraphEdges\), handles self-edges and multiple edges between nodes, and provides interactive features like panning, zooming, and selection highlighting.

_crates/views/re\_view\_graph, crates/views/re\_view\_text\document · high confidence

The custom visualizer example now includes a HeightField archetype and visualizer, allowing users to render 2D height maps as 3D terrain meshes. This new capability adds a HeightField renderer, visualizer, and archetype definition, and registers the visualizer in the Spatial3D view with a default colormap fallback. The example also ships with a built-in recording that demonstrates the feature by logging an animated 512x512 height field.

_examples/rust/custom\visualizer · high confidence

The \rerun\_js\ directory now includes a set of Node.js scripts (\common.mjs\, \publish.mjs\, \version.mjs\, \docs.mjs\, \serve-docs.mjs\) to manage the npm workspace, including publishing packages, updating versions across workspaces, and serving documentation. Additionally, a new \web-viewer-react\ package has been added, providing a React component wrapper for the framework-agnostic \web-viewer\ package, allowing developers to embed the Rerun viewer in React applications with props for recording URLs, dimensions, and event callbacks.

_rerun\js · high confidence

The \re\_lerobot\ crate now provides the core logic for loading LeRobot datasets (v2 and v3) into Rerun chunks. It supports lazy, per-episode streaming of tabular data, language annotations, and video features, with configurable entity path prefixes and video emission modes (Native or Skip). The loader automatically detects the dataset version, handles timeline selection (frame\_index vs. timestamp), and converts raw Parquet and MP4 data into Rerun archetypes like Scalars, EncodedImage, TextDocument, and AssetVideo. It also includes diagnostics for skipped episodes or features and supports task/subtask text resolution.

_crates/data\_flow/re\lerobot · high confidence

A new Map view has been added to display GPS coordinates, geographic points, and line strings on an interactive map. This view automatically centers on the Rerun HQ location when no data is present and supports configurable map providers and zoom levels. It includes visualizers for GeoPoints and GeoLineStrings, allowing users to see their geospatial data overlaid on a map background with support for custom colors and radii.

_crates/views/re\_view\map · high confidence

Added the \re\_rvl\ crate, providing codecs and helpers for RVL (Run length encoding and Variable Length encoding) depth compression formats. This includes utilities to parse \compressedDepth\ metadata from ROS2 payloads and decode RVL streams into either disparity (\u16\) or metric depth (\f32\) buffers, with built-in protection against excessively large resolutions.

_crates/utils/re\rvl · high confidence

The \re\_uri\ crate now provides a comprehensive parser and type system for Rerun's custom URI schemes (\rerun://\, \rerun+http://\, \rerun+https://\). This change introduces structured types for key catalog endpoints, including \CatalogUri\, \DatasetUri\, \EntryUri\, \FolderUri\, and \ProxyUri\, enabling the application to correctly parse and construct links to datasets, entries, and folders on the Rerun Hub. It also adds support for dataset hierarchy paths using dot-separated names (e.g., \project.subdir.leaf\) and allows specifying time ranges and segment IDs within dataset URIs to control which data is loaded and displayed.

_crates/store/re\uri · high confidence

The \skills\ directory now includes a comprehensive set of agent instructions (SKILL.md files) and helper scripts to guide coding agents in using Rerun. Key additions include \rerun-data-model\ for foundational data modeling, \rerun-chunk-processing\ for the mandated reader+lens ingestion pipeline, and source-specific skills for MCAP, Parquet, MP4, URDF, and LeRobot datasets. A new \investigate-puffin\ skill provides Python tools (\compare\_traces.py\, \find\_scopes.py\) and jq recipes for analyzing Puffin profiler traces. Additionally, \rerun-blueprint\ and \rerun-catalog-queries\ offer guidance on designing viewer layouts and optimizing catalog query performance, while \assemble-changelog\ automates release changelog generation.

skills · high confidence

Added a new Rust example (\examples/rust/blueprint\) that demonstrates how to programmatically define a Rerun blueprint. The example shows how to configure a grid layout with 2D spatial views, apply property overrides to specific entities (such as changing box radii), and set initial states for UI panels like the Blueprint, Selection, and Time panels (including timeline selection and loop mode). It also includes logic to log sample image and rectangle data to visualize these blueprint settings.

examples/rust/blueprint · high confidence

A new Rust example (\examples/rust/clock\) has been added that builds an analog clock using Rerun's \Vector3D\ primitives and \Boxes3D\. The application logs static world coordinates and 3D points/arrows representing clock hands, updating their positions over a configurable number of steps. It demonstrates the use of \rec.set\_duration\_secs\ to associate visual updates with simulation time, serving as a benchmark for handling many small events.

examples/rust/clock · high confidence

Added a new Rust example (\examples/rust/log\_file\) that demonstrates how to log files using the \Importer\ machinery. The example supports two modes: logging a file directly from its path or logging it from its in-memory contents, allowing users to see how to ingest external data into Rerun recordings.

_examples/rust/log\file · high confidence

The \examples/rust/raw\_mesh\ example now demonstrates how to log 3D scenes using either the \Mesh3D\ archetype (parsing glTF geometry, normals, colors, and textures into raw components) or the \Asset3D\ archetype (logging the original file directly). Users can toggle between these modes via the \--asset3d\ CLI flag, and the example supports multiple built-in scenes (Buggy, BrainStem, Lantern, Avocado) as well as custom glTF file paths.

_examples/rust/raw\mesh · high confidence

Added a new Rust example (\examples/rust/objectron\) that demonstrates logging the Objectron dataset using the Rerun SDK. The example parses protobuf-generated data structures to log video frames as \EncodedImage\, camera poses and intrinsics via \Transform3D\ and \Pinhole\, 3D feature points as \Points3D\, and bounding boxes as \Boxes3D\ with static transforms and labels.

examples/rust/objectron · high confidence

Added a new Rust example (\examples/rust/dataframe\_query\) that demonstrates how to use the Rerun DataFrame API to query \.rrd\ recording files. The example loads a recording, constructs a \QueryExpression\ with a configurable entity path filter and \LatestAtGlobal\ sparse fill strategy, retrieves the first 10 rows of data as Arrow record batches, and prints them as a formatted table to the terminal.

_examples/rust/dataframe\query · high confidence

The \examples/rust/lenses\ directory now contains a complete Rust application showcasing the Lenses API. This example illustrates how to define and apply semantic mappings—such as extracting text instructions, deconstructing nested scalar payloads into separate entities, and deriving timeline data from timestamps—using the new \Selector\-based API and \CastTo\ capabilities.

examples/rust/lenses · high confidence

A new State Timeline view has been added, displaying state transitions as horizontal colored lanes over time. The view supports multiple instances per entity, polymorphic state values (strings, booleans, and numeric scalars), and a customizable selection panel where users can edit value-to-label/color/visibility mappings via the blueprint. It integrates with the existing time-axis and pan/zoom controls, and includes a visualizer that converts logged StateChange rows into the lane data rendered by the UI.

_crates/views/re\_view\_state\timeline/src · high confidence

A new Tensor view has been added to visualize tensors of arbitrary dimensionality. It renders N-dimensional data as a 2D slice, allowing users to interactively select which dimensions map to width and height, and to scrub through other dimensions using sliders. The view supports drag-and-drop dimension mapping, applies custom colormaps and gamma correction, and handles various numeric types (including 64-bit integers and floats) by safely casting to GPU-compatible formats.

_crates/views/re\_view\tensor · high confidence

A new Text Log view has been added to the application, displaying \TextLog\ entries in a scrollable table that tracks the active time. Users can customize the view via a selection panel to filter by log level and toggle column visibility (such as Entity Path, Log Level, and Body). The view includes a memoized caching system for performance and is supported by snapshot tests verifying temporal anchoring and level filtering behavior.

_crates/views/re\_view\_text\log · high confidence

A new URDF importer has been added to the data flow crate, enabling the loading of robot models from URDF files. The implementation includes a dedicated module for computing 3D joint transforms (supporting revolute, continuous, and prismatic joints) and handles URDF 1.1 features such as quaternion-based orientations. This change introduces the \UrdfImporter\ and associated utilities (\UrdfTree\, \joint\_transform\) that parse URDF XML, resolve relative mesh paths, and emit Rerun chunks for visual/collision geometries and static transforms.

_crates/data\_flow/re\_importer/src/importer\urdf · high confidence

A new \re\_arrow\_util\ crate has been introduced to centralize utilities for working with Apache Arrow data structures. It provides type-safe array downcasting with improved error messages, helpers for manipulating RecordBatches (such as polymorphic concatenation, column projection, and horizontal concatenation), and a comprehensive formatting system for displaying RecordBatches as tables with support for transposed views, cell width limits, and metadata redaction. The crate also includes deep slicing capabilities for Arrow arrays, approximate floating-point comparison for testing, and memory optimization for StringViewArrays.

_crates/utils/re\_arrow\util/src · high confidence

The \re\_chunk\_index\ crate has been extracted from \re\_log\_encoding\ to provide a dedicated, storage-agnostic layer for indexing Rerun chunks. This new module introduces \RawRrdManifest\ and \RrdManifest\ to catalog chunk metadata (such as entity paths, timelines, byte offsets, and size) without holding the actual data, enabling efficient relevancy queries like latest-at and range scans. It also defines the \ChunkProvider\ trait and an \InMemoryChunkProvider\ implementation, which pair the index with a mechanism to load the corresponding chunk bytes, allowing the rest of the system to query and retrieve data based on the index.

_crates/store/re\_chunk\index · high confidence

A new utility crate, \re\_dump\_puffin\, has been added to the workspace. It converts \.puffin\ profiler recordings into a structured JSON format, enabling users to analyze the scope tree using command-line tools like \jq\. The crate exposes a \dump\_to\_json\_writer\ function that reads a \.puffin\ file and outputs a JSON document containing file metadata, scope details (name, function, file, line, kind), and a nested tree of frames and threads with their respective scope nodes.

_crates/utils/re\_dump\puffin · high confidence

A new \re\_lenses\ crate has been added to the \data\_flow\ workspace, providing a lens-based API for extracting, transforming, and restructuring component data. This crate introduces built-in operations for semantic transformations (such as converting timestamps to nanoseconds, mapping video codec strings to enums, and handling RGBA structures) and includes a comprehensive set of lenses for converting Foxglove Protobuf messages (including camera calibration, compressed images/videos, frame transforms, point clouds, and location fixes) into Rerun archetypes.

(repo-wide) · high confidence

The \rerun mcap\ CLI now includes two new subcommands for inspecting MCAP files without converting them. \rerun mcap info\ displays file metadata, chunk statistics, compression details, and channel information. \rerun mcap check\ validates the structural integrity of the file by analyzing timeline ordering across chunks and topics, reporting issues like row-order conflicts or unordered chunks. Both commands support a \--recover\ flag to handle files with missing or invalid summaries.

crates/top/rerun/src/commands/mcap · high confidence

The viewer now includes an agent chat panel that allows users to interact with a coding assistant to explore data, set up blueprints, and debug logging code. This panel is backed by an MCP server and includes a self-improvement feature in development builds that reviews agent sessions to fix tools and instructions. Additionally, the viewer now collects analytics on agent turns, with a background process that redacts sensitive data before sending reports.

_crates/top/re\viewer · high confidence

The Rerun CLI now includes a dedicated set of analytics commands, allowing users to manage their analytics settings directly from the terminal. Users can enable or disable analytics collection, associate an email address with their user profile, view the current configuration, print detailed analytics information, or clear all pending local data and reset the analytics ID.

crates/top/rerun/src/commands/analytics · high confidence

The SDK's type definitions have been updated to include new archetypes for audio (\AssetAudio\), 3D volume raymarching (\Volume3D\), and measurements (\Measurement\), alongside support for TIFF-encoded depth images (\EncodedDepthImage\) and video frame references (\VideoFrameReference\). Existing spatial archetypes such as \Boxes3D\, \Cylinders3D\, and \Capsules3D\ now support rotation via quaternions and axis-angle representations, while \EncodedDepthImage\ and \EncodedImage\ definitions have been refined to better specify media types and visualization options like colormaps and draw order.

_crates/build/re\_type\definitions/rerun/archetypes · high confidence

This change introduces a comprehensive set of new Rust archetype types in the \re\_sdk\_types\ blueprint module, enabling detailed configuration of the user interface and data views. Key additions include \DataframeQuery\ for controlling dataframe filters, timelines, and auto-scroll behavior; \CardLayout\ for customizing how table records are displayed as cards; \ContainerBlueprint\ for defining the structure and layout of UI containers (tabs, grids, splits); \AudioPlayback\ for managing audio view volume; and \ActiveVisualizers\ for overriding which visualizers are active for specific entities. These types form the foundational data structures for the new blueprint system that governs how logged data is presented and interacted with.

_crates/store/re\_sdk\types/src/blueprint/archetypes · high confidence

The \re\_sdk\_types\ crate now includes a comprehensive set of auto-generated blueprint component types that define how views and layouts are configured. These new components allow users to control specific view behaviors and structural properties, including time range selection (\AbsoluteTimeRange\), automatic layout and view generation (\AutoLayout\, \AutoViews\), auto-scrolling behavior (\AutoScroll\), and container organization (\ContainerKind\ for tabs, grids, and panels). Additional components provide fine-grained control over dataframe table presentation, such as column ordering (\ColumnOrder\), display modes (\ColumnDisplayMode\), and column selection (\ComponentColumnSelector\), as well as visual settings like background styles (\BackgroundKind\) and active tab management (\ActiveTab\).

_crates/build/re\_type\_definitions/rerun/blueprint/components, crates/store/re\_sdk\types/src/blueprint/components · high confidence

The \re\_sdk\_types\ crate now includes a new \blueprint/encodings\ module containing auto-generated Arrow serialization and deserialization logic for several blueprint configuration types. This adds support for \ComponentColumnSelector\ (defining columns in dataframe views), \ComponentSourceKind\ (allowing visualizers to resolve component sources from annotation context, overrides, or defaults), \FilterByRange\ and \FilterIsNotNull\ (dataframe filtering), \SelectedColumns\, \TensorDimensionIndexSlider\, and \TextLogColumn\ variants. These types enable users to configure dataframe views and visualizer component mappings via blueprints, with the annotation context source being a new option for resolving component data.

_crates/store/re\_sdk\types/src/blueprint/encodings · high confidence

The \re\_dev\_tools\ crate now includes a comprehensive \build-examples\ subcommand that collects, installs, and runs Python and notebook examples to generate \.rrd\ files and a manifest for the website, supporting \main\, \release\, and \nightly\ channels. It also adds a \snippets\ subcommand to execute code snippets from \docs/snippets\ and a \build-search-index\ module that ingests documentation, examples, and API references (Python via mkdocs/griffe, C++ via Doxygen) into a Meilisearch index.

_crates/build/re\_dev\tools · high confidence

Tables can now be displayed as a grid of cards instead of rows. This adds a card layout mode that renders each record as a card with a configurable title column, a link column for navigation, and a set of visible fields. The layout supports a special flag field for quick toggles and allows users to switch between card and table views via the blueprint.

_crates/viewer\_support/re\_dataframe\ui/src · high confidence

The \re\_chunk\_optimizer\ crate has been added to provide analysis and memory-bounded optimization of Rerun chunk layouts. It introduces a chunk-index-based optimizer that assesses recordings for mergeability and executes plans to merge small chunks and split oversized ones toward a configurable byte target. The optimizer supports splitting chunks by specific component columns (own-chunk rules), ordering merges by a target timeline, and applying row-count guards to manage memory usage during the optimization process.

_crates/store/re\_chunk\optimizer/src · high confidence

The \re\_chunk\ crate now exposes dedicated \LatestAtQuery\ and \EarliestAtQuery\ types along with corresponding \Chunk::latest\_at\ and \Chunk::earliest\_at\ methods, allowing users to retrieve the most recent or earliest version of a component at a specific time. These queries handle tie-breaking on \RowId\ for both sorted and unsorted chunks, and the crate also includes new benchmarks to measure the performance of these lookups under different time and row-ID sorting conditions.

_crates/store/re\chunk/src · high confidence

The \re\_lenses\_core\ crate introduces a new \Selector\ API that parses and executes jq-like query strings against Apache Arrow arrays. This engine supports columnar path navigation (e.g., \.field\), list iteration (\\[\]\), and a \pack\ function to combine scalar fields into \FixedSizeList\ columns. It also includes a function registry for named built-ins and allows chaining anonymous functions via \Selector::pipe\, enabling dynamic, runtime-defined transformations on the data.

_crates/store/re\_lenses\core/src/selector · high confidence

The \re\_component\_ui\ crate now provides dedicated UI editors for several data types. Colors can be edited via a swatch with a color picker popup, and arrays of colors are displayed as a row of swatches. Vectors (2D and 3D) are now editable using drag values for each component. Enums are rendered as selectable toggles or comboboxes, with support for conditional availability (e.g., Mapbox providers requiring a token). Other additions include editors for booleans, floats, integers, strings, and specific components like entity paths, timestamps, and UUIDs.

_crates/viewer\_support/re\_component\ui/src · high confidence

A new crate, \re\_protos\_builder\, has been added to handle the generation of Rust code from \re\_protos\ protobuf definitions. This tool uses \tonic\_build\ and \prost\ to generate both client and server definitions for the remote store gRPC API, including support for server reflection via a file descriptor set. It configures type names and specific byte paths for common, cloud, log message, and manifest registry namespaces.

_crates/build/re\_protos\builder/src · high confidence

The \re\_arrow\_ui\ crate introduces a new UI for displaying Arrow data, rendering arrays as interactive trees of \list\_items\ with syntax highlighting and data type information. It supports various array types including structs, lists, maps, unions, and primitives, with configurable display options for nested items and string truncation. The \re\_plot\ crate provides shared utilities for plot-based views, including a configurable legend widget that supports click-to-toggle visibility and Alt+click to solo/restore series. Both crates include comprehensive snapshot tests to verify correct rendering of diverse data structures.

_crates/viewer\_support/re\_arrow\_ui, crates/viewer\_support/re\plot · high confidence

Added a new Rust example that demonstrates how to extend the Rerun viewer with a custom UI panel and bidirectional communication with an external control application. The example introduces a \Control\ eframe app that embeds the standard Rerun viewer and adds a right-side panel for sending 3D point/box messages and controlling a dynamic animated snake visualization. It implements a TCP-based protocol (using bincode serialization) with a server (\ControlApp\) for the external app and a client (\ControlViewer\) for the viewer, enabling real-time updates to logged data via custom callbacks.

_examples/rust/custom\callback · high confidence

The \re\_mcap\ crate now includes dedicated decoders that extract file-level information and specific message formats from MCAP logs. Attachments are decoded into a static \McapAttachment\ entity, while metadata records are merged and exposed as a static \McapMetadata\ entity. The crate also adds support for decoding ROS 2 messages via both a fixed set of known types (e.g., \sensor\_msgs\, \std\_msgs\) and a dynamic reflection-based parser that handles arbitrary schemas at runtime. Additionally, a raw decoder is provided to capture uninterpreted message bytes, and file-level statistics are now exposed as \RecordingInfo\.

_crates/data\_flow/re\mcap · high confidence

The re\_error crate now provides structured error handling capabilities, including a StructuredError type that separates error summaries from detailed context lines, and a format function that displays the full error chain using a ': ' separator to match anyhow's formatting. Additionally, a downcast\_source helper allows walking error chains to find specific error types within a bounded number of hops.

_crates/utils/re\error · high confidence

Added the \custom\_store\_subscriber\ example, which demonstrates how to implement \ChunkStoreSubscriber\ to create custom secondary indices and trigger systems. The example includes an \Orchestrator\ that manages multiple subscriber views, a \ComponentsPerRecording\ view that tracks component occurrence counts and logs when components are introduced or retired, and a \TimeRangesPerEntity\ view that indexes time ranges covered by each entity across all timelines.

_examples/rust/custom\_store\subscriber · high confidence

The \examples/rust/extend\_viewer\_ui\ example demonstrates how to wrap the Rerun Viewer inside your own application. It shows how to initialize the viewer with a custom native window, add a custom side panel using egui, and access the underlying log database (\EntityDb\) to display entity and component data directly within the custom interface.

_examples/rust/extend\_viewer\ui · high confidence

A new Rust example demonstrates how to load a URDF file, parse its joint structure, and animate it by logging dynamic transforms over time. The example uses the \UrdfTree\ API to compute joint transforms based on simulated angle changes and logs them to the recording stream, providing a reference implementation for visualizing animated robotic models.

_examples/rust/animated\urdf · high confidence

Added \chunk\_latest\_at.rs\ and \chunk\_range.rs\ examples in \crates/store/re\_chunk/examples\ that demonstrate how to query a \Chunk\ using \LatestAtQuery\ and \RangeQuery\ respectively. These examples show users how to retrieve specific component data based on timeline values and how to slice the resulting data by timeline and component descriptors.

_crates/store/re\chunk/examples · high confidence

Added a new example executable importer plugin (\examples/rust/external\_importer\) that allows the Rerun Viewer to ingest Rust source files. When a \.rs\ file is opened, this importer logs the file content as a markdown text document. It supports standard Rerun CLI arguments for recording IDs, entity path prefixes, and time sequences/durations, and correctly exits with an incompatibility code for non-Rust files.

_examples/rust/external\importer · high confidence

The \re\_format\ crate now provides a dedicated library for formatting and parsing numbers, durations, and timestamps. Users can format durations with configurable precision, rounding modes, and unit breakdowns (e.g., \1h 42m\ vs \63s\), and format integers and floats with thousands separators and controlled decimal precision. Additionally, the crate includes utilities for pluralization (e.g., "1 item" vs "2 items") and formatting/parsing relative timestamps (e.g., \01:03.53\), supporting consistent time display across the application.

_crates/utils/re\format · high confidence

The \re\_protos\ crate now exposes the generated types for the remote store gRPC service API, including the \RerunCloudService\, \MessageProxyService\, and \ViewerControlService\. This update introduces a server capability system that allows clients to query supported features (such as \per\_segment\_index\_values\) and data source URL schemes, enabling better compatibility checks. Additionally, the protocol now supports out-of-band entry headers for identifying requests, canonical protobuf JSON serialization for debugging, and gRPC server reflection for tooling integration.

_crates/store/re\protos/src · high confidence

Added a new Rust example (\incremental\_logging\) that demonstrates how to log data belonging to the same archetype incrementally and reuse parts of it across frames. The example logs colors and radii once, then updates only the positions of 3D points in subsequent frames, showing how the viewer retains the static attributes while the dynamic ones change.

_examples/rust/incremental\logging · high confidence

The file import system has been restructured into a modular plugin architecture, introducing dedicated importers for new data formats and improving existing ones. Users can now import Puffin profiler captures (\.puffin\), which are converted into state-change timelines showing thread call stacks, and generic Parquet files (\.parquet\), which are streamed as tabular data. Additionally, LeRobot datasets (\.h5\) are now supported via a dedicated importer that streams episodes individually, including diagnostic warnings for skipped features. The existing RRD importer has been updated to use the new \re\_log\_msg\ types, and the generic Archetype importer now handles PLY files with improved performance using the \ply-rs-bw\ 4.0.0 API, correctly distinguishing between mesh and point-cloud data based on file headers.

_crates/data\_flow/re\importer/src · high confidence

The \re\_redap\_client\ crate has been introduced as the official gRPC client for the Rerun Data Protocol. This new component provides the foundational infrastructure for connecting to Rerun Hub, including a robust error handling system (\ApiError\), a connection registry for managing credentials and shared connections, and a chunk cache to optimize data retrieval. It also introduces support for client-side analytics export via OpenTelemetry and handles asset registration workflows, enabling the viewer to interact with datasets and assets on the server.

_crates/data\_flow/re\_redap\client · high confidence

The v1alpha1 cloud API now includes strongly-typed Rust helpers for asset properties and chunk keys. The new \asset\_properties\ module lets you define whether an asset applies to specific segments (OptIn) or all except specific ones (OptOut), and provides utilities to read and write these properties in Arrow RecordBatches. Additionally, \ChunkKey\ and \RrdChunkLocation\ types decode the opaque location payloads used by the FetchChunks API, exposing chunk IDs, data source kinds, ETags, and direct fetch URLs with byte ranges for efficient data retrieval.

_crates/store/re\protos/src/v1alpha1 · high confidence

A new \re\_async\ utility crate has been introduced to provide a unified abstraction layer for asynchronous operations across native and WebAssembly targets. This change introduces an \AsyncRuntimeHandle\ that allows library code to accept an executor supplied by the application rather than creating its own runtime, supporting both Tokio on native and the browser's local executor on WebAssembly. It also adds a \yield\_now\ function that utilizes the browser's \scheduler.yield()\ API when available to prevent main loop starvation, and implements an \AsyncReadAt\ trait for stateless, positional reads from files and in-memory buffers, enabling concurrent reads without shared cursors.

_crates/utils/re\async · high confidence

The \re\_audio\ crate has been added to provide audio decoding and playback capabilities for the Rerun Viewer. It supports decoding WAV, AAC, MP3, FLAC, Ogg Vorbis, and M4A files into PCM using the Symphonia library, and includes a mixer and player to output audio through the system's default device on native platforms (Linux, macOS, and others) as well as the web. The implementation handles multi-channel downmixing to stereo, gain ramping to prevent audio clicks, and platform-specific output backends, including runtime loading of ALSA on Linux to avoid hard dependencies.

_crates/utils/re\audio · high confidence

The \re\_auth\ crate introduces a dedicated authentication layer for Rerun, supporting both JWT-based machine tokens (for the Redap storage node) and OAuth 2.0 device code flows (for Rerun Hub/Cloud via WorkOS). Users can now authenticate via the \rerun auth\ CLI commands (\login\, \logout\, \token\, \generate-token\), which handle local credential storage, automatic token refreshing, and secure logout by clearing WorkOS session cookies. The system enforces strict host-matching rules on tokens to prevent credential leakage and supports granular read/write permissions within JWT claims.

_crates/utils/re\auth/src · high confidence

The \re\_backoff\ utility crate has been introduced to provide simple, dependency-free exponential backoff and retry logic. It features a \BackoffGenerator\ that calculates backoff durations using an exponential strategy (doubling base) capped by a maximum duration, and applies a configurable 'full jitter' to randomize sleep times and prevent thundering herd problems. This allows applications to implement robust retry mechanisms for transient failures without pulling in external libraries.

_crates/utils/re\backoff · high confidence

Added the \re\_build\_info\ crate, which provides a \BuildInfo\ struct and \build\_info!\ macro to capture compile-time details such as crate name, version, git hash, compiler version, and build timestamp. It also introduces a custom \CrateVersion\ type with a compact binary encoding for use in \.rrd\ files and on the wire, supporting alpha, RC, and dev versions. Additionally, it exposes an \exposed\_version()\ function that reads a runtime \EXPOSED\_VERSION\ environment variable, allowing deployed servers to report their version independently of the compiled binary.

_crates/utils/re\_build\info · high confidence

The \re\_build\_tools\ crate is introduced to centralize build-script logic for the Rerun project. It provides utilities to capture build-time metadata (git commit hash, branch, and datetime) via environment variables or by invoking git, with behavior that adapts to the build environment (e.g., workspace vs. published crate). It also includes robust dependency tracking via \cargo\_metadata\ to ensure rebuilds occur when any direct or indirect source files change, SHA-256 hashing for versioning, and a helper to format generated Rust code using \rustfmt\ with Edition 2024.

_crates/build/re\_build\tools · high confidence

The viewer now includes a new \re\_component\_fallbacks\ crate that centralizes default values for blueprint and visualizer components (such as colors, opacities, and radii for 2D/3D primitives), ensuring consistent rendering when data is missing. Additionally, the \re\_renderer\ crate introduces a comprehensive set of WGSL shaders for visualization features including colormaps, YUV video conversion, depth clouds, and compositing, along with a build system to embed these shaders for release builds.

_crates/viewer\_support/re\renderer · high confidence

A new \re\_data\_source\ crate has been introduced to centralize how Rerun loads data. It provides a \LogDataSource\ enum that classifies inputs into HTTP URLs, local files, standard input, and Rerun Enterprise Data Access Platform (REDAP) URIs. The crate handles file extension detection, magic-byte format identification for HTTP downloads, and streaming RRD data from both HTTP and stdin, effectively consolidating previous disparate loading logic into a single, reusable component.

_crates/data\_flow/re\_data\source · high confidence

The \re\_data\_ui\ crate has been introduced to centralize the UI rendering logic for Rerun component data within the viewer. This change adds dedicated display handlers for various data types, including annotation contexts (class descriptions and keypoints), application IDs, data sources, and entity databases, providing users with structured views of recordings and blueprints. It also implements specialized UIs for complex data blobs (showing size, MIME type, and EXIF metadata), images (with GPU-accelerated previews and download options), and component paths, ensuring that users can inspect and interact with logged data through a consistent and detailed interface.

_crates/viewer\_support/re\_data\ui · high confidence

The \crates/store\_app\ area now includes the \re\_dataframe\ crate, which exposes the Rerun public data APIs for retrieving dataframes from the datastore. This new component provides a \QueryEngine\ that allows users to load RRD files, inspect the recording schema, and execute queries with filters (such as timeline ranges and entity path filters) and sparse fill strategies, returning results as Arrow RecordBatches. The crate also includes a benchmark suite for the query hot loops and an example CLI tool for running queries against RRD files.

_crates/store\app · high confidence

This change introduces the \re\_hdf5\ crate, which provides core logic to read HDF5 files into a lazy stream of Rerun chunks. It maps HDF5 groups to entities and leaf datasets to components, supporting a single file-wide timeline (via a designated index column or a synthesized sequence) and emitting HDF5 attributes as static components. The implementation uses the pure-Rust \hdf5-pure\ backend, handles various data types and compression, and includes configuration options for chunk sizing, entity path prefixes, and dataset exclusion.

_crates/data\_flow/re\hdf5 · high confidence

The \re\_log\ crate introduces a structured logging system built on \tracing\, providing macros like \debug\_warn\, \debug\assert\, and \\\_once\ variants to reduce log spam. It includes a \ChannelLayer\ that pipes log messages to receivers, enabling the viewer to convert \info\-level and above logs into user-facing notifications. The crate also adds a \GUI\_NOTIFICATION\_FIELD\ to allow specific log events to be suppressed from the notification center while still appearing in logs, and provides \PanicOnWarnScope\ for testing.

_crates/utils/re\log · high confidence

The \re\_mp4\_reader\ crate introduces core logic to load MP4 files and emit Rerun chunks in two modes: \Asset\ mode logs the video as a single \AssetVideo\ blob with a \VideoFrameReference\ index, while \Stream\ mode demuxes the video into \VideoStream\ codec metadata, per-GOP \VideoSample\ chunks, and a sparse \IsKeyframe\ marker chunk. Stream mode supports lazy, on-demand reading from disk or memory, handles B-frame transcoding via FFmpeg when necessary, and allows time-window slicing. This enables efficient, low-memory video ingestion for Rerun recordings.

_crates/data\_flow/re\_mp4\reader · high confidence

Added the \re\_mutex\ crate, which wraps \parking\_lot::Mutex\ and \RwLock\ to help developers debug deadlocks. In debug builds, these wrappers log warnings with backtraces if a lock cannot be acquired within 10 seconds, including the location of the existing lock holder or the blocking call site.

_crates/utils/re\mutex · high confidence

Added the \re\_quota\_channel\ crate, providing async channels that enforce byte-size limits to prevent memory pressure. The new \async\_broadcast\_channel\ applies backpressure by pausing senders when the total bytes in flight exceed a configured maximum, ensuring messages are not dropped under load. It also includes an \async\_mpsc\_channel\ wrapper that logs warnings if send operations block for too long, aiding in the debugging of pipeline bottlenecks.

_crates/utils/re\_quota\channel/src · high confidence

The new re\_tracing crate provides helpers for integrating the Puffin profiling library into the application. It exposes macros like profile\_function and profile\_scope to mark code regions for performance analysis, and includes a ProfileCapture struct to record profile data in memory for a specified number of frames. Additionally, it offers a Profiler component that starts a local HTTP server to stream profiling data to the puffin\_viewer tool, automatically attempting to launch the viewer and providing fallback instructions if it is not installed.

_crates/utils/re\tracing · high confidence

The \crates/viewer\_support/re\_ui\ crate has been added to define the Rerun Viewer's visual identity. It bundles the Inter and Hack fonts, a comprehensive set of SVG icons for the interface, and RON configuration files that specify the dark theme colors, layout dimensions, and UI styling. A build script also enables hot-reloading of these design tokens during development.

_crates/viewer\_support/re\ui · high confidence

The \re\_video\ crate has been introduced in \crates/utils/re\_video\ to provide a unified interface for parsing video containers and decoding their contents. It supports H.264, H.265, AV1, VP8, and VP9 codecs, utilizing native decoders like \dav1d\ for AV1 and \ffmpeg\ for other formats. The crate includes a streaming MP4 transcoder for efficient chunked playback, handles large video files (2GiB+), and provides utilities for video sampling and frame extraction.

_crates/utils/re\video · high confidence

The \re\_view\ crate has been introduced to centralize types and utilities for defining View classes and communicating with the Viewport. This new module provides core infrastructure for resolving visualizer components from blueprint data, including support for annotation context resolution, component mapping error handling, and query plan execution. It also introduces shared component drag-and-drop handling for views, caching mechanisms for annotation maps, and utilities for processing color and keypoint data, effectively consolidating view-specific logic previously scattered across the codebase.

_crates/viewer\_support/re\view · high confidence

The \re\_web\_viewer\_server\ crate has been introduced to serve the Rerun web viewer (Wasm and HTML) over HTTP. It supports three asset-loading modes: embedding assets at compile time (default), appending a zip archive to the binary via a post-processing step (\RERUN\_TRAILING\_WEB\_VIEWER=1\), or loading assets from an external zip archive on disk (\RERUN\_EXTERNAL\_WEB\_VIEWER=1\). The crate includes the web viewer's HTML, JavaScript, and service worker files, and exposes a server on port 9090 by default.

_crates/top/re\_web\_viewer\server · high confidence

The \re\_memory\ crate has been introduced to provide run-time memory tracking and profiling capabilities. It includes an \AccountingAllocator\ that intercepts allocations to track live memory usage, and an opt-in sampling profiler that captures callstacks to help identify memory leaks and high-usage patterns. The library also features a \MemoryLimit\ system for configuring RAM constraints (supporting absolute bytes, percentages of total RAM, or unlimited), a \PeakMemoryStats\ monitor to capture statistics at memory high-water marks, and a \RamLimitWarner\ to log warnings when usage exceeds configured thresholds.

_crates/utils/re\memory · high confidence

The \re\_perf\_telemetry\ crate now exposes a comprehensive \TelemetryArgs\ configuration struct, allowing users to control telemetry behavior via command-line flags and environment variables (such as \TELEMETRY\_ENABLED\, \OTEL\_SERVICE\_NAME\, and \RUST\_LOG\). This change introduces a new HTTP \/metrics\ endpoint that serves Prometheus-compatible metrics (both text and protobuf formats) on demand, enabling local scraping of telemetry data. Additionally, the crate now includes modules for memory usage tracking (\memory\_telemetry\) and shared manual readers for metrics, providing a foundation for detailed performance monitoring.

_crates/utils/re\_perf\telemetry/src · high confidence

The \re\_time\_ruler\ crate introduces shared UI primitives for the time panel and time-aware views, including \TimeRangesUi\ for mapping time to screen coordinates with gap collapsing, and rendering helpers for tick marks, labels, and visual gap indicators. A new tooltip component now displays the start, stop, and length of a time range when hovering over a state in the timeline.

_crates/viewer\_support/re\_time\ruler · high confidence

The viewer now uses a new, unified caching system in \re\_viewer\_context\ to improve performance and memory management. This introduces a \Memoizers\ framework that manages per-store caches with fine-grained locking to reduce contention, and an \AppCaches\ container for global state. New specialized caches have been added to cache decoded images, image histograms, image stats, tensor stats, video assets, and transform data, all of which now automatically invalidate themselves when underlying data is deleted from the store.

_crates/viewer\_support/re\_viewer\context/src/cache · high confidence

The viewer now uses a new \re\_viewer\_context\ crate to centralize application state, introducing \AppContext\ for global viewer state (including authentication, selection, and routing) and \ActiveStoreContext\ for the currently active recording and blueprint. This change adds support for OAuth login via \AuthContext\, exposes command palette commands over \ViewerControl\ and MCP, and introduces a \BlueprintId\ system with typed IDs for views and containers to improve blueprint management.

_crates/viewer\_support/re\_viewer\context/src · high confidence

The \re\_viewport\_blueprint\ crate has been introduced to centralize the data model and logic for the viewport's layout and view selection. It provides the \ViewBlueprint\ and \ContainerBlueprint\ structures that define how views and containers (tabs, grids, horizontal/vertical splits) are stored and rendered. The crate includes an auto-layout engine that arranges views into grids or tab groups based on class priority, and a UI modal for adding new views or containers, which now separates stable views from experimental ones. It also introduces \ViewContents\ to manage entity path filters and \EntityAddInfo\ to determine if entities can be added to a view, along with benchmarks for data query performance.

_crates/viewer\_support/re\_viewport\blueprint · high confidence

The SpatialView now includes dedicated visualizer implementations for several new and existing data types. 2D and 3D arrows (Arrows2D, Arrows3D) are rendered as customizable line segments with support for color, radius, and labels. 2D and 3D boxes (Boxes2D, Boxes3D) are drawn as outlines or filled meshes, with 3D boxes supporting rotation and fill modes. 3D capsules and cylinders (Capsules3D, Cylinders3D) are visualized as procedural meshes with configurable subdivisions and fill modes. 3D assets (Asset3D) are rendered as loaded meshes with caching and albedo support. Camera frustums (Cameras) are visualized based on Pinhole projections, including resolution and coordinate system handling.

_crates/views/re\_view\spatial/src/visualizers · high confidence

The \rerun\ crate has been restructured to improve modularity and add new capabilities. It now exposes a \clap\ module for easier command-line argument integration, a \demo\_util\ module with helper functions for examples, and a \log\_integration\ module to forward standard Rust log events to Rerun. The SDK now supports blueprints, allowing users to initialize a recording stream with a default or active blueprint via \init\_with\_blueprint\ and \init\_with\_default\_blueprint\. Additionally, the \rrd\ module provides a standalone API for optimizing \.rrd\ files, and the crate re-exports types from \re\_sdk\_types\ (renamed from \re\_types\) with \datatypes\ deprecated in favor of \encodings\.

crates/top/rerun/src · high confidence

A new \rrd.hexpat\ file has been added to the \re\_log\_encoding\ crate, providing a shallow pattern definition for the ImHex binary editor. This allows users to load and inspect the outer layers of RRD files (including stream headers, message kinds, and raw data lengths) directly in ImHex, serving as a starting point for visualizing the RRD byte layout.

_crates/store/re\_log\encoding · high confidence

The spatial view now includes dedicated context systems to handle rendering depth and coordinate transformations. The new \EntityDepthOffsets\ system calculates specific depth offsets for entities based on their draw order to prevent z-fighting artifacts in 3D scenes. Additionally, the \TransformTreeContext\ system provides a unified transform tree, allowing visualizers to correctly resolve entity positions and instance poses relative to the view's space.

_crates/views/re\_view\spatial/src/contexts · high confidence

The \re\_grpc\headers\ utility now provides a unified \tower\ layer that automatically stamps every outbound gRPC request with standardized \x-rerun-\\ headers, including a unique client ID, client version, and server version. This ensures consistent identity tracking across all Rerun SDK connections, allowing servers to distinguish between different client instances (such as native binaries vs. web browsers) and versions for metrics and tracing purposes.

_crates/utils/re\_grpc\headers · high confidence

The time series visualization logic has been moved into its own crate (crates/views/re\_view\_time\_series) and restructured. This change introduces a new aggregation system that groups plot points into windows to smooth lines and reduce rendering load, while also handling non-finite values (NaN, infinity) by breaking aggregation windows. It adds support for rendering translucent error bands around measurement series based on variance data. The view now supports configurable aggregation policies (Average, Min, Max, MinMax, MinMaxAverage) and interpolation modes (Continuous, Stepped, Scatter) via the blueprint, with automatic fallbacks for series naming and coloring when not explicitly configured.

_crates/views/re\_view\_time\series/src · high confidence

The Python SDK has removed legacy APIs that were previously deprecated. This change cleans up the public interface by eliminating older, unsupported methods and classes, requiring users to migrate to the current stable API surface.

_rerun\py · high confidence

The web\_server module, which previously served the web-viewer WASM and HTML assets via a local Hyper-based HTTP server on port 9090, has been removed. This eliminates the ability to run the embedded viewer locally through this specific service component.

_web\server · high confidence

The viewer module's source files (including app, panels, views, and data handling) and the \build\_web.sh\ and \setup\_web.sh\ scripts have been deleted. This removes the previous implementation of the viewer from the codebase.

viewer · high confidence

The local WebSocket-based communication layer in the \comms\ crate has been removed. This deletes the \Connection\ struct for client-side connections, the \Server\ struct for handling incoming WebSocket traffic, and the associated log message encoding/decoding logic. This change indicates that the application no longer manages its own direct WebSocket connections for this component, likely shifting to an external data store or different communication mechanism.

comms · high confidence

The \re\_protos\ crate now includes the complete v1alpha1 protobuf definitions for the Rerun Cloud service (catalog, manifest registry, and chunk writing), the SDK-to-viewer message proxy, and the ViewerControl API (remote control operations like screenshots, time cursor, and command palette). These files establish the public gRPC surface for client-server communication, replacing the previous ad-hoc or internal definitions with a versioned, documented schema.

_crates/store/re\protos/proto · high confidence

The \re\_chunk\_store\ crate's source code has been reorganized from a single large module into distinct, focused files (e.g., \compact.rs\, \gc.rs\, \dataframe.rs\, \drop\_time\_range.rs\, \entity\_tree.rs\, \events.rs\). This structural change improves code maintainability and separation of concerns without altering the public API or runtime behavior of the chunk store.

_crates/store/re\_chunk\store/src · high confidence

The \re\_log\_msg\ crate has been introduced to centralize the message types that carry Rerun data between the SDK, \.rrd\ files, and the viewer. This change lifts \LogMsg\, \ArrowMsg\, \TableMsg\, and related structures out of \re\_log\_types\ into this new location. \LogMsg\ now serves as the primary envelope for recordings and blueprints, containing \SetStoreInfo\, \ArrowMsg\ (which wraps a \re\_sorbet::ChunkBatch\), and \BlueprintActivationCommand\. \TableMsg\ is defined separately to handle standalone tables that are not stored in \.rrd\ files. This restructuring clarifies the separation between persistent recording data and transient table data.

_crates/store/re\_log\msg · high confidence

The internal logging transport has been reorganized into a new \re\_log\_channel\ crate, replacing the previous \re\_smart\_channel\ implementation. This change introduces a unified \DataSourceMessage\ type that consolidates log data, blueprint registrations, and viewer control commands, and adds a \LogSource\ enum to explicitly track where data originates (e.g., files, HTTP streams, SDK, or gRPC). The new channel supports backpressure via \re\_quota\_channel\, provides a \LogReceiverSet\ for managing multiple data streams, and exposes viewer control commands (such as screenshots and UI inspection) as first-class messages within the channel.

_crates/store/re\_log\channel/src · high confidence

The \re\_types\_core\ crate has been reorganized to introduce a new foundational data model. This change introduces the \Archetype\ trait to represent logical collections of components, the \AsComponents\ trait for serializing data bundles, and the \ComponentBatch\ trait for handling arrays of loggable instances. New core types such as \ComponentDescriptor\, \ComponentIdentifier\, \ArchetypeName\, \LayerName\, and \ChunkId\ have been added to uniquely identify and describe data columns and storage units. The module also includes new helper traits and types for Arrow serialization (\ArrowString\, \arrow\_helpers\, \arrow\_zip\_validity\) and reflection, establishing the basis for the updated logging and storage architecture.

_crates/store/re\_types\core/src · high confidence

The \re\_log\_encoding\ crate now includes an \ApplicationIdInjector\ mechanism to handle backward compatibility with RRD files created before version 0.25. Since older files lack application IDs in their \StoreId\ protobuf messages, this new logic caches the application ID from \SetStoreInfo\ payloads and injects it into subsequent messages during decoding. This ensures that legacy data streams are correctly associated with their applications in the viewer without breaking existing functionality.

_crates/store/re\_log\encoding/src · high confidence

The blueprint type definitions have been restructured to support a new, more powerful table blueprint structure and expanded view configuration. This includes new archetypes for table layouts (CardLayout, TableLayout, TableColumn, TableColumnPreview) and queries (DataframeQuery), as well as enhanced controls for 3D views (EyeControls3D, NearClipPlane, LineGrid3D), map views (MapBackground, MapZoom), and plots (PlotInteraction, PlotLegend, ScalarAxis). Additionally, new archetypes define audio playback settings (AudioPlayback), text log formatting (TextLogColumns, TextLogFormat, TextLogRows), and time axis linking (TimeAxis), providing finer control over how data is visualized and interacted with in the Rerun viewer.

_crates/build/re\_type\definitions/rerun/blueprint/archetypes · high confidence

The \re\_string\_interner\ library now caches string interning calls to optimize hot paths. This change reduces the overhead of hashing and locking the global interner for repeated invocations, such as those found in visualizer execute methods and codegen accessors, leading to improved performance in scenarios where the same interned identifiers are produced frequently.

_crates/utils/re\_string\interner · high confidence

The crash handler utility in \re\_crash\_handler\ has been expanded to detect and report SIGINT (interrupt) signals. Previously, only fatal signals like SIGSEGV and SIGABRT were captured for analytics; the new \sigint\ module now tracks SIGINT events and, when the analytics feature is enabled, records them via \re\_analytics::event::CrashSignal\. This allows the product to collect data on how often users interrupt the application, providing better insight into user behavior during crashes or forced stops.

_crates/utils/re\_crash\handler/src · high confidence

The \custom\_view\ example has been updated to demonstrate the modern blueprint property system. It now defines a manual \ColorCoordinatesConfiguration\ archetype with reflection metadata and registers a custom UI editor for the \ColorCoordinatesMode\ component via the component UI registry. The view class uses \ViewProperty\ to read this blueprint property at runtime, allowing users to change the color coordinate mode (Hue/Saturation, Hue/Value, or Red/Green) directly in the viewer's UI.

_examples/rust/custom\view · high confidence

The \Clear\ archetype is now auto-generated in \re\_types\_core\, providing a way to empty components of an entity. It includes a new \is\_recursive\ field (mapped to \ClearIsRecursive\) that allows users to choose between clearing only the specific entity (\Clear::flat()\) or clearing the entity and all its descendants (\Clear::recursive()\). This change replaces the previous manual implementation with code-generated serialization/deserialization logic using arrow-rs and updates the module structure to expose the archetype via \mod.rs\.

_crates/store/re\_types\core/src/archetypes · high confidence

The pixi environment setup is now handled by a new Python package (\rerun\_pixi\_env\) that replaces previous shell-based or ad-hoc scripts. This package installs \uv\ and \uvpy\ shims into \scripts/pixi/\ to ensure Python tooling targets the correct \.venv\ environment by unsetting \CONDA\_PREFIX\, and it generates a \pyo3-build.cfg\ file to standardize Rust/PyO3 builds across different environments. This change simplifies the bootstrap process and ensures consistent build configurations for developers using pixi.

_rerun\_pixi\env · high confidence

The minimal serve example has been updated to use the new \RecordingStreamBuilder\ API, replacing the legacy \rr.serve\ pattern with \RecordingStreamBuilder::new(...).serve\_grpc()\. It also explicitly launches the web viewer using the new \serve\_web\_viewer\ function with a proxy configuration, demonstrating the modern approach for serving Rerun data via a browser.

_examples/rust/minimal\serve · high confidence

A new CI Docker image has been introduced, based on the manylinux\_2\_28 base, to standardize the build environment. This image pre-installs the Rust toolchain (version pinned via rust-toolchain), essential build dependencies (gcc, cmake, git, etc.), and system libraries required for compilation. The image is published to GitHub Container Registry (ghcr.io) for both amd64 and arm64 architectures, replacing previous setups that relied on Docker Hub or different base images.

_ci\docker · high confidence

The \rerun\ and \rerun-cli\ crates now include dedicated README files and build scripts. The \rerun-cli\ README documents installation via \cargo install rerun-cli --locked --features nasm\ and notes that the CLI connects to SDKs over gRPC. A new \build.rs\ for \rerun-cli\ warns users in release builds if the \nasm\ feature is not enabled, as this impacts video decoding performance. The \rerun\ SDK README provides usage examples and installation instructions, while its \build.rs\ exports build info variables.

crates/top/rerun, crates/top/rerun-cli · high confidence

The \re\_analytics\ crate introduces a dedicated analytics SDK that collects anonymous usage statistics via PostHog. Users can now explicitly opt out of all data collection using the \rerun analytics disable\ command, and can inspect the configuration or clear stored data with \rerun analytics config\ and \rerun analytics clear\. The SDK defines specific events (such as \crash-panic\, \crash-signal\, and \identify\) and collects metadata like build version, platform, and graphics backend, while ensuring no personally identifiable information is gathered unless the user explicitly logs in to cloud services.

_crates/utils/re\analytics · high confidence

The blueprint encoding layer now includes new type definitions that enable more granular configuration of the dataframe view and visualizer component mappings. Users can now define specific column selections (including time and component columns), apply range and null-value filters, and configure text log and timeline columns. Additionally, visualizer component mappings support a new 'AnnotationContext' source kind, allowing visualizers to resolve values from the recording's annotation context when explicit selections or overrides are not provided.

_crates/build/re\_type\definitions/rerun/blueprint/encodings · high confidence

The \re\_types\_core\ crate now includes a new \encodings\ module containing auto-generated Rust types (such as \Bool\, \Float32\, \Float64\, \TimeInt\, \TimeRange\, and \EntityPath\) that implement Arrow serialization and deserialization traits. This change replaces the previous \datatypes\ module and introduces a new \ArrowDataType\ trait (renamed from \ArrowDatatype\) to define the underlying Arrow schema for these types, enabling more reliable and standardized data interchange with the Arrow format.

_crates/store/re\_types\core/src/encodings · high confidence

The path module now includes \ComponentPath\ and \DataPath\ types to explicitly represent paths to specific components and data instances (e.g., \entity:Component\ or \entity\[\#id\]\), alongside a refactored \EntityPathFilter\ that uses \ResolvedEntityPathFilter\ to handle variable substitutions and sorting rules more accurately. These changes improve how the system identifies, filters, and displays specific data points within entity hierarchies.

_crates/store/re\_log\types/src/path · high confidence

The \re\_int\ utility crate has been introduced to replace the external \saturating\_cast\ dependency, offering two key traits for safer numeric handling across Rerun. The \SaturatingCast\ trait allows casting between integer types by clamping values to the target range (e.g., capping 300 to 255 when casting to \u8\) instead of wrapping or panicking, while \UnsignedAbs\ computes the absolute value of signed integers without overflow risks. This change centralizes these common numeric helpers within the Rerun codebase.

_crates/utils/re\int · high confidence

The viewer now uses a new view class framework defined in the \re\_viewer\_context\ crate, introducing a structured system for view registration, execution, and UI customization. This change enables view classes to define their own selection panel sections, including custom visualizer menus and blueprint property editors, allowing for more tailored and customizable selection interfaces. The framework also introduces a diagnostic system for reporting viewer errors and warnings, and a new highlighting system for managing entity selection and hover states within views.

_crates/viewer\_support/re\_viewer\context/src/view · high confidence

The authentication mechanism for Jupyter notebooks has been updated to use the OAuth Device Code flow instead of the previous Authorization Code flow. This change allows users to authenticate in environments where opening a browser window automatically is not possible or reliable; users will now receive a verification URI and a user code to manually enter in their browser to complete the login. The implementation includes new API client functions for device code exchange, a dedicated \DeviceCodeFlow\ state machine for polling and handling the flow, and ensures credentials are stored securely using the existing platform-specific storage abstractions (file system on native, localStorage on web).

_crates/utils/re\auth/src/oauth · high confidence

The RRD decoder in \re\_log\_encoding\ has been restructured to use a push-based state machine (\Decoder\) that ingests byte chunks and outputs messages, enabling it to run in diverse environments like web, async, and HTTP fetches. This change introduces \DecoderIterator\ for synchronous iteration and \DecoderStream\ for asynchronous streaming, both supporting eager and lazy initialization modes. The decoder now handles concatenated RRD streams by accumulating manifests from footers and supports both transport-level (\DecoderTransport\) and application-level (\DecoderApp\) decoding entry points.

_crates/store/re\_log\encoding/src/rrd/decoder · high confidence

The RRD file format has been updated to include a footer containing a manifest of all stored chunks. This allows the SDK to perform efficient, sequential I/O reads by looking up chunk byte offsets in the manifest, rather than scanning the entire file. The \FileSink\ now supports a \write\_footer\ option (defaulting to \true\) to opt out of generating this footer, which can reduce memory usage for long-running streaming sessions at the cost of random-access performance. Additionally, a new \RrdFingerprint\ feature computes a SHA-256 hash of RRD files (using the footer payload when available) to uniquely identify recordings.

_crates/store/re\_log\encoding/src/rrd · high confidence

The RRD encoding layer now includes dedicated modules for handling RRD footers and manifests. A new \read\_raw\_rrd\_manifests\ helper allows direct parsing of manifest data from the end of an RRD file without decoding the entire stream. The \RrdFooter\ type aggregates these manifests, and a new \HubRrdManifest\ type extends the raw manifest schema with three additional columns (\chunk\_partition\_id\, \rerun\_partition\_layer\, \chunk\_key\) to support Hub-specific storage addressing and byte-range calculations that include message headers.

_crates/store/re\_log\encoding/src/rrd/footer · high confidence

The SDK's foundational data types—such as vectors, matrices, colors, and image formats—are now defined in the \encodings\ module. These \.def.rs\ files serve as the source of truth for the type builder, which generates the corresponding Rust, Python, and C++ bindings. This change introduces explicit definitions for primitives like \Vec3D\, \Mat4x4\, and \Rgba32\, as well as complex structures like \TensorData\ and \ClassDescription\, ensuring consistent serialization and cross-language compatibility.

_crates/build/re\_type\definitions/rerun/encodings · high confidence

This change updates the type definition files in the \rerun/components\ directory, which serve as the source for generating SDK bindings. It introduces and refines components that control visual appearance and data handling, including \AggregationPolicy\ for optimizing line plot performance, \Colormap\ for scalar-to-color mapping, and \FillMode\ for 3D shape rendering. It also defines structural components like \AnnotationContext\ for semantic class descriptions, \GraphEdge\ and \GraphNode\ for graph data, and \IsKeyframe\ for video synchronization. Additionally, it establishes geometric primitives such as \LineStrip2D\, \LineStrip3D\, and \Plane3D\, alongside standard attributes like \Color\, \Opacity\, and \Radius\.

_crates/build/re\_type\definitions/rerun/components · high confidence

The time and index-related types have been reorganized into a new \index\ submodule within \re\_log\_types\. This change introduces dedicated types for absolute time ranges (\AbsoluteTimeRange\, \AbsoluteTimeRangeF\), durations (\Duration\), and index windows (\IndexWindow\), alongside refined representations for time points (\TimePoint\, \TimeCell\) and timelines (\Timeline\). The refactoring also includes a new \NonMinI64\ type to safely handle integer ranges and improves the precision of time handling with \TimeReal\ for sub-nanosecond operations, providing a more robust foundation for timeline interactions and indexing.

_crates/store/re\_log\types/src/index · high confidence

The time control subsystem has been reorganized into a new \time\_control\ folder within \re\_viewer\_context\, separating the core state machine, command definitions, and blueprint persistence helpers into distinct files (\mod.rs\, \command.rs\, \blueprint\_ext.rs\). This change introduces a structured command-based interface (\TimeControlCommand\) for managing playback state, timeline selection, and time ranges, while adding a \TimeBlueprintExt\ trait to persist these settings to the blueprint. The refactoring also includes a comprehensive test suite (\tests.rs\) validating playback mechanics, timeline handling, and looping behavior.

_crates/viewer\_support/re\_viewer\_context/src/time\control · high confidence

The \datatypes\ module in \re\_sdk\_types\ has been renamed to \encodings\. This change updates the module path for all generated encoding types (such as \Angle\, \Blob\, and \ChannelDatatype\) and their associated extension traits, requiring updates to any code that previously imported from the old \datatypes\ namespace.

_crates/store/re\_sdk\types/src/encodings · high confidence

The \rerun\ CLI binary entry point (\rerun.rs\) has been established to initialize the application environment. It configures a custom memory allocator (\mimalloc\ with \AccountingAllocator\) for memory tracking and sets up the main thread token to ensure UI operations like file dialogs run on the correct thread. Additionally, it implements conditional logging setup: if the \perf\_telemetry\ feature is enabled and the \TELEMETRY\_ENABLED\ environment variable is set, standard stderr logging is suppressed to allow exclusive access for performance telemetry tracing; otherwise, standard logging is initialized.

crates/top/rerun-cli/src · high confidence

The SDK's data archetypes (such as Arrows2D, Arrows3D, Asset3D, AssetAudio, AssetVideo, and BarChart) are now auto-generated Rust types located in the \re\_sdk\_types\ crate. This change introduces a codegen-based approach for defining and serializing data, replacing the previous manual implementations and ensuring consistent serialization traits and component descriptors across all archetypes.

_crates/store/re\_sdk\types/src/archetypes · high confidence

The \re\_types\_builder\ crate has been completely rewritten to replace the legacy \arrow2\ dependency with \arrow-rs\, simplifying the internal type system and removing Flatbuffers IDL support. This change updates the code generation pipeline for Rust, C++, and Python, introducing new attributes for controlling serialization and documentation, and ensuring that generated code is compliant with modern Arrow standards.

_crates/build/re\_types\builder · high confidence

The Rust SDK has been reorganized into a new \re\_sdk\ crate, introducing a \GrpcServerSink\ that hosts an in-process gRPC server for live streaming, a \BinaryStreamSink\ for in-memory RRD encoding, and a \WebViewerSink\ for hosting the web viewer. The \spawn\ API now exposes \SpawnOptions\ with a default gRPC server memory limit of 1GiB and a \detach\_process\ flag, while the \RecordingStream\ builder supports explicit \RecordingInfo\ properties and global/thread-local scoping.

_crates/top/re\sdk/src · high confidence

The Sorbet storage layer now uses a formalized, versioned migration pipeline to ensure older recordings are compatible with the current schema. The system detects the Sorbet version of incoming Arrow record batches (falling back to heuristics for legacy Rerun Hub data) and applies a chain of migrations: v0.0.1→v0.0.2 handles legacy TUID encoding and archetype renames; v0.0.2→v0.1.0 migrates metadata keys from dot-notation to colon-notation and renames \RecordingProperties\ to \RecordingInfo\; v0.1.0→v0.1.1 drops indicator columns; v0.1.1→v0.1.2 replaces deprecated \Pose\*\ components with standard transformation components, moves \Transform3D::axis\_length\ to \TransformAxes3D\, and renames \CoordinateFrame::frame\_id\ to \CoordinateFrame::frame\; and v0.1.2→v0.1.3 replaces the temporary \SeriesVisible\ component with \Visible\. Additionally, chunk batches are now normalized so that all data columns are wrapped in \ListArrays\ to support larger data types like 2GiB+ videos.

_crates/store/re\sorbet/src/migrations · high confidence

The spatial view implementation has been moved into its own crate (\re\_view\_spatial\), introducing new modules for 3D camera control (\eye.rs\), entity visualization heuristics (\heuristics.rs\), and a comprehensive GPU-based picking system (\picking.rs\, \picking\_ui.rs\). This refactoring adds support for tracking maximum image dimensions and video codecs via a store subscriber, implements PLY mesh loading, and provides pixel-level interaction capabilities for images and depth maps.

_crates/views/re\_view\spatial/src · high confidence

The state timeline example now logs state data as arrays of instances (e.g., gamepad buttons), where each element in the array represents a separate lane and \None\ values create gaps in the timeline. It also shows how to use alternative state sources, such as boolean signals or dynamic string components, which can be remapped to the state slot via the source selector in the UI.

_examples/rust/state\timeline · high confidence

The \re\_tuid\ crate now strictly validates TUID string representations, rejecting inputs that are not exactly 32 hexadecimal characters to prevent silent aliasing or truncation errors. It also defines the Arrow extension name as \rerun.datatypes.TUID\ for compact terminal formatting and integrates with the \quiver\ library to support \Tuid\ columns backed by \FixedSizeBinary(16)\ arrays.

_crates/utils/re\tuid/src · high confidence

The \TimePoint\ structure has been updated to include a \Sequence\ variant in its \TimeValue\ enum, allowing log entries to be indexed by a sequence number (u64) in addition to absolute time. This enables the system to track and reference data points using relative sequence indices, which is useful for scenarios where absolute timestamps are less relevant or unavailable.

_log\types · high confidence

Add test assets and infrastructure for snapshot and compatibility testing; Added Rust logging benchmark suite; Added Rust plot dashboard stress test tool; Added benchmark for LogMsg protobuf encoding and decoding; Added benchmark for Tuid Arrow serialization and deserialization; Added benchmarking for Tuid creation and comparison; Added benchmarks for entity path parsing and VecDeque operations; Added generated test archetype definitions for type fuzzing; Added integration tests for DataFusion table widget; Added integration tests for chunk optimization and log encoding; Added integration tests for the State Timeline view; Added memory usage test for logging large images; Added regression test for RowId ordering; Added roundtrip and serialization tests for re\_sdk\_types archetypes; Added screenshot tests for link button rendering; Added smoke test for Gaussian Splat rendering; Added stress-test for out-of-order transform logging; Added test for UI wakeup behavior; Added test for multi-line label compaction in 3D spatial views; Added tests for server capabilities presence and decoding; Added type definitions for testing code generation edge cases; Added unit tests for authentication token generation and validation; Added visual regression snapshots for component UI list items; Added visual test for timeline density graphs; Generated testing component types for the type zoo; Integration test suite for data importers; New inspection-based integration test harness for Rerun viewers; New official test suite for the Rerun Data Protocol (redap); Updated chunk lineage test snapshots; Updated snapshot tests for recording stream flush behavior.

This release updates dependencies across 237 manifests, including upgrades to egui, wgpu, arrow, datafusion, and various other crates to improve performance, fix bugs, and address security vulnerabilities.

(dependencies) · high confidence

The repository is initialized with essential configuration files, including \.RERUN\_ROOT\, \.clang-format\, \.editorconfig\, \.gitattributes\, \.mcp.json\, \.prettierignore\, \.prettierrc.toml\, and \.python-version\. This establishes the baseline project structure, coding standards, and environment settings for the Rerun codebase.

(repo-wide) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 67 → 66 (-0.8)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.17) — scores are not directly comparable.

• Code Health 83 → 83 (+0.3)
• Architecture 99 → 70 (-29.0)
• Maturity 70 → 70 (+0.0)
• Readiness 73 → 74 (+1.0)
• Security 69 → 72 (+2.5)
• Event Sourcing 100 → 100 (+0.0)
• Accessibility 59 → 61 (+1.1)
• Performance 70 (new)

• App::is_back_destination_open (cyclomatic 17) (crates/viewer/re_viewer/src/app/command_handling.rs)
• App::load_data_source (cognitive 35) (crates/viewer/re_viewer/src/app/add_data_source.rs)
• App::load_data_source (cyclomatic 22) (crates/viewer/re_viewer/src/app/add_data_source.rs)
• App::move_time (cognitive 18) (crates/viewer/re_viewer/src/app/mod.rs)
• App::on_new_store (cognitive 18) (crates/viewer/re_viewer/src/app/logic.rs)
• App::prefetch_chunks (cognitive 17) (crates/viewer/re_viewer/src/app/logic.rs)
• App::purge_memory_if_needed (cognitive 16) (crates/viewer/re_viewer/src/app/logic.rs)
• App::receive_data_source_ui_command (cognitive 18) (crates/viewer/re_viewer/src/app/logic.rs)
• App::receive_fetched_chunks (cognitive 25) (crates/viewer/re_viewer/src/app/logic.rs)
• App::receive_log_msg (cognitive 34) (crates/viewer/re_viewer/src/app/logic.rs)
• App::receive_messages (cognitive 23) (crates/viewer/re_viewer/src/app/logic.rs)
• App::receive_messages (cyclomatic 17) (crates/viewer/re_viewer/src/app/logic.rs)
• App::run_recording_command (cognitive 51) (crates/viewer/re_viewer/src/app/command_handling.rs)
• App::run_recording_command (cyclomatic 35) (crates/viewer/re_viewer/src/app/command_handling.rs)
• App::run_system_command (cognitive 127) (crates/viewer/re_viewer/src/app/command_handling.rs)
• App::run_system_command (cyclomatic 94) (crates/viewer/re_viewer/src/app/command_handling.rs)
• App::run_ui_command (cognitive 37) (crates/viewer/re_viewer/src/app/command_handling.rs)
• App::run_ui_command (cyclomatic 57) (crates/viewer/re_viewer/src/app/command_handling.rs)
• App::ui (cognitive 60) (crates/viewer/re_viewer/src/app/mod.rs)
• App::ui (cyclomatic 46) (crates/viewer/re_viewer/src/app/mod.rs)
• …and 1769 more

• Ambiguous naming convention: get_attr vs try_get_attr. Typically, get implies a direct access (possibly panicking or returning a default on miss), while try_get implies returning a Result or Option. However, the return types are both T (generic), which makes it unclear if get_attr panics on missing keys or if try_get_attr returns a Result<T, Error>. If T is Option<U>, the naming is misleading. If T is Result<U, E>, the naming is also confusing.
• AnyBatchValue.init (cognitive 19) (rerun_py/rerun_sdk/rerun/any_batch_value.py)
• App::is_back_destination_open (cyclomatic 17) (crates/top/re_viewer/src/app/command_handling.rs)
• App::load_data_source (cognitive 35) (crates/top/re_viewer/src/app/add_data_source.rs)
• App::load_data_source (cyclomatic 22) (crates/top/re_viewer/src/app/add_data_source.rs)
• App::move_time (cognitive 18) (crates/top/re_viewer/src/app/mod.rs)
• App::on_new_store (cognitive 18) (crates/top/re_viewer/src/app/logic.rs)
• App::prefetch_chunks (cognitive 17) (crates/top/re_viewer/src/app/logic.rs)
• App::purge_memory_if_needed (cognitive 16) (crates/top/re_viewer/src/app/logic.rs)
• App::receive_fetched_chunks (cognitive 25) (crates/top/re_viewer/src/app/logic.rs)
• App::receive_log_msg (cognitive 34) (crates/top/re_viewer/src/app/logic.rs)
• App::receive_messages (cognitive 23) (crates/top/re_viewer/src/app/logic.rs)
• App::receive_messages (cyclomatic 17) (crates/top/re_viewer/src/app/logic.rs)
• App::run_recording_command (cognitive 51) (crates/top/re_viewer/src/app/command_handling.rs)
• App::run_recording_command (cyclomatic 35) (crates/top/re_viewer/src/app/command_handling.rs)
• App::run_system_command (cognitive 133) (crates/top/re_viewer/src/app/command_handling.rs)
• App::run_system_command (cyclomatic 97) (crates/top/re_viewer/src/app/command_handling.rs)
• App::run_ui_command (cognitive 37) (crates/top/re_viewer/src/app/command_handling.rs)
• App::run_ui_command (cyclomatic 59) (crates/top/re_viewer/src/app/command_handling.rs)
• App::ui (cognitive 54) (crates/top/re_viewer/src/app/mod.rs)
• …and 1985 more

• 144 commits — 119 feature/other, 25 fixes

• crates/store — 26 commits
• (root) — 16 commits
• crates/viewer_support — 13 commits
• crates/top — 12 commits
• crates/data_flow — 11 commits
• tests/rust — 11 commits
• crates/views — 9 commits
• crates/utils — 7 commits
• crates/store_app — 6 commits
• docs/content — 6 commits
• crates/viewer — 4 commits
• .github/workflows — 3 commits
• crates/panels — 3 commits
• examples/python — 2 commits
• rerun_py/src — 2 commits
• skills/rerun-dataset-conversion — 2 commits
• skills/rerun-lerobot — 2 commits
• crates/tests — 1 commit
• docs/snippets — 1 commit
• examples/rust — 1 commit

• fix: Clarify and fix Chunk::taken() test
• fix: Fix H.264 views stuck on a loading spinner on machines with many cores
• fix: Fix URL in rerun analytics details
• fix: Fix assets with old server
• fix: Fix dataframe UI warning bug
• fix: Fix dependabot resolution: ignore torch and setuptools due to lerobot version limits
• fix: Fix drift in the docs
• fix: Fix fetching of instance poses
• fix: Fix flaky refused_asset_registration snapshot
• fix: Fix four dependency risks found during weekly audit
• fix: Fix idle agent connections spinning at 100% CPU (futures 0.3.34)
• fix: Fix incorrect handling of "infinity" bounds when panning
• fix: Fix integration test kittest races
• fix: Fix missing component warnings on state view
• fix: Fix non-deterministic crate diagram
• fix: Fix sampling inaccuracies on segmentation images
• fix: Fix showing error for temporarily missing data
• fix: Fix stale docs on component mapping and table blueprints
• fix: Fix the published skill name (add rerun- prefix)
• fix: Fix time series plots of Float32 scalars logged under the native Scalars descriptor
• …and 124 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

rerun-io/rerun was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.