microsoft/windows-rs

This system is a comprehensive Rust toolchain and library ecosystem for interacting with the Windows operating system, providing safe bindings for Win32, WinRT, and the Windows Driver Kit. It includes infrastructure for generating these bindings from C/C++ headers and metadata, alongside a suite of libraries for core COM/WinRT interop, system services, and UI components like a 2D graphics canvas and a declarative UI framework. The project also bundles utilities for managing Windows App SDK deployment and embedding WebView2, enabling the creation of modern, self-contained Windows desktop applications in Rust.

50 changes.

This period established the foundational structure of the Windows-RS project, introducing a modular crate architecture with dedicated libraries for core types, error handling, string management, and COM/WinRT implementation. It involved building a custom metadata parsing engine and a flexible binding generation tool to replace external dependencies, while simultaneously expanding raw Win32 API coverage. The work was supported by comprehensive test suites and sample applications to validate the new interop capabilities and ensure cross-language compatibility.

108 changes.

This period focused on introducing the Windows Reactor UI framework, including its core engine, canvas graphics, window management, and WebView2 integration, alongside supporting crates for threading, collections, and numerics. It also established a comprehensive Rust-native metadata pipeline using RDL and Clang to generate bindings for Win32, WDK, and WinRT APIs, supported by extensive test coverage and tooling for workspace and packaging automation.

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

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

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

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

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

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

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

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

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

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

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

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

The \crates/libs/implement\ and \crates/libs/interface\ directories now include standard Apache-2.0 and MIT license files, along with \readme.md\ documentation files that describe the \\#\[implement\]\ and \\#\[interface\]\ macros and provide usage examples for integrating \windows-implement\ and \windows-interface\ into Rust projects.

crates/libs/implement, crates/libs/interface · high confidence

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

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

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

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

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

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

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

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

New \.rdl\ metadata files have been added to the \metadata/wdk\ directory, providing formal definitions for key Windows Driver Kit (WDK) headers. These files introduce structs, enums, constants, and extern functions for MCE (Machine Check Exception), NTDDK (NT Device Driver Kit), NTDEF (NT Definitions), NTIFS (NT IFS Kernel), NTNLS (NT National Language Support), OFFREG (Offline Registry), and WDM (Windows Driver Model). This enables the generation of bindings for low-level Windows kernel and driver APIs, including hardware error handling, file system filters, registry operations, and device driver interfaces.

metadata/wdk · high confidence

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

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

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

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

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

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

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

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

A new \windows-reactor-setup\ crate has been introduced to help developers stage the Windows App SDK runtime files required for building fully self-contained Windows applications. By adding this crate as a build dependency and calling \windows\_reactor\_setup::as\_self\_contained()\ in \build.rs\, users can ensure their applications include the necessary runtime components without requiring separate installation on the target machine.

crates/libs/reactor-setup · high confidence

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

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

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

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

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/reactor, crates/libs/sys/src · high confidence

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

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

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

This change adds the foundational implementation of the Windows Reactor UI framework within the \crates/libs/reactor/src\ directory. It introduces the core engine responsible for managing the component tree, reconciliation, and native element mounting, alongside a robust arena-based memory model for efficient node lifecycle management. The update also includes the application host layer, which handles window lifecycle, event pumping, and transient UI elements like menus, providing the runtime environment necessary for Reactor-based applications to execute on Windows.

crates/libs/reactor/src · high confidence

Added the \windows-pickers\ crate, providing \OpenFilePicker\, \SaveFilePicker\, and \FolderPicker\ components that wrap the Windows Common Item Dialog. These pickers allow users to select files, save files, or choose folders with support for file-type filters, known folder locations, and multi-selection. The library also includes a \reactor\ feature that enables queuing picker requests directly within a \windows-reactor\ component context.

crates/libs/pickers · high confidence

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

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

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

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

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

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

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

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

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

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

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

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-default\ crate embeds Windows Runtime (WINRT) and Windows API (WIN32) metadata directly as byte slices, eliminating the need to locate or distribute separate \.winmd\ files at build time. Users can now depend on \windows-default\ to access \WINRT\ and \WIN32\ metadata constants, simplifying the setup for build tools and applications that rely on these definitions.

