rust-windowing/winit

Winit is a cross-platform windowing library for Rust that manages event loops, window creation, and input handling across diverse environments including Windows, macOS, Linux (X11/Wayland), iOS, Android, Web, and Redox OS. It provides a unified API for managing window state, DPI scaling, and user input while delegating platform-specific implementations to dedicated backend crates. The system supports advanced features such as drag-and-drop, IME, gestures, and fractional scaling, ensuring consistent behavior across different operating systems and display servers.

The \dpi\ module is now a standalone crate providing \LogicalUnit\ and \PhysicalUnit\ types to handle UI scaling between device pixels and logical coordinates. This allows applications to maintain consistent visual sizing across screens with different pixel densities by converting between physical pixels and scale-factor-adjusted logical units. The module also supports \no\_std\ environments via a bundled \libm\ implementation for mathematical functions, ensuring compatibility with embedded or bare-metal targets.

dpi/src · high confidence

Users can now run winit applications on the Redox OS Orbital display server. This change adds the \winit-orbital\ crate, which implements the platform-specific event loop, window management, and input handling (keyboard, mouse, scroll) by communicating with the Orbital compositor via file descriptors and scheme paths. It supports standard window attributes such as resizing, transparency, and borderless fullscreen modes, and exposes raw window/display handles for low-level integration.

winit-orbital/src · high confidence

The \winit-web\ crate now includes a complete event loop implementation (\winit-web/src/event\_loop\), providing the \EventLoop\, \EventLoopProxy\, and \ActiveEventLoop\ types required to run applications on the web platform. This change adds the core infrastructure for handling application lifecycle events, window focus, keyboard input, and custom cursors within the web environment, implementing the \EventLoopProvider\ trait to integrate with the core winit abstractions.

_winit-web/src/event\loop · high confidence

A new \winit-common\ crate has been created to house shared implementation details previously scattered across platform-specific backends. This change introduces an \EventHandler\ helper that manages interior-mutable access to the \ApplicationHandler\ via a \RefCell\, ensuring safe registration and cleanup during event loop execution. It also includes a \positioner\ module that implements the \xdg\_positioner\-style algorithm for calculating popup window placement (handling anchors, gravity, and constraint adjustments like flip, slide, and resize) for backends lacking native equivalents, such as Win32 and AppKit. Additionally, a \foundation\ module provides a \create\_observer\ function to register Objective-C notification observers, offering an alternative to declaring application delegates.

winit-common/src · high confidence

The \winit-core\ crate has been introduced to provide a common set of types, traits, and abstractions shared across different winit backends. This new location now houses core components such as the \ApplicationHandler\ trait, the \EventLoopProvider\ interface, and foundational modules for events, windows, cursors, data transfer (drag-and-drop), and error handling. By centralizing these definitions, the library establishes a unified API surface that platform-specific implementations can build upon, ensuring consistency in how applications interact with the windowing system.

winit-core · high confidence

Added a new \core\_foundation\ module in \winit-common\ providing safe Rust wrappers for macOS Core Foundation run loop components. This includes an \EventLoopProxy\ that signals a \CFRunLoopSource\ to wake the main thread, a \MainRunLoop\ helper for queuing closures and managing observers, and \MainRunLoopObserver\ for tracking run loop activities. Additionally, \tracing\_observers\ were added to emit TRACE-level spans for run loop phases (entry, timers, sources, waiting) to aid in debugging event loop behavior.

_winit-common/src/core\foundation · high confidence

Winit now includes a dedicated \winit-uikit\ crate that provides a native implementation of the event loop, window management, and input handling for Apple platforms using UIKit. This new backend replaces the previous implementation by removing the symlinks between \winit-appkit\ and \winit-uikit\, establishing a distinct codebase for iOS/tvOS/visionOS. It introduces full lifecycle management via \UIApplication\ notifications, support for screen orientation and safe area insets, and exposes platform-specific window controls such as status bar visibility, home indicator hiding, and screen edge gesture deferral through the \WindowExtIOS\ trait.

winit-uikit/src · high confidence

The Wayland backend has been moved to the \winit-wayland\ crate, introducing a new drag-and-drop API that handles URI, text, and binary data transfers via \winit\_core::data\_transfer\. It also adds a popup implementation using \xdg\_popup\ with configurable anchoring and gravity, and supports pointer gestures including pinch, rotation, and pan. The backend exposes Wayland-specific extensions such as client-side decoration preferences (\prefer\_csd\), activation tokens, and monitor handling, while integrating with \sctk\ for low-level Wayland protocol interactions.

