iced-rs/iced

This system is a Rust-based cross-platform GUI toolkit that provides a declarative widget library for building desktop and web applications. It features a high-performance rendering engine with support for both GPU-accelerated (WGPU) and CPU-based (Tiny-Skia) backends, enabling complex layouts, animations, and custom shader integration. The framework includes comprehensive tooling for development, such as time-travel debugging, hot-reloading, and headless end-to-end testing, while managing asynchronous tasks and system-level interactions like windowing and clipboard access.

36 changes.

This period focused on rewriting the graphics backend to use wgpu, introducing a new functional Application API with hot-reloading, and establishing a robust core system with state trees and async subscriptions. The work also involved expanding the example suite to demonstrate these new capabilities across native and web platforms.

51 changes.

This period focused on a comprehensive restructuring of the iced framework, introducing a new Task-based runtime API and decoupling the core widget logic from the native event loop. Significant work was done on the graphics layer, including the implementation of a CPU-based Tiny-Skia backend, a robust WGPU renderer with custom WGSL shaders, and a redesigned geometry and layout engine. The effort also expanded the widget library with new components like menus, image viewers, and text editors, while adding extensive examples to demonstrate these new capabilities.

29 changes.

This period focused on establishing robust debugging and testing capabilities, introducing time-travel debugging, telemetry, and a headless testing framework with an Ice format. It also expanded the example suite to demonstrate new features like rich text, dynamic widgets, and layout constraints, while refining the core program model and theme system.

Introduces a new \arc\ example that renders a rotating arc using the \Canvas\ widget. The application animates the arc's angle over time and draws geometric shapes (circles and an arc path) with stroke styling, providing a demo for custom canvas rendering capabilities.

examples/arc · high confidence

The \game\_of\_life\ example has been added, providing an interactive simulation of Conway's Game of Life. It features an infinite grid rendered via \Canvas\ with support for zooming, panning, and drawing cells. Users can control the simulation speed, toggle grid lines, clear the board, and load various preset patterns (such as Gliders and the Gosper Glider Gun) from a dropdown menu. The simulation runs in a background thread to maintain UI responsiveness.

_examples/game\_of\life · high confidence

The \examples/lazy\ directory now contains a new interactive demo application that showcases the \lazy\ widget. This example allows users to add, delete, and recolor items in a list, using the \lazy\ function to defer the expensive sorting and rendering of the item list until the data actually changes (triggered by adding, removing, or changing the sort order). It serves as a practical guide for implementing performant, lazy-loaded UI sections in iced applications.

examples/lazy · high confidence

A new Pokédex example has been added to the examples directory, demonstrating how to build an application that fetches random Pokémon data from the PokéAPI. The example showcases key iced features including the new \Task\ API for asynchronous operations, the \image::viewer\ widget for displaying sprites, the \center\ layout helper, and conditional compilation to support both native and WebAssembly targets.

examples/pokedex · high confidence

The \qr\_code\ example now provides a functional QR code generator application. Users can input text data, select from available themes, and toggle an option to limit the total size of the generated QR code via a slider. The example demonstrates the new \qr\_code\ widget, \text\_input\ with \on\_input\ handling, and theme switching capabilities within the iced framework.

_examples/color\_palette, examples/qr\code · high confidence

A new interactive example demonstrating the canvas API has been added. It renders a Sierpiński triangle using a slider to control iteration depth and allows users to add or remove fixed points via left and right mouse clicks on the canvas.

_examples/sierpinski\triangle · high confidence

Introduces a new interactive example demonstrating a canvas-based animation effect inspired by The Matrix, featuring falling green characters with randomized opacity and content. The implementation uses a shared cache group for efficient rendering and updates the display every 50 milliseconds via a time subscription.

_examples/the\matrix · high confidence

The \tour\ example now includes an \index.html\ entry point and README, enabling it to be run on the web via Trunk in addition to native platforms. The example also features a new 'Debugger' screen that utilizes the \explain\ method to visualize layout constraints, helping users understand how the UI is structured.

examples/tour · high confidence

The examples/url\_handler directory now includes a new application that demonstrates how to handle incoming URLs (deep links) within the iced framework. The example subscribes to URL events using \event::listen\_url()\ and displays the received URL string in the center of the window, providing a reference implementation for developers needing to integrate URL handling into their iced applications.

_examples/url\handler · high confidence

The \websocket\ example now demonstrates a real-time echo client using the new \Sipper\ task API and \Task::batch\ for initialization. The application connects to a local echo server at \ws://127.0.0.1:3030\, displaying messages in a scrollable log that automatically snaps to the end upon new input, and features an auto-focused text input for immediate interaction.

examples/websocket/src · high confidence

A new WebSocket echo server example has been added to the examples/websocket/src/echo directory. This server listens on localhost port 3030 and echoes back any messages received from connected clients, providing a reference implementation for integrating WebSocket functionality.

examples/websocket/src/echo · high confidence

The examples/combo\_box directory now includes a runnable demo that showcases the new combo\_box widget. This example illustrates how to initialize a searchable dropdown list, handle option selection, and respond to option hover events using the on\_option\_hovered callback. It also demonstrates layout integration by centering the widget within a scrollable column.

_examples/combo\box · high confidence

The \custom\_shader\ example now demonstrates rendering animated 3D cubes using a custom WGSL shader pipeline. Users can interact with the scene via UI controls to adjust the number and size of cubes, toggle a depth buffer visualization, and modify light color (RGB). The example utilizes the \iced::widget::shader\ API to integrate custom GPU rendering with the standard iced widget layout, featuring a scene graph that handles cube updates, camera positioning, and shader uniform uploads.

_examples/custom\shader/src · high confidence

The \examples/custom\_widget\ directory now includes a README and a \main.rs\ source file that demonstrate how to build a custom widget. The example implements a \Circle\ widget that draws a rounded shape using the \renderer::fill\_quad\ method with a rounded border, and integrates it into a UI layout alongside a slider to dynamically adjust the circle's radius.

_examples/custom\widget · high confidence

The \examples/custom\_quad\ directory now contains a new example that showcases how to create and render a custom quad widget. This example provides an interactive playground where users can adjust border radius (per corner), border width, shadow offset, and shadow blur radius using sliders, and toggle pixel-grid snapping. It serves as a reference for implementing custom \Widget\ types that utilize \renderer::Quad\ for drawing.

