Skip to content
CAI
Software that uses CAICheck a score

microsoft/windows-rs

55.8

Adequate · 14 November 2026

2010.8k

lines of production code

Rust

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add IReference\<T\> support for boxing WinRT value types

The \windows-reference\ crate now provides the \IReference\<T\>\ type, allowing Rust values to be boxed into WinRT-compatible reference types for passing as optional or boxed parameters to Windows APIs. This includes a stock implementation that automatically handles type detection and value extraction for primitive types, strings, GUIDs, and time-related types via the new \windows-time\ crate.

crates/libs/reference/src · high confidence

Add WebView2 binding generation tool

A new tool in \crates/tools/webview\ generates Rust bindings for the WebView2 SDK. It downloads the pinned WebView2 headers, processes them through the internal clang and reader pipeline, and outputs the final bindings to \crates/libs/webview/src/bindings.rs\.

crates/tools/webview · high confidence

Add Windows App SDK runtime assets for the Windows Reactor

The \windows-reactor-setup\ helper crate now includes the necessary runtime assets to support the Windows App SDK. This adds an \app.manifest\ file declaring COM classes, WinRT activatable classes, and proxy/stub DLLs required by the SDK, along with a \runtime.txt\ listing the specific native DLLs and language packs bundled with the application. These changes enable the Windows Reactor to function correctly on Windows by providing the underlying UI and input infrastructure.

crates/libs/reactor-setup/assets · high confidence

Add Windows Composition crate with documentation and license files

The \crates/libs/composition\ directory now contains the \windows-composition\ crate, which wraps the retained-mode Windows composition engine for standalone windows and WinUI 3 applications. This addition includes the Apache-2.0 and MIT license files, along with a README that documents the crate's features (\system\ and \reactor\) and provides usage examples for creating visual elements like sprites and brushes.

crates/libs/composition · high confidence

Add Windows UI Animation library bindings

The \crates/libs/animation\ crate now provides a Rust interface to the Windows UI Animation API. This adds a \Manager\ for coordinating animation state, \Variable\ and \Storyboard\ types for defining and sequencing transitions, and a \TransitionLibrary\ for creating standard effects like linear, instantaneous, and accelerate-decelerate animations. These bindings allow applications to schedule and manage complex animations on Windows.

crates/libs/animation/src · high confidence

Add Windows WebView2 crate with Apache-2.0 and MIT licenses

The \crates/libs/webview\ directory now contains the \windows-webview\ crate, which wraps the WebView2 COM APIs to host Microsoft Edge (Chromium) in a window. This addition includes the Apache-2.0 and MIT license files and a README detailing usage with \windows-window\ or Reactor frameworks. Users can now integrate WebView2 into their Windows applications by adding the \windows-webview\ dependency and enabling features like \system\ or \reactor\.

crates/libs/webview · high confidence

Add Windows.AI.Actions and Windows.AI.Agents bindings

New bindings are now available for the Windows.AI.Actions.Hosting and Windows.AI.Actions.Provider namespaces, exposing classes like ActionCatalog and ActionDefinition for managing AI actions, as well as interfaces like IActionProvider and IActionFeedbackHandler for implementing action providers. Additionally, bindings for the Windows.AI.Agents.Mcp namespace are included, providing experimental interfaces such as IMcpMessageFilterExperimental and IMcpMessageFilterResponseExperimental to support message filtering in AI agent scenarios.

crates/libs/windows/src/Windows · high confidence

Add clang pin validation tool

Introduces a new CLI tool in \crates/tools/clang\ that validates the pinned libclang version used by the generator helpers. The tool ensures that the loaded \libclang.dll\ matches the expected version constant, preventing silent drift between the DLL and clang builtin resource headers during metadata generation. It supports a \path\ argument to output the directory of the pinned DLL and verifies the pin by loading the library and asserting its version.

crates/tools/clang · high confidence

Add core type definitions and string literal macros

The \sys\ crate now exposes fundamental Windows types such as \BOOL\, \HRESULT\, \GUID\, and string pointers (\PCSTR\, \PCWSTR\, \BSTR\) in its core module, along with vtable structures for \IUnknown\ and \IInspectable\. Additionally, new \s!\ and \w!\ macros are provided to create null-terminated UTF-8 and UTF-16 string literals at compile time, simplifying the creation of C-compatible string arguments.

crates/libs/sys/src/core · high confidence

Add cppwinrt crate for C++/WinRT compiler in Rust

The new \cppwinrt\ crate bundles the C++/WinRT compiler for use in Rust projects. Users can now add \cppwinrt\ as a dependency in their \Cargo.toml\ and invoke the compiler via the \cppwinrt\ function. The crate includes Apache 2.0 and MIT license files and provides a README with getting started instructions.

crates/libs/cppwinrt · high confidence

Add feature search page for Windows APIs

A new tool generates a static, self-contained HTML page at \web/features\ that allows users to search for Windows APIs and see which Cargo features are required. The tool reads Windows metadata (\.winmd\ files), indexes types, functions, and constants by namespace, and calculates the specific feature flags needed for each API based on its signature, ensuring the generated page works offline and reflects the actual feature taxonomy of the \windows\ and \windows-sys\ crates.

crates/tools/features/src, web · high confidence

Add kernel-mode WDK scrape to Win32 metadata generation

The \crates/tools/win32\ generator now includes a new kernel-mode (KM) scraping phase (\km.rs\) that runs alongside the existing user-mode (UM) scrape. This phase parses specific WDK headers (\ntifs.h\, \wdm.h\, \offreg.h\) using a pinned WDK version (\10.0.28000.1839\) and merges the resulting kernel-mode APIs into the same \Windows.Win32\ namespace as the user-mode APIs. To support this, the tool now handles kernel-specific requirements, including arch-define macros, import library resolution for kernel symbols, and a new SAL capture shim (\sal.h\) to ensure annotation data is preserved during parsing.

crates/tools/win32 · high confidence

Add windows-reference crate for IReference\<T\> support

The new windows-reference crate is now available, providing an implementation of IReference\<T\> for boxed Windows values. Users can add it as a dependency (version 0.100) and use it to create and access reference-wrapped values, such as IReference\<i32\>.

crates/libs/reference · high confidence

Add windows-registry crate with Apache-2.0 and MIT license files and README

The \crates/libs/registry\ location now includes the \windows-registry\ crate, providing a library for reading and writing the Windows registry. This change introduces the Apache-2.0 and MIT license text files and a README that documents the crate's purpose and provides a usage example for integrating it via Cargo.

crates/libs/clang, crates/libs/registry · high confidence

Add windows-result crate with Apache-2.0 and MIT licensing

The new \windows-result\ crate is introduced to provide Windows error types for Win32, COM, and WinRT APIs, including \HRESULT\, \Error\, and specialized \Result\ types. The crate is dual-licensed under Apache-2.0 and MIT, with corresponding license files added to the repository. A \readme.md\ file documents the crate's purpose and provides usage examples, while a \windows-result.natvis\ file is included to enhance debugging experiences in Visual Studio by defining custom visualizers for error types.

crates/libs/result · high confidence

Add windows-strings crate with documentation and debugging support

The \windows-strings\ crate is introduced, providing Windows string types and literals such as \PCSTR\, \PCWSTR\, \BSTR\, and \HSTRING\. This change includes the crate's \README\ with usage examples, standard Apache-2.0 and MIT license files, and a \.natvis\ file to enable visual debugging of these string types in Visual Studio.

crates/libs/strings · high confidence

Add windows-time crate for TimeSpan and DateTime types

The \windows-time\ crate is now available, providing \TimeSpan\ and \DateTime\ types with Rust constructors, arithmetic operations, and conversions to \std::time\. Users can add \windows-time\ as a dependency to work with Windows-style time values (100-nanosecond ticks) directly in Rust.

crates/libs/time · high confidence

Add windows-time crate for idiomatic TimeSpan and DateTime handling

Introduces the new \windows-time\ crate, providing idiomatic Rust wrappers for Windows time types. It includes \DateTime\ for managing UTC timestamps with conversions to local time and Unix epoch compatibility, and \TimeSpan\ for representing durations with arithmetic operations and unit conversions (microseconds, milliseconds, seconds, etc.).

crates/libs/time/src · high confidence

Add windows-version crate for detecting Windows OS versions