winit-wayland/src · high confidence

The \winit-web\ crate has been introduced as the dedicated Web platform backend, replacing the previous implementation. This new module provides a complete WebAssembly-based windowing system backed by an HTML canvas, featuring support for custom cursors (including animated ones), pointer lock with unadjusted movement, screen orientation locking, and monitor handling. It also includes specific web behaviors such as preventing default browser events on the canvas and managing main-thread safety for DOM interactions.

winit-web/src · high confidence

The Windows platform support has been restructured into a dedicated \winit-win32\ crate, replacing the previous monolithic backend. This new module introduces a comprehensive implementation of the drag-and-drop API, enabling file and data transfers via OLE interfaces, and adds native support for Windows Dark Mode, allowing applications to respect system theme settings. The backend also includes refined DPI awareness handling for high-DPI displays, a robust Input Method Editor (IME) context for accurate text composition, and improved keyboard event processing. Additionally, it provides new error types for window creation and custom cursors, and implements tablet input support.

winit-win32/src · high confidence

Added two new helper modules to the examples utility directory: \fill.rs\ provides functions to resize and fill the softbuffer surface with a solid color, enabling simpler rendering logic for examples; \tracing.rs\ initializes the tracing subscriber, configuring it to use \tracing\_subscriber\ with environment-based filtering on native platforms and falling back to \tracing\_web\ for web platforms, allowing examples to use standard tracing macros instead of \println!\.

winit/examples/util · high confidence

The macOS backend has been moved to the \winit-appkit\ crate, introducing a new architecture that uses method swizzling to override \NSApplication::sendEvent:\ rather than subclassing, allowing users to retain full control over their \NSApplication\ instance. This new implementation includes a dedicated drag-and-drop system via \dnd.rs\ and \Pasteboard\ wrappers, a custom cursor provider in \cursor.rs\, and a refined event loop and application state management in \app\_state.rs\ and \event\_loop.rs\.

winit-appkit/src · high confidence

Winit now exposes platform-specific capabilities through the \winit::platform\ module, providing \PhysicalKeyExtScancode\ for accessing raw hardware key identifiers on Windows, macOS, Wayland, and X11, and \WindowExtStartupNotify\ (along with event loop and window attribute extensions) to manage activation tokens for proper window focus on Wayland and X11.

winit/src/platform · high confidence

The Wayland backend now implements several new capabilities through new protocol handlers in \winit-wayland/src/types\. It supports fractional scaling via \wp\_fractional\_scaling\_v1\ to provide more precise display scaling, and adds full tablet input support via \wp\_tablet\_input\_v2\ to handle pen, eraser, and other stylus events. Additionally, it enables window background blur effects using either the \ext-background-effect\ protocol or the KDE-specific \org\_kde\_kwin\_blur\ protocol, and supports setting window icons via \xdg\_toplevel\_icon\_v1\. The backend also includes standard support for \wp\_viewporter\ and \xdg\_activation\ for window geometry and user attention requests.

winit-wayland/src/types · high confidence

The Wayland backend in \winit-wayland/src/seat/pointer\ now handles advanced pointer interactions. It implements support for pinch, rotation, and pan gestures via the \zwp\_pointer\_gestures\_v1\ protocol, emitting corresponding \WindowEvent\ updates for applications. Additionally, it adds support for pointer hold gestures and relative pointer motion (unaccelerated mouse movement) using the \zwp\_relative\_pointer\_v1\ protocol, allowing for more precise input handling in Wayland environments.

winit-wayland/src/seat/pointer · high confidence

The Wayland backend now includes a dedicated touch input handler (\winit-wayland/src/seat/touch\) that translates Wayland \wl\_touch\ events into \winit\ window events. This implementation manages multi-touch states, including tracking individual finger IDs, identifying the primary touch point, and handling touch down, motion, and up events. It ensures that touch interactions correctly trigger pointer enter/leave and button press/release events with appropriate physical coordinates and scale factors, enabling native touch support for applications running on Wayland.

winit-wayland/src/seat/keyboard, winit-wayland/src/seat/touch · high confidence

The X11 platform implementation has been extracted into a dedicated \winit-x11\ crate, introducing a new drag-and-drop API that handles file and text transfers via Xdnd atoms, and implementing the X11 startup notification specification to support activation tokens for window launching.

winit-x11/src · high confidence