crates/libs/default · 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

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

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

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

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

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

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

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

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

The \metadata/win32\ directory now includes hand-authored RDL (Rust Definition Language) files for several Win32 API sets, including access control (\accctrl\, \aclapi\), AMSI (\amsi\), app model (\appmodel\), and others. These files define the structs, enums, constants, and extern functions for these APIs, enabling the Windows crate to generate bindings for them. This adds support for interacting with Windows security descriptors, anti-malware scan interfaces, and application model policies.

metadata/win32 · high confidence

This update adds new RDL metadata definitions for several Windows Runtime namespaces, enabling language projections for newly exposed APIs. Specifically, it introduces the Windows.AI.Actions namespace (including ActionCatalog, ActionDefinition, and ActionRuntime classes) for managing AI-driven actions, the Windows.AI.Agents.Mcp namespace with experimental interfaces for filtering Model Context Protocol messages, and the Windows.AI.MachineLearning.Preview namespace which deprecates older preview interfaces in favor of the stable Windows.AI.MachineLearning APIs (such as LearningModel and LearningModelSession). Additionally, it adds metadata for the Windows.ApplicationModel.Activation namespace, defining the ActivatedEventsContract and expanding the ActivationKind enum to support new activation scenarios like WalletAction and ComponentUI.

metadata/winrt · high confidence

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.

crates/samples · high confidence

The \crates/libs/composition\ crate introduces a new Rust API for Windows Composition, enabling users to create and manage visual trees, animations, and graphics surfaces. It provides a \Compositor\ to create visuals (such as \SpriteVisual\ and \ShapeVisual\), brushes (like \CompositionColorBrush\ and \CompositionNineGridBrush\), and animations (including \ScalarKeyFrameAnimation\ and \Vector3KeyFrameAnimation\). The library supports scoped batches for tracking animation completion and offers two mutually exclusive backends via features: \system\ for direct desktop window hosting and \reactor\ for integration with a Reactor composition host. It also includes Direct2D surface interop for custom rendering.

crates/libs/composition/src · high confidence

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

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

Added a new \crates/tools/helpers\ library providing shared utilities for internal tooling. This includes automatic provisioning of a pinned libclang version (22.1.8) via NuGet packages, parsing of Cargo metadata (Crate, Package, Lints structs), and helper functions for reading Rust source constants and deriving SDK directory names.

crates/tools/helpers · high confidence

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

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

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

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

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

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

Introduces a new 2D graphics library for Windows that wraps Direct2D, Direct3D 11, DXGI, and DirectWrite. It provides a \GpuDevice\ for hardware or WARP software rendering, a \DrawingSession\ for drawing primitives (lines, rectangles, ellipses, paths), and \Bitmap\ support for loading images and reading back pixels. The library integrates with the UI stack via a \CanvasCompositionExt\ trait for drawing into \CompositionDrawingSurface\ and a Reactor integration (\Canvas\, \animated\_canvas\) that supports both continuous and demand-driven (invalidator-based) rendering modes, including robust handling of GPU device loss.

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

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

The \windows-notifyicon\ crate is now available, providing a safe Rust wrapper for managing Windows notification-area (system tray) icons. Users can create, update, and remove icons using the \NotifyIcon\ builder, handle events like activation and context menus, and manage tooltips. The implementation uses separate hidden windows for shell reception and callback dispatch, ensuring compatibility with filtered message loops, and automatically handles DPI awareness.

crates/libs/notifyicon · high confidence

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

The \crates/tools/reactor\ directory now contains the source code for the Windows Reactor code generator. This includes schema definitions (\winui.toml\), RDL metadata (\extras.rdl\), and binding filters (\bindings.txt\, \control\_bindings.txt\, \canvas.txt\) that define the Windows App SDK 2.5.1 interfaces used by the reactor. The tool generates Rust bindings and UI element code for the \windows-reactor\ library, handling WinUI controls, canvas rendering, and surface capabilities.

crates/tools/reactor/src · high confidence

A change to existing behaviour in crates/tools/reactor/winmd — 7 commits, 27 files.

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

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

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

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

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

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

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