_examples/custom\quad · high confidence

The \examples/events\ directory now includes a new example that logs native runtime events using a conditional subscription. Users can toggle event listening on and off via a checkbox, view the last five events in a scrollable list, and trigger a graceful window close using a dedicated exit button or by handling the window close request directly.

examples/events · high confidence

The \examples/exit\ directory now includes a runnable example that shows how to close an application based on user input. It uses the new \Task\ API, specifically \window::latest().and\_then(window::close)\, to handle the exit command after a confirmation dialog, and utilizes the \center\ widget helper for layout.

examples/exit · high confidence

The \examples/loading\_spinners\ directory now provides a demonstration of animated indeterminate loading spinners, featuring both circular and linear progress indicators. Users can explore various motion easing curves (such as Emphasized, Standard, and their accelerate/decelerate variants) and adjust the animation cycle duration via a slider, showcasing the new \lyon\-based easing implementation and the updated \Widget\ lifecycle.

_examples/loading\spinners · high confidence

The \examples/loupe\ directory now contains a new example application that showcases a custom \Loupe\ widget. This widget allows users to zoom into a specific area of the UI by hovering the mouse cursor, effectively acting as a magnifying glass. The implementation demonstrates advanced widget composition by wrapping existing elements (like buttons and text) and applying a transformation matrix during the draw phase to scale and translate the content based on cursor position.

examples/loupe · high confidence

The \examples/modal\ directory now contains a new interactive demo showcasing a modal dialog for user sign-up. The example demonstrates updated API usage, including \text\_input\ with \on\_input\ and \on\_submit\ handlers, a \secure\ mode for password fields, and a \pick\_list\ for plan selection. It also highlights new layout helpers like \center\ and \space::horizontal\, as well as keyboard accessibility features such as Tab/Shift+Tab focus navigation and Escape key dismissal.

examples/modal · high confidence

A new interactive sandpile simulation example has been added to the examples directory. It uses the iced framework to render a grid where grains of sand are added and topple when they reach a saturation threshold, with controls to adjust the animation speed and add new sandfalls.

examples/sandpiles · high confidence

The slider example now includes a demonstration of both horizontal and vertical sliders, allowing users to select values from a range using either orientation. The example showcases the \slider\ and \vertical\_slider\ widgets, along with configuration options like \default\ and \shift\_step\, and displays the current value in real-time.

examples/slider · high confidence

The stopwatch example now demonstrates how to listen to time using the \time::every\ subscription to update the display every 10 milliseconds, and supports keyboard shortcuts (Space to toggle, 'R' to reset) via the \keyboard::listen\ subscription.

examples/stopwatch · high confidence

A new example application has been added to demonstrate system information retrieval and display. The app fetches details such as system name, kernel, version, CPU brand and core count, memory usage (total and used, displayed in bytes with human-readable formatting via \bytesize\), and graphics adapter/backend. It features a loading state while data is fetched, a refresh button to re-fetch information, and uses the new \center\ widget helper for layout.

_examples/system\information, examples/todos · high confidence

A new \text\ example demonstrates rendering text with different font families and handling window rescaling. The example lists available font families, allows users to select a font via a pick list, and adjusts text sizes based on the window's scale factor to ensure consistent physical dimensions across different displays.

examples/text · high confidence

The \src/application\ module now exposes a \timed\ constructor and \UpdateFn\ trait that allow applications to receive an \Instant\ timestamp alongside each message during the update phase. This enables the creation of pure, deterministic update logic that does not rely on side-effect calls like \Instant::now()\, facilitating time-travel debugging and consistent state reproduction.

src/application · high confidence

The \examples/toast\ directory now contains a complete example application demonstrating how to create and manage toast notifications. This example showcases features such as adding toasts with custom titles, bodies, and status levels (primary, secondary, success, danger, warning), setting automatic expiration timeouts, and closing individual toasts. It also demonstrates keyboard navigation support using Tab and Shift+Tab for focus management within the form inputs.

examples/toast · high confidence

The examples/tooltip directory now includes a runnable demo that showcases the Tooltip widget's capabilities. Users can interact with the example to cycle through various tooltip positions (Top, Bottom, Left, Right, Follow Cursor) and toggle a display delay. The example also demonstrates how to customize the tooltip's appearance using the \gap\ method for spacing and the \rounded\_box\ style for theming.

examples/tooltip · high confidence

A new example demonstrating advanced vectorial text rendering via the canvas API. It showcases interactive controls for adjusting text size, rotation angle, and scale, along with a toggle for Japanese characters, utilizing the new \canvas::Program\ API and text alignment features.

_examples/download\_progress, examples/solar\_system, examples/vectorial\text · high confidence

The \wgpu/src/triangle\ module now includes a new \msaa.rs\ file that implements Multi-Sample Anti-Aliasing (MSAA) for the triangle rendering pipeline. This change introduces a dedicated \Pipeline\ struct that manages MSAA render targets, bind groups, and a blit shader to resolve multisampled textures to the final output. Users will benefit from smoother visual edges in rendered content when antialiasing is enabled, as the pipeline now handles the creation of multisampled attachments and their subsequent resolution.

wgpu/src/triangle · high confidence

The \src/window\ module now exposes \from\_file\ and \from\_file\_data\ functions, allowing users to easily attach icons to application windows by loading them from image files or byte arrays. These functions handle the decoding of image data and return a typed \Error\ enum to report issues such as invalid icons, OS-level failures, or image decoding errors.

src/window · high confidence

The wasm-bindgen backend for iced\_futures has been implemented, providing a dedicated Executor that utilizes wasm\_bindgen\_futures::spawn\_local for task scheduling. Additionally, a time module is now available for this backend, leveraging wasmtimer to handle time-based subscriptions and intervals, enabling applications targeting the WebAssembly environment to properly manage asynchronous timing events.

futures/src/backend/wasm · high confidence

Adds a new \Rich\ text widget in \widget/src/text/rich.rs\ that allows composing text from multiple styled \Span\ objects. Users can now apply per-span formatting, configure global text properties like size, font, alignment, wrapping, and ellipsis, and handle link clicks via the \on\_link\_click\ callback.

widget/src/text · high confidence

The \examples/component\ directory now contains a new example application demonstrating a custom \NumericInput\ widget. This example showcases the usage of the \component\ helper to wrap a custom widget implementation, utilizing the \center\ layout helper for positioning, and interacting with standard widgets like \text\_input\ and \button\ within a row layout.