The new windows-version crate allows applications to read the current Windows version without relying on the application manifest. Users can add it as a dependency and use the OsVersion API to check the current OS, determine if the system is a Windows Server release, or compare the version against specific build numbers to enable version-specific features.

crates/libs/version · high confidence

Add windows-version crate for querying OS details

The new \windows-version\ crate provides APIs to inspect the current Windows operating system. Users can retrieve the OS version (major, minor, build, service pack) via \OsVersion::current()\, determine if the system is a server edition with \is\_server()\, and query the specific revision number via \revision()\. The crate links against \advapi32.dll\ and \ntdll.dll\ to perform these queries.

crates/libs/version/src · high confidence

Added clippy\_all tool to run clippy checks on all crates individually

A new tool located at crates/tools/clippy\_all has been added to the repository. This utility iterates through all crates in the 'crates' directory and runs 'cargo clippy --all-targets' on each one individually, reporting any failures and exiting with an error code if any crate fails the lint checks.

_crates/tools/clippy\all · high confidence

Added composition binding generator tool

The \tool-composition\ utility now generates Rust bindings for both the Windows.UI.Composition system stack and the Microsoft.UI.Composition lifted stack. It uses a single filter file (\composition.txt\) to define the public surface, automatically deriving the lifted bindings by excluding system-only regions (such as standalone HWND hosting) and rewriting namespaces to their Microsoft equivalents. The tool also processes interop declarations from \interop.rdl\ to support Direct2D canvas bridging.

crates/tools/composition · high confidence

Added core library documentation, license files, and debugger visualizers

The \crates/libs/core\ location now includes a \readme.md\ providing usage examples for \windows-core\ (including \HSTRING\ and \HRESULT\ handling), standard Apache-2.0 and MIT license files, and a \windows-core.natvis\ file that enhances debugging by displaying \Array\ length and \RefCount\ values in the debugger.

crates/libs/core · high confidence

Added license files and README for windows-bindgen

The \crates/libs/bindgen\ location now includes the Apache-2.0 and MIT license texts (\license-apache-2.0\, \license-mit\) and a \readme.md\ file. The README provides getting-started instructions for using the \windows-bindgen\ crate as a build dependency to generate Rust bindings from Windows metadata, including example \Cargo.toml\ configuration and \build.rs\ usage.

crates/libs/bindgen · high confidence

Added license files and documentation for the windows-sys crate

The \crates/libs/sys\ location now includes the Apache-2.0 and MIT license texts, a \readme.md\ providing usage instructions for the \windows-sys\ crate, and a \rustfmt.toml\ configuration file. This establishes the licensing and documentation foundation for the raw Windows API declarations provided by this crate.

crates/libs/sys · high confidence

Added license files and updated documentation for the windows crate

The windows crate now includes explicit Apache-2.0 and MIT license files, clarifying the licensing terms for users. Additionally, a new README has been added that provides getting-started instructions and code examples for using the crate with Cargo.toml dependencies, and a rustfmt configuration file has been introduced to standardize code formatting with Unix newlines and an 800-character max width.

crates/libs/windows · high confidence

Added license tool to copy license files to library crates

A new license tool has been added to the repository. When executed, it scans the \crates/libs\ directory for subdirectories containing a \Cargo.toml\ file and copies the \license-mit\ and \license-apache-2.0\ files into each of those directories, ensuring consistent license file distribution across library crates.

crates/tools/license · high confidence

Added roundtrip validation tool for WinRT, Win32, and WDK metadata

A new \roundtrip\ tool has been added to validate that Windows metadata (WinRT, Win32, and WDK) can be accurately converted from RDL source files to compiled \.winmd\ binaries and back again without drift. The tool compiles committed RDL definitions into \.winmd\ files and then decompiles them back into RDL, using \git diff\ to detect any changes in the generated output. This ensures that the metadata definitions remain consistent with the compiled binaries, catching any lossy transformations or structural changes during the build process.

crates/tools/roundtrip · high confidence

Automated CI workflow generation for documentation, MSRV, and feature flags

The \crates/tools/yml\ tool now automatically generates three GitHub Actions workflows: \.github/workflows/doc.yml\ for building API documentation, \.github/workflows/msrv.yml\ (and its Windows variant) for verifying compatibility with the Minimum Supported Rust Version, and \.github/workflows/no-default-features.yml\ for checking builds with default features disabled. The tool scans library manifests to determine which crates to include, handling mutually exclusive feature stacks (such as \windows-composition\ and \windows-canvas\) by generating separate, specific check steps for each configuration.

crates/tools/yml · high confidence

Automated workspace dependency generation tool

A new utility in crates/tools/workspace now automatically generates the workspace Cargo.toml by reading crate metadata from crates/libs and writing dependency entries with default-features disabled. This tool ensures that all workspace crates are consistently listed in the root manifest, supporting the goal of enforcing workspace lints and improving dependency management.

crates/tools/workspace · high confidence

Expanded Win32 API bindings for access control, security, and app model

This update adds new generated bindings for several Win32 subsystems, enabling Rust code to interact with Windows access control, security descriptors, and application packaging. The \accctrl\ and \aclapi\ modules now expose types and functions for managing ACLs, trusties, and security descriptors (e.g., \SetEntriesInAcl\, \GetSecurityInfo\). New \amsi\ bindings provide access to the Antimalware Scan Interface for content scanning and UAC trust evaluation. The \appmodel\ module adds functions for querying and managing package dependencies, retrieving package information, and checking app policies. Additional modules include \activationregistration\ for COM activation scopes, \adshlp\ for Active Directory service bindings, \adtgen\ for audit event parameters, \afunix\ for Unix-domain socket support, and \amvideo\ for multimedia video information structures.

crates/libs/sys/src/Windows/Win32 · high confidence

Expose Win32 module in Windows crate

The \crates/libs/sys/src/Windows\ location now exposes the \Win32\ module, making Win32 APIs available for import within the \windows-sys\ crate.

crates/libs/sys/src/Windows · high confidence

Initial release of windows-reactor crate

The windows-reactor crate is now available as a declarative WinUI 3 library for Rust, allowing developers to build Windows UI applications using a Component/View model. This release includes the public API surface (documented in public-api.txt), Apache-2.0 and MIT license files, and documentation explaining how to add the dependency and use components like StackPanel and Button.

crates/libs/metadata, crates/libs/sys/src · high confidence

Initial release of windows-reactor declarative UI library

The \windows-reactor\ crate is introduced as a typed, declarative UI library for building native WinUI 3 applications in Rust. It provides a public API for defining components that own Rust state and describe views, supporting features such as window placement, theme-aware notification icons, and typed control builders. The release includes the Apache-2.0 and MIT license files and documentation for the library.

crates/libs/reactor · high confidence

Initial repository setup with dual licensing and Git configuration

The repository is initialized with the Apache 2.0 and MIT license texts, allowing users to choose their preferred license for the software. A .gitattributes file is added to enforce consistent line endings (LF) for text files and mark binary assets (such as .winmd, .dll, .exe, and images) as binary to prevent unwanted line-ending conversions. Additionally, a .gitignore file is introduced to exclude common build artifacts, IDE settings, and temporary files, while a rustfmt.toml configures the Rust formatter to use Unix-style newlines.

(repo-wide) · high confidence

Introduce RDL (Rust Definition Language) crate for Windows metadata representation

Adds the \windows-rdl\ crate, providing a new intermediate format and tooling for representing Windows metadata. This includes a reader and writer to convert between \.winmd\ files and the new \.rdl\ source format, utilities for emitting Rust code from metadata, and support for parsing COFF import libraries to map symbols to their exporting DLLs. The crate also introduces a command-line driver (\riddle\) and integrates with the \windows-clang\ scraper to generate RDL from C/C++ headers.

crates/libs/rdl/src · high confidence

Introduce RDL (Rust Definition Language) reader and encoder for Windows metadata

