linebender/xilem

This system is a Rust-based GUI framework ecosystem comprising Xilem, a declarative view layer, and Masonry, a platform-independent widget engine. It provides a comprehensive toolkit for building user interfaces across desktop, web, and mobile platforms, featuring a structured rendering pipeline, a cascading property system for styling, and support for complex layouts and asynchronous state management. The codebase includes extensive documentation, benchmarks, and integration tests to ensure performance and correctness across its multi-target architecture.

31 changes.

This period focused on replacing the legacy Xilem prototype with a new, robust core architecture featuring generic view traits, environment systems, and multi-window support. The project expanded its scope by introducing the Masonry desktop GUI framework and significantly enhancing Xilem Web with advanced async handling, SVG/MathML rendering, and comprehensive lifecycle hooks. These changes were supported by the creation of new utility crates like tree\_arena and extensive documentation and example suites for both platforms.

21 changes.

This period focused on establishing the foundational Masonry GUI engine, introducing a layered rendering system, cascading property architecture, and a structured render-pass pipeline. It simultaneously developed the xilem\_masonry bridge to integrate Masonry widgets into the Xilem framework and expanded the widget library with new layout and styling components. The work also included building the Placehero Mastodon client as a reference application and adding comprehensive testing and Android support.

7 changes.

This period focused on overhauling the core layout system with logical pixel units and new sizing types, while expanding the framework's rendering capabilities through the masonry\_imaging backend adapters. It also introduced new UI components like SelectorMenu and Tooltip, alongside comprehensive examples and benchmarks to validate performance and usability.

A new Elm Architecture example has been added to the web examples, demonstrating how to emulate the Elm pattern within Xilem Web. The example includes an HTML entry point and a Rust implementation featuring a simple counter model with increment and decrement actions, illustrating the use of \map\_action\ to handle state updates and view rendering.

_xilem\_web/web\examples/elm · high confidence

Introduces a new \svgdraw\ example in \xilem\_web/web\_examples\ that demonstrates vector drawing capabilities. The application provides an infinite, zoomable canvas where users can draw smooth spline lines using various colors and adjustable stroke widths. It supports mouse-based panning and zooming via wheel events, allowing for detailed exploration of the drawn content.

_xilem\_web/web\examples/svgdraw · high confidence

Introduces the SvgToy example application, demonstrating Xilem Web's SVG capabilities and event handling. Users can interact with the demo by dragging a blue rectangle, which updates its position and triggers pointer events, while other elements demonstrate CSS transforms, scaling, dashed strokes, and click interactions.

_xilem\_web/web\examples/svgtoy · high confidence

The xilem\_web web examples now include a complete TodoMVC implementation, providing a reference for building interactive web applications with Xilem. This example demonstrates core framework capabilities including state management with local storage persistence, event handling for user interactions (adding, editing, completing, and deleting todos), and dynamic UI rendering with filtering and styling.

_xilem\_web/web\examples/todomvc · high confidence

The \xilem\_web/src/concurrent\ module now provides three new view types to handle asynchronous operations and periodic updates. The \task\ view allows spawning async futures that can send messages back to the application state via a \TaskProxy\, while \task\_raw\ offers a version without capture restrictions. The \interval\ view wraps the browser's \setInterval\ to invoke a callback at specified millisecond intervals, resetting when the interval duration changes. Additionally, \memoized\_await\ enables awaiting futures with debouncing capabilities, allowing developers to control update frequency and reset behavior during rapid state changes.

_xilem\web/src/concurrent · high confidence

A new example demonstrating how to create web elements by raw tag name using custom elements instead of typed elements, events, and attributes. This example shows creating a counter application that uses string-based element definitions via the custom\_element API.

_xilem\_web/web\_examples/counter\_custom\element · high confidence

The counter example now includes an HTML entry point with CSS classes for gray and green backgrounds, and a Rust implementation that allows users to increment, decrement, and reset a click counter. The example demonstrates dynamic behavior by toggling the button's CSS class between gray and green, changing displayed text, and conditionally rendering a 'Huzzah' message when the click count reaches five or more.

_xilem\_web/web\examples/counter · high confidence