The Win32 backend implementation has been removed from the codebase. This change deletes the \src/win32/ffi.rs\ file, which contained manual FFI bindings for Windows API types and constants, and the \src/win32/mod.rs\ file, which implemented the \Window\ struct and its lifecycle methods (creation, title setting, positioning, sizing) using the Win32 API. Users can no longer create or manage windows on Windows platforms using this library.

src/win32 · high confidence

The \src/lib.rs\ file has been deleted, removing the original, now-obsolete public API surface. This deletion eliminates the legacy \Event\ enum (including \FramebufferSizeChanged\, \PositionChanged\, \SizeChanged\, etc.), the \Hints\ struct for window configuration, and the \ClientAPI\/\Profile\ enums. Users relying on these specific types and the initial window creation patterns defined in this root module will need to migrate to the current, evolved API provided by the crate's other modules.

src · high confidence

The \deps/gl\ directory and the \gl.rs\ file, which provided the \gl-rs\ OpenGL function loader, have been removed from the project. This eliminates the external dependency on the \gl-rs\ crate and its associated OpenGL type definitions and constants, requiring any code that previously relied on this local binding to use an alternative method for OpenGL access.

deps · high confidence

The legacy \window.rs\ example, which demonstrated basic OpenGL rendering using the \gl-init-rs\, \libc\, and \gl\ crates, has been removed. This change eliminates the outdated manual OpenGL context management and buffer swapping pattern in favor of modern, supported examples.

examples · high confidence

The Android platform support has been reorganized into a new \winit-android\ crate, separating it from the core winit library. This change introduces Android-specific implementations for the event loop, window management, and key code mappings, while re-exporting the \android\_activity\ API to help applications avoid dependency conflicts. Users targeting Android will now interact with platform-specific extensions like \EventLoopBuilderExtAndroid\ and \WindowExtAndroid\ provided by this new module.

winit-android/src · high confidence

The \winit\ crate has been refactored from a monolithic structure into a facade that delegates to platform-specific crates (e.g., \winit\_x11\, \winit\_wayland\, \winit\_appkit\, \winit\_web\). This change introduces a new \EventLoopProvider\ trait in \winit\_core\ to unify event loop behavior across platforms, allowing the main \winit\ crate to expose a consistent API while handling platform-specific logic in its respective sub-crates. Users will now interact with a cleaner, modular architecture where the core event loop management is abstracted, and platform implementations are isolated, improving maintainability and cross-platform compatibility.

winit/src · high confidence

Winit has been moved into its own crate directory, including the addition of a build script that configures platform-specific conditional compilation flags (such as Android, Web, macOS, iOS, Windows, and Unix variants) using the cfg\_aliases library. Documentation and license files are now symlinked to the root directory to maintain consistency.

winit · high confidence

The \winit/src/changelog\ module has been reorganized to provide structured, version-specific migration documentation. The new \mod.rs\ file dynamically includes changelog content for versions ranging from v0.8 through v0.30, allowing users to access historical breaking changes and migration instructions for each major release. Additionally, an \unreleased.md\ file has been introduced to document pending changes, currently noting that the \url\ dependency has been removed from \winit-core\ and that users should migrate from \SendData::from\_file\_paths\ to \SendData::Uris\.

winit/src/changelog · high confidence

The dpi crate now provides \LogicalUnit\, \PhysicalUnit\, and \PixelUnit\ types for handling display scaling, along with \Insets\ and \Logical/PhysicalInsets\ for safe area calculations. It supports \no\_std\ environments by incorporating code from the libm crate, which changes the licensing model: enabling the \std\ feature keeps the crate under Apache-2.0, while disabling it requires compliance with both Apache-2.0 and MIT licenses due to the inclusion of libm-derived math routines.

dpi · high confidence

The winit examples have been updated to use the new \ApplicationHandler\ trait (replacing the previous \EventHandler\ pattern) and the \run\_app\ entry point. All examples now use \softbuffer\ for rendering and the \tracing\ crate for logging, replacing previous \println!\-based output. New examples demonstrate the \pump\_events\ and \run\_on\_demand\ event loop modes, as well as the new drag-and-drop API, popup windows, and IME capabilities.

winit/examples · high confidence

The Wayland backend's event loop logic has been moved into the \winit-wayland\ crate, introducing a dedicated \EventLoop\ struct that manages the connection to the Wayland server, integrates with \calloop\ for event dispatching, and handles window and device events via an internal \EventSink\. This change adds new public error enums (\CreateWindowError\, \CustomCursorError\, \TransferError\) to the core API to provide more specific error reporting for window creation, cursor handling, and data transfer operations. Additionally, the event loop now supports an \ApplicationHandler\-based lifecycle with \run\_app\_on\_demand\ and \run\_app\_never\_return\ methods, allowing applications to manage their event loop execution more flexibly, while also implementing \EventLoopProvider\ to standardize backend integration.