examples/component · high confidence

The \iced\_futures\ crate has been introduced to provide a unified, cross-platform asynchronous runtime for GUI programming. This new module exposes core abstractions such as \Subscription\ for listening to external events (including keyboard, system theme, and platform-specific events like macOS URL handling), \Executor\ for spawning and running futures, and \Runtime\ for managing command execution and subscription lifecycles. It implements platform-specific handling for \Send\/\Sync\ bounds via \MaybeSend\ and \MaybeSync\ traits, ensuring compatibility with both native (Linux/macOS/Windows) and WebAssembly targets, and provides utilities like \stream::channel\ and \stream::try\_channel\ for creating asynchronous data streams.

futures/src · high confidence

A new \iced\_selector\ subcrate has been added, providing a \Selector\ trait and helper functions (such as \id\ and \is\_focused\) to traverse the widget tree and locate specific widgets. This change decouples the \iced\_widget\ crate from \iced\_runtime\ by moving selector logic into this dedicated module, allowing users to query widget properties like focus state or text content via a unified API.

selector · high confidence

Adds a new \iced\_tiny\_skia\ crate that provides a CPU-rendered backend for Iced applications using the \tiny-skia\ library. This renderer supports drawing primitives (quads, paths, strokes), raster images with configurable filtering, SVGs with optional text rendering, and vectorial text with caching. It implements a layering system for damage tracking and clipping, allowing users to run Iced on platforms without GPU acceleration or for headless testing.

_tiny\skia/src · high confidence

The \winit\ crate now provides a complete windowing shell for Iced applications, exposing a renderer-agnostic \Program\ trait and a \run\ function to start the event loop. This new module includes a \Clipboard\ implementation that supports reading and writing text, HTML, images, and file lists via the \arboard\ library, and a \conversion\ module that translates \winit\ window events (such as resize, close, and mouse input) into Iced's internal event types. It also manages window state, handles platform-specific settings (like decorations, transparency, and window levels), and implements a \Proxy\ with backpressure to safely send actions from the application to the event loop.

winit/src · high confidence

A new \Program\ trait has been added to \widget/src/shader/program.rs\ to define the state, update, and drawing logic for shader-based widgets. This trait allows developers to manage internal state, handle events via an \update\ method, and render custom primitives, effectively unifying the API for shader programs within the widget system.

widget/src/shader · high confidence

The beacon module now includes a new client implementation that connects to a debugging server to transmit application metrics and support time-travel debugging. This client logs events such as theme changes, span timings (boot, update, view, layout, interact, draw, present), command counts, subscription states, and rendered layers. It exposes a \Connection\ API allowing users to rewind to specific messages or return to live mode, and it maintains application metadata including name, version, theme, and time-travel capability during the connection.

beacon · high confidence

The \core\ crate now exposes foundational types for building user interfaces, including \Alignment\ (with \Horizontal\ and \Vertical\ variants) for positioning widgets within containers, and \ContentFit\ strategies (\Contain\, \Cover\, \Fill\, \None\, \ScaleDown\) to control how images scale within their bounds. An \Animation\ API is provided to interpolate state changes over time with configurable duration, easing, and repetition. Additionally, \Angle\ types (\Degrees\ and \Radians\) are introduced to handle rotational transformations with standard arithmetic operations.

core/src · high confidence

The \debug\ crate now provides a public API to enable application telemetry and hotpatching capabilities. Users can initialize the debug session with metadata (name, theme, time-travel support) and track runtime metrics such as spawned tasks, active subscriptions, and rendered layers. The API exposes span-based timing for core application stages (boot, update, view, layout, interact, draw, present) and integrates with the \beacon\ client to send this data. Additionally, it introduces a hotpatching mechanism allowing developers to apply code changes at runtime, controlled via the \hot\ feature flag.

debug · high confidence

The library now provides \iced::application\ and \iced::daemon\ helper functions that allow users to define and configure applications using a functional, step-by-step builder pattern rather than implementing the \Application\ trait. This new API supports configuration of settings, window properties, and presets, and integrates with the new \iced\_debug\ devtools. Additionally, a \hot\ feature is introduced, wrapping programs to enable hot-patching and live code reloading during development.

src · high confidence

The \tester\ module has been moved to a new \iced\_tester\ subcrate, providing a new capability to record, edit, and run end-to-end tests for iced applications. This change introduces a \Tester\ wrapper that attaches to an application \Program\, enabling users to capture user interactions as \Ice\ instructions and replay them. The tester includes a custom icon font (\iced\_tester-icons\) for its UI controls (play, stop, record, etc.) and utilizes a \Recorder\ widget to intercept events and highlight hovered elements during recording sessions.

tester · high confidence

Adds a new \keyed::Column\ widget that distributes content vertically while maintaining continuity of child elements based on unique keys. This allows lists to preserve the state of individual items when the order or content of the list changes, rather than resetting all children.

widget/src/keyed · high confidence

A new \null.rs\ module has been added to \core/src/renderer\, providing a no-op implementation of the \Renderer\ and \text::Renderer\ traits for the unit type \()\. This allows the UI framework to operate in headless or testing contexts where actual drawing is unnecessary, by stubbing out all rendering operations (such as filling quads, allocating images, and drawing text) with empty bodies or default values.

core/src/renderer · high confidence

The devtools now include a time-travel debugging feature (controlled by the \time-travel\ feature flag) that records application messages and state, allowing users to rewind to specific points in time to inspect the application's history. Additionally, the devtools automatically manage the \iced\_comet\ daemon: it detects if the daemon is missing or outdated, and provides an installation wizard to fetch the compatible revision (\6f5ba89410d407f5c7b5f5d915804594ba24a92d\) from the \iced-rs/comet\ repository, handling the \cargo install\ process with progress logging.

devtools · high confidence

Adds a new CPU-based rendering backend using \tiny-skia\ and \softbuffer\, enabling iced applications to run without GPU support. This implementation features damage tracking to optimize rendering by only redrawing changed areas, supports window resizing, and allows for off-screen screenshots.

_tiny\skia/src/window · high confidence