The fetch example now demonstrates how to fetch remote data (cat images) within a Xilem Web application. It introduces a \MemoizedAwait\ view to handle asynchronous requests, allowing users to control the number of images fetched via an input field. The example includes logic for debouncing and throttling fetch requests to manage API call frequency, and displays loading states, errors, and the fetched images in the UI.

_xilem\_web/web\examples/fetch · high confidence

The \mathml\_svg\ example now demonstrates rendering a Pythagorean theorem visualization that combines SVG graphics with MathML equations. Users can interact with range sliders to adjust the triangle's side lengths, which dynamically updates the SVG polygon and the corresponding mathematical formula displayed on the page.

_xilem\_web/web\_examples/mathml\svg · high confidence

A new client-side web application example has been added to the xilem\_web examples directory, demonstrating how to open and save text files without a server. The example uses gloo\_file and web\_sys to handle file input and Blob-based downloads, showcasing asynchronous file reading and DOM manipulation within the Xilem Web framework.

_xilem\_web/web\_examples/open\_and\_save\file · high confidence

A new example application has been added to the web\_examples directory that demonstrates how to manage external asynchronous tasks within the Xilem Web framework. The example shows how to spawn a background task (simulating a periodic ping) that can send messages to update the application state, and how to gracefully shut down the task when the associated UI component is removed or stopped.

_xilem\_web/web\_examples/spawn\tasks · high confidence

The masonry application now includes built-in localization resources for its core UI menus, specifically supporting English (US), German (DE), French (CA), and Italian (IT). These new Fluent (.ftl) files define translations for the macOS application menu (e.g., About, Preferences, Hide, Quit), common File menu items (New, Open, Save, Print), and Edit menu actions (Cut, Copy, Paste, Undo, Redo), ensuring these interface elements are displayed in the user's preferred language.

masonry/resources · high confidence

The Android examples (calc, emoji\_picker, http\_cats, mason, stopwatch, to\_do\_mvc, and variable\clock) are now provided as separate \\\_android.rs\ files that act as entry points, importing the core logic from the parent directory. This structure allows each example to be built and run directly on Android devices using \cargo apk\, enabling users to test Xilem applications on mobile hardware without modifying the shared example code.

xilem/examples/android · high confidence

Adds a new interactive example application that showcases the Masonry widget library. The gallery includes a sidebar for navigation and demo pages for core widgets such as Buttons, Labels, Checkboxes, Badges, Dividers, Images, Progress Bars, Sliders, Spinners, Radio Buttons, Step Inputs, Switches, and SVGs. It also demonstrates layout containers like Flex, Grid, and ZStack, and includes a custom HorizontalColorPicker widget to allow users to interactively adjust Slider properties like thumb and track colors.

masonry/examples/gallery · high confidence

This change introduces the \masonry\_winit\ crate, providing the Winit-based windowing and event-loop backend for the Masonry GUI framework. It enables applications to create and manage multiple windows, each with its own render root and persistent \WindowId\. The backend exposes an \AppDriver\ trait for handling widget actions, async events, and lifecycle hooks, including a new \on\_wgpu\_ready\ callback that grants access to the shared WGPU device, adapter, and queue for custom GPU resource creation. Users can now configure WGPU device limits (default, adapter-max, or custom) and set a base background color for windows to support themes like light mode. The implementation handles the conversion of Winit events to Masonry's internal event types, manages clipboard access with fallbacks, and integrates with the \masonry\_imaging\ backend for rendering.

_masonry\winit/src · high confidence

The Placehero application is now available as a functional Mastodon client built using the Xilem GUI framework. Users can browse timelines anonymously or log in to access their accounts. The client features a unified navigation system for switching between the main timeline, user profiles, and status context threads, alongside a dedicated avatar caching system that displays user images with a loading spinner placeholder. Mastodon status content is rendered by sanitizing HTML and converting it to plain text, while media attachments are displayed within the status view.

placehero/src · high confidence

Masonry now supports a structured layer system that separates the main application content from overlays like tooltips, menus, and dialogs. The \RenderRoot\ now manages a \LayerStack\ to track multiple widget trees, each representing a distinct visual layer. Rendering output is exposed via \VisualLayerPlan\, which provides a list of \VisualLayer\ objects containing retained scenes and their transforms, allowing hosts to composite layers individually or replay them in window space for compatibility. This change enables proper z-ordering and independent positioning of UI elements that float above the base content.

