alvr-org/ALVR

ALVR is a virtual reality streaming system that transmits VR content from a PC to standalone headsets over a network. It functions as an OpenVR driver that captures and encodes video streams using hardware acceleration, then delivers them to Android-based clients via a custom protocol. The system includes a Rust-based dashboard for configuration and a launcher for installation, supporting advanced features like foveated rendering, body tracking, and cross-platform deployment on Windows and Linux.

18 changes.

The project underwent a comprehensive rebrand to ALVR and a major architectural shift from C++ and Visual Studio to a Rust-based codebase. This period involved removing legacy drivers, MATLAB integrations, and shared memory utilities while introducing new Rust crates for the launcher, dashboard, audio, and networking. The work focused on modernizing the build system with xtask, updating dependencies, and establishing a unified, type-safe configuration and session management layer.

18 changes.

This period focused on enabling headless Linux operation through a new Vulkan capture layer and Wayland DRM lease shim, while simultaneously rewriting the client and server components in Rust. The work also introduced a comprehensive schema-driven dashboard, a structured event system for telemetry, and standardized packet protocols to unify the streaming architecture.

14 changes.

This period focused on refactoring the server core and OpenVR driver into modular components while introducing hardware-accelerated video encoding for Linux and Windows. It also expanded client capabilities with new UI elements, OpenXR extension wrappers, and external tracking support, alongside improved setup tools for Android and cross-platform development.

The ALVR Vulkan layer now supports headless Linux environments by implementing the VK\_KHR\_display extension. This change adds a new 'ALVR display' virtual device that exposes display properties and modes based on the configured render width, height, and refresh rate. The layer intercepts surface creation and swapchain operations, routing them to a headless surface implementation so that applications can present frames without a physical monitor. This enables ALVR to function on headless Linux systems or in scenarios where standard X11/Wayland surfaces are unavailable.

_alvr/vulkan\layer/layer · high confidence

The ALVR server OpenVR driver has been reorganized into a new modular structure, introducing a dedicated \foveated\_encoding\ module that implements eye-tracked foveated rendering by filtering and aligning gaze-based center shifts for per-eye video encoding. The driver now supports expanded hardware emulation, including specific serial numbers and properties for Pico 4, Quest 1, Quest Pro, and PSVR2 Sense devices, as well as separate OpenVR hand trackers for VRChat. Additionally, the build system has been updated to integrate the OpenVR SDK v2.15.6 and support Intel VPL encoding on Windows, while common utilities for string conversion and exception handling have been consolidated into the \ALVR-common\ library.

_alvr/server\openvr · high confidence

The tracking module now includes dedicated sinks for exporting tracking data to external applications. A new BodyTrackingSink sends body joint positions via OSC to support VRChat body tracking and generic motion trackers. A FaceTrackingSink exports eye gaze and facial expression data via OSC or the VRC Face Tracking protocol. Additionally, a VMCSink publishes full body and hand tracking data via OSC to Unity-based applications using the VMC protocol.

_alvr/server\core/src/tracking · high confidence

The Vulkan WSI layer now supports a headless platform, allowing applications to create swapchains and present images without a physical display. This change introduces a new \wsi::headless\ implementation that provides surface capabilities, formats, and present modes (FIFO and FIFO\_RELAXED) for headless surfaces. It includes a \display\ component that generates VSync signals via a dedicated thread and a \swapchain\ implementation that exports image memory and semaphores as file descriptors over a Unix socket to a receiver. The \wsi\_factory\ registers the \VK\_KHR\_display\ extension as the headless platform, enabling this capability when the extension is requested.

_alvr/vulkan\layer/wsi · high confidence

A new mock client application has been added to the ALVR client suite, providing a standalone tool for testing and development. This utility simulates a VR headset connection by generating synthetic tracking data (head pose, orientation) and exposing a simple UI to adjust parameters like height, yaw, pitch, and frame timing. It allows developers to verify server-side behavior and client-core integration without requiring physical VR hardware.

_alvr/client\mock · high confidence