The \iced\_wgpu\ crate now provides a complete graphics backend using the \wgpu\ API, replacing previous implementations. This renderer introduces a new \Engine\ and \Renderer\ architecture that manages pipelines for quads, triangles, text, and images. A key behavioral change is the implementation of a 'nudge' algorithm in \nudge.rs\ to snap coordinates to the physical pixel grid, ensuring crisp rendering by correcting floating-point rounding errors at half-pixel boundaries. The diff also adds support for offscreen rendering via a \screenshot\ method and a \color::convert\ function for texture format conversion, along with a new \Buffer\ abstraction for efficient GPU memory management using \StagingBelt\.

wgpu/src · high confidence

The \graphics/src\ directory has been reorganized into a new \iced\_graphics\ crate, providing a comprehensive set of backend-agnostic types for building renderers. This includes a new \Compositor\ trait for managing window surfaces and renderer initialization, a \Cache\ system for efficiently reusing generated values, and a \Layer\ architecture with a \Stack\ for drawing and merging graphical primitives. The crate also introduces support for linear gradients via \Gradient\ and \Mesh\ types, antialiasing strategies (\Antialiasing\), damage tracking (\damage\), and a unified \Image\ type for raster and vector content. Additionally, it provides a global \FontSystem\ for text rendering and a \Viewport\ struct to handle physical/logical size and scale factors.

graphics/src · high confidence

The native futures backends for \smol\, \thread\_pool\, and \tokio\ now implement the \time\ module, allowing applications to create subscriptions that trigger at set intervals. Specifically, the \time::every\ function provides a stream of timestamps, while the new \time::repeat\ function allows running an async function at a specified interval and producing its result as a subscription message. This enables periodic tasks and timers directly within the application's event loop for these backends.

futures/src/backend/native · high confidence

The gallery example now fetches images from the Civitai API, displaying the most reacted images from the past month (up to 200). It features a new UI with rounded image borders, hover-to-zoom interactions, and smooth fade-in animations. To improve perceived loading speed, the example decodes blurhashes in the background and displays them as placeholders before the full image thumbnails are downloaded and allocated.

examples/gallery · high confidence

A new interactive example has been added that demonstrates drawing Bézier curves using the \Canvas\ widget. The tool allows users to click and drag to create quadratic curves, with a 'Clear' button to reset the canvas. It showcases features like cached rendering, custom cursor interaction (crosshair), and integration with the \hover\ widget for UI feedback.

_examples/bezier\tool · high confidence

Added a new \ferris\ example that demonstrates the \Image\ widget's support for dynamic opacity, rotation (including a continuous spin mode), and content-fit modes. The example provides a UI with sliders and pick lists to adjust width, opacity, rotation strategy (floating vs. solid), and content fit (contain, cover, fill, none, scale down) in real-time.

examples/ferris · high confidence

The \examples/markdown\ directory now contains a complete, runnable application demonstrating the new \markdown\ widget capabilities. Users can edit Markdown in a \text\_editor\ with live syntax highlighting, view the rendered output with support for images (including fade-in animations), links, and code blocks, and toggle between a standard preview mode and an incremental streaming mode that parses content character-by-character. The example also showcases custom theming, clipboard operations for code blocks, and the use of \iced::animation\ and \iced::time\ for timed updates.

examples/markdown · high confidence

A new \Menu\ widget has been introduced to display dropdown lists of selectable options. This component supports extensive text customization, including configurable text size, font, line height, and shaping strategies. It also features layout controls such as width, height, and padding, along with text overflow handling via an ellipsis strategy. The menu is implemented as an overlay that can be positioned relative to a target element, and it supports publishing messages on option selection and hover events.

widget/src/overlay · high confidence

The \pane\_grid\ example has been reintroduced to demonstrate the \PaneGrid\ widget, showcasing capabilities such as vertical and horizontal splitting, mouse-based resizing, drag-and-drop reorganization, and hotkey support. The example includes a configurable title bar with pin/unpin functionality, maximize/restore actions, and close controls that respect pinned state, providing a comprehensive reference for building complex, multi-pane user interfaces.

_examples/pane\grid · high confidence

A new interactive demo application has been added to showcase the Scrollable widget's capabilities. It allows users to experiment with various size and style options, including switching between vertical, horizontal, and multi-directional scrolling, adjusting scrollbar width, margin, and padding, and controlling scroll alignment (Start/End). The example also demonstrates programmatic scrolling operations like snapping to specific offsets.

_examples/layout, examples/multi\window, examples/scrollable · high confidence

The \examples/changelog\ directory now contains a new interactive tool that helps maintainers review and organize pull requests for the project's CHANGELOG.md. The application parses the existing changelog to identify pending contributions, fetches details for each pull request, and allows users to assign categories (Added, Fixed, Changed, Removed), edit titles, and preview the formatted markdown output before saving the updated CHANGELOG.md file. It also displays author information sorted by contribution count and includes a custom icon font for the UI.

examples/changelog · high confidence

Added a new \clock\ example that demonstrates the \Canvas\ widget by drawing a functional analog clock face with hour numbers, minute ticks, and animated hands. The example uses the \chrono\ library for time handling and cycles through available themes based on the current time.

examples/clock · high confidence

A new example application has been added to the \examples/delineate\ directory that showcases the \selector\ API. This demo allows users to track mouse position and window resize events to dynamically find specific widgets by ID (outer and inner containers) and retrieve their visible bounds, displaying this information in real-time to illustrate how to interact with and inspect widget geometry within the UI.

examples/delineate · high confidence

The \wgpu/src/quad\ module now includes dedicated \gradient.rs\ and \solid.rs\ files that define new rendering pipelines for gradient-filled and solid-colored quads. These pipelines introduce specific vertex layouts (including attributes for colors, positions, borders, shadows, and snapping) and load combined WGSL shader modules to handle rendering. This change adds the infrastructure for these specific visual styles within the quad subsystem, while also disabling the gradient pipeline on WebAssembly targets.

wgpu/src/quad · high confidence

The \test\ crate now provides a complete framework for testing iced applications without a display. It introduces the \Emulator\ for running applications in a headless runtime that executes real tasks and subscriptions, and the \Simulator\ for lightweight, side-effect-free UI simulation. Additionally, it adds support for the \Ice\ format, allowing end-to-end tests to be defined in plain-text \.ice\ files and executed via the new \run\ entry point, which parses these files and drives the \Emulator\ to verify application behavior.

test · high confidence