_masonry\core/src/app · high confidence

Masonry now supports cascading properties via a new \PropertyStack\ and \Selector\ system. Widgets can define default properties, and these can be overridden by layers that match a widget's \ClassSet\ (which tracks classes and pseudo-classes like hover, active, disabled, and focus). The \PropertyArena\ manages these stacks, and \PropertiesRef\/\PropertiesMut\ resolve property values by checking local properties, then the cascading stack, then defaults, with caching via \PropertyCache\. This enables dynamic styling based on widget state and classes.

_masonry\core/src/core · high confidence

Added a new \login\_model.rs\ module that defines the data structures and persistence logic for the login flow. This includes models for \LoginData\, \MastodonServer\, and \RemoteApp\, along with logic to load and save user credentials to a local \user\_data/login.json\ file. The implementation ensures OAuth tokens are not persisted in plain text and handles server-specific app registrations, laying the groundwork for the authentication UI.

_placehero/src/login\flow · high confidence

Xilem Web now provides \AfterBuild\, \AfterRebuild\, and \BeforeTeardown\ views, allowing developers to run custom callbacks after a DOM element is created, after it is updated, or before it is destroyed. This is supported by a new \App\ runner that manages the application lifecycle and a \ViewCtx\ that handles message thunks and hydration state. The update also introduces \Templated\ views for hydration support, a new \AttributeValue\ type for optimized attribute handling, and a \DiffIterator\ utility for view rebuilding.

_xilem\web/src · high confidence

The masonry\_imaging crate now provides a unified set of backend adapters that bridge Masonry's retained scene output to concrete rendering engines. Users can enable specific backends via feature flags—imaging\_vello, imaging\_vello\_hybrid, imaging\_vello\_cpu, and imaging\_skia—to access corresponding renderer modules. The crate exposes a host-neutral texture rendering helper (texture\_render) for writing Masonry paint output into caller-provided WGPU targets, and provides headless rendering support (including a new headless\_wgpu module) for non-windowed image generation.

_masonry\imaging · high confidence

The new \tree\_arena\ crate provides two tree implementations for use in Masonry: a default safe tree and an optional unsafe tree optimized for performance. The safe tree uses a \Vec\-based structure with a parent map, while the unsafe tree leverages \hashbrown::HashMap\ and \UnsafeCell\ to achieve O(1) node lookups and child access. The crate is \no\_std\ compatible (with \alloc\) and allows users to switch between implementations via the \safe\_tree\ feature flag, with the unsafe version offering significantly faster access times at the cost of requiring manual safety invariants.

_tree\arena/src · high confidence

A new \xilem\_masonry\ crate has been added to implement the Xilem architecture using Masonry widgets as underlying elements. This location provides the core integration layer, including the \Pod\ wrapper to manage widget lifecycles, \WidgetView\ and \WidgetViewSequence\ traits for representing the widget tree, and a \Style\ trait for setting visual properties like dimensions, colors, and borders. It also introduces \ViewCtx\ to handle view context, action routing, and property change tracking, enabling developers to use Masonry widgets directly within Xilem's view hierarchy.

_xilem\masonry/src · high confidence

The \masonry\_core/src/properties\ module now provides a comprehensive set of properties for styling widgets, including \Background\ (supporting solid colors and CSS-like linear, radial, and sweep gradients), \BorderColor\, \BorderWidth\, \CornerRadius\, \BoxShadow\, \Padding\, and \Dimensions\. These properties allow users to define visual appearance and layout constraints, with the framework automatically handling layout recalculation for size-affecting changes (dimensions, padding, borders, shadows) and pre-paint requests for visual changes (background, border color).

_masonry\core/src/properties · high confidence

The \masonry\_core\ crate has been introduced to provide the base GUI engine for Masonry, separating core functionality from the widget library. This new module exposes the \Widget\ trait, event handling, layout communication, and compositing APIs (using \imaging\), allowing library authors to build custom widget sets or alternative drivers with greater compilation parallelism. It re-exports essential dependencies like \imaging\, \parley\, \accesskit\, and \kurbo\, and includes utility traits such as \Sanitize\ for input validation.