The \alvr/server\_openvr/cpp/shared\ directory now includes a comprehensive set of AMD AMF (Advanced Media Framework) common implementation files, such as \AMFFactory\, \AMFSTL\, \CPUCaps\, and \DataStream\ components. This change introduces the underlying C++ infrastructure required for the OpenVR server to interact with AMD hardware acceleration features, providing necessary memory management, CPU capability detection, and data stream handling.

_alvr/server\openvr/cpp/shared · high confidence

The \alvr/client\_openxr/src/extra\_extensions\ module now contains new in-tree Rust wrappers for several vendor-specific OpenXR extensions, enabling support for advanced tracking and passthrough features. These include body tracking for Meta (FB) and Bigscreen (BD) headsets, high-fidelity body tracking for Quest 3, motion and object tracking for Pico headsets, eye and lip tracking for Vive, facial simulation for Bigscreen, and passthrough layers for both Meta and HTC headsets. This change consolidates these extension implementations directly into the client codebase rather than relying on external or out-of-tree definitions.

_alvr/client\_openxr/src/extra\extensions · high confidence

The \alvr/system\_info\ crate now provides a dedicated Android implementation that retrieves device identifiers (manufacturer, model, device, product) and local IP address via JNI, enabling accurate platform detection for headsets like Quest, Pico, and VIVE. It also introduces batched permission requests for Android runtime permissions and a Wi-Fi lock mechanism to prevent streaming disruption during VR sessions.

_alvr/system\info · high confidence

Developers can now build ALVR for Linux and Windows targets directly from macOS using Docker containers. New Dockerfiles and build scripts (build-linux.sh, build-windows.sh) provide isolated environments that replicate CI dependencies, allowing full builds, cargo checks, and interactive debugging without polluting the host system. The Windows build specifically handles cross-compiling libvpl and uses clang-19 with the MSVC toolchain to ensure compatibility.

docker · high confidence

This change introduces the initial Flatpak packaging infrastructure for ALVR on Linux, enabling users to install and run the application as a Flatpak extension within Steam. The diff adds the necessary build manifests (defining the Freedesktop SDK 25.08 and Steam runtime), a desktop entry for the ALVR Launcher, and helper scripts to build, install, and configure the launcher (including ADB key support and XDG shortcut setup). This provides a standardized distribution method for Linux users to access ALVR through the Steam ecosystem.

alvr/xtask/flatpak · high confidence

This change adds the ALVR Vulkan capture layer, a new component designed to overcome SteamVR runtime limitations on Linux regarding software-based output devices. The layer intercepts Vulkan calls to add a display to physical device properties, allowing swapchain images to be shared with the ALVR server process. It is implemented as a C++ library compiled via a Rust build script, exposing an \ALVR\_Negotiate\ entry point to register with the Vulkan loader.

_alvr/vulkan\layer · high confidence

A new \alvr\_common\ crate has been added to the project to centralize shared functionality across the ALVR workspace. This library provides core primitives for VR interactions, including \Pose\, \Fov\, and \DeviceMotion\ structures with math operations, as well as a comprehensive input definition system for controller profiles (e.g., Quest, Vive, Pico) and device paths. It also introduces a structured logging system with debug groups, a sliding window average utility for metrics, C API bindings for interoperability, and connection result handling with retry logic.

alvr/common · high confidence

The ALVR filesystem module now provides a structured \Layout\ type that defines absolute paths for executables, configuration, logs, and platform-specific resources (such as Vulkan layers and firewall scripts on Linux). This change enables the application to resolve installation and data directories dynamically, supporting environment variable overrides on Linux for FHS compliance while maintaining a simpler root-based layout on other platforms.

alvr/filesystem · high confidence

The \alvr/packets\ crate has been created to centralize the serialization structures for the ALVR communication protocol. This change introduces specific data types for video streaming capabilities (including support for HDR, 10-bit encoding, and AV1), negotiated streaming configurations (handling resolution, refresh rates, and foveated encoding parameters), and control packets for both server-to-client (start stream, decoder config, keep-alive) and client-to-server (playspace sync, IDR request) interactions. This establishes the foundational message schema for the streaming connection.

alvr/packets · high confidence