_winit-wayland/src/event\loop · high confidence

The web backend for winit has been moved into the winit-web crate, introducing a new \web\_sys\ implementation that manages HTML canvas elements, handles pointer and keyboard events, and supports tablet input, fullscreen modes, and animation frames via the Web API.

_winit-web/src/web\sys · high confidence

The Linux backend now relies on the XKB system (via libxkbcommon) to handle keyboard input, replacing the previous implementation. This change aligns scancode-to-keycode conversions with Chromium and Firefox, ensuring that physical keys map to the correct logical keys (e.g., handling layout-specific characters and modifier states accurately). It also introduces support for XKB compose sequences, allowing users to input special characters and accented letters using standard dead-key combinations. This results in more consistent and correct keyboard behavior across different Linux desktop environments and input methods.

winit-common/src/xkb · high confidence

The X11 backend has been moved into the \winit-x11\ crate and re-implemented in \winit-x11/src/util\, introducing a new set of utility modules for window management. This change adds support for custom cursors (including image-based cursors via XRender), improved modifier key handling, and EWMH-compliant window hints (such as \\_NET\_WM\_STATE\ and Motif hints). It also introduces new geometry utilities for frame extents and coordinate translation, along with updated input handling that replaces the previous \XQueryKeymap\ call with an \x11rb\ equivalent.

winit-x11/src/util · high confidence

The Wayland backend's text input implementation now correctly processes \DeleteSurroundingText\ events from the input method, allowing applications to receive precise byte-range deletion requests for surrounding text. Additionally, the commit refines the sequence of IME events (preedit, commit, and delete) sent to the application to strictly follow the \text-input-v3\ protocol order, ensuring that preedit strings are cleared and re-inserted in the correct cursor position without redundant empty preedit notifications.

_winit-wayland/src/seat/text\input · high confidence

The Wayland windowing backend has been relocated to the \winit-wayland\ crate, introducing a new modular window implementation. This change adds a dedicated \WindowState\ struct to manage window properties (title, size, decorations, theme) and a \WindowCommon\ component shared across window types. It also implements a new Input Method Editor (IME) API via \request\_ime\_update\, allowing applications to enable, update, and disable IME state, and refactors window and popup state handling to be reusable across different window types.

winit-wayland/src/window · high confidence

The Wayland backend's seat management has been consolidated into a new \WinitSeatState\ structure that explicitly tracks capabilities for touch, keyboard, pointer, text input, and tablet devices. This change introduces support for advanced input features by integrating Wayland protocols for relative pointers, pinch/hold pointer gestures, and tablet input, while also updating the underlying \sctk\ library to version 0.21 to enable these capabilities.

winit-wayland/src/seat · high confidence

The X11 backend's input method implementation has been relocated to the \winit-x11\ crate. This change consolidates the XIM (X Input Method) handling—including context management, callback registration, and preedit text processing—within the X11-specific module, ensuring that IME functionality is now strictly part of the X11 platform support rather than the shared core.

winit-x11/src/ime · high confidence

Added X11 settings test fixture; Added tests for Send, Sync, and Serde trait implementations.

Winit has been restructured into a multi-crate workspace (version 0.31.0-beta.3) with the main library split into platform-specific backends: winit-android, winit-appkit, winit-common, winit-core, winit-orbital, winit-uikit, winit-wayland, winit-web, winit-win32, and winit-x11, alongside a new dpi crate. The workspace now targets Rust edition 2024 and MSRV 1.86. Key dependency updates include raw-window-handle 0.6, windows-sys 0.61, objc2 0.6.1, sctk-adwaita 0.12.0, and rustix 1.0.7.

(dependencies) · high confidence

The repository has been reorganized and renamed from 'gl-init-rs' to 'winit', with the README updated to reflect the new identity and usage instructions. New configuration files have been added to standardize development workflows: \rustfmt.toml\ enforces import grouping and string formatting, \taplo.toml\ configures TOML formatting, \clippy.toml\ restricts logging macros in favor of tracing, and \deny.toml\ sets up dependency auditing and license checks. Documentation standards are now enforced via \typos.toml\ and a structured \CHANGELOG.md\ that points to the unreleased changelog module.

(repo-wide) · high confidence

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