_masonry\core/src · high confidence

The \masonry\ crate is introduced as a foundational GUI framework, providing a platform-independent widget tree manager and runtime inspection tools. It ships with a default dark theme (\default\_property\_set\) that defines specific colors (e.g., \BACKGROUND\_COLOR\, \ACCENT\_COLOR\) and layout properties for widgets like Buttons, Checkboxes, and Switches. The crate integrates Vello for graphics, Parley for text, and AccessKit for accessibility, and exposes features such as a widget inspector (F11) and debug layout painting (F12).

masonry/src · high confidence

The \masonry/src/doc\ module now includes a complete set of documentation articles and compilable example code. This adds tutorials for building a "To-Do List" app, creating new widgets (via the \ColorRectangle\ example), and implementing container widgets (via the \VerticalStack\ example). It also introduces a guide for testing widgets using \TestHarness\ and screenshot assertions, alongside a reference on using widget properties. These files serve as the source for the crate's rustdoc and provide verified code snippets for users.

masonry/src/doc · high confidence

The \masonry/examples\ directory now includes a set of runnable applications that demonstrate key features of the framework. These include \hello\_masonry\ for basic setup, \calc\_masonry\ for stateful calculator logic, \grid\_masonry\ for grid layout and dynamic gap adjustment, \to\_do\_list\ for text input and list management, \custom\_widget\ for implementing the full Widget trait with custom painting, \simple\_image\ for image rendering, \layers\ for tooltip overlays, \split\_playground\ for resizable panes, and \virtual\_fizzbuzz\ for infinite virtual scrolling. A README documents each example with screenshots.

masonry/examples · high confidence

The Placehero application now includes dedicated UI components for displaying media attachments, threaded conversations, and user timelines. The new \media.rs\ component renders images, videos, and audio files, utilizing blurhashes for placeholder previews and displaying metadata like file size or duration. The \thread.rs\ component visualizes a status within its conversation context, listing ancestor posts and descendant replies in a column layout with specific padding. The \timeline.rs\ component manages a scrollable list of statuses for a given user, implementing virtual scrolling and background loading of additional posts via a worker to handle large feeds efficiently.

placehero/src/components · high confidence

The \masonry/src/layers\ module now exposes two new layer implementations: \SelectorMenu\, which provides a dropdown list of options for \Selector\ widgets, and \Tooltip\, which displays content until the mouse moves or clicks away. These layers are now publicly exported from the \layers\ module, enabling widgets to attach these specific UI behaviors.

masonry/src/layers · high confidence

The \xilem/examples\ directory now includes a comprehensive suite of demonstration applications, providing concrete usage patterns for the framework. These examples cover fundamental UI concepts such as flex and grid layouts (\flex.rs\, \scroll.rs\), state management via lenses and modular components (\components.rs\, \elm.rs\), and advanced features like asynchronous workers with image loading (\http\_cats.rs\) and canvas rendering (\canvas.rs\). Additional examples demonstrate specific widget capabilities including sliders (\slider\_demo.rs\), emoji pickers (\emoji\_picker.rs\), and memoization techniques (\memoization.rs\), while also illustrating multi-window support (\multiple\_windows.rs\) and integration with external event loops (\external\_event\_loop.rs\).

xilem/examples · high confidence

The \xilem\_masonry/src/view\ module now provides Xilem \View\ implementations for a wide range of Masonry widgets, including \Badge\, \Badged\, \Button\, \Canvas\, \Checkbox\, \CollapsePanel\, \Divider\, \Flex\, \Grid\, and \Image\. These views expose the underlying widgets to the Xilem declarative syntax, allowing users to build UIs with features such as non-interactive badges, optional badged overlays, pointer-aware buttons, custom canvas drawing, styled checkboxes, collapsible panels, configurable dividers, flex and grid layouts, and image fitting.

_xilem\masonry/src/view · high confidence

The \include\_doc\_path\ crate introduces a proc-macro that resolves local file paths to valid URLs for use in documentation. When a file exists locally, it returns the local path; otherwise, it generates a fallback URL pointing to the file on GitHub (using the repository URL, crate version, and name). This ensures documentation links remain valid both during local development and when published to docs.rs or other hosting services.