A new \Viewer\ widget has been added to the image module, enabling users to display images with interactive zoom and pan capabilities. This widget allows configuration of minimum and maximum scale limits, the zoom step size, padding, and content fitting strategies (such as \ContentFit\). It also supports setting the filter method for image rendering, providing a robust way to inspect large images within the application.

widget/src/image · high confidence

Added a new \examples/table\ application that demonstrates the \table\ widget. The example includes interactive controls (sliders) allowing users to adjust horizontal/vertical padding and separator thickness in real-time. It also showcases column-specific features such as width constraints (\Fill.max\), horizontal/vertical alignment (\align\_x\, \align\_y\), and conditional styling based on data values (e.g., warning/danger/success styles for price and rating).

examples/table · high confidence

This change introduces new operation modules in the core widget system, enabling programmatic control over widget states. For focus management, it adds operations to focus, unfocus, and traverse focusable widgets (previous/next), as well as finding the currently focused widget. For scrolling, it provides operations to scroll to a specific position, scroll by an offset, and snap to a percentage, supporting both absolute and relative offsets with animation. For text inputs, it adds operations to move the cursor to the front, end, or a specific position, and to select all or a specific range of text.

core/src/widget/operation · high confidence

The \screenshot\ example now demonstrates how to capture the application window, crop specific regions using numeric inputs for coordinates and dimensions, and save the result as a PNG file. It utilizes the new \window::screenshot\ API and \Task\ chaining for asynchronous operations, providing a complete workflow for users to interact with window screenshots directly within the application.

examples/screenshot · high confidence

A new \highlighter\ crate has been introduced to provide syntax highlighting capabilities for the iced UI framework. It exposes a \Parser\ and a \Stream\ that leverage the \two-face\ library to map syntax scopes to \iced\_core::Code\ types, enabling efficient, incremental highlighting of code streams with caching support.

highlighter · high confidence

The \examples/styling\ directory now includes a runnable example that showcases custom styling with light and dark themes. It demonstrates how to switch between built-in theme variants (such as Dracula, Nord, Solarized, and Grubvox) using a theme selector, and illustrates various widget styles including buttons with primary/secondary/success/warning/danger variants, checkboxes and togglers with disabled states, sliders, progress bars, and scrollable containers with auto-scrolling. The example also highlights layout helpers like \center\, \Fill\, \Fit\, and \Shrink\, and shows how to apply custom styles to containers and rules.

examples/styling · high confidence

The \core/src/text\ module has been replaced with a new architecture featuring a dedicated \Editor\ trait for multi-line text manipulation, a generic \Input\ widget that supports secure (password) mode, placeholders, and multiline wrapping, and a \Paragraph\ trait for rendering text with alignment, ellipsis, and wrapping strategies. This change introduces a new \Highlighter\ trait and \Parser\ interface to decouple syntax highlighting logic from the editor, allowing custom parsers to integrate with the new text pipeline.

core/src/text · high confidence

The \examples/editor\ directory now contains a complete text editor application demonstrating the new \text\_editor\ widget. Users can open, save, and create new files, with support for word wrapping, syntax highlighting, and theme selection (including Catppuccin Mocha). The example showcases the new \Task\ API for asynchronous operations, the \operation::focus\ mechanism for initial widget focus, and the \text\_editor::Content\ API for managing text state and line endings.

examples/editor · high confidence

The \examples/integration\ directory now contains a complete demonstration of how to integrate the Iced GUI toolkit into an existing \wgpu\ application. This example provides a standalone entry point (\main.rs\) that manages the \winit\ event loop and \wgpu\ device/surface lifecycle, while rendering a custom 3D scene (defined in \scene.rs\ with WGSL shaders) alongside an interactive Iced UI panel (defined in \controls.rs\) featuring background color sliders and text input. It serves as a reference implementation for developers needing to combine custom graphics rendering with Iced's widget system.

examples/integration · high confidence

The \wgpu\ backend now uses a new \Compositor\ struct in \wgpu/src/window/compositor.rs\ to manage the connection between the window and the renderer. This change introduces support for configuring the GPU power preference (LowPower, HighPerformance, or None) via \iced\_wgpu::Settings\, allowing users to optimize for battery life or performance. It also implements explicit texture format selection logic that respects a blacklist of formats and can enforce sRGB linear blending when the \web-colors\ feature is enabled, ensuring consistent color rendering across different platforms.

wgpu/src/window · high confidence

The runtime now exposes a new \selector\ module for finding widgets by criteria (such as focus state) and an \operation\ module for programmatically controlling widget state. Users can now query whether a widget is focused, scroll or snap scrollable areas with animation support, and manipulate text input cursors and selections (move cursor, select all, select range) via new public functions.

runtime/src/widget · high confidence

The progress bar example has been updated to demonstrate the new vertical progress bar capability, allowing users to toggle between horizontal and vertical layouts via a checkbox. The example also showcases animated transitions using the new \transition\ helper and \Animation\ API, providing a smoother visual experience when the value changes. Additionally, the slider step has been reduced to 0.01 for finer control, and the example now includes a README for easier execution.

_examples/progress\bar · high confidence

The \wgpu\ shader layer for quads has been updated to support drop shadows and consistent pixel-grid snapping. The \solid\ and \gradient\ shaders now accept shadow parameters (color, offset, blur radius) and use a shared \shadow.wgsl\ module to render shadows that blend only into transparent areas, preventing them from obscuring the quad's own content. Additionally, a \snap\ attribute allows quads to be aligned to the pixel grid, reducing visual blur by applying a consistent rounding offset (nudge) to vertex positions and scales. These changes ensure sharper rendering and new visual effects for UI elements.

wgpu/src/shader/quad · high confidence

The \geometry\ example has been re-added to the repository, providing a demonstration of how to create a custom widget that renders arbitrary 2D geometry using the \Mesh2D\ primitive. The example features a \Rainbow\ widget that draws a multi-colored triangle fan, with the center vertex dynamically following the mouse cursor position when hovered, illustrating low-level rendering capabilities within the \iced\_wgpu\ backend.

examples/geometry · high confidence

The renderer now supports dynamic fallback between the WGPU and Tiny-Skia backends at runtime. When both the \wgpu-bare\ and \tiny-skia\ features are enabled, the default \Renderer\ and \Compositor\ types automatically wrap the respective backend implementations, allowing the application to switch to the secondary renderer if the primary one fails or is unavailable. This change introduces a type-safe composition layer in \renderer/src/fallback.rs\ that delegates all drawing operations, ensuring that users get a working graphics pipeline even if one backend is unsupported on the target device.