The \alvr/gui\_common\ library now provides a centralized dark theme and reusable UI components for the application. The new \theme.rs\ module defines a consistent dark visual style with specific accent colors, rounded corners, and adjusted spacing, while also configuring the UI to always use the dark theme preference. Additionally, \lib.rs\ exposes basic components and utility structs like \DisplayString\ to standardize UI elements across the dashboard.

_alvr/gui\common/src · high confidence

The ALVR server now exposes a comprehensive, structured event system that broadcasts real-time telemetry, tracking data, and system status to connected clients. This new capability includes detailed video and network statistics (such as latency breakdowns, throughput, and bitrate directives), precise head and hand tracking data (including bone positions and face tracking), controller button states, haptic feedback details, and ADB progress updates. By standardizing these outputs into serializable event types, the server provides a richer, more consistent data stream for dashboard visualization and external monitoring tools.

alvr/events · high confidence

The project now uses a dedicated Rust-based build tool (xtask) to manage compilation, dependency preparation, and release packaging. This replaces previous build scripts with a unified CLI that supports building the server (streamer), launcher, and client libraries across Windows, Linux, macOS, and Android. It handles downloading and compiling external dependencies like FFmpeg and x264, manages OpenXR loader selection for different stores (Meta, Pico), and generates third-party license reports for distribution packages.

alvr/xtask · high confidence

On Linux, the vrcompositor wrapper now builds and loads a new \alvr\_drm\_lease\_shim.so\ library (via \build.rs\ and \drm-lease-shim.cpp\) that intercepts Wayland DRM lease protocol calls to enable screen sharing/VR sessions under Wayland. The Rust entry point (\src/main.rs\) sets up Vulkan layer paths, disables conflicting Vulkan layers, and preloads the DRM lease shim when a Wayland display is detected before launching the original SteamVR compositor.

_alvr/vrcompositor\wrapper · high confidence

The ALVR setup process now includes dedicated scripts and configuration files to automatically manage firewall rules on Linux systems. This adds support for three firewall backends: firewalld (with a new service definition for ports 9943-9944), UFW (with an application profile), and raw iptables (creating rules and persisting them to /etc/iptables/rules.v4). These changes ensure that the necessary network ports for streaming VR games are opened correctly during installation or setup.

alvr/xtask/firewall · high confidence

This change introduces a new ADB module that handles the installation of Android platform tools, manages device connections, and configures port forwarding for wired ALVR clients. It automatically downloads the latest platform-tools, detects connected Android devices, and forwards the necessary control and stream ports. Additionally, it supports automatic client launching with a configurable boot delay and identifies the correct client package based on the selected flavor (Store, GitHub Stable, or GitHub Dev).

alvr/adb · high confidence

The launcher has been rewritten in Rust using the egui framework, replacing the previous implementation. This new launcher provides a native UI for managing ALVR installations, including fetching release information from GitHub (both stable and nightly channels), installing the server and Android client APKs, and handling updates. It introduces a worker thread model for background tasks like downloads and ADB operations, and includes specific fixes for Steam Deck compatibility (scaling) and Windows-specific behaviors (session file copying, icon handling).

alvr/launcher · high confidence

The dashboard UI has been replaced with a new implementation built on egui, introducing a redesigned layout with dedicated tabs for Settings, Devices, Logs, Statistics, and Installation. Users can now manage trusted and new client devices, configure session presets (resolution, framerate, encoder, foveation, codec, audio, tracking), and view real-time performance graphs for latency, FPS, and bitrate. The Logs tab includes controls to copy, open the log directory, and clear entries, while also supporting the hiding of spammy events. A new Setup Wizard guides users through hardware/software requirements and firewall configuration, and a New Version Popup notifies users of updates with options to open the launcher or download it. The About tab displays the ALVR version and license, and a Debug tab provides developer tools for capturing frames and recording.

alvr/dashboard/src/dashboard/components · high confidence

The Linux server now uses a new C++ encoding architecture that supports hardware-accelerated video encoding via VAAPI (for Intel and AMD GPUs) and NvEnc (for NVIDIA GPUs), falling back to software x264 encoding when hardware encoders are unavailable or disabled. This change introduces a modular encoder pipeline that handles Vulkan frame conversion, hardware context management, and codec-specific settings (H.264, HEVC, AV1) while maintaining compatibility with existing foveated encoding and color correction features.