The \windows-rdl\ crate now includes a complete reader and encoder implementation located in \crates/libs/rdl/src/reader\. This adds support for parsing a new declarative syntax (RDL) and converting it into Windows metadata (\.winmd\) files. The reader handles a wide range of Windows-specific types and constructs, including WinRT classes, interfaces, delegates, callbacks, enums, structs, unions, constants, and free functions. It also supports advanced features such as GUID derivation, custom attributes, parameter attributes (\\#\[in\]\, \\#\[out\]\, \\#\[opt\]\), bitfields, and P/Invoke library mappings. This enables users to define Windows ABI types using a Rust-like syntax and generate standard metadata for interop.

crates/libs/rdl/src/reader · high confidence

Introduce Windows Reactor declarative UI framework

The \crates/libs/reactor/src\ directory now contains the core implementation of the Windows Reactor UI framework. This adds a new declarative component model where applications define state and views via the \Application\ trait, managing multiple keyed windows and system notification icons through \ApplicationContext\. The framework features a reconciliation engine (\reconcile.rs\) that generates mutations to update the native UI, a generated object model (\generated.rs\) covering standard Windows controls, and a validation layer (\ir.rs\) to enforce structural constraints. It also provides imperative element references (\reference.rs\) for direct control access and window management APIs (\window.rs\) for handling placement, sizing, and themes. Also in this area: Reactor simplifies feedback handling and coalesces redundant state reports; Fixes selection echo and adds IsOpen state tracking for InfoBar and TeachingTip; Fixes virtualization layout and adds collapsed title bar support; Radio buttons now fire Unchecked events and event callbacks are delivered to the subscription active when the event fired.

crates/libs/reactor/src · high confidence

Introduce \`windows-implement\` crate for COM interface implementation

The \windows-implement\ crate is introduced to provide the \\#\[implement\]\ proc macro, which allows Rust types to implement COM interfaces. This new crate contains the core logic for generating the necessary boilerplate, including the \Foo\_Impl\ struct, vtable constants, \IUnknown\ implementation, and trait conversions, effectively separating the implementation generation logic from the rest of the \windows\ crate ecosystem.

crates/libs/implement/src · high confidence

Introduce \`windows-rdl\` writer for generating RDL from Windows metadata

The \windows-rdl\ crate now includes a writer that converts \.winmd\ metadata files into RDL (Rust Definition Language) source code. This new capability allows users to generate Rust definitions for WinRT classes, interfaces, delegates, enums, structs, and Win32 functions directly from metadata. The writer supports features such as GUID attributes, architecture-specific filtering, custom attributes, and property/event shorthand syntax for WinRT interfaces, while handling nested types and packing/alignment attributes for structs.

crates/libs/rdl/src/writer · high confidence

Introduce cppwinrt crate for invoking the C++/WinRT compiler

A new \cppwinrt\ crate has been added, providing a Rust API to invoke the \cppwinrt.exe\ compiler binary. The library embeds the compiler executable and uses a unique temporary path (generated via \CoCreateGuid\) for execution. It exposes a \cppwinrt\ function that accepts arguments, runs the compiler, and returns the standard output; on failure, it panics with the compiler's error output. The crate includes bindings for \ole32.dll\ to support unique path generation and contains tests verifying the compiler version (2.0.250303.1) and error handling for invalid arguments.

crates/libs/cppwinrt/src · high confidence

Introduce dedicated WinMD reader module for metadata parsing

A new \winmd\ module has been added to the bindgen library to handle Windows Metadata (winmd) parsing. This module introduces a \Reader\ struct that consumes \windows\_metadata\ index data to build an internal type map, distinguishing between Windows Runtime types (classes, interfaces, structs, etc.) and C++/WinRT types (enums, delegates, interfaces, structs). It includes specific logic to detect and optionally project numeric types from \Windows.Foundation.Numerics\ and handles nested struct discovery. The module also provides extension traits for extracting type names and GUID attributes, serving as the foundational layer for subsequent binding generation.

crates/libs/bindgen/src/winmd · high confidence

Introduce dedicated \`bindgen\` crate for Windows bindings generation

The \crates/tools/bindings\ directory now contains a new \bindgen\ tool that generates Rust bindings for various Windows libraries. This tool uses configuration files (e.g., \animation.txt\, \canvas.txt\, \core.txt\) to specify output paths, filtering rules, and generation flags like \--flat\, \--minimal\, and \--dead-code\. The main entry point (\main.rs\) orchestrates the generation process for multiple crates including \collections\, \core\, \cppwinrt\, \future\, \metadata\, \numerics\, \reference\, \registry\, \result\, \strings\, \threading\, \time\, \services\, \canvas\, \animation\, \pickers\, \notifyicon\, and \window\. This centralizes the binding generation logic and allows for more controlled and modular generation of Windows API bindings.

crates/tools/bindings · high confidence

Introduce dedicated windows-threading crate with thread pool support

A new \windows-threading\ crate has been added to provide cross-platform threading capabilities on Windows. It exposes a \submit\ function to run closures on the default system thread pool, a \for\_each\ function for parallel iteration, and a \Pool\ struct for creating private thread pools with configurable thread limits. The \Pool\ implementation includes a \scope\ method that allows submitting closures with non-static lifetimes by ensuring all work completes before the scope exits, alongside standard \join\ and \drop\ semantics for cleanup.

crates/libs/threading/src · high confidence

Introduce incremental ECMA-335 metadata file writer

The metadata writer now supports building ECMA-335 metadata files incrementally in memory before serializing them into a complete binary stream. This change adds a new \file\ module containing components for managing strings, blobs, and metadata records, along with helpers for writing binary data and aligning PE headers to loader expectations. Users can now construct metadata structures programmatically and export them as valid Windows Runtime metadata files.

crates/libs/metadata/src/writer/file · high confidence

Introduce minimal Windows window creation and message loop

Added a new \window\ library crate that provides a minimal, builder-based API for creating top-level Windows windows and running a message loop. Users can now create windows with configurable titles, sizes, and styles, and register handlers for messages, resizing, moving, and closing events via the \WindowBuilder\. The crate exposes \run\, \run\_with\, \pump\, and \quit\ functions to manage the application's message loop, along with a \Window\ struct that exposes the raw \HWND\ for interop.

crates/libs/window/src · high confidence

A new \windows-link\ crate has been added to provide a \link!\ macro for importing external functions from dynamic libraries. The macro generates an \extern\ block and a corresponding function pointer type alias, with platform-specific behavior: on Windows x86, it uses \raw-dylib\ with \undecorated\ import names, while other platforms use standard linking. This enables users to resolve and call symbols (e.g., via \GetProcAddress\) at runtime with consistent type safety.

crates/libs/link/src · high confidence

Introduce the \`windows-registry\` crate for low-level Windows Registry access

A new \windows-registry\ library is added to provide a low-level, \no\_std\-compatible interface for interacting with the Windows Registry. This crate exposes a \Key\ struct for managing registry keys (including creation, opening, renaming, and deletion) and supports \OpenOptions\ for configuring access rights, transactional operations, and WOW64 registry redirection (32-bit/64-bit views). It includes comprehensive value handling via a \Value\ type and iterators (\KeyIterator\, \ValueIterator\) for enumerating keys and values, supporting all standard registry data types such as strings (\REG\_SZ\, \REG\_EXPAND\_SZ\, \REG\_MULTI\_SZ\), integers (\REG\_DWORD\, \REG\_QWORD\), and raw binary data (\REG\_BINARY\).

crates/libs/registry/src · high confidence

Introduce the windows-future crate for WinRT async interoperability

The new \windows-future\ crate provides a dedicated library for working with WinRT asynchronous operations (\IAsyncAction\, \IAsyncOperation\, and their progress-enabled variants). It introduces the \Async\ trait to abstract over these four types and implements it for all of them. The crate adds \join()\ and \when()\ methods to these interfaces, allowing users to synchronously wait for completion or register a callback to run when the operation finishes. Additionally, it implements \IntoFuture\ for these types, enabling them to be used directly with Rust's \async\/\await\ syntax via the \AsyncFuture\ adapter.

crates/libs/future/src · high confidence

Introduce the windows-strings crate with HSTRING, BSTR, and literal macros

The new \windows-strings\ crate provides a cross-platform, reference-counted \HSTRING\ type that uses the Windows process heap on Windows and the Rust global allocator elsewhere, ensuring interoperability with native APIs. It also includes a Windows-only \BSTR\ type for OLE Automation, a builder for preallocating \HSTRING\ values, and compile-time literal macros (\s!\, \w!\, \h!\) for creating null-terminated and length-prefixed strings. The crate exposes standard pointer types (\PCSTR\, \PCWSTR\, \PSTR\, \PWSTR\) and implements traits like \Debug\, \Display\, \Clone\, and \Deref\ for ergonomic string handling.

crates/libs/strings/src · high confidence

Introduce windows-core crate with foundational COM/WinRT types

The \windows-core\ crate is introduced in \crates/libs/core/src\, providing the foundational types and traits for COM and WinRT interop. This includes \AgileReference\ for cross-apartment object references, \Array\<T\>\ for WinRT array handling, \ComObject\<T\>\ for heap-allocated COM objects with reference counting, and \Event\<T\>\ for thread-safe event registration. It also adds \GUID\ generation and parsing, \IInspectable\ and \Interface\ traits, and declarative macro alternatives (\interface\_decl!\, \implement\_decl!\) for defining COM interfaces and implementations without proc-macro dependencies. Additional support includes \InRef\ for input parameters, \EventRevoker\ for automatic event unregistration, and \ComposeBase\ for COM aggregation.

crates/libs/core/src · high confidence

The new windows-link crate provides a \link\ macro that simplifies linking to dynamic libraries by leveraging \raw-dylib\, eliminating the need for separate import library files. Users can now import functions and their corresponding function-pointer types directly, allowing for easier runtime resolution of symbols from DLLs like kernel32 and user32.

crates/libs/link · high confidence

Introduce windows-result crate for Windows error handling

The \windows-result\ crate is added to provide a unified \Result\<T, Error\>\ type for Windows APIs. It introduces \HRESULT\, \BOOL\, \WIN32\_ERROR\, \NTSTATUS\, and \RPC\_STATUS\ types with ergonomic conversion methods (e.g., \.ok()\, \.unwrap()\) and integrates with Rust's standard \Error\ trait. The \Error\ type captures extended COM error information (like \IErrorInfo\) by default, but supports a \windows\_slim\_errors\ configuration to reduce size by omitting this data. It also includes bindings for necessary Win32/OLE functions and supports \no\_std\ environments.

crates/libs/result/src · high confidence

Introduces a dedicated Windows services library for building Windows services

A new \windows-services\ crate has been added to provide a high-level API for creating and managing Windows services. It exposes a \Service\ struct that allows developers to configure accepted commands (such as stop, pause, and resume), define custom fallback behavior for non-service contexts, and register callbacks to handle control events. The library handles the underlying Windows API interactions, including service status reporting and dispatcher management, simplifying the process of hosting applications as Windows services.

crates/libs/services/src · high confidence

Introduces metadata writer infrastructure for encoding and ID management

The metadata writer module now includes foundational components for handling metadata encoding and identifier management. New files define macros and enums for encoding specific metadata table codes (such as TypeDefOrRef, ResolutionScope, and HasAttribute) and establish a set of strongly-typed identifier structs (like MethodDef, Field, TypeRef) to manage references within the metadata structure.

crates/libs/metadata/src/writer · high confidence

Introduces the windows-numerics crate with 2D, 3D, and 4D vector and matrix types

The new \windows-numerics\ crate provides Rust implementations of \Vector2\, \Vector3\, \Vector4\, \Matrix3x2\, and \Matrix4x4\ structs, exposing them via \bindings.rs\ and re-exporting them in \lib.rs\. These types support standard arithmetic operations (addition, subtraction, multiplication, division, negation) and include utility methods such as \dot\, \cross\, \normalize\, \length\, and \distance\ for vectors, while the matrices provide transformation helpers like \translation\, \rotation\, \scale\, and \skew\. The implementation is safe (forbids unsafe code) and supports \no\_std\ environments, with certain trigonometric features gated behind the \std\ feature flag.

crates/libs/numerics/src · high confidence

Introduction of the windows-threading crate

The new \windows-threading\ crate is now available, providing a Rust wrapper around the Windows thread pool. Users can add it as a dependency to submit work to the default pool or process iterators in parallel using the \submit\ and \for\_each\ APIs. This release also includes the Apache-2.0 and MIT license files and documentation for the new crate.

(repo-wide) · high confidence

Introduction of windows-window crate for basic window management

The \windows-window\ crate is now available, providing foundational support for creating windows and running message loops for Canvas, WebView2, and custom rendering scenarios. Users can integrate this library (version 0.100) to instantiate windows with configurable client sizes, handle resize and close events, and retrieve the underlying HWND for use with other graphics or webview libraries.

crates/libs/window · high confidence

New Rust-based Clang binding generator for Windows headers

The \crates/libs/clang\ library has been introduced to replace the previous binding generation pipeline. It provides a Rust-native toolchain that parses C/C++ headers using libclang and emits Rust Definition Language (RDL) files. The library exposes a \Clang\ builder API for configuring inputs, namespaces, and filters, and an \extract\ function for the core parsing and constant-evaluation logic. It also includes \MetadataReferences\ to index WinMD files, allowing the generator to resolve types and exclude declarations that already exist in Windows Runtime or Win32 metadata.

crates/libs/clang/src · high confidence

New WebView2 integration library for Windows

The \crates/libs/webview\ crate introduces a new Rust library for hosting Microsoft WebView2 on Windows. It provides a high-level API to create and manage browser environments and controllers, allowing applications to embed web content in native windows. The library exposes comprehensive controls for navigation, cookie management, download handling, and permission requests, along with event handlers for page lifecycle events like navigation completion and script message reception.

crates/libs/webview/src · high confidence

New Windows Canvas and Reactor sample applications

Added a comprehensive suite of sample applications demonstrating the new \windows-canvas\ 2D graphics library and the \windows-reactor\ UI framework. These samples cover fundamental drawing operations (lines, shapes, text, gradients, bitmaps), interactive features (keyboard input, hit testing, pointer events), and advanced capabilities like on-demand canvas invalidation, animated canvases, and direct \CanvasImageSource\ integration. The collection also includes samples for Windows Animation storyboards, bindgen context alignment, and VSS backup, providing practical examples for building modern Windows desktop applications with Rust. Also in this area: 1 commit (0 fixes) modifying crates/libs/canvas, crates/libs/reactor, crates/samples; 3 commits (1 fix) modifying crates/samples.

crates/samples · medium confidence · unverified

New \`\#\[interface\]\` macro for defining COM and non-COM interfaces

The \crates/libs/interface\ crate introduces the \\#\[interface\]\ procedural macro, allowing users to define COM interfaces (with optional inheritance from \IUnknown\ or other interfaces) and non-COM scoped interfaces. When applied to a trait, it generates a wrapper struct, implements the \windows\core::Interface\ trait, and produces a vtable (\\\Vtbl\) with the necessary function pointers. For COM interfaces, it handles pointer adjustment for inheritance chains and generates a \matches\ function for \QueryInterface\ traversal. For non-COM interfaces, it generates a simpler vtable and constructor without \QueryInterface\ support. The macro also generates an \\\_Impl\ trait that implementors must satisfy to provide method bodies.

crates/libs/interface/src · high confidence

New \`windows-reactor-setup\` crate for self-contained Windows deployment

A new helper crate has been added to manage the deployment of Windows App SDK 2.5.1 and WebView2 1.0.4078.44 for self-contained applications. It downloads the required NuGet packages, extracts the runtime files and the WebView2 Core DLL, and modifies the app manifest to embed the necessary resources, ensuring the application runs without requiring system-wide installation of these dependencies.

crates/libs/reactor-setup/src · high confidence

New internal implementation module for core COM and WinRT primitives

The \crates/libs/core/src/imp\ module has been introduced to house low-level internal implementations for the \windows-core\ crate. This change adds support for agile references (\AgileSlot\), a factory caching system (\FactoryCache\), and a generic delegate box (\DelegateBox\) that provides shared COM reference counting and marshaling for generated WinRT delegates. It also includes a custom SHA-1 implementation for generating type signatures, atomic reference counting primitives, and a weak reference tear-off mechanism, all of which are required for the core COM/WinRT runtime support.

crates/libs/core/src/imp · high confidence

New metadata merging and namespace remapping capabilities

The \windows-metadata\ crate now includes a new \merge\ module that provides a \Merger\ builder for combining multiple \.winmd\ files into a single output. This tool supports architecture-tagged inputs and can union same-named enums across inputs to deduplicate members, which is useful for reconciling truncated definitions (e.g., \um\ vs \km\ headers). Additionally, a \Remapper\ component is introduced to rewrite flat metadata into header-based namespaces for package generation, allowing specific namespaces to be routed to different targets while preserving type references.

crates/libs/metadata/src/merge · high confidence

New metadata table reader implementations for assembly, attributes, and types

The \crates/libs/metadata/src/reader/tables\ module now includes concrete reader implementations for ECMA-335 metadata tables, including \AssemblyRef\, \Attribute\, \ClassLayout\, \Constant\, \Field\, \GenericParam\, \ImplMap\, \InterfaceImpl\, \MemberRef\, \MethodDef\, \MethodParam\, \Module\, \ModuleRef\, \NestedClass\, \TypeDef\, \TypeRef\, and \TypeSpec\. These additions enable the metadata reader to parse and expose detailed structural information such as attribute values, method parameter sequences and directions, type categories, and field constants, providing the foundational data structures required for deeper metadata analysis and code generation.

crates/libs/metadata/src/reader/tables · high confidence

New packaging tool to generate \`windows\` and \`windows-sys\` crates with header-based namespace partitioning

A new internal packaging tool (\crates/tools/package\) has been added to generate the published \windows\ and \windows-sys\ crates. This tool remaps the flat Win32/WDK metadata into a header-based namespace structure (e.g., \Windows.Win32.d2d\), allowing the generated crates to use per-header Cargo features and file layouts. It also copies the existing WinRT metadata alongside the remapped Win32 data, applying specific filters to exclude deprecated or preview namespaces from the final \windows\ crate output.

crates/tools/package · high confidence

New type-generation modules for C++ and WinRT bindings

The bindgen library now includes dedicated source modules for generating C++ and WinRT types, including classes, delegates, enums, functions, handles, interfaces, methods, and structs. These modules define the logic for emitting Rust representations of C++ constructs (such as function pointers, handles, and enums) and WinRT constructs (such as classes, interfaces, and delegates), handling configuration, code generation, and dependency tracking for these specific type categories.

crates/libs/bindgen/src/types · high confidence

New windows-animation crate for variable interpolation and storyboards

The \windows-animation\ crate is introduced to wrap the Windows Animation Manager (\IUIAnimationManager\), enabling variable interpolation, transitions, and storyboards without depending on a UI or rendering framework. The crate is licensed under Apache-2.0 and MIT, and users can integrate it by adding \windows-animation\ version \0.100\ to their \Cargo.toml\.

crates/libs/animation · high confidence

New windows-canvas 2D graphics library

Introduces a new 2D graphics library for Windows that wraps Direct2D, Direct3D 11, DXGI, and DirectWrite to provide GPU-accelerated rendering. The library exposes a \GpuDevice\ for managing hardware or WARP software rendering, a \DrawingSession\ for drawing primitives (lines, rectangles, ellipses, paths) and text, and support for loading and displaying bitmaps. It includes specific integrations for the \windows-composition\ API to draw into composition surfaces and for the \windows-reactor\ framework to host demand-driven or continuous canvas views within a UI tree, while also handling Direct2D device loss recovery.

crates/libs/canvas, crates/libs/canvas/src · high confidence

New windows-collections crate with stock WinRT collection implementations

The new \windows-collections\ crate provides stock (reference) implementations for key Windows Runtime collection interfaces, allowing Rust code to create and manipulate WinRT-compatible collections using standard Rust types. It includes mutable and read-only implementations for \IVector\<T\>\ and \IVectorView\<T\>\ (backed by \Vec\), as well as \IMap\<K, V\>\ and \IMapView\<K, V\>\ (backed by \BTreeMap\). Additionally, it offers observable variants (\IObservableVector\<T\>\ and \IObservableMap\<K, V\>\) that fire change events when items are added, removed, or modified. The crate also introduces a \BufferedIterator\ that optimizes iteration over \IIterable\ and \IIterator\ by batching element retrieval via \GetMany\, significantly reducing the overhead of repeated ABI virtual calls compared to element-by-element iteration.

crates/libs/collections/src · high confidence

New winrt tool for generating canonical WinRT metadata and RDL snapshots

A new \winrt\ tool has been added to \crates/tools/winrt\ to automate the generation of the canonical WinRT metadata (\Windows.winmd\) and human-readable RDL snapshots. The tool fetches the pinned \microsoft.windows.sdk.contracts\ NuGet package (version 10.0.28000.2270), merges the per-contract \.winmd\ files using the in-house \windows-metadata\ merger, and then decompiles the result into per-namespace RDL files in \metadata/winrt\. These RDL files serve as the committed source of truth, which are then recompiled back into the canonical \Windows.winmd\ in \crates/libs/default\, ensuring reproducible and reviewable metadata updates.

crates/tools/winrt · high confidence

Windows Reactor introduces native application lifecycle and transient menu support

The Windows Reactor library now includes native infrastructure for managing the application lifecycle and rendering transient menus. A new \app\_shim\ module intercepts the application launch event and installs XAML controls resources, while \bootstrap.rs\ handles the dynamic loading of the Windows App Runtime framework package, including a user-facing dialog to download it if missing. Additionally, a \transient\_menu\ component provides a window-less menu host using \DesktopWindowXamlSource\, allowing menus to follow the system theme and remain visible across callback updates.

crates/libs/reactor/src/native · high confidence

Windows notification area icon support added to Reactor

The Reactor library now includes native support for managing system tray (notification area) icons on Windows. This change introduces the necessary bindings to the Windows Shell API and implements logic to register, update, and remove icons, as well as handle user interactions like activation and context menu requests. Users on Windows will now have their application represented in the system tray with proper icon management and tooltip support.

crates/libs/reactor/src/native/notifyicon · high confidence

Behavioural changes

10 commits (1 fix) modifying crates/libs/pickers/src

A change to existing behaviour in crates/libs/pickers/src — 10 commits (1 fix), 9 files: “Preserve HRESULTs in native interface implementations (\#5299)”; “\windows-pickers\ (\#4900)”; “Fix minimal interface implementation generation (\#5300)”; and 7 more (refs \#5299, \#4900, \#5300, \#5233, \#5000, …).

crates/libs/pickers/src · medium confidence · unverified

10 commits (1 fix) modifying crates/libs/reactor/src/native/app

A change to existing behaviour in crates/libs/reactor/src/native/app — 10 commits (1 fix), 2 files: “Fix Reactor virtualization and add opt-in cast diagnostics (\#5201)”; “\windows-reactor\ preserve open menus across callback updates (\#5079)”; “\windows-reactor\ simplify notification dispatch and follow taskbar theme (\#5052)”; and 7 more (refs \#5201, \#5079, \#5052, \#5266, \#5046, …).

crates/libs/reactor/src/native/app · medium confidence · unverified

10 commits (1 fix) modifying crates/libs/reactor/src/reconcile

A change to existing behaviour in crates/libs/reactor/src/reconcile — 10 commits (1 fix), 9 files: “Harden Reactor property dependencies and feedback (\#5366)”; “Track native child order in the Reactor reconciler (\#5268)”; “Pair Reactor event callbacks with their values (\#5270)”; and 7 more (refs \#5366, \#5268, \#5270, \#5298, \#5275, …).

crates/libs/reactor/src/reconcile · medium confidence · unverified

12 commits (0 fixes) modifying metadata

A change to existing behaviour in metadata — 12 commits, 1 file: “Remove returned-pointer metadata (\#5290)”; “Remove nullable metadata (\#5291)”; “Support enum group and association header annotations (\#5297)”; and 9 more (refs \#5290, \#5291, \#5297, \#5278, \#5233, …).

metadata · medium confidence · unverified

14 commits (1 fix) modifying crates/tools/reactor-metadata/src

A change to existing behaviour in crates/tools/reactor-metadata/src — 14 commits (1 fix), 3 files: “Control InfoBar and TeachingTip open state (\#5211)”; “Update to Windows App SDK 2.6.4 (\#5228)”; “Keep dependency update guidance with the tools (\#5238)”; and 11 more (refs \#5211, \#5228, \#5238, \#5290, \#5233, …).

crates/tools/reactor-metadata/src · medium confidence · unverified

15 commits (1 fix) modifying crates/tools/helpers

A change to existing behaviour in crates/tools/helpers — 15 commits (1 fix), 3 files: “Add readme existence check to package validation (\#3787)”; “Adds Cargo package validation (\#3714)”; “Keep dependency update guidance with the tools (\#5238)”; and 12 more (refs \#3787, \#3714, \#5238, \#4733, \#5374, …).

crates/tools/helpers · medium confidence · unverified

16 commits (0 fixes) modifying crates/libs/text/src

A change to existing behaviour in crates/libs/text/src — 16 commits, 10 files: “Add glyph runs and decorations to windows-text (\#5334)”; “Sharper small glyphs and system rendering params in windows-text (\#5338)”; “Add windows-text crate (\#5321)”; and 13 more (refs \#5334, \#5338, \#5321, \#5331, \#5379, …).

crates/libs/text/src · medium confidence · unverified

17 commits (0 fixes) modifying crates/libs/reactor/src/test\_support

A change to existing behaviour in crates/libs/reactor/src/test\_support — 17 commits, 5 files: “Prune dormant Reactor native test support (\#5126)”; “Track native child order in the Reactor reconciler (\#5268)”; “Pair Reactor event callbacks with their values (\#5270)”; and 14 more (refs \#5126, \#5268, \#5270, \#5298, \#5032, …).

_crates/libs/reactor/src/test\support · medium confidence · unverified

19 commits (2 fixes) modifying crates/libs/clang/src/projection

A change to existing behaviour in crates/libs/clang/src/projection — 19 commits (2 fixs), 17 files: “Support explicit ordinal imports (\#5308)”; “Remove returned-pointer metadata (\#5290)”; “Remove nullable metadata (\#5291)”; and 16 more (refs \#5308, \#5290, \#5291, \#5260, \#5297, …).

crates/libs/clang/src/projection · medium confidence · unverified

21 commits (2 fixes) modifying metadata/wdk

A change to existing behaviour in metadata/wdk — 21 commits (2 fixs), 8 files: “\windows-clang\ fix value/fact planning (\#4960)”; “Remove returned-pointer metadata (\#5290)”; “Remove nullable metadata (\#5291)”; and 18 more (refs \#4960, \#5290, \#5291, \#5260, \#5278, …).

metadata/wdk · medium confidence · unverified

23 commits (2 fixes) modifying crates/libs/composition/src

A change to existing behaviour in crates/libs/composition/src — 23 commits (2 fixs), 13 files: “Fix delegate invocation borrows and validate metadata blobs (\#5348)”; “Preserve HRESULTs in native interface implementations (\#5299)”; “\metadata\ add \DispatcherQueue.h\ (\#4774)”; and 20 more (refs \#5348, \#5299, \#4774, \#5325, \#4721, …).

crates/libs/composition/src · medium confidence · unverified

3 commits (0 fixes) modifying crates/libs/clang/src/sal

A change to existing behaviour in crates/libs/clang/src/sal — 3 commits, 3 files: “Replace legacy header extraction with compiler-backed windows-clang (\#5233)”; “Replace NativeSal with a parameter incomplete marker (\#5282)”; “Don't mark parameters incomplete for static-analysis SAL (\#5283)” (refs \#5233, \#5282, \#5283).

crates/libs/clang/src/sal · medium confidence · unverified

38 commits (1 fix) modifying crates/libs/rdl

A change to existing behaviour in crates/libs/rdl — 38 commits (1 fix), 4 files: “Add (incomplete) new \windows-rdl\ crate (\#3861)”; “Trim documentation and fix stale guidance (\#5314)”; “\windows-default\ (\#4779)”; and 35 more (refs \#3861, \#5314, \#4779, \#5308, \#5237, …).

crates/libs/rdl · medium confidence · unverified

4 commits (0 fixes) modifying crates/libs/pickers

A change to existing behaviour in crates/libs/pickers — 4 commits, 3 files: “Consolidate crate documentation into READMEs (\#5237)”; “\windows-pickers\ (\#4900)”; “Prepare the next crate release versions (\#5316)”; and 1 more (refs \#5237, \#4900, \#5316, \#5354).

crates/libs/pickers · medium confidence · unverified

4 commits (1 fix) modifying crates/libs/reactor/src/native/winui/window

A change to existing behaviour in crates/libs/reactor/src/native/winui/window — 4 commits (1 fix), 2 files: “Fix Reactor TitleBar hit testing after content updates (\#5296)”; “Improve Reactor updates and Canvas rendering, with process monitor and Max CPU samples (\#5368)”; “Split large windows-reactor modules by concern (\#5241)”; and 1 more (refs \#5296, \#5368, \#5241, \#5351).

crates/libs/reactor/src/native/winui/window · medium confidence · unverified

46 commits (2 fixes) modifying crates/libs/default

A change to existing behaviour in crates/libs/default — 46 commits (2 fixs), 6 files: “\windows-clang\ hresult normalization (\#4906)”; “\windows-default\ (\#4779)”; “Preserve WinRT delegate instance signatures (\#5255)”; and 43 more (refs \#4906, \#4779, \#5255, \#5237, \#4900, …).

crates/libs/default · medium confidence · unverified

49 commits (0 fixes) modifying metadata/win32

A change to existing behaviour in metadata/win32 — 49 commits, 691 files: “\windows-clang\ hresult normalization (\#4906)”; “\windows-clang\ add \IDisplayInformationStaticsInterop\ (\#4754)”; “\windows-rdl\ make RDL\<-\>WINMD generation reproducible (\#4732)”; and 46 more (refs \#4906, \#4754, \#4732, \#4760, \#4700, …).

metadata/win32 · medium confidence · unverified

5 commits (1 fix) modifying crates/libs/reactor/src/test\_support/native

A change to existing behaviour in crates/libs/reactor/src/test\_support/native — 5 commits (1 fix), 1 file: “Fix Reactor virtualization and add opt-in cast diagnostics (\#5201)”; “Prune dormant Reactor native test support (\#5126)”; “\windows-reactor\ reduce public API and isolate test support (\#5032)”; and 2 more (refs \#5201, \#5126, \#5032, \#5245, \#5351).

_crates/libs/reactor/src/test\support/native · medium confidence · unverified

6 commits (0 fixes) modifying crates/tools/reactor-metadata/winmd

A change to existing behaviour in crates/tools/reactor-metadata/winmd — 6 commits, 27 files: “Update to Windows App SDK 2.6.4 (\#5228)”; “Remove returned-pointer metadata (\#5290)”; “Collapse pointer nullability to a single flag-free nullable attribute (\#5278)”; and 3 more (refs \#5228, \#5290, \#5278, \#5281, \#5000, …).

crates/tools/reactor-metadata/winmd · medium confidence · unverified

6 commits (1 fix) modifying crates/libs/clang-sys

A change to existing behaviour in crates/libs/clang-sys — 6 commits (1 fix), 9 files: “Consolidate crate documentation into READMEs (\#5237)”; “Support SetLastError and ImportLibrary header annotations (\#5295)”; “Replace legacy header extraction with compiler-backed windows-clang (\#5233)”; and 3 more (refs \#5237, \#5295, \#5233, \#5317, \#5305, …).

crates/libs/clang-sys · medium confidence · unverified

7 commits (0 fixes) modifying crates/libs/reactor/src/component

A change to existing behaviour in crates/libs/reactor/src/component — 7 commits, 10 files: “Expose current component input through context (\#5311)”; “Scope windows-reactor test internals to a hidden test module (\#5243)”; “Allow a component view to be another component (\#5342)”; and 4 more (refs \#5311, \#5243, \#5342, \#5368, \#5254, …).

crates/libs/reactor/src/component · medium confidence · unverified

8 commits (0 fixes) modifying crates/libs/implement

A change to existing behaviour in crates/libs/implement — 8 commits, 6 files: “Add readme existence check to package validation (\#3787)”; “Consolidate crate documentation into READMEs (\#5237)”; “Add license tool (\#2207)”; and 5 more (refs \#3787, \#5237, \#2207, \#4876, \#5185, …).

crates/libs/implement · medium confidence · unverified

8 commits (0 fixes) modifying crates/libs/reactor-setup

A change to existing behaviour in crates/libs/reactor-setup — 8 commits, 3 files: “Consolidate crate documentation into READMEs (\#5237)”; “\windows-reactor\ inline bootstrap for framework-dependent apps (\#4847)”; “Windows Reactor (second preview) (\#4848)”; and 5 more (refs \#5237, \#4847, \#4848, \#5109, \#4876, …).

crates/libs/reactor-setup · medium confidence · unverified

80 commits (9 fixes) modifying crates/libs/reactor/src/native/winui

A change to existing behaviour in crates/libs/reactor/src/native/winui — 80 commits (9 fixs), 13 files: “Control InfoBar and TeachingTip open state (\#5211)”; “Subscribe to WinUI events lazily in Reactor (\#5110)”; “Add WindowTitleBarHeight::Collapsed to windows-reactor (\#5205)”; and 77 more (refs \#5211, \#5110, \#5205, \#5160, \#4914, …).

crates/libs/reactor/src/native/winui · medium confidence · unverified

9 commits (0 fixes) modifying crates/libs/text

A change to existing behaviour in crates/libs/text — 9 commits, 3 files: “Add glyph runs and decorations to windows-text (\#5334)”; “Add windows-text crate (\#5321)”; “Add Interface::as\_interface and remove avoidable canvas overhead (\#5331)”; and 6 more (refs \#5334, \#5321, \#5331, \#5379, \#5347, …).

crates/libs/text · medium confidence · unverified

9 commits (0 fixes) modifying metadata/winrt

A change to existing behaviour in metadata/winrt — 9 commits, 344 files: “\windows-rdl\ make RDL\<-\>WINMD generation reproducible (\#4732)”; “Update Windows SDK to 10.0.28000.2957 (\#5310)”; “Replace legacy header extraction with compiler-backed windows-clang (\#5233)”; and 6 more (refs \#4732, \#5310, \#5233, \#5257, \#5303, …).

metadata/winrt · medium confidence · unverified

90 commits (9 fixes) modifying crates/tools/reactor

A change to existing behaviour in crates/tools/reactor — 90 commits (9 fixs), 5 files: “Trim Reactor binding filter and dead\_code allows (\#5247)”; “Control InfoBar and TeachingTip open state (\#5211)”; “Subscribe to WinUI events lazily in Reactor (\#5110)”; and 87 more (refs \#5247, \#5211, \#5110, \#5027, \#5205, …).

crates/tools/reactor · medium confidence · unverified

Introduce in-house ECMA-335 metadata parsing and model types

The \metadata\ crate now includes a new in-house implementation for parsing ECMA-335 (WinMD) metadata, replacing the previous reliance on the \windows-ecma335\ crate. This change introduces core data structures for representing types (\Type\), type names (\TypeName\), values (\Value\), and method signatures (\Signature\), along with definitions for CLR element type codes and assembly metadata attributes. It also provides utilities for merging WinMD files and remapping namespaces, enabling the \windows-bindgen\ tool to generate bindings directly from the Windows SDK using this internal metadata engine.

crates/libs/metadata/src · high confidence

Introduce new metadata reader implementation

The \crates/libs/metadata/src/reader\ module has been replaced with a new implementation that parses COM/ECMA-335 metadata files directly from disk. This new reader introduces an \Index\ structure that pre-builds type and item lookups, supports architecture-specific filtering, and expands Win32 \Apis\ classes into individual function and constant items for easier iteration. The change includes new modules for handling blob decoding, table row indexing, and type categorization, providing a more efficient and structured way to access metadata compared to the previous reader.

crates/libs/metadata/src/reader · high confidence

Refactor bindgen table handling to use extension traits and explicit reader context

The \crates/libs/bindgen/src/tables\ module has been restructured to replace static or implicit reader access with explicit \&Reader\ parameters in extension traits (\ConstantExt\, \FieldExt\, \InterfaceImplExt\, \MethodDefExt\, \TypeDefExt\). This change improves code clarity and testability by making the metadata reader dependency explicit in functions like \method\_signature\ and \underlying\_type\_ext\. The \MethodDefExt\ implementation now includes robust parameter handling, including \\#\[track\_caller\]\ for better error reporting and logic to correctly map sparse or out-of-order parameters based on sequence numbers. Additionally, \TypeDefExt\ adds specific logic to detect agile and async types via attributes and type names, ensuring accurate type classification during binding generation.

crates/libs/bindgen/src/tables · high confidence

Replace logos-based RDL formatter with proc\_macro2 TokenTree traversal

The RDL formatter in \crates/libs/rdl/src/formatter\ has been rewritten to use \proc\_macro2\ TokenTree traversal instead of the previous logos-based lexer. This change implements canonical indented formatting by directly parsing and traversing Rust token streams, handling attributes, punctuation, and nested groups to produce consistent output for RDL source files.

crates/libs/rdl/src/formatter · high confidence

Reworked windows-bindgen CLI and internal architecture

The \windows-bindgen\ tool has been refactored to use a new builder pattern and a unified filter parser, significantly changing how bindings are generated and configured. Users can now use the \windows\_bindgen::bindgen(args)\ function or the \builder()\ fluent API to configure generation via new flags like \--sys\ (for raw \windows-link\ dependencies), \--minimal\ (to drop class wrappers and handle ergonomics), \--implement\ (to scope implementation traits), and \--compose\ (for minimal-mode class composition). The filter syntax now supports method-level targeting (e.g., \Namespace.Type::Method\) and grouped paths, while output layouts can be set to \--flat\ (single file) or \--package\ (Cargo features per namespace). Internally, the tool now uses a \Config\ struct to manage state, a \Filter\ module for resolving type/method inclusion rules, and a \Derive\ system for adding custom traits to specific types.

crates/libs/bindgen/src · high confidence

Windows crate re-exports windows-core and includes platform-specific modules

The \windows\ crate now acts as a thin wrapper that re-exports the \windows\_core\ crate as \core\ and conditionally includes platform-specific module definitions via \include!("Windows/mod.rs")\. This change consolidates core functionality into the \windows-core\ crate while maintaining the \windows\ crate as the primary entry point for Windows API bindings, with documentation and standard library support controlled by feature flags.

crates/libs/windows/src · high confidence

Test coverage

1 commit adding/updating tests in crates/tests/libs/pickers; 10 commits adding/updating tests in crates/tests/libs/rdl/errors; 11 commits adding/updating tests in crates/tests/libs/windows; 13 commits adding/updating tests in crates/tests/interop; 13 commits adding/updating tests in crates/tests/libs/reference/src; 15 commits adding/updating tests in crates/tests/libs/bindgen/tests; 15 commits adding/updating tests in crates/tests/libs/text; 19 commits adding/updating tests in crates/tests/libs/rdl/input; 21 commits adding/updating tests in crates/tests/libs/clang/input; 21 commits adding/updating tests in crates/tests/libs/clang/tests; 24 commits adding/updating tests in crates/tests/libs/canvas; 29 commits adding/updating tests in crates/tests/libs/bindgen/src; 3 commits adding/updating tests in crates/tests/libs/clang-sys; 39 commits adding/updating tests in crates/tests/libs/metadata; 43 commits adding/updating tests in crates/tests/libs/rdl/tests; 5 commits adding/updating tests in crates/tests/libs/reactor/src/drag; 50 commits adding/updating tests in crates/tests/libs/bindgen/input; 56 commits adding/updating tests in crates/tests/libs/bindgen/expected; 6 commits adding/updating tests in crates/tests/libs/docs; 7 commits adding/updating tests in crates/tests/libs/clang/src; 8 commits adding/updating tests in crates/tests/libs/clang/input/fixtures; Added Linux-specific tests for COM interop and error handling; Added Reactor benchmark and live-input test harnesses; Added Reactor performance benchmark test suite; Added Windows-specific link tests for kernel32 and wldap32; Added compile-time size and alignment checks for Win32 metadata bindings; Added component tests for context, lifecycle, messaging, and windowing; Added comprehensive test coverage for the Reactor UI framework; Added comprehensive tests for the COM implement macro; Added dedicated test crate for windows-rdl; Added expected metadata test for Win32 slice generation; Added integration tests for the Windows Animation library; Added live WebView2 self-test harness; Added native Reactor test coverage for window observers, transient menus, and event queuing; Added no\_std compatibility tests for Windows crates; Added performance benchmarking tool for the Windows Reactor backend; Added test coverage for Windows core library components; Added test coverage for windows-collections stock implementations; Added test crate for the interface library; Added test infrastructure for Windows reference type ABI conformance; Added test suite for the windows-registry crate; Added test suite for windows-metadata library; Added tests for IReference and IPropertyValue stock implementation; Added tests for Windows Future library async operations; Added tests for Windows service lifecycle and command handling; Added tests for Windows string types and literals; Added tests for interface core library; Added tests for the Windows threading pool and utilities; Added tests for the interface macro; Added tests for the windowing library; Added tests for the windows\_time crate; Added tests for windows-composition library; Added tests for windows\_result error handling and type conversions; Added unit tests for COM object implementation and chaining; Added validation tests for Cargo package metadata; Added validation tests for Win32 metadata generation; Automated generation of Clang library tests from input fixtures; Automated test generation for bindgen RDL inputs; Expanded Reactor UI fixture test coverage; Expanded UI test coverage for Reactor controls and lifetimes; New Reactor test harness with native bindings and coverage tooling.

Dependencies

Windows-rs crates updated to version 0.100.0 with Rust 2024 edition

The windows-rs library and its associated crates (including windows-core, windows-sys, windows-bindgen, windows-reactor, and windows-canvas) have been updated to version 0.100.0. This release adopts the Rust 2024 edition and raises the minimum supported Rust version (MSRV) to 1.95 for most crates, with windows-link requiring 1.85 and windows-sys requiring 1.88. The workspace configuration has been updated to use resolver version 3, and dependency management has been centralized in the root Cargo.toml.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 53 → 56 (+3.2)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 91 → 85 (-5.5)
  • Architecture 95 → 95 (-0.0)
  • Maturity 60 → 66 (+5.6)
  • Readiness 42 → 41 (-1.3)
  • Security 48 → 62 (+13.3)

Resolved (5539)

  • Change coupling: winui.rs ↔ main.rs (crates/libs/reactor/src/test_support/native/winui.rs)
  • ClassTooLong: ComponentHost (crates/libs/reactor/src/component.rs)
  • ClassTooLong: ID3D11DeviceContext (crates/libs/windows/src/Windows/Win32/d3d11/mod.rs)
  • ClassTooLong: IDebugControl2_Vtbl (crates/libs/windows/src/Windows/Win32/dbgeng/mod.rs)
  • ClassTooLong: IDebugControl3 (crates/libs/windows/src/Windows/Win32/dbgeng/mod.rs)
  • ClassTooLong: IDebugControl3_Vtbl (crates/libs/windows/src/Windows/Win32/dbgeng/mod.rs)
  • ClassTooLong: IDebugControl4 (crates/libs/windows/src/Windows/Win32/dbgeng/mod.rs)
  • ClassTooLong: IDebugControl4_Vtbl (crates/libs/windows/src/Windows/Win32/dbgeng/mod.rs)
  • ClassTooLong: IDebugControl5 (crates/libs/windows/src/Windows/Win32/dbgeng/mod.rs)
  • ClassTooLong: IDebugControl5_Vtbl (crates/libs/windows/src/Windows/Win32/dbgeng/mod.rs)
  • ClassTooLong: IDebugControl6 (crates/libs/windows/src/Windows/Win32/dbgeng/mod.rs)
  • ClassTooLong: IDebugControl6_Vtbl (crates/libs/windows/src/Windows/Win32/dbgeng/mod.rs)
  • ClassTooLong: IDebugControl7 (crates/libs/windows/src/Windows/Win32/dbgeng/mod.rs)
  • ClassTooLong: IDebugControl7_Vtbl (crates/libs/windows/src/Windows/Win32/dbgeng/mod.rs)
  • ClassTooLong: IDebugControl_Vtbl (crates/libs/windows/src/Windows/Win32/dbgeng/mod.rs)
  • ClassTooLong: IDebugSymbols3 (crates/libs/windows/src/Windows/Win32/dbgeng/mod.rs)
  • ClassTooLong: IDebugSymbols4 (crates/libs/windows/src/Windows/Win32/dbgeng/mod.rs)
  • ClassTooLong: IDebugSymbols5 (crates/libs/windows/src/Windows/Win32/dbgeng/mod.rs)
  • ClassTooLong: IDebugSystemObjects2_Vtbl (crates/libs/windows/src/Windows/Win32/dbgeng/mod.rs)
  • ClassTooLong: IDebugSystemObjects3_Vtbl (crates/libs/windows/src/Windows/Win32/dbgeng/mod.rs)
  • …and 5519 more

New (540)

  • BitfieldBacking::write_typed_accessor (cognitive 40) (crates/libs/bindgen/src/types/cpp_struct.rs)
  • BitfieldBacking::write_typed_accessor (cyclomatic 24) (crates/libs/bindgen/src/types/cpp_struct.rs)
  • Capture::attribute (cyclomatic 25) (crates/libs/clang/src/capture/mod.rs)
  • Capture::constant_observation (cognitive 18) (crates/libs/clang/src/capture/values.rs)
  • Capture::constant_observation (cyclomatic 16) (crates/libs/clang/src/capture/values.rs)
  • Capture::constant_value (cognitive 17) (crates/libs/clang/src/capture/values.rs)
  • Capture::declaration_attributes (cognitive 31) (crates/libs/clang/src/capture/mod.rs)
  • Capture::declaration_attributes (cyclomatic 19) (crates/libs/clang/src/capture/mod.rs)
  • Capture::enum_observation (cognitive 17) (crates/libs/clang/src/capture/mod.rs)
  • Capture::observation (cognitive 123) (crates/libs/clang/src/capture/mod.rs)
  • Capture::observation (cyclomatic 50) (crates/libs/clang/src/capture/mod.rs)
  • Capture::parameter_comments (cognitive 32) (crates/libs/clang/src/capture/comments.rs)
  • Capture::parameter_comments (cyclomatic 23) (crates/libs/clang/src/capture/comments.rs)
  • Capture::record (cognitive 18) (crates/libs/clang/src/capture/mod.rs)
  • Capture::ty (cognitive 34) (crates/libs/clang/src/capture/mod.rs)
  • Capture::ty (cyclomatic 55) (crates/libs/clang/src/capture/mod.rs)
  • Change coupling: mod.rs ↔ main.rs (crates/libs/windows/src/Windows/Win32/mod.rs)
  • ClassTooLong: Capture (crates/libs/clang/src/capture/mod.rs)
  • ClassTooLong: CppStruct (crates/libs/bindgen/src/types/cpp_struct.rs)
  • ClassTooLong: ID3D11VideoContext_Vtbl (crates/libs/windows/src/Windows/Win32/d3d11/mod.rs)
  • …and 520 more

Changes since last survey

  • 126 commits — 108 feature/other, 18 fixes

By area

  • crates/libs — 78 commits
  • crates/tests — 17 commits
  • crates/samples — 14 commits
  • metadata/win32 — 10 commits
  • .github/workflows — 3 commits
  • crates/tools — 2 commits
  • .github/copilot-instructions.md — 1 commit
  • metadata/winrt — 1 commit

Notable commits

  • fix: Fix Cargo 1.100 build failures (#5374)
  • fix: Fix Reactor TitleBar hit testing after content updates (#5296)
  • fix: Fix Reactor row replacement crash (#5373)
  • fix: Fix Reactor runtime deployment for custom profiles (#5375)
  • fix: Fix WDK callback ABIs and simplify Win32 generation (#5260)
  • fix: Fix WinRT array return provenance and empty-array leaks (#5339)
  • fix: Fix buffer and scoped interface pointer provenance (#5242)
  • fix: Fix byte-backed bitmap decoding in Reactor (#5294)
  • fix: Fix delegate invocation borrows and validate metadata blobs (#5348)
  • fix: Fix macro capture and annotation reconciliation (#5305)
  • fix: Fix minimal interface implementation generation (#5300)
  • fix: Fix noexcept static member generation (#5244)
  • fix: Fix ownership leaks in direct and optional output parameters (#5344)
  • fix: Fix ownership leaks when replacing WinRT output values (#5341)
  • fix: Implement core::error::Error without std and fix slim errors warning (#5356)
  • fix: Reactor: fix ListView crash when moving and selecting an item with content (#5222)
  • fix: Simplify virtual sample loading and fix repeater counts (#5312)
  • fix: Trim documentation and fix stale guidance (#5314)
  • change: Add ClearType rasterization to windows-text (#5345)
  • change: Add Direct3D 11 glyph atlas sample for windows-text (#5347)
  • …and 106 more

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

Survey your own repository

microsoft/windows-rs 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.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 520097a3f3278259a293e3a2915f395f1e8c5fa5 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-e1a3b69fc8ee.