_include\_doc\path · high confidence

The library introduces new \MainAxisAlignment\ and \CrossAxisAlignment\ enums in the \masonry/src/properties/types\ module to control how widgets are positioned within containers. \MainAxisAlignment\ offers options like \Start\, \Center\, \End\, \SpaceBetween\, \SpaceEvenly\, and \SpaceAround\ for arranging children along the main axis. \CrossAxisAlignment\ provides \Start\, \Center\, \End\, \Stretch\, and new baseline-based options (\FirstBaseline\, \LastBaseline\) to align widgets along the cross axis, with specific logic to handle baseline alignment and overflow behavior.

masonry/src/properties/types · high confidence

Added two new examples in \xilem\_core/examples\ that showcase the updated \View\ trait API. The \filesystem.rs\ example demonstrates state-driven file operations (create, rename, write) using a custom \FsPath\ element and the new \ViewCtx\ environment system. The \user\_interface.rs\ example provides a model of the Masonry widget system, illustrating how to implement the \View\ trait for a custom widget (\Button\) with \WidgetBox\ elements, including build, rebuild, teardown, and message handling within the new generic \View\ framework.

_xilem\core/examples · high confidence

Added new rustdoc articles in the \masonry\_core\ documentation module that define core widget statuses (such as disabled, stashed, and focus states) and detail the internal architecture of the pass system, including event, rewrite, and render passes.

_masonry\core/src/doc · high confidence

The widget library in \masonry/src/widgets\ has been expanded with several new components to support more complex UI structures. The \Align\ widget allows positioning a single child using \UnitPoint\ coordinates, while \Flex\ provides a configurable horizontal or vertical container with support for gaps and child constraints. For visual annotations, \Badge\ creates non-interactive pill-shaped labels (with numeric count formatting), and \Badged\ overlays a badge onto existing content with configurable placement. Structural UI is supported by \CollapsePanel\ and \DisclosureButton\ for collapsible sections, and \Divider\ for drawing horizontal or vertical lines with optional labels and dash patterns. For custom rendering, the \Canvas\ widget accepts a painter callback to draw arbitrary graphics. These additions provide foundational building blocks for layout, decoration, and custom drawing within the Masonry framework.

masonry/src/widgets · high confidence

A new example application has been added to the xilem\_web web examples that demonstrates how to access raw DOM nodes via \after\_build\, \after\_rebuild\, and \before\_teardown\ lifecycle hooks. This example illustrates a pattern for interacting with external JavaScript libraries or performing direct DOM manipulation, such as focusing an input element after it is rebuilt, while noting that these callbacks do not trigger subsequent rebuilds.

_xilem\_web/web\_examples/raw\_dom\access · high confidence

The masonry\_testing crate now includes several new tools to simplify widget testing. It introduces \assert\_any\, \assert\_all\, and \assert\_none\ functions for more descriptive predicate assertions, and an \assert\_debug\_panics\ macro to verify debug-mode panics. A new \DebugName\ property allows tying human-readable names to widgets for easier debugging. Additionally, the crate provides \ModularWidget\ for constructing widgets from individual callback functions, \Recorder\ for tracking widget method calls during tests, and \WrapperWidget\ for dynamically replacing child widgets.

_masonry\testing/src · high confidence

The \xilem\_core/src/views\ module now provides a comprehensive set of view adapters and type-erasure utilities. Users can now use \AnyView\ for dynamic, type-erased views, and \OneOf\ (with variants \Either\, \OneOf2\–\OneOf9\) for statically typed conditional views. New adapter views include \lens\ for accessing nested state, \map\_state\ and \map\_message\ (via \map\_action\) for transforming state and actions between parent and child views, \memoize\ and \frozen\ for optimizing view construction, \fork\ for running side-effect views alongside active views, and \run\_once\ for executing code exactly once during view build. Additionally, \Box\ and \Rc\/\Arc\ wrappers now implement \View\ with optimized rebuild logic, and \OrphanView\ allows implementing \View\ for external types like primitives and strings.

_xilem\core/src/views · high confidence