Add bindgen test harness for compile fixtures; Added RDL input test cases for Windows metadata types; Added Reactor benchmark and live-input test harnesses; Added WinRT constructor tests for activatable and composable runtime classes; Added WinRT projection benchmark harness; Added WinRT regression tests for generic GUIDs, URI handling, and XML parsing; Added Windows Reactor benchmarking and regression-testing infrastructure; Added Windows-specific link tests for kernel32 and wldap32; Added automated surface validation tests for Windows Reactor controls; Added bindgen input test cases for architecture-specific types and minimal projection scenarios; Added build script for WinRT constructors client tests; Added build script for WinRT ref\_params test crate; Added build scripts for WinRT overloads test crate; Added build scripts for reactor test crates; Added clang integration test harness; Added compile-time size and alignment checks for Win32 metadata bindings; Added composable aggregation test harness; Added comprehensive tests for the COM implement macro; Added declarative clang binding tests for Windows scenarios; Added dedicated test crate for windows-rdl; Added expected metadata test for Win32 slice generation; Added integration tests for the Windows Animation library; Added integration tests for windows-canvas; Added live WebView2 self-test harness; Added reactor test coverage validation script; Added reference bindings test crate; Added self-test suite for windows-reactor; Added test coverage for WinRT activation; Added test coverage for WinRT activation scenarios; Added test coverage for Windows core library components; Added test coverage for core Windows-RS capabilities; Added test coverage for windows-bindgen error handling and input modes; Added test coverage for windows-collections stock implementations; Added test for composable type authoring support; Added test harness for composable aggregation support; 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 COM interface reference parameters (Ref/OutRef); Added tests for IReference and IPropertyValue stock implementation; Added tests for Reactor UI component composition and window lifecycle; Added tests for WinRT Event core functionality; Added tests for WinRT activation client scenarios; Added tests for WinRT constructor interop; Added tests for WinRT method overload handling; Added tests for WinRT method overloads in the overloads\_client crate; Added tests for WinRT noexcept interface support; Added tests for Windows Future library async operations; Added tests for Windows GuidHelper functionality; Added tests for Windows service lifecycle and command handling; Added tests for Windows std feature integration; Added tests for Windows string types and literals; Added tests for composable type authoring support; Added tests for interface core library; Added tests for the Windows Clang code generator; 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 Win32 metadata generation; Automated generation of Clang library tests from input fixtures; Automated test generation for bindgen RDL inputs; Expanded bindgen test coverage for Windows Core bindings; Expanded test coverage for windows-rdl reader, writer, and import library.

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

The \crates/libs/rdl\ directory now includes \license-apache-2.0\ and \license-mit\ files, establishing the licensing terms for the \windows-rdl\ crate which compiles RDL (Rust Definition Language) into Windows metadata.

crates/libs/rdl · high confidence

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

• CAI 46 → 49 (+2.3)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.17) — scores are not directly comparable.

• Code Health 70 → 90 (+19.1)
• Architecture 87 → 99 (+12.1)
• Maturity 61 → 56 (-4.4)
• Readiness 52 → 40 (-12.8)
• Security 28 → 40 (+11.6)

• App::run_with (cognitive 18) (crates/libs/reactor/src/app/mod.rs)
• Clang::parse_and_emit (cognitive 21) (crates/libs/clang/src/lib.rs)
• Clang::parse_and_emit_by_header (cognitive 71) (crates/libs/clang/src/lib.rs)
• Clang::parse_and_emit_by_header (cyclomatic 36) (crates/libs/clang/src/lib.rs)
• Clang::process_tu (cognitive 33) (crates/libs/clang/src/lib.rs)
• Clang::process_tu (cyclomatic 19) (crates/libs/clang/src/lib.rs)
• Clang::process_tu_by_header (cognitive 46) (crates/libs/clang/src/lib.rs)
• Clang::process_tu_by_header (cyclomatic 27) (crates/libs/clang/src/lib.rs)
• ClassTooLong: Clang (crates/libs/clang/src/lib.rs)
• ClassTooLong: Colors (crates/libs/windows/src/Windows/UI/mod.rs)
• ClassTooLong: ComponentLoop (crates/libs/reactor/src/app/mod.rs)
• ClassTooLong: ComponentStore (crates/libs/reactor/src/core/component/mod.rs)
• ClassTooLong: CppMethod (crates/libs/bindgen/src/types/cpp_method.rs)
• ClassTooLong: CurrencyIdentifiers (crates/libs/windows/src/Windows/Globalization/mod.rs)
• ClassTooLong: Encoder (crates/libs/rdl/src/reader/mod.rs)
• ClassTooLong: File (crates/libs/metadata/src/reader/file.rs)
• ClassTooLong: File (crates/libs/metadata/src/writer/file/mod.rs)
• ClassTooLong: IADsUser_Vtbl (crates/libs/windows/src/Windows/Win32/iads/mod.rs)
• ClassTooLong: IBrowserService2_Vtbl (crates/libs/windows/src/Windows/Win32/shdeprecated/mod.rs)
• ClassTooLong: ICoreWindow_Vtbl (crates/libs/windows/src/Windows/UI/Core/mod.rs)
• …and 1903 more