renderer · high confidence

The \examples/svg\ directory now contains a \README.md\ file that documents the example's purpose (rendering the Ghostscript Tiger) and provides instructions for running it via \cargo run --package svg\. Additionally, the SVG source file (\resources/tiger.svg\) has been added to the repository, ensuring the example has the necessary asset to function correctly.

examples/svg · high confidence

The checkbox example now showcases multiple usage patterns: a default checkbox, styled checkboxes using primary/secondary/success/danger themes, and a custom checkbox with a specific icon font and line height. It also demonstrates conditional enabling via \on\_toggle\_maybe\, allowing the styled checkbox to be disabled based on the state of the default checkbox.

examples/checkbox · high confidence

The counter example has been refactored to use the new \iced::run\ API and the \Center\ alignment type, replacing the previous application model. It now features a simplified view using \column!\ and \align\_x(Center)\ for centered layout. Additionally, web execution is now supported via a new \index.html\ file and instructions in the README, allowing users to run the example with \trunk serve\.

examples/counter · high confidence

The custom shader example has been updated to use wgpu version 29, requiring adjustments to the rendering pipeline and camera setup. Specifically, the camera module now correctly converts the field of view from degrees to radians before calculating the projection matrix, ensuring accurate visual scaling. The scene's rendering pipeline has been refactored to align with the new wgpu API, including updates to buffer management, bind group layouts, and texture handling for skybox and normal map effects.

_examples/custom\shader/src/scene · high confidence

The path geometry module now uses \f64\ precision for internal arc calculations to eliminate visual artifacts when drawing small arcs, and introduces a \rounded\_rectangle\ builder method that allows users to create paths with customizable corner radii.

graphics/src/geometry/path · high confidence

The mouse module has been reorganized into dedicated files (button, click, cursor, event, interaction) to provide a more robust API for handling user input. This change introduces a new \Interaction\ enum that exposes specific cursor types (such as \Hidden\, \Help\, \Copy\, and \NotAllowed\) to replace the previous generic \MouseCursor\ naming, allowing applications to display appropriate visual feedback for different UI states. Additionally, the \Cursor\ state now supports \Levitating\ and \Obstructed\ variants, enabling precise control over cursor visibility and interaction when layers overlap (e.g., in scrollable containers or popups). The \Click\ tracking logic has also been refined to support consecutive click detection (single, double, triple) with configurable distance and time thresholds, and mouse buttons are now explicitly typed with support for extended buttons (back/forward) via \u16\.

core/src/mouse · high confidence

The widget core now manages internal state via a new \Tree\ structure that persists and reconciles widget state across updates, ensuring continuity for interactive components. Additionally, a new \Operation\ trait and \Outcome\ system allow applications to query or modify internal widget state (such as focus, scroll position, or text input) by traversing the widget tree, replacing the previous ad-hoc mechanisms with a unified, composable API.

core/src/widget · high confidence

The \iced\_runtime\ crate has been introduced to provide a renderer-agnostic native GUI runtime, replacing the previous \iced\_native\ module. This change brings a new \Task\ API for handling asynchronous operations and side effects, including support for chaining, batching, and progress reporting via \sipper\. The runtime now exposes dedicated modules for managing windows (open, close, resize, screenshot), clipboard access (read/write text, HTML, files, images), font loading and listing, system information, and backend configuration. This shift decouples the core widget logic from the native event loop, allowing for more flexible integration and explicit control over runtime actions.

runtime/src · high confidence

The multitouch example has been updated to demonstrate canvas-based rendering of touch input. Instead of simple circles, the application now computes and draws Voronoi cells for each active finger, creating a dynamic geometric pattern that updates as fingers are pressed, moved, or lifted. This change replaces the previous simple visualization with a more complex, reactive drawing that utilizes the \voronator\ crate for geometry calculation.

examples/multitouch · high confidence

The widget library introduces a new \Action\ type that replaces the previous return mechanism for widget event handlers. This type allows widgets to explicitly declare whether they are capturing an event (preventing it from bubbling to parent widgets), publishing a message to the application, or requesting a redraw. This change provides more granular control over event propagation and rendering cycles within the UI.

widget/src · high confidence

The wgpu renderer now uses dedicated WGSL shaders for core rendering tasks, replacing previous implementations. This includes a new blit shader for texture copying, a color utility module for premultiplied alpha handling, and specialized shaders for images (supporting rotation, border radius, and opacity), quads (with signed distance field rounded corners), and triangles. A shared vertex utility shader provides normalized coordinate generation, ensuring consistent primitive rendering across the wgpu backend.

wgpu/src/shader · high confidence

The \gradient\ example (renamed from \gradients\) has been updated to showcase the new \theme::Style\ struct pattern and the ability to enable window transparency via \.transparent(true)\. The example now uses \space()\ for layout, \Color::WHITE\ for defaults, and allows users to toggle a transparent background, illustrating how to customize the application's appearance using the new styling API.

examples/gradient · high confidence

The image module now exposes a new \Storage\ trait and an associated \Entry\ trait in \graphics/src/image/storage.rs\. This change introduces a standardized interface for caching and managing image data, allowing implementations to define how image data is uploaded and removed from storage, which supports the broader reorganization of the graphics codebase.

graphics/src/image · high confidence

The \graphics/src/text\ module has been replaced with a new implementation featuring a dedicated \Cache\ for efficient text storage, a new \Editor\ widget for multi-line text input with selection and history support, and a refactored \Paragraph\ component that now supports rich spans, explicit metrics hinting, and improved alignment. This change introduces a new text rendering pipeline that decouples caching from the paragraph API and leverages the updated \cosmic-text\ library for shaping and layout.

graphics/src/text · high confidence

The window module has been restructured to provide granular control over window behavior and appearance. Users can now configure initial states such as maximized or fullscreen modes, set specific positioning strategies (including dynamic positioning via functions), and control title bar buttons (close/minimize). A new blur effect is available for transparent windows on macOS and Linux. The event system has been updated to include a \Rescaled\ event for scale factor changes and an \exit\_on\_close\_request\ setting allows applications to intercept close requests for custom cleanup logic before the window is destroyed.