The \masonry/src/properties\ module now exposes a comprehensive set of configurable properties for widgets, allowing users to customize appearance and behavior. This includes visual styling properties such as \ContentColor\, \PlaceholderColor\, \CaretColor\, \SelectionColor\, \BarColor\, \TrackColor\, \ThumbColor\, and \CheckmarkColor\, as well as layout and interaction properties like \ObjectFit\, \LineBreaking\, \Gap\, \ThumbRadius\, \TrackThickness\, and \AutoHideScrollBar\. New widgets like \StepInput\ are supported via specific properties (\StepInputStyle\, \BackwardColor\, \ForwardColor\, \HeatColor\), and existing widgets like \Slider\ and \ProgressBar\ now expose their customizable attributes through this unified property system.

masonry/src/properties · high confidence

The \xilem\_web/src/svg\ module now provides views for rendering SVG elements, including \Fill\ and \Stroke\ modifiers that apply color and opacity attributes to child views, and \OrphanView\ implementations for \kurbo\ shapes (\Line\, \Rect\, \Circle\) that generate the corresponding SVG elements with their geometric attributes.

_xilem\web/src/svg · high confidence

The view system now supports composing multiple views into arrays, tuples, vectors, and optional sequences, allowing developers to group and manage child views more flexibly. Additionally, a new \without\_elements\ adapter enables embedding side effects directly into the view flow without generating UI elements, offering an alternative to \fork\ for managing state updates within existing view sequences.

_xilem\_core/src/view\sequences · high confidence

The \src\ directory's legacy Xilem prototype implementation has been removed. This change deletes the core application lifecycle (\App\, \AppLauncher\), the view and widget traits (\View\, \Widget\), and supporting modules for event handling, IDs, and view sequences. This cleanup eliminates the skeletal proof-of-concept code in favor of the current architecture.

src · high confidence

The \src/view\ directory has been cleaned up by deleting several legacy view implementation files, including \adapt.rs\, \any\_view.rs\, \button.rs\, \layout\_observer.rs\, \memoize.rs\, \text.rs\, \use\_state.rs\, and \vstack.rs\. This change removes the old view definitions and associated types from this location, likely as part of a broader refactoring or migration to a new view architecture.

src/view, src/widget · high confidence

The counter example file has been removed from the examples directory, eliminating this specific demonstration of the application's functionality.

examples · high confidence

Xilem Core has been refactored to introduce a new generic View trait and a dedicated environment system for sharing values across the view tree. This change adds new modules for elements (ViewElement, SuperElement, NoElement), view sequences with element splicing, and an Environment type that allows views to provide and access context resources. It also introduces new message handling primitives (DynMessage, SendMessage, MessageCtx) and a message proxy for asynchronous communication, while reorganizing the crate's public API to expose these new core primitives.

_xilem\core/src · high confidence

The \masonry\_core/src/passes\ module has been reorganized into a dedicated, structured render-pass system. This change introduces distinct, modular files for each stage of the rendering pipeline—\accessibility\, \action\, \anim\, \compose\, \event\, \layout\, \mutate\, \paint\, and \update\—replacing the previous monolithic or less-structured implementation. For users, this provides a clearer separation of concerns within the framework's core, enabling more maintainable widget lifecycle management and potentially easier debugging via the new \PassTracing\ configuration (controlled by the \MASONRY\_TRACE\_PASSES\ environment variable).

_masonry\core/src/passes · high confidence

The layout module in \masonry\_core\ has been replaced with a new implementation that defines widget sizing using logical pixels. This change introduces a dedicated \Length\ type to represent distances, along with traits like \AsUnit\ to simplify creating lengths from numeric values. It also adds new types for layout definitions (\Dim\, \LenDef\, \LenReq\, \SizeDef\) to specify how widgets determine their size (e.g., fixed, auto, ratio, min/max content), a \LayoutSize\ struct to hold computed dimensions, and a \MeasurementCache\ to optimize layout performance. Additionally, a \UnitPoint\ type is provided for normalized coordinate alignment.

_masonry\core/src/layout · high confidence