• App::run_host (cognitive 24) (crates/libs/reactor/src/app/mod.rs)
• App::run_host (cyclomatic 17) (crates/libs/reactor/src/app/mod.rs)
• Change coupling: interface.rs ↔ interface.rs (crates/libs/rdl/src/reader/interface.rs)
• Change coupling: lib.rs ↔ lib.rs (crates/libs/sys/src/lib.rs)
• ComponentLoop::live_controlled_feedback_native_finish (cognitive 21) (crates/libs/reactor/src/app/mod.rs)
• ComponentLoop::live_controlled_feedback_native_finish (cyclomatic 22) (crates/libs/reactor/src/app/mod.rs)
• Dependency hygiene PARTLY measured — Cargo dependencies read, no committed lock to grade for currency
• Documentation: no architecture or design documentation (docs/readme.md)
• Duplicated block (10 lines × 2) (crates/libs/clang/src/lib.rs)
• Duplicated block (10 lines × 2) (crates/libs/windows/src/Windows/Win32/comsvcs/mod.rs)
• Duplicated block (10–11 lines × 2) (crates/libs/reactor/src/native/winui/mod.rs)
• Duplicated block (11 lines × 2) (crates/libs/clang/src/extract.rs)
• Duplicated block (11 lines × 2) (crates/libs/clang/src/lib.rs)
• Duplicated block (11 lines × 2) (crates/libs/clang/src/lib.rs)
• Duplicated block (116 lines × 103) (crates/libs/sys/src/Windows/Win32/bdatypes/mod.rs)
• Duplicated block (12 lines × 2) (crates/libs/clang/src/lib.rs)
• Duplicated block (19 lines × 2) (crates/libs/windows/src/Windows/Win32/corewindow/mod.rs)
• Duplicated block (19 lines × 5) (crates/libs/reactor/src/native/winui/bindings.rs)
• Duplicated block (25 lines × 161) (crates/libs/metadata/src/bindings.rs)
• Duplicated block (254 lines × 96) (crates/libs/sys/src/Windows/Win32/bdatypes/mod.rs)
• …and 262 more

• 24 commits — 23 feature/other, 1 fixes

• crates/libs — 17 commits
• crates/tests — 5 commits
• crates/tools — 2 commits

• fix: windows-clang fix value/fact planning (#4960)
• change: Enforce the unused_dependencies lint (#4965)
• change: windows-clang constant repr (#4962)
• change: windows-clang data classes (#4950)
• change: windows-clang declarative tests (#4954)
• change: windows-clang enum mask (#4955)
• change: windows-clang non-finite constants (#4949)
• change: windows-clang refactor (#4944)
• change: windows-clang restore builder (#4947)
• change: windows-clang type reconciliation (#4961)
• change: windows-clang type value collisions (#4957)
• change: windows-notifyicon (#4919)
• change: windows-rdl detect invalid bases (#4956)
• change: windows-reactor icon view constraint (#4970)
• change: windows-reactor improve code generation (#4929)
• change: windows-reactor improve grid length controls (#4958)
• change: windows-reactor normalize rich edit box feedback (#4926)
• change: windows-reactor reduce reconciliation allocation and event overhead (#4963)
• change: windows-reactor reposition theme transitions (#4966)
• change: windows-reactor simplifies code generation (#4927)
• …and 4 more

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

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.