core/src/window · high confidence

The pane grid now enforces minimum pane sizes during splits to prevent panes from becoming too small, and introduces a deadband distance before a drag action initiates to improve interaction stability. Additionally, the layout system prioritizes 'Shrink' over 'Fill' when calculating pane dimensions, and the split line bounds are now calculated with rounding to ensure precise visual alignment.

_widget/src/pane\grid · high confidence

The window settings API now exposes a \PlatformSpecific\ struct that allows users to configure OS-dependent behaviors. On Linux, you can set an application ID and enable \override\_redirect\ for precise window positioning. Windows users can now control drag-and-drop, hide the window from the taskbar (\skip\_taskbar\), enable shadows for undecorated windows, and choose corner rounding styles (default, do not round, round, or round small). macOS supports hiding the title, making the titlebar transparent, and enabling full-size content views. For WebAssembly, the default target element for mounting the application is now explicitly set to \iced\ instead of appending to the body.

core/src/window/settings · high confidence

The \graphics/src/geometry\ module has been restructured to provide a more robust and flexible drawing API. A new \Cache\ system is introduced to store and reuse generated geometry, significantly reducing recomputation when layer dimensions remain unchanged. The \Frame\ API now supports drawing images and SVGs (behind feature flags) and includes methods for clipping and transform management. Styling capabilities have expanded with the introduction of \Fill\ and \Stroke\ structs that support both solid colors and gradients, along with configurable stroke properties like line caps, joins, and dashes. The \Path\ struct now includes a \rounded\_rectangle\ constructor. Text rendering has been enhanced with support for configurable line height, horizontal/vertical alignment, shaping strategies, and ellipsis handling, allowing for more precise control over text layout within the canvas.

graphics/src/geometry · high confidence

The wgpu image subsystem has been refactored to use a multi-layer texture atlas for storing raster images and SVGs. The new \Atlas\ implementation manages texture memory across multiple layers, specifically initializing two layers for the OpenGL backend to ensure correct texture array interpretation. It supports both contiguous and fragmented image allocations, handles automatic deallocation of dropped textures, and includes padding logic to prevent texture bleeding. The \Cache\ now coordinates with this atlas to manage host/device memory states and trim unused entries, while the \Pipeline\ has been updated to use a D2Array texture view and bind group layout compatible with the new layered structure.

wgpu/src/image · high confidence

The keyboard event system has been refactored to provide richer context for user interactions. \keyboard::Event\ now includes \modified\_key\ and \physical\_key\ fields for both press and release events, allowing applications to distinguish between logical keys, their modifier-adjusted values, and physical hardware locations. A new \ModifiersChanged\ event variant notifies listeners when modifier states shift. The \Key\ type now supports non-Latin character translation via a \to\_latin\ method, and the \Modifiers\ struct has been replaced with a \bitflags\-based implementation that exposes platform-aware helpers like \command()\ and \jump()\, alongside a new \NONE\ constant.

core/src/keyboard · high confidence

The built-in themes now use a new color generation system that leverages Oklch for better contrast and readability. A new \warning\ color category has been added to all themes (Light, Dark, Dracula, Nord, Solarized, Tokyo Night, Kanagawa, Moonfly, Nightfly, Gruvbox, Catppuccin), ensuring diagnostic warnings are visually distinct. The palette structure has been unified with a new \Swatch\ type, and background shades now include a \neutral\ variant between weak and strong. Secondary colors have been differentiated from primary colors, and light themes have been tweaked to be more colorful while maintaining accessibility standards.

core/src/theme · high confidence

The \custom\_shader\ example's scene pipeline has been reorganized into distinct modules (\buffer.rs\, \cube.rs\, \uniforms.rs\, \vertex.rs\) to improve code structure. This change introduces a dedicated \Buffer\ wrapper for dynamic resizing, defines specific vertex and instance data layouts for cube rendering, and centralizes uniform management for camera and lighting data, resulting in a cleaner and more maintainable example implementation.

_examples/custom\shader/src/scene/pipeline · high confidence

The layout system in \core/src/layout\ has been significantly restructured to improve how elements are sized and aligned. The \Length\ enum now includes \Bounded\ and \Fit\ variants (renamed from \Intrinsic\), allowing for more precise control over minimum, maximum, and intrinsic sizing. The \flex.rs\ module implements a multi-pass layout algorithm that prioritizes \Shrink\ over \Fill\ and correctly handles \min\/\max\ constraints, including skipping unnecessary passes when the main axis is compressed. Additionally, \Limits\ now explicitly tracks \compression\ and \infinite\ flags, and the layout cache is reused via \widget::Tree\ to reduce allocations. These changes result in more predictable layout behavior, especially for nested containers and elements with mixed sizing constraints.

core/src/layout · high confidence

The overlay handling in the core layout system has been restructured to support nested overlay groups and message transformation. A new \Group\ type allows multiple overlays to be managed together, automatically sorting them by their z-index (via the \index\ method) to ensure correct visual stacking order. The \Element\ wrapper now includes a \map\ method, enabling overlays to transform the messages they produce, which facilitates cleaner event handling pipelines. Additionally, the internal logic for processing events and drawing has been updated to recursively handle these nested structures, ensuring that cursor interactions and event propagation work correctly across complex, layered UI components.

core/src/overlay · high confidence

The \widget/src/canvas\ module now exposes the \Program\ trait, which defines the interface for canvas state management, event handling, and rendering. This trait allows developers to implement custom logic for updating state based on events and drawing geometry. A key behavioral addition is the blanket implementation for references (\&T\), enabling composable and type-safe usage of program logic without requiring ownership, thereby simplifying how canvas interactions are structured and reused within the application.

widget/src/canvas · high confidence

The \iced\_futures\ backend implementation has been split into distinct modules to support multiple async runtimes and target platforms. A new default backend selection logic now chooses between \tokio\, \smol\, or \thread-pool\ executors on native platforms based on enabled features, falling back to a null executor if none are specified, while WebAssembly targets consistently use \wasm\_bindgen\. This change introduces separate module files for native backends (\tokio\, \smol\, \thread\_pool\), a null executor that drops futures, and a dedicated Wasm backend, replacing the previous monolithic backend structure.

futures/src/backend · high confidence