The \xilem\_web\ modifiers module has been completely rewritten to improve efficiency and correctness when managing DOM element properties. The new implementation introduces dedicated modifier types for attributes (\Attributes\), CSS classes (\Classes\), and inline styles (\Styles\), each tracking changes via internal indices and dirty flags to minimize unnecessary DOM updates. A new \OverwriteBool\ modifier optimizes boolean attribute handling (such as \checked\ or \disabled\ on input elements) using bitflags to avoid allocations. Additionally, style application now explicitly supports \MathMlElement\s alongside HTML and SVG elements, ensuring consistent styling across all supported DOM node types.

_xilem\web/src/modifiers · high confidence

The Xilem application entry point has been restructured to support multiple windows and runtime customization. The \Xilem\ builder now accepts an app logic function that returns an iterator of \WindowView\ objects, enabling multi-window applications, while \Xilem::new\_simple\ remains for single-window apps that exit on close. The \WindowView\ now exposes \with\_base\_color\ and \with\_default\_properties\ methods, allowing users to customize the window background color and apply tree-wide default properties (themes) at runtime. The internal \MasonryDriver\ has been updated to manage a map of windows and handle their lifecycle, including creation, logic updates, and teardown, while integrating with a Tokio runtime for async event handling.

xilem/src · high confidence

Add widget list performance benchmarks; Added build stress tests for Xilem; Added integration tests for example widgets with zero-size layouts; Added integration tests for xilem\_core view implementations; Added test utilities for Xilem Core view lifecycle; Added tests for TreeArena basic operations and memory safety; Comprehensive test coverage for Masonry core passes and features.

This update releases Xilem and Masonry at version 0.4.0, migrating the workspace to the Rust 2024 edition and raising the minimum supported Rust version (MSRV) to 1.96. The dependency graph has been significantly updated, including Vello to 0.8.0, wgpu to 28.0.0, Parley to 0.8.0, and AccessKit to 0.24.0. The workspace structure has been standardized with a root \Cargo.toml\ defining shared versions and linting rules, and new crates such as \include\_doc\_path\ and \tree\_arena\ (v0.2.0) have been added to support documentation and tree management.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 66.

• Code Health 82
• Architecture 97
• Maturity 79
• Readiness 76
• Security 83
• Domain Modelling 100
• Accessibility 49

• 300 commits — 266 feature/other, 34 fixes

• masonry/src — 98 commits
• masonry_core/src — 56 commits
• (root) — 25 commits
• masonry/screenshots — 19 commits
• xilem/src — 17 commits
• xilem_masonry/src — 13 commits
• masonry_winit/src — 12 commits
• masonry/examples — 10 commits
• xilem_core/src — 9 commits
• xilem_web/web_examples — 8 commits
• xilem/examples — 5 commits
• masonry_testing/src — 4 commits
• tree_arena/src — 4 commits
• masonry_imaging/src — 3 commits
• .github/workflows — 2 commits
• include_doc_path/src — 2 commits
• xilem/Cargo.toml — 2 commits
• xilem/README.md — 2 commits
• docs/assets — 1 commit
• docs/flake.lock — 1 commit

• fix: Apply default font to fix number rendering in fontconfig environments (#1831)
• fix: Bump git Vello to fix rendering artifacts (#1546)
• fix: Fix Parley glyph y-offset rendering (#1769)
• fix: Fix Portal view internals (#1520)
• fix: Fix Slider widget not working with non-mouse pointers (#1670)
• fix: Fix Slider widget properties (#1770)
• fix: Fix TextInput placeholder invisible to assistive technologies (#1832)
• fix: Fix Portal::set_viewport_pos dirty flag choice. (#1814)
• fix: Fix Portal MinContent measurement. (#1585)
• fix: Fix Portal scrollbar rendering. (#1587)
• fix: Fix ProgressBar painting. (#1599)
• fix: Fix ScrollBar behavior with large content sizes. (#1537)
• fix: Fix ScrollBar pointer move handler. (#1582)
• fix: Fix Split bar area. (#1580)
• fix: Fix TextInput placeholder text alignment (#1504)
• fix: Fix click_anchors_focus test and focus anchor behavior (#1621)
• fix: Fix clippy::collapsible_match lints (#1749)
• fix: Fix masonry/examples folder (#1509)
• fix: Fix accessibility region in TextArea. (#1805)
• fix: Fix alignment of oversized children. (#1674)
• …and 280 more

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

linebender/xilem 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.