• CAI 73 → 77 (+4.0)
• Rubric changed (rubric-2026.09.9 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 80 → 80 (-0.1)
• Architecture 97 → 98 (+1.2)
• Maturity 71 → 72 (+0.4)
• Readiness 76 → 79 (+2.8)
• Security 67 → 77 (+9.9)
• Event Sourcing 100 → 100 (+0.0)
• Performance 100 (new)

• ClassTooLong: Popup (winit-wayland/src/popup.rs)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (5 lines × 2) (winit-wayland/src/seat/touch/mod.rs)
• Duplicated block (6 lines × 2) (winit-wayland/src/popup.rs)
• Duplicated block (7 lines × 2) (winit-wayland/src/popup.rs)
• Duplicated block (7 lines × 2) (winit-wayland/src/window/state.rs)
• FileTooLong: window/state.rs (winit-wayland/src/window/state.rs)
• Further sole-owners (lower concentration)
• Hotspot: winit-android/src/event_loop.rs (winit-android/src/event_loop.rs)
• Hotspot: winit-appkit/src/cursor.rs (winit-appkit/src/cursor.rs)
• Hotspot: winit-core/src/event.rs (winit-core/src/event.rs)
• Hotspot: winit-wayland/src/window/state.rs (winit-wayland/src/window/state.rs)
• Hotspot: winit-x11/src/event_processor.rs (winit-x11/src/event_processor.rs)
• Hotspot: winit-x11/src/window.rs (winit-x11/src/window.rs)
• Members sharing a duplicated core (4 members, 50+ identical tokens) (winit-android/src/event_loop.rs)
• Off-boarding risk: anonymized user #1
• Popup::new (cognitive 32) (winit-wayland/src/popup.rs)
• Scanner failed to run — not a clean result
• TodoComment (winit-wayland/src/window/state.rs)
• …and 4 more

• Boundary-crossing change coupling: event_loop.rs ↔ mod.rs (winit-android/src/event_loop.rs)
• Boundary-crossing change coupling: icon.rs ↔ mod.rs (winit-win32/src/icon.rs)
• Boundary-crossing change coupling: mod.rs ↔ event_loop.rs (winit-wayland/src/seat/touch/mod.rs)
• Boundary-crossing change coupling: mod.rs ↔ event_processor.rs (winit-wayland/src/seat/touch/mod.rs)
• Boundary-crossing change coupling: view.rs ↔ mod.rs (winit-uikit/src/view.rs)
• Change coupling: mod.rs ↔ mod.rs (winit-wayland/src/seat/pointer/mod.rs)
• Dependency hygiene PARTLY measured — Cargo dependencies read, no committed lock to grade for currency
• Documentation: no project overview (winit/README.md)
• Documentation: no usage examples (winit/README.md)
• Duplicate methods with identical signatures and likely identical implementation intent. add_type and with_type are semantically equivalent in builder patterns.
• Duplicated block (9 lines × 2) (winit-wayland/src/window/state.rs)
• Hotspot: winit-win32/src/window.rs (winit-win32/src/window.rs)
• Low cohesion: ActiveEventLoop (LCOM4 4) (winit-appkit/src/event_loop.rs)
• Low cohesion: ActiveEventLoop (LCOM4 4) (winit-win32/src/event_loop.rs)
• Low cohesion: WinitState (LCOM4 4) (winit-wayland/src/state.rs)
• Members sharing a duplicated core (4 members, 50+ identical tokens) (winit-android/src/event_loop.rs)
• MethodTooLong: Window.new (winit-wayland/src/window/mod.rs)
• Off the main sequence: dpi
• Off the main sequence: winit-common
• Off-boarding risk: anonymized user #1
• …and 5 more

• 11 commits — 10 feature/other, 1 fixes

• winit-wayland/src — 4 commits
• winit-appkit/src — 3 commits
• (root) — 1 commit
• winit-core/Cargo.toml — 1 commit
• winit-core/src — 1 commit
• winit-win32/src — 1 commit

• fix: win32: fix crash when moving a window that owns non-winit windows (#4700)
• change: Add enum CreateWindowError
• change: Add enum CustomCursorError
• change: Add enum TransferError
• change: Add struct InternalError and use in SurfaceSizeWriter
• change: Remove the url dependency from winit-core
• change: Remove the url dependency from winit-win32 and the dnd example
• change: Remove variant RequestError::Ignored
• change: clamp anchor rect size before storing the new positioner in the last_config (#4714)
• change: wayland: refactor window/popup state to be reusable across window types (#4695)
• change: wayland: use touch serials for drag_window, resize and window_menu

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

rust-windowing/winit 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.