The pick\_list example has been updated to use the new \iced::run\ API and demonstrates the \placeholder\ feature on the pick list widget, allowing users to see a hint text like "Choose a language..." before making a selection. The example now uses \iced::widget::space\ for vertical spacing and \iced::Center\ for alignment, reflecting recent API changes in the framework.

_examples/pick\list · high confidence

The subscription system now uses a \Tracker\ to manage the lifecycle of subscription streams, automatically spawning new ones for active recipes and closing dropped ones. It introduces a \broadcast\ mechanism that allows shell events to be sent to all currently open subscriptions, with errors logged as warnings. This change also replaces the standard hasher with \rustc\_hash\ for performance and ensures subscriptions are \MaybeSend\ compatible.

futures/src/subscription · high confidence

The \program\ crate now provides a unified \Program\ trait that serves as the core interface for application logic, replacing previous fragmented definitions. This change introduces \Preset\, a new capability allowing developers to define named boot strategies that return an initial state and tasks, facilitating easier testing and configuration of application startup. The \Program\ trait also standardizes type parameters for State, Message, Theme, Renderer, and Executor, and includes a \with\_subscription\ helper for wrapping programs with custom subscription logic.

program · high confidence

The \styling\ example's test snapshots have been regenerated to reflect improvements in the built-in themes, specifically leveraging Oklch color space for better contrast and adjusting color definitions (such as differentiating secondary from primary and reducing text influence on secondary colors). This results in updated visual outputs for themes including Catppuccin (frappé, latte, macchiato, mocha), Dracula, Gruvbox (dark, light), Kanagawa (dragon, lotus, wave), Moonfly, Nightfly, Nord, Oxocarbon, Solarized (dark, light), Tokyo Night (night, light, storm), and the default light/dark themes.

examples/styling/snapshots · high confidence

The window state implementation has been updated to track the system's current theme mode (light or dark) and apply a corresponding default theme style when no explicit theme is set by the application. This ensures that the window's background and text colors automatically adapt to the user's system color scheme preferences, providing a consistent look and feel without requiring manual configuration.

winit/src/window · high confidence

Add CPU and GPU rendering benchmarks; Added integration tests for UserInterface overlay behavior; Added integration tests for widget behavior; Added layout constraint tests for Fill.min and Fill.max; Added test case for the todos example; Updated snapshot for the todos example.

The repository now includes a generated \Cargo.lock\ file and a comprehensive set of \Cargo.toml\ manifests for the iced workspace, including subcrates like \iced\_core\, \iced\_futures\, \iced\_graphics\, and \iced\_beacon\, as well as all example projects. This establishes the dependency graph and workspace structure for the project.

(dependencies) · high confidence

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

• CAI 43 → 70 (+26.5)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 82 (-17.6)
• Architecture 69 → 100 (+30.5)
• Maturity 57 → 61 (+4.0)
• Readiness 26 → 66 (+40.3)
• Security 50 → 84 (+33.2)
• Event Sourcing 100 (new)

• Dimension evaluation failed
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 15 more

• Atlas::allocate (cognitive 25) (wgpu/src/image/atlas.rs)
• Binding::from_key_press (cognitive 38) (core/src/text/editor.rs)
• Binding::from_key_press (cyclomatic 30) (core/src/text/editor.rs)
• Boundary-crossing change coupling: damage.rs ↔ layer.rs (graphics/src/damage.rs)
• Button::update (cognitive 21) (widget/src/button.rs)
• Cache::draw (cognitive 20) (tiny_skia/src/vector.rs)
• Cache::receive (cognitive 18) (wgpu/src/image/cache.rs)
• Cache::upload (cognitive 19) (wgpu/src/image/vector.rs)
• Change coupling: cache.rs ↔ editor.rs (graphics/src/text/cache.rs)
• Change coupling: cache.rs ↔ paragraph.rs (graphics/src/text/cache.rs)
• Change coupling: paragraph.rs ↔ text_input.rs (core/src/text/paragraph.rs)
• ClassTooLong: Editor (graphics/src/text/editor.rs)
• ClassTooLong: Engine (tiny_skia/src/engine.rs)
• ClassTooLong: PaneGrid (widget/src/pane_grid.rs)
• ClassTooLong: PickList (widget/src/pick_list.rs)
• ClassTooLong: Renderer (wgpu/src/lib.rs)
• ClassTooLong: Scrollable (widget/src/scrollable.rs)
• ClassTooLong: State (widget/src/scrollable.rs)
• ClassTooLong: Tester (tester/src/lib.rs)
• ComboBox::update (cognitive 54) (widget/src/combo_box.rs)
• …and 408 more

• 242 commits — 205 feature/other, 37 fixes

• widget/src — 99 commits
• core/src — 38 commits
• (repo) — 33 commits
• (root) — 13 commits
• widget/tests — 8 commits
• wgpu/src — 7 commits
• runtime/src — 6 commits
• winit/src — 6 commits
• test/src — 4 commits
• examples/gallery — 3 commits
• examples/styling — 3 commits
• examples/component — 2 commits
• examples/editor — 2 commits
• examples/markdown — 2 commits
• examples/scrollable — 2 commits
• examples/todos — 2 commits
• graphics/src — 2 commits
• tests/sticky.rs — 2 commits
• debug/src — 1 commit
• devtools/src — 1 commit

• fix: Disable infinite flags for Length::Fixed
• fix: Disable infinite for Fixed and max-Bounded lengths
• fix: Fix Length::Bounded in text_editor widget
• fix: Fix Length::min bounds inside scrollable
• fix: Fix Scrollable leaking cursor to content while scrollers are grabbed
• fix: Fix cargo doc warnings
• fix: Fix markdown convergence for lists and reference links
• fix: Fix text_editor layout bounds
• fix: Fix tooltip positioning and invalidation
• fix: Fix code block Font in markdown without highlighter feature
• fix: Fix code snippets in UserInterface documentation
• fix: Fix dropped events when an overlay disappears during update
• fix: Fix emulator cache after taking screenshot
• fix: Fix event loop spin on stale redraw deadlines in winit shell
• fix: Fix incorrect viewport in Scrollable::update
• fix: Fix incorrect commits in markdown::code::Parser
• fix: Fix incorrect pixel snapping in image pipeline
• fix: Fix layout invalidation in component
• fix: Fix macOS deletion shortcuts in Binding::from_key_press
• fix: Fix minor code styling nits in markdown module
• …and 222 more

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

iced-rs/iced 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.