_alvr/server\openvr/cpp/platform/linux · high confidence

The \alvr/client\_core\ directory now contains a new Rust crate (\alvr\_client\_core\) that serves as the central engine for the ALVR client. This library exposes a C API (\c\_api.rs\) for external integration and manages the core streaming lifecycle, including connection negotiation, video decoding (using Android's MediaCodec on mobile), audio recording and playback, and statistics tracking. It replaces previous platform-specific implementations with a unified Rust backend, providing a stable interface for the XR runtime to control streaming, handle haptics, and receive video frames.

_alvr/client\core · high confidence

The dashboard has been rewritten in Rust using the egui framework, replacing the previous implementation. This new version introduces a dual-backend architecture: it runs as a native desktop application on Windows and Linux (handling local session management, logging, and SteamVR launching) and can also be compiled to WebAssembly for hosting in a browser via WebSocket communication. Key user-facing additions include a new version check popup, SteamVR launch toggle, Steam Deck display scaling workaround, and real-time logging integration.

alvr/dashboard/src · high confidence

The \alvr/audio\ crate has been introduced to centralize audio handling, providing a unified interface that delegates to platform-specific modules. On Linux, it integrates with PipeWire for both speaker and microphone streams, including logic to handle Flatpak environments and prevent audio packet buildup. On Windows, it leverages the Windows Audio Session API (WASAPI) and COM interfaces to manage device enumeration, mute control, and ID retrieval. The module also adds support for virtual microphone setups via Virtual Audio Cable (VAC), VB-Cable, and VoiceMeeter variants, allowing users to route game audio to their microphone for streaming or communication.

alvr/audio · high confidence

The application now includes a set of reusable UI components in the \basic\_components\ module. Users can now see a \button\_group\ widget for selecting from a list of options, a \modal\ dialog for displaying content with customizable buttons (OK, Cancel, Close, or custom text), and a \switch\ toggle for binary on/off states. These components provide a consistent look and feel for common interface patterns across the GUI.

_alvr/gui\_common/src/basic\components · high confidence

The dashboard has been replaced with a new tabbed UI (Devices, Statistics, Settings, Logs, Debug, About) built on egui. It introduces a Setup Wizard that opens automatically on first launch, a New Version Popup for updates, and a Notification Bar that displays log events. The interface manages server requests including session configuration, client connection lists, and SteamVR restart/shutdown actions, while also supporting ADB download progress and statistics graphs.

alvr/dashboard/src/dashboard · high confidence

A new \alvr/server\_io\ crate has been introduced to centralize functionality for data storage and system information retrieval, making it shared between the server and the dashboard executable. This module provides a \ServerSessionManager\ to handle session configuration loading, saving, and updates, including robust error handling for invalid session files. It also introduces platform-specific firewall management (using \netsh\ on Windows and a script on Linux) and utilities for managing OpenVR driver registrations and paths.

_alvr/server\io · high confidence

The dashboard now uses a new schema-driven system for key video settings, allowing users to select presets for resolution (Very Low to Extreme), preferred framerate (60–120Hz), codec (H264, HEVC, AV1), encoder quality (Speed, Balanced, Quality), and foveation. These presets automatically apply the correct underlying session settings and require a SteamVR restart when changed, with clear warnings about hardware support (e.g., AV1 requirements) and performance impacts.

_alvr/dashboard/src/dashboard/components/settings\controls/presets · high confidence

The OpenXR client implementation has been completely rewritten in Rust, replacing the previous codebase with a new modular structure. This change introduces a dedicated C API entry point for Android initialization, separates graphics handling (swapchains, HDR support, and composition layers) into its own module, and organizes input handling, lobby rendering, passthrough, and video streaming into distinct components. The new architecture supports advanced features such as clientside foveation, post-processing, and detailed interaction profiles for various headsets, while maintaining compatibility with existing streaming and tracking capabilities.

_alvr/client\openxr/src · high confidence

The Windows-specific OpenVR server implementation is now present in the codebase, providing the core components for video encoding, frame rendering, and foveated rendering on Windows. This includes the CEncoder class which manages the encoding pipeline (supporting AMF, NVENC, VPL, and software encoders), the FrameRender class for D3D11 texture handling and view projection, and the FFR class for foveated encoding. Additionally, the platform-specific crash handler and NVIDIA NVENC encoder wrappers are included to support hardware-accelerated encoding on Windows.

_alvr/server\openvr/cpp/platform/win32 · high confidence

The MATLAB interface for transmitting visual data to the virtual display headset has been removed. Specifically, the C++ source file \vr\_display.cpp\ (which handled MEX gateway functions and shared memory communication) and its associated test script \vr\_display\_test.m\ have been deleted from the repository. Users can no longer compile or run this specific MATLAB-to-headset pipeline.

MATLAB · high confidence

The shared library has removed the inter-process communication (IPC) synchronization primitives (IPCMutex, IPCEvent) and the system time utilities (SystemTime). This deletion eliminates the ability to synchronize data across processes via named mutexes/events and to retrieve high-resolution system time in ticks or seconds, which were previously used for coordinating shared memory state between the driver and host applications.

shared · high confidence

The \driver\_virtual\_display\ source code and its associated Visual Studio project file have been deleted from the repository. This removes the example OpenVR driver implementation that demonstrated the \IVRVirtualDisplay\ interface, including the logic for launching a separate remote display process, encoding frames via shared memory, and handling DirectX rendering for virtual display simulation.

_driver\_virtual\display · high confidence

The standalone \virtual\_display\ application and its associated Visual Studio project file have been removed from the codebase. This eliminates the legacy Windows desktop process that previously handled remote display presentation via a separate thread and Direct3D swap chain, simplifying the virtual display example by removing this unused component.

_virtual\display · high confidence

The \alvr/graphics\ module has been restructured into a dedicated crate containing three distinct rendering components: a lobby renderer that draws the virtual environment (grid floor and HUD), a staging renderer that handles OpenGL external texture imports for Android hardware buffers, and a stream renderer that composites the incoming video stream with support for sRGB correction, encoding gamma, foveated encoding, and upscaling. This change introduces new WGSL and GLSL shader resources and the corresponding Rust implementation files to manage these rendering tasks.

alvr/graphics · high confidence

The OpenVR server driver code in this location has been restructured from a monolithic implementation into distinct, modular C++ classes. The diff introduces dedicated source files for core subsystems: ChaperoneUpdater (managing play area and calibration), Controller (handling input, buttons, and hand skeletons), FakeViveTracker (emulating external trackers), HMD (managing the headset, encoding, and display), IDRScheduler (managing video stream keyframes), Logger (centralized logging), NalParsing (video stream parsing), Paths (input path definitions), PoseHistory (tracking state buffering), and TrackedDevice (the base class for all tracked entities). This refactoring organizes the driver's logic into specific responsibilities, improving maintainability and separation of concerns within the C++ layer.

_alvr/server\_openvr/cpp/alvr\server · high confidence

The server core logic has been reorganized into distinct modules (bitrate, connection, hand\_gestures, haptics, input\_mapping, sockets, statistics, web\_server) to improve maintainability. The web server implementation has been migrated to the Axum framework, which now handles the dashboard API and WebSocket event streaming. This change also introduces a new BitrateManager for dynamic encoder parameter adjustments based on network and decoder latency, and adds support for hand gesture recognition and refined haptic mapping.

_alvr/server\core/src · high confidence

This update applies a series of patches to the VAAPI encoder integration to enhance stability and flexibility on Linux. It fixes Vulkan-to-CUDA frame import issues for RGBx formats, forces global header generation for VAAPI codecs, and enables VUI parameters for HEVC encoding. Additionally, the encoder now supports dynamic bitrate and framerate adjustments during streaming, allows toggling of filler data, and introduces a specific alignment quirk for AMD Radeon HEVC encoders to ensure correct surface sizing.

alvr/xtask/patches · high confidence

The session configuration system has been rewritten in Rust, replacing the previous implementation. This change introduces a new \alvr/session\ crate that manages \SessionConfig\ (including server version, client connections, and streaming parameters) and \SessionSettings\ (the full UI settings tree). A build script now parses OpenVR driver headers to automatically generate type-safe mappings for OpenVR property keys, ensuring the application stays in sync with the SDK. The new settings schema supports advanced features like collapsible sections, GUI-specific metadata (sliders, button groups), and robust migration logic that extrapolates old JSON settings into the new structure to preserve user preferences across upgrades.

alvr/session · high confidence

The \alvr/sockets\ crate now provides a new synchronous socket abstraction layer, replacing previous asynchronous or mixed implementations. This change introduces dedicated \ControlSocket\ and \StreamSocket\ modules that handle TCP connection lifecycle, framing, and serialization using \bincode\. Users benefit from consistent timeout handling, configurable socket buffers, and DSCP/ToS network prioritization settings applied uniformly across control and streaming channels. The new architecture simplifies connection management by unifying client and server connection logic under a single \ProtoControlSocket\ interface, improving reliability and maintainability of the network stack.

alvr/sockets/src · high confidence

The SteamVR launcher now includes Linux-specific logic to improve startup reliability. It performs hardware checks to detect NVIDIA, AMD, and Intel GPUs, warning users if incompatible drivers (like AMDVLK or amdgpu-pro) are detected. It also automatically unblocks the ALVR driver in SteamVR settings if it was previously blocked by safe mode, and wraps the vrcompositor binary to ensure proper process management. Additionally, it unconditionally kills any lingering ADB processes before launch to prevent conflicts.

_alvr/dashboard/src/steamvr\launcher · high confidence

The Linux installation resources have been updated with a new alvr.desktop file to properly register the ALVR dashboard application in the system menu, including correct execution commands and icon references. Additionally, the VR driver manifest has been moved into the resources directory and its internal identifier has been changed from 'virtual\_display' to 'alvr\_server' to better reflect the component's role.

alvr/xtask/resources · high confidence

The settings controls module has been replaced with a new, schema-driven implementation that dynamically renders UI widgets based on the settings schema. This adds support for complex configuration types including arrays, vectors, and dictionaries (with add/remove/reorder capabilities), choice controls with dropdowns or button groups, optional settings, and collapsible sections. The new controls also feature real-time value editing for numbers and text, boolean toggles, and a consistent reset-to-default button on every field, ensuring the dashboard accurately reflects the full range of available configuration options.

_alvr/dashboard/src/dashboard/components/settings\controls · high confidence

The stream socket layer has been replaced with a new implementation that supports multiplexed communication over both TCP and UDP. This change introduces sharding for UDP packets to handle large payloads efficiently, enables TCP\_NODELAY for lower latency, and allows configurable socket buffer sizes. The new architecture uses a synchronous model with zero-copy buffer management and supports multiple concurrent streams via stream IDs, improving reliability and performance for audio and video streaming.

_alvr/sockets/src/stream\socket · high confidence

The project has been rebranded from 'Virtual Display' to 'ALVR' (Air Light VR), with the repository now serving as a fork of the original ALVR codebase. This change includes a comprehensive update to the README with new compatibility tables, installation guides, and donation links, alongside a shift to the MIT license. The repository structure has been reorganized: the old Visual Studio solution and driver installation scripts have been removed, replaced by a Rust-based toolchain (pinned to 1.97.1), a new \xtask\ build system, and an \openvr\ git submodule. Additionally, developer workflows are standardized with new \.clang-format\, \.editorconfig\, and \CONTRIBUTING.md\ files, while GitHub metadata is updated via \.gitattributes\ and \.gitignore\.

(repo-wide) · high confidence

The default configuration file for the virtual display driver has been removed. This eliminates the pre-configured settings for a virtual display device, including its serial number, model number, resolution (2160x1200), refresh rate (90Hz), and latency parameters, meaning users will no longer have these specific defaults applied automatically.

resources/settings · high confidence

The OpenVR driver headers have been updated from version 1.0.8 to 1.0.15. This change refreshes the underlying SDK definitions used by the driver, ensuring compatibility with the latest OpenVR specification and potentially exposing new API capabilities or fixes provided by Valve in the newer SDK release.

openvr · medium confidence

This update refreshes the project's dependency tree and build configuration for the 21.0.0-dev14 development cycle. Key changes include upgrading the Rust edition to 2024 and raising the Minimum Supported Rust Version (MSRV) to 1.92. Several core libraries have been updated to newer versions, including the graphics backend wgpu to 25, the UI framework egui to 0.35, and the HTTP client reqwest to 0.13. The server's web framework has been migrated to Axum 0.8, and the audio handling libraries cpal and rodio have been updated to 0.16 and 0.21 respectively. Additionally, the Android NDK dependency was bumped to version 0.9.

(dependencies) · high confidence

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

• CAI 65 → 66 (+0.8)
• Rubric changed (rubric-2026.09.9 → rubric-2026.09.17) — scores are not directly comparable.

• Code Health 77 → 78 (+0.5)
• Architecture 97 → 98 (+1.3)
• Maturity 61 → 61 (+0.1)
• Readiness 83 → 66 (-16.3)
• Security 56 → 63 (+6.6)
• Event Sourcing 100 → 100 (+0.0)
• Performance 100 (new)

• Change-coupling hub: connection.rs → builtin_schema.rs, hand_gestures.rs, props.rs (alvr/server_core/src/connection.rs)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Hotspot: alvr/client_openxr/src/stream.rs (alvr/client_openxr/src/stream.rs)
• Hotspot: alvr/server_core/src/c_api.rs (alvr/server_core/src/c_api.rs)
• InteractionContext::new (cognitive 17) (alvr/client_openxr/src/interaction.rs)
• Off-boarding risk: anonymized user #1

• Change coupling: connection.rs ↔ hand_gestures.rs (alvr/server_core/src/connection.rs)
• Change coupling: connection.rs ↔ props.rs (alvr/server_core/src/connection.rs)
• Change coupling: main.rs ↔ lib.rs (alvr/client_mock/src/main.rs)
• Duplicate intent between VideoStreamingCapabilities and ClientCapabilities. Both types contain nearly identical properties: default_view_resolution, max_view_resolution, refresh_rates, foveated_encoding, encoder_high_profile, encoder_10_bits, encoder_av1, prefer_10bit, preferred_encoding_gamma, prefer_hdr. VideoStreamingCapabilities is used in network packets, while ClientCapabilities is used in the core client context. This duplication increases maintenance burden and risk of desync.
• End-of-life runtime: Rust 1.97
• EyeTrackedFoveation::update (cognitive 41) (alvr/server_openvr/src/foveated_encoding.rs)
• EyeTrackedFoveation::update (cyclomatic 23) (alvr/server_openvr/src/foveated_encoding.rs)
• Inconsistent naming convention for C API conversions. Most pairs use 'to_capi_' and 'from_capi_' prefixes, but the module itself is named 'c_api'. While this is internally consistent within the module, it differs from common Rust FFI patterns (e.g., 'into_*'/'from_*' or 'to_*'/'from_*') and creates a slight cognitive load compared to standard library conventions. More critically, the existence of both AlvrFov (C API) and Fov (Primitives) with identical structures suggests a lack of a unified type system for cross-boundary data, forcing manual conversion functions for every primitive type.
• Medium vulnerability: RUSTSEC-2026-0285 (Cargo.lock)
• Off the main sequence: alvr_common
• Off the main sequence: alvr_filesystem
• Off the main sequence: alvr_packets
• Off the main sequence: alvr_session
• Off-boarding risk: anonymized user #1
• Outdated: anyhow
• Outdated: bytemuck
• Outdated: cc
• Outdated: chrono
• Outdated: encoding_rs_io
• Outdated: env_logger
• …and 21 more

• 6 commits — 2 feature/other, 4 fixes

• alvr/server_openvr — 3 commits
• alvr/audio — 1 commit
• alvr/client_core — 1 commit
• alvr/xtask — 1 commit

• fix: fix(android): batch startup permission requests (#3400)
• fix: fix(audio): correct 5.1 to stereo downmix channel map (#3403)
• fix: fix(ci): install cargo-msrv with locked dependencies (#3392)
• fix: fix(server_openvr): use AV1 bitrate properties instead of HEVC on AMF (#3401)
• change: feat(foveation): drive per-frame centers from headset eye tracking (#3394)
• change: feat(foveation): synchronize encoder-aligned centers per frame (#3388)

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

alvr-org/ALVR 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.