fschutt/azul

Azul is a cross-platform desktop GUI framework written in Rust that renders user interfaces using a CSS-driven layout engine and a retained-mode CPU compositor. It provides native integrations for hardware features such as camera, audio, sensors, and video decoding across Windows, macOS, Linux, iOS, and Android. The system includes a comprehensive code generation toolchain that produces idiomatic bindings for over twenty programming languages, enabling broad ecosystem interoperability.

69 changes.

This period focused on integrating the WebRender GPU engine and replacing the windowing backend with a new cross-platform shell supporting macOS, Windows, Linux, iOS, and Android. The work included rewriting the layout and text engines, expanding multi-language code generation, and establishing comprehensive testing and documentation tooling.

112 changes.

This period focused on expanding the Azul framework's reach by generating idiomatic bindings for a vast array of programming languages, including C\#, Go, Rust, Ada, and many others. Simultaneously, the project implemented comprehensive native backends for mobile and desktop platforms, adding support for Android, iOS, and Linux with features like hardware-accelerated video, geolocation, and system media controls. The work also included significant infrastructure improvements, such as a headless testing environment, supply-chain security gates, and a new telemetry system.

The codebase now includes a new Ada language binding generator (v2) that produces idiomatic Ada 2012 bindings for the Azul GUI framework. The generator outputs a complete GNAT project structure, including a spec (azul.ads) and body (azul.adb), along with a ready-to-use GNAT project file (azul.gpr) for building and linking against the native libazul library. Key features include automatic FFI function imports with exact C symbol mapping, managed memory handling via Ada.Finalization.Controlled wrappers that automatically call C destructors on scope exit, and a host-invoker runtime pattern to safely route user callbacks through a handle table. The generator also handles complex type mappings, including tagged-union enums as Ada variant records, monomorphized type aliases, and topological ordering of type definitions to resolve mutual recursion.

_doc/src/codegen/v2/lang\ada · high confidence

The Ada example now includes a smoke test that initializes the host-invoker subsystem and verifies that object references can be created and recovered via FFI without address mismatch. This confirms the basic interoperability plumbing for Ada bindings, serving as a foundational test for the new language support.

examples/ada · high confidence

A new Algol 68 example has been added to the showcase directory, demonstrating a counter application built with the Azul framework. This file illustrates how to define data models, create UI layouts with buttons and labels, and handle click events using Algol 68 syntax.

examples/algol68 · high confidence

The examples/lisp directory now includes a runnable Common Lisp example using SBCL and CFFI. This addition provides a hello-world application that demonstrates refany round-trip smoke testing and basic DOM manipulation (text, div, button with click handlers) via generated bindings. Note that full GUI functionality on macOS is currently blocked by an NSApp threading conflict with SBCL's runtime ownership of the main thread.

examples/lisp · high confidence

A new Crystal example has been added to the examples/crystal directory, demonstrating a basic application built against the Azul layer. The example includes a shard.yml manifest and a hello-world.cr source file that implements a simple counter UI with a label and button, providing users with a concrete starting point for building Crystal applications with Azul.

examples/crystal · high confidence

A new Fortran example demonstrates the host-invoker dispatch mechanism using a generic \class(\*)\ model. The \hello\_world.f90\ file implements a counter application that handles type mismatches gracefully by logging errors instead of crashing, while the accompanying \Makefile\ configures the build with F2008 standard compliance and specific compiler flags.

examples/fortran · high confidence

The Go examples directory now includes a counter application that imports the Azul UI library via the azul.rs/ui/go module path. The example demonstrates a basic interactive widget with a label and button, utilizing the updated Go bindings for layout and event handling.

examples/go · high confidence

A new Julia example application has been added to the examples directory, demonstrating a counter-incrementing UI using the Azul framework. The code includes a data model, callback handlers for button clicks and layout rendering, and window initialization, providing a reference implementation for Julia users.

(repo-wide) · high confidence

A new 'Hello World' example has been added for the Odin programming language, demonstrating how to integrate with the Azul UI framework. This example implements a simple counter application, showing users how to define a data model, handle state updates via click events, and render a layout with a button and text label using Odin-specific bindings.

examples/odin · high confidence

A new PHP example (\examples/php/hello-world.php\) has been added, showcasing a counter application using the Azul PHP bindings. The example initializes the \azul-dll\ extension, registers layout and click callbacks, and renders a button that increments a counter value displayed in the UI.

examples/php · high confidence

The examples/pascal directory now includes a complete, runnable hello-world application (hello-world.lpi and hello-world.pas) demonstrating the new idiomatic Pascal bindings. Users can now see how to define a model, use the TAzApp\<T\> generic wrapper, and leverage the new typed callback surface (OnClick\<T\>) and builder-style API (e.g., .SetButtonType, .WithCss) to create a simple counter interface.

examples/pascal · high confidence

Introduces a new code generation backend for PowerShell that produces an \Azul.psm1\ module and \Azul.psd1\ manifest. The module embeds the C\# P/Invoke layer (generated via \Add-Type\ at import time) and exposes idiomatic \Verb-AzulNoun\ function shims (e.g., \New-AzulApp\, \Invoke-AzulAppRun\) that delegate to the C\# wrapper classes, allowing users to interact with the Azul GUI framework using standard PowerShell cmdlet conventions.

_doc/src/codegen/v2/lang\powershell · high confidence

A new 'hello-world' example has been added to the Red examples directory, demonstrating a full-GUI counter application built using Red/System and the Azul FFI. This example illustrates how to define a data model, register layout and click callbacks, and construct a UI with a label and button using the Red dialect.

examples/red · high confidence

A new VB6 example project has been added to the examples directory, demonstrating how to interact with the Azul GUI engine from Visual Basic 6. The project includes a module (HelloWorld.bas) and a project file (HelloWorld.vbp) that set up a simple application with a counter and a button, utilizing the Azul FFI to create windows, manage state, and handle user interactions.

examples/vb6 · high confidence

Users can now run the Azul hello-world example in Zig. The change introduces a \build.zig\ manifest that configures the Zig build system to link against the prebuilt native library and a \hello-world.zig\ source file demonstrating an idiomatic implementation using a named data model, typed comptime callbacks, and the lowerCamelCase API.

examples/zig · high confidence

The webrender/swgl module now includes a Rust implementation of the shader logic previously handled by C++ GLSL, enabling a software-rendered path for WebRender. This change introduces the core rendering infrastructure in src/common.rs (handling GPU cache, transforms, and primitive headers) and provides specific shader implementations in src/shaders/ for various brush types, including solid colors, image blending, and advanced alpha-pass effects with antialiasing and texture repetition.

webrender/swgl · high confidence

New asset files have been added to support the C examples: a full XHTML/CSS layout for a spreadsheet application (mimicking Excel's ribbon interface) and a JSON file containing GeoJSON MultiPolygon data for map rendering. These assets provide the structural and data foundations for the respective demo applications.

examples/c · high confidence

Users can now install the Azul shared library via the Arch User Repository (AUR) using the new PKGBUILD, which builds the C-ABI library and headers. Additionally, documentation for the Python bindings has been added to the PyPI packaging directory, clarifying that the native extension is bundled in the wheel via maturin.

packaging · high confidence

A new HTML probe file (doc/probes/fontblend-probe.xht) has been added to visually verify LCD subpixel text blending. It displays text samples in various sizes (12px and 16px) and colors (white and black) against a range of background colors (green, blue, red, yellow, gray, near-black, and white) to help validate the rendering quality of the colorimetric LCD text blending feature.

doc/probes · high confidence

A new Lua example demonstrating a counter application has been added to the examples directory. The file shows how to create a window with a label and a button, handle click events to update the model, and run the application using the Azul framework.

examples/lua, examples/ruby · high confidence

Introduced a new code generator for the Red and Red/System languages, which emits a single \azul.reds\ include file containing FFI bindings to the prebuilt \libazul\ C-ABI shared library. The generator handles platform-specific library loading (\.dll\, \.dylib\, \.so\), defines type aliases for C structs, maps unit enums to integer constants, and implements host-invoker plumbing for callbacks via parallel arrays to manage handle lifetimes. This module is currently marked as alpha and is not yet wired into the main orchestrator.

_doc/src/codegen/v2/lang\red · high confidence

A new command-line utility, azinput, has been added to the documentation directory to facilitate GUI testing. It injects synthetic pointer, keyboard, and touch events into a KWin Wayland session by implementing the \org\_kde\_kwin\_fake\_input\ protocol. This allows automated tests to simulate user interactions—such as clicks, drags, scrolling, and key presses—without requiring root access or physical hardware, ensuring events are routed through the compositor as genuine input.

doc/aztest · high confidence

New utility scripts have been added to the \scripts/debugging\ directory to aid in verifying Azul's behavior on Linux Wayland sessions. \azinput-portal.py\ injects real pointer, keyboard, and wheel events via the xdg-desktop-portal RemoteDesktop API, ensuring input reaches applications through the compositor. \azshot.py\ captures silent screenshots using the xdg-desktop-portal Screenshot API. \azul-a11y-probe.py\ verifies accessibility support by probing the AT-SPI desktop for an accessibility tree published by Azul. Additionally, \az-crosscheck.sh\ automates \cargo check\ across multiple target platforms (macOS, Linux, Windows) to ensure cross-platform compilation validity.

scripts/debugging · high confidence

The \azul-doc\ tool now includes a \doc-coverage\ command that analyzes \api.json\ to identify public-facing items (structs, fields, enum variants, constructors, and methods) lacking documentation. It maps these gaps to their corresponding Rust source files and generates balanced task files for multiple agents to add \///\ doc comments, facilitating a workflow where documentation is added to the source code and then synced back into the API manifest.

_doc/src/doc\coverage · high confidence

A new shell script (ios-runner.sh) has been added to the project to facilitate deploying iOS applications. This script accepts an executable path as an argument, constructs the corresponding .app bundle path, and uses the ios-deploy tool to install and launch the application on a connected device.

dll/scripts · high confidence

The Android backend now includes an accessibility bridge that exposes the UI tree to TalkBack via \AccessibilityNodeProvider\, and implements system clipboard read/write operations using JNI to interact with \ClipboardManager\. These additions enable screen reader support and standard copy/paste functionality on Android, which were previously missing or non-functional.

dll/src/desktop/shell2/android · high confidence

This change introduces the core Java/Kotlin infrastructure required to run Azul apps on Android, replacing the previous state where the engine was largely invisible to the platform. It adds AzulActivity to manage the application lifecycle and explicitly load the native library, ensuring Java-side native methods resolve correctly. New bridges provide TalkBack accessibility support via AzulAccessibilityBridge, file management through the Storage Access Framework in AzulFilePicker, and biometric authentication via AzulBiometric. It also adds bridges for gamepad input and IMU sensors (AzulGamepad), location services (AzulGeolocation), secure secret storage (AzulKeyring), and system media sessions with audio focus management (AzulMediaSession). The AndroidManifest.xml is configured to declare necessary permissions and the main activity, enabling features like dark mode detection, window insets, and runtime permission handling.

scripts/android · high confidence

Mobile builds now use an asynchronous file picker that integrates with the OS-native UI: Android uses the Storage Access Framework (SAF) via JNI, and iOS uses UIDocumentPickerViewController. The picker is registered as a backend for the layout layer's FileDialog, allowing open, save, and directory selection to return immediately with a handle that users poll for the result, avoiding UI thread blocking.

_dll/src/desktop/extra/file\picker · high confidence

The Azul Writer example now features a complete document editing interface with a ribbon toolbar, backstage menu, and virtualized page canvas. It introduces an intermediate representation (IR) that unifies Markdown and DOCX inputs into a single editable model, enabling live word counts and structural formatting. The UI mimics an Office-style layout with a QuickAccess bar, a Backstage for file operations, and a ribbon for text styling, all rendered using a virtual view for efficient page scrolling.

examples/azul-writer · high confidence

The AzulPaint example application has been introduced, providing a brush canvas that supports undo/redo, background images, and PNG export. It features a GPU-accelerated metaball shader effect that reacts to pen pressure, tilt, and barrel roll, with a CPU fallback. The app includes a window menu bar, a telemetry HUD for pen input, and is packaged with a Dockerfile for web deployment.

examples/azul-paint · high confidence

The \css/src/codegen\ module now provides a pluggable code-generation system that converts parsed CSS into standalone project source code for multiple languages. The Rust backend is fully implemented, generating a \const CSS\ literal, a \src/main.rs\ skeleton, and a \Cargo.toml\ file. Stub backends for C++ and Python are also added to the dispatch layer, ensuring that requests for these languages return structured responses rather than 404 errors, while the Rust backend handles the actual code emission logic.

css/src/codegen · high confidence

The \css/src\ crate now provides the core data model and parsing infrastructure for the application's styling system. This includes FFI-safe core types like \AzString\ and \EmptyStruct\ for cross-language interoperability, a comprehensive \Css\ data structure for managing stylesheets, rules, and keyframes, and a new \DynamicSelector\ system that enables runtime evaluation of selectors based on OS, media queries, theme, and pseudo-states. The module also introduces a robust CSS parser (\parser2\) that supports modern features like CSS nesting, variables, and at-rules, alongside a new \cast\ module for safe numeric conversions and a \compact\_cache\ for efficient style resolution.

css/src · high confidence

The DLL crate now includes an embedded web end-to-end test executor (dll/src/e2e\_web\_runner.rs) that allows running the application binary as a test harness against a remote web server URL, extracting a brotli-compressed JS bundle and executing it via Node, Bun, or Deno. Additionally, a new PHP extension entry point (dll/src/php\_extension.rs) has been added, wiring host-invoker primitives to the Zend engine to enable calling back into PHP from C function pointers, alongside granular C-ABI feature flags and strict linting in the main library.

dll/src · high confidence

The Rust examples directory has been significantly expanded with new demonstration applications covering timer-driven animations, asynchronous map rendering with HTTP clients, a calculator, Fluent and ICU localization, infinite-scroll spreadsheets, OpenGL rendering, resumable dialogs (file, HTTP, DB), and an MS Office-style ribbon widget. Additionally, a new .cargo/config.toml has been added to redirect the build target directory to a shared consumer path.

examples/rust · high confidence

The library now exposes a generic HID interface that allows applications to interact with raw HID devices (such as flight sticks, racing wheels, and Stream Decks) beyond standard gamepads. This change introduces platform-specific backends: Linux support via \/dev/hidraw\*\ character devices, macOS support via \IOHIDManager\ with Input Monitoring permission handling, and Windows support via the Raw Input API (\WM\_INPUT\). The implementation provides device enumeration, real-time report polling, and the ability to read feature reports for per-pad calibration. It also establishes a per-instance identity for devices to ensure stable identification across reconnections.

dll/src/desktop/extra/hid · high confidence

The Go language bindings have migrated from a cgo-based implementation to purego, eliminating the need for a C compiler during builds and enabling seamless cross-compilation. This change introduces a new code generation layer in \doc/src/codegen/v2/lang\_go\ that emits Go packages using the \github.com/ebitengine/purego\ library (pinned to v0.10.2) for runtime symbol binding and callback trampolines. The generated code includes idiomatic wrapper types with automatic memory management via \runtime.SetFinalizer\, a host-invoker pattern for callbacks, and native Go type mirrors that ensure ABI compatibility with the underlying \libazul\ without requiring CGO.

_doc/src/codegen/v2/lang\go · high confidence

The video codec module now supports real hardware decoding of H.264 video on Linux and Windows using the Vulkan Video API (via the \gpu-video\ crate). This change introduces a new Vulkan-backed decoder that processes Annex-B H.264 streams and outputs RGBA8 frames, along with an MP4-to-H.264 demuxer to prepare the data for the decoder. A streaming decode worker has been added to handle video playback on a background thread, ensuring the UI remains responsive. The module also includes a hardware capability probe to detect if the system supports Vulkan Video decode and can remediate missing drivers. On Apple platforms, the module continues to use the VideoToolbox backend (loaded dynamically), while other platforms fall back to stubs.

_dll/src/desktop/extra/video\codec · high confidence

A new Haskell example application (HelloWorld.hs) has been added to the examples directory. It demonstrates a basic counter application using the Azul framework, featuring a data model, a click handler that increments the counter, and a layout with a label and button.

examples/haskell · high confidence

The layout crate now includes a complete headless end-to-end testing infrastructure, ported from the DLL's desktop shell. This adds a CPU-based render backend (\CpuBackend\) that performs incremental damage diffing to support precise visual assertions, a JSON-driven scenario runner that emulates the platform event loop and timer system, and an HTTP debug server for cross-platform automated testing. The runner enables deterministic, wall-clock-free execution of E2E scenarios, allowing tests to assert on layout, damage, and state changes without a real display server.

layout/src/e2e · high confidence

Added the \webrender/api\ crate, providing the public interface and data structures for the WebRender rendering engine. This includes definitions for display items, colors, fonts, images, and gradients, along with serialization support via Serde and cross-platform channel implementations for inter-process communication. A backport of the \precise\_time\_ns\ function is also included to maintain compatibility with the \time\ 0.3.x API.

webrender/api · high confidence

The repository is initialized with the foundational configuration for the Azul desktop GUI framework, including a pinned Rust toolchain (1.91.0), a Dockerfile for in-process WebAssembly lifting via remill, and a new MIT license. The project introduces a build environment setup for worktrees to share target directories and defines the initial API surface and code generation tooling (azul-doc) required to generate bindings for multiple languages.

(repo-wide) · high confidence

The C++ code generator has been rewritten for v2, introducing a modular architecture that produces C++ headers tailored to specific language standards (C++03, C++11, C++14, C++17, C++20, and C++23). This change adds new generator modules that implement a \CppDialect\ trait, allowing the system to emit appropriate syntax for each version—for example, using Colvin-Gibbons proxy structs for C++03 move emulation, real move semantics and \noexcept\ for C++11, \std::optional\ and \\[\[nodiscard\]\]\ for C++17, and \std::span\ or \std::expected\ for C++20/23. The new code also includes shared utilities for escaping C++ reserved keywords (such as \linux\, \unix\, \near\, and \far\) to prevent macro collisions, and implements a \RefAny\-based reflection system with template helpers for type-safe downcasting and JSON serialization across all dialects.

_doc/src/codegen/v2/lang\cpp · high confidence

Adds a new Crystal language binding generated from the Azul API definition. The binding provides a low-level \LibAzul\ module that mirrors the C ABI one-to-one, and an idiomatic \Azul::\ wrapper layer that exposes native Crystal types (such as \String\, \Array(T)\, and \T?\), handles memory ownership via finalizers, and manages callbacks through trampoline functions and handle tables. The generated code includes a Crystal shard structure with a \shard.yml\ manifest, runtime support for object lifecycle management, and wrapper classes for all API structs and enums.

_doc/src/codegen/v2/lang\crystal · high confidence

A new semi-automated verification system has been added to the documentation tooling to check the CSS layout engine against W3C specifications. This pipeline downloads relevant W3C CSS specs (such as CSS 2.2, Text, Sizing, Display, Overflow, Positioning, and Writing Modes), extracts relevant paragraphs using keyword matching, and organizes verification tasks into a dependency-based skill tree. It provides commands to run parallel AI agent sessions for generating implementation patches, review prompts for architecture and code quality checks, and tools to apply and track the status of these verification steps.

doc/src/spec · high confidence

Added the \azul.iroh\ module providing a peer-to-peer QUIC endpoint (\IrohEndpoint\) with hole punching and relay fallback, allowing applications to connect directly to peers or via configured relay servers. The change includes a load balancer (\IrohLoadBalancer\) that selects forwarders based on peer capacity and stability, and defines a set of configuration types (\IrohConfig\, \IrohEvent\) and data structures for managing connections, frames, and messages.

dll/src/desktop/extra/iroh · high confidence

The build system now includes a new Rust module (webrender/build/src) that handles shader source parsing, feature flag evaluation, and string generation at compile time. This change introduces support for GL and GLES shader versions, manages shader imports, and configures specific rendering features such as dithering, dual-source blending, and advanced blend equations, ensuring shaders are correctly generated based on the target platform and enabled features.

webrender/build · high confidence

The texture packing module now includes a new \GuillotineAllocator\ implementation, adding a bin-packing strategy for 2D rectangle allocation within texture atlases. This change introduces the \guillotine.rs\ module and updates \mod.rs\ to expose the new allocator alongside existing ones, allowing the rendering pipeline to utilize this specific packing algorithm for texture memory management.

_webrender/core/src/texture\pack · high confidence

The codebase now generates a complete D language binding for the Azul GUI framework, providing both a raw C-ABI layer (\azul.raw\) and an idiomatic D API (\import azul\). The idiomatic layer maps C types to native D equivalents (e.g., \string\, \T\[\]\, \Nullable!T\), implements refcounted handle structs for ownership management, and uses free functions with typed parameters for callbacks instead of closures. The generated output includes a single-file \azul.d\ for simple usage and a \dub\ package structure for integration, complete with compile-time checks and exception handling for moved values and variant errors.

_doc/src/codegen/v2/lang\d · high confidence

The \webrender/glyph\ crate has been replaced with a new pure-Rust implementation that eliminates external C dependencies (such as FreeType, CoreText, and DirectWrite) from the text rendering pipeline. This change enables WebRender-based applications to compile and run in pure-Rust environments like Redox OS and wasm32. The new rasterizer uses \azul-layout\ for font parsing and \agg-rust\ for rendering vector glyph outlines into anti-aliased alpha masks. While it maintains API compatibility with the official \wr\_glyph\_rasterizer\, it currently supports only grayscale anti-aliasing and does not include platform-specific subpixel rendering or advanced hinting.

webrender/glyph · high confidence

The shell2 windowing system now includes a shared common module providing the foundational components for all platform backends. This includes a unified event processing system that uses state-diffing to detect and dispatch input events consistently across macOS, Windows, X11, and Wayland. A new CPU compositor stub enables software rendering as a fallback or default mode, while a thread-safe accessibility action queue ensures assistive technology requests are properly queued and processed regardless of the platform. Additionally, dynamic library loading utilities and comprehensive error types for window, compositor, and library operations are now available to all backends, along with a deterministic end-to-end test harness for memory leak detection.

dll/src/desktop/shell2/common · high confidence

The application now uses the new \shell2\ module as its windowing backend, providing a unified event loop and window management layer for macOS, Windows, Linux (X11 and Wayland), iOS, and Android. By default, the system uses CPU (software) rendering, ensuring consistent output across platforms and simplifying E2E testing in headless environments. Users can switch to GPU rendering or headless mode via the \AZ\_BACKEND\ environment variable.

dll/src/desktop/shell2 · high confidence

The codebase now uses a new v2 code generation system that builds a language-agnostic Intermediate Representation (IR) from \api.json\ to produce bindings for multiple languages. This includes a unified generator dispatching to language-specific emitters for C, C++, Rust, and Python, alongside a new C-ABI layout calculator to ensure correct memory representation across targets. The system also introduces comprehensive bug-class tests to validate IR invariants and generated output, and adds support for new language targets such as PHP extensions and Crystal, while removing the legacy v1 code generator.

doc/src/codegen/v2 · high confidence

Adds a new \Db\ handle implementation backed by the \turso\ SQLite engine (behind the \db-sqlite\ feature), providing a local-first key/value store with index support and automatic background synchronization. The engine is conditionally compiled: it is active on most targets but disabled on 32-bit Linux due to compilation constraints, where the database handle will fail to open rather than crash. This change introduces the core persistence layer for the desktop application, enabling offline data storage and conflict-resolved syncing via HTTPS.

dll/src/desktop/extra/sqlite · high confidence

The Kotlin code generator now emits a single \Azul.kt\ file that includes idiomatic wrapper classes implementing \AutoCloseable\ for memory safety, as well as derived value-surface methods (such as \toString\, \equals\, \hashCode\, and \compareTo\) for types that do not have standard wrapper classes. It also generates a managed-FFI host-invoker runtime (\AzulHostInvoker\) to handle callback dispatch and memory management, and produces a \build.gradle.kts\ script for building Kotlin applications with JNA dependencies.

_doc/src/codegen/v2/lang\kotlin · high confidence

Added a new \accessibility.rs\ module for the X11 backend that bridges Azul's accessibility tree to Linux AT-SPI using the \accesskit\_unix\ library. This enables screen readers and assistive technologies to interact with Azul applications on Linux by providing an adapter that handles tree updates, focus state changes, and root window bounds, while safely handling potential DBus connection failures.

dll/src/desktop/shell2/linux/x11 · high confidence

Applications on Linux with the GNOME desktop environment now display their menus in the system application menu bar instead of client-side decorations. This is achieved by implementing the \org.gtk.Menus\ and \org.gtk.Actions\ DBus protocols, which converts the application's internal menu structure into the flat format expected by GNOME Shell. The implementation uses \dlopen\ to load \libdbus-1\ at runtime, allowing for cross-compilation support, and sets the necessary X11 window properties to advertise the menu service to the desktop. Users can disable this feature by setting the \AZ\_DISABLE\_GNOME\_MENUS=1\ environment variable.

_dll/src/desktop/shell2/linux/gnome\menu · high confidence

The layout module now exposes native OS dialog capabilities (message boxes, file open/save, and color picker) on desktop platforms via the \tfd\ crate, while providing no-op safe defaults on Android and iOS to maintain a consistent API surface across all targets.

layout/src/desktop · high confidence

The Linux Wayland backend now supports native clipboard operations and window capture. Clipboard handling uses the native \wl\_data\_device\ protocol to publish multi-flavor payloads (including styled text) and falls back to XWayland when necessary. Additionally, a new \screencopy\ module implements window capture via the \ext-image-copy-capture-v1\ protocol, allowing the application to take screenshots of its own window including server-side decorations, a capability previously unavailable on Wayland.

dll/src/desktop/shell2/linux/wayland · high confidence

The audio subsystem now uses platform-native backends for both microphone capture and audio playback, replacing previous generic or stub implementations. On Android, it uses the AAudio API (loaded dynamically to support older versions); on Linux, it uses ALSA via dlopen; on macOS and iOS, it uses AVFoundation (AVAudioEngine for playback, AVCaptureSession for capture); and on Windows, it uses cpal (WASAPI). This change ensures real-time audio works reliably across all supported platforms, with proper error reporting when devices are unavailable.

dll/src/desktop/extra/audio · high confidence

The camera widget now displays live video from physical devices on Android, macOS, and Windows, replacing the previous test-pattern fallback. Android uses the NDK Camera2 API via \ndk-sys\ to capture YUV frames and convert them to RGBA. macOS leverages AVFoundation with a dedicated TCC permission gate that requests and enforces camera/microphone access before starting capture. Windows supports both a default Media Foundation backend (loaded dynamically to handle systems without the Media Feature Pack) and an optional native \nokhwa\ backend behind the \camera-native\ feature. Linux support remains via the existing v4l2 backend.

dll/src/desktop/extra/camera · high confidence

The geolocation subsystem now includes real platform-specific implementations for all major operating systems. Android uses JNI to call the Java \AzulGeolocation\ helper (wrapping \FusedLocationProviderClient\ or \LocationManager\), while iOS and macOS use \CLLocationManager\ with native Objective-C delegates to request authorization and stream location fixes. Linux connects to the GeoClue2 D-Bus service via \zbus\ to subscribe to location updates, and Windows uses the classic COM Location API (\LocationApi.dll\) with a polling loop to retrieve position data. A central dispatcher in \mod.rs\ routes subscription, reconfiguration, and release events to the appropriate backend, feeding results into the layout manager's geolocation channel.

dll/src/desktop/extra/biometric, dll/src/desktop/extra/geolocation, dll/src/desktop/extra/keyring · high confidence

The \screencap\ module now provides real-time screen capture on all three desktop platforms, replacing the previous test-pattern fallback. On Linux, it uses the xdg-desktop-portal ScreenCast API with PipeWire for video streaming and EGL/DMA-BUF for efficient GPU frame import. On macOS, it leverages the ScreenCaptureKit framework (runtime-loaded for macOS 12.3+) with proper TCC permission handling. On Windows, it uses DXGI desktop duplication with D3D11 staging textures. The module registers these backends via a common \CaptureVTable\ interface, allowing the \ScreenCaptureWidget\ to pull actual frames instead of static patterns.

dll/src/desktop/extra/screencap · high confidence

The codegen v2 framework now includes a generator for Algol 68 (targeting the a68g implementation). This new binding produces a single source file containing MODE type definitions (including MODE aliases and digit-spelled names to handle a68g's identifier rules), ALIEN PROC declarations for C-ABI symbols, and manual cleanup helpers (delete procedures) to manage native memory, as Algol 68 lacks destructors. The generator handles unit enums as INT constants, tagged unions via native UNION modes, and skips recursive, generic, or destructor-only types.

_doc/src/codegen/v2/lang\algol68 · high confidence

Adds the \examples/azul-review\ application, a stress-test example for tablet input that enables users to review source code using ink annotations. The example introduces a file-tree sidebar, a code viewer with page-based layout, and tools for highlighting, marking issues, and recording audio notes, all rendered via a custom ink rasterizer that supports pressure and tilt.

examples/azul-review · high confidence

The documentation site now includes new HTML templates for the Azlin Workspace, Azlin OS, and Azlin index pages, featuring a hero section, feature cards, and an FAQ. A new client-side search panel is introduced with dedicated CSS and JavaScript files, supporting both inline and floating modes with dark theme support. Additionally, a temporary, hidden in-page documentation review tool (azul-review.js) has been added for internal use, allowing comment and WYSIWYG editing of documentation content.

doc/templates · high confidence

The debugger now features a complete, VS Code-inspired interface for inspecting and controlling the application. Users can explore the DOM tree, edit CSS overrides, and manage global app state with snapshot save/restore capabilities. A dedicated Node Dataset panel displays serialized RefAny data for selected elements. The interface also introduces a Component Registry view for creating, filtering, and managing reusable component libraries, along with import/export functionality for projects, tests, and libraries. An integrated E2E testing environment allows users to create, run, and view test results directly within the debugger.

dll/src/desktop/shell2/common/debugger · high confidence

The examples/azul-maps directory now contains a complete, runnable map demonstration. Users can interact with a map widget featuring pan/zoom controls, a 'locate me' feature that centers the view on the device's geolocation, and a compass rose overlay that displays magnetometer heading data. The demo includes a 'tap-to-pin' callout for marking locations and a 'clear pins' button. It is packaged with a Dockerfile for web deployment and a Cargo configuration for mobile builds (Android APKs), demonstrating the integration of the MapWidget API with geolocation probes and sensor data.

examples/azul-maps · high confidence

The examples/azul-meet directory now contains a complete Google Meet-style demo application. This example showcases real-time audio and video capabilities, including device enumeration for microphones and speakers, live microphone level metering via a progress bar, and peer-to-peer connectivity using azul.iroh. It also introduces new UI widgets such as CameraWidget, MicrophoneWidget, and ScreenCaptureWidget, and supports running as a web app via a provided Dockerfile.

examples/azul-meet · high confidence

A new C\# Hello World example has been added to the examples directory, demonstrating the updated C\# bindings. The example uses strongly-typed delegates for layout and click callbacks (replacing IntPtr-based approaches) and utilizes typed structs like CallbackInfo and LayoutCallbackInfo. It showcases the new App.Create and app.Run API pattern with a simple counter widget, reflecting the recent codegen improvements for C\#.

examples/csharp · high confidence

The C\# code generator now produces idiomatic bindings that include a \HostInvoker\ runtime for typed, generic callback delegates (e.g., \Button.OnClick\<T\>\) and a custom \DllImportResolver\ that automatically locates the native \libazul\ library in the application directory or working directory, fixing cross-platform loading issues. The generated code also features a \csproj\ template targeting .NET 8 with built-in support for platform-specific native payloads, value-type derives (like \ToString\ and \Equals\) routed through C exports, and structured handling of \Option\/\Result\ returns.

_doc/src/codegen/v2/lang\csharp · high confidence

The C++03 example suite has been rewritten to showcase the engine's modern API surface. Seven new examples—hello-world, calc, async (slippy map), infinity, opengl, widgets, and xhtml—demonstrate key features including state management via RefAny, event handling, builder-pattern DOM construction, and integration with external systems like HTTP clients and OpenGL. These examples serve as updated, compilable reference implementations for C++ developers using the Azul framework.

examples/cpp/cpp03 · high confidence

The C++11 example directory now includes a comprehensive set of modernized demos, including an asynchronous slippy map using HTTP and thread pools, a fully functional calculator, an infinite gallery, an OpenGL integration placeholder, a widget showcase, and an XHTML parser example. These files demonstrate the updated C++ API surface, featuring builder-pattern DOM construction, RefAny-based state management, and callback handling.

examples/cpp/cpp11 · high confidence

Added seven new C++20 examples (hello-world, calc, widgets, infinity, opengl, xhtml, async) that showcase the updated Azul C++ API surface. These examples demonstrate key capabilities including a calculator with state management, an infinite scroll gallery, OpenGL integration placeholders, XHTML parsing, and an async map view with HTTP tile fetching and thread pools, all built using the modern C++20 bindings.

examples/cpp/cpp20 · high confidence

The C++23 example directory now includes seven distinct applications (hello-world, calc, async, infinity, opengl, widgets, xhtml) that demonstrate the updated C++ codegen surface. These examples utilize the new non-prefixed enum and callback types, ODR-safe constants, and the builder-pattern DOM API (e.g., \Dom::create\_p\_with\_text\, \Button::create\), replacing previous free-function and prefixed styles. The \async\ example specifically illustrates the new resumable dialog and HTTP client capabilities within a map widget context.

examples/cpp/cpp23 · high confidence

The documentation source now includes a complete COBOL binding generator for the Azul library, producing a single \azul.cpy\ copybook for GnuCOBOL 3.0+. This copybook provides level-78 constants for C-ABI function symbols (e.g., \FN-AZ-APP-CREATE\) to simplify \CALL\ statements, level-01 records for structs and tagged unions (using \REDEFINES\ for unions), and \USAGE PROGRAM-POINTER\ typedefs for callbacks. It also includes a host-invoker pattern for managing callbacks and native memory lifetimes, along with documentation on manual cleanup and helper paragraphs for the user's \PROCEDURE DIVISION\.

_doc/src/codegen/v2/lang\cobol · high confidence

The \css/src/props/basic\ module has been introduced to provide the foundational types and parsing logic for CSS properties. This includes support for angle units (degrees, radians, gradians, turns), animation interpolation functions (including cubic beziers and mass-spring-damper physics), color values (hex, rgb, hsl, named colors, and system themes), gradient directions, font properties (weight, style, size, family), geometric primitives (points, sizes, rects), length units (px, em, rem, percentages), and robust error handling for FFI compatibility. The module also provides shared parsing utilities for handling complex CSS strings, such as respecting parentheses in function calls and splitting by whitespace or commas while maintaining nesting depth.

css/src/props/basic · high confidence

The \css/src/props/layout\ module has been introduced to organize CSS layout-related properties into dedicated files. This change adds support for multi-column layout (\column-count\, \column-width\, \column-span\, \column-fill\, \column-rule\), flexbox (\flex-grow\, \flex-shrink\), CSS Grid (\grid-template-columns\, \grid-template-rows\, \grid-auto-columns\, \grid-auto-rows\, \grid-area\, \grid-template-areas\), positioning (\position\, \top\, \right\, \bottom\, \left\, \z-index\), overflow (\overflow\, \overflow-x\, \overflow-y\), display types (\display\, \float\), fragmentation (\break-before\, \break-after\, \break-inside\, \widows\, \orphans\, \box-decoration-break\), content flow (\flow-into\, \flow-from\), and shape properties (\shape-outside\, \shape-inside\, \clip-path\, \shape-margin\). It also includes dimension handling with \calc()\ expression support and \fit-content()\ variants. These types are defined with \repr(C)\ for FFI compatibility and include parsers for converting CSS strings into these structured values.

css/src/props/layout · high confidence

The \css/src/props/style\ module now includes dedicated files for core visual styling properties. This adds support for background layers (including linear, radial, and conic gradients), border properties (style, width, and color for all four sides), border-radius, box shadows, and visual effects such as opacity, visibility, mix-blend-mode, and cursor types. It also introduces modules for CSS filters (blur, brightness, contrast, etc.), list styling (list-style-type and list-style-position), generated content (content, counters), and scrollbar styling (scroll-behavior, overscroll-behavior). These files define the data structures, parsers, and FFI-safe types for these CSS properties.

css/src/props/style · high confidence

The code generator now produces idiomatic Common Lisp bindings for the Azul GUI framework. The output consists of an ASDF system definition (\azul.asd\) and a source file (\azul.lisp\) that uses the CFFI library to expose the C-ABI of \libazul\. The bindings include raw FFI declarations in the \:azul-internal\ package and high-level CLOS wrappers (classes, constructors, methods, and \with-\*\ macros) in the \:azul\ package. The implementation also includes a host-invoker pattern to safely manage callbacks and user data across the FFI boundary.

_doc/src/codegen/v2/lang\lisp · high confidence

Added new 'hello-world' examples for the D and V programming languages, demonstrating how to build a simple counter application using the Azul framework. The D example uses idiomatic imports and a clean class-based structure, while the V example illustrates manual memory management and FFI bindings via the C API, providing users with reference implementations for these specific language bindings.

examples/d · high confidence

Added a new code generator for Fortran bindings, producing a split module structure (types, FFI interfaces, and an idiomatic wrapper layer) along with an auto-generated Makefile for building examples. The wrapper layer provides type-bound procedures for classes, generic constructors, and a managed host-invoker runtime that handles callbacks and object lifetimes via a handle table, allowing users to interact with the Azul library using standard Fortran idioms without manual memory management or C-ABI marshalling.

_doc/src/codegen/v2/lang\fortran · high confidence

Added a new code generator for FreeBASIC that produces an \azul.bi\ header file, enabling FreeBASIC programs to link against and use the Azul GUI framework. The generated bindings include C-ABI function declarations with case-sensitive symbol aliases, idiomatic wrapper types with automatic memory management (constructors/destructors), and mappings for primitive types, pointers, and tagged unions.

_doc/src/codegen/v2/lang\freebasic · high confidence

The Azul code generator now produces idiomatic Java bindings using Java Native Access (JNA). This adds a complete multi-file Java source tree including per-module native interfaces (e.g., \AzulNativeApp\), JNA \Structure\/\Union\ types for structs and tagged unions, \AutoCloseable\ wrapper classes for resource management, and a host-invoker runtime (\AzulHostInvoker\) for safe callback handling. A Maven \pom.xml\ is also generated to manage the JNA dependency and native library resources.

_doc/src/codegen/v2/lang\java · high confidence

The codegen system now includes new backends for Julia and V, expanding the list of supported languages. The Julia generator produces an \azul.jl\ module that maps C-ABI symbols to \ccall\ wrappers, handles callbacks via direct function pointers, and provides idiomatic aliases (e.g., \App\_create\ for \AzApp\_create\). The V generator emits an \azul.v\ module with explicit struct/enum definitions and \C.\ namespace extern declarations, also supporting direct callback pointers. Both generators ensure ABI compatibility with the existing C/Odin/Zig bindings by mirroring their callback handling strategies.

_doc/src/codegen/v2/lang\_julia, doc/src/codegen/v2/lang\v · high confidence

Added a new \dll/src/desktop/shell2/linux/common\ module providing shared infrastructure for the Linux X11 and Wayland backends. This includes \gl.rs\, which centralizes OpenGL function pointer loading via EGL and \libGL.so.1\ and now explicitly warns when GL entry points fail to resolve (preventing silent downstream rendering failures), and \compose.rs\, which implements an XKB compose sequencer to support dead keys and multi-key sequences (e.g., \´\ + \e\ → \é\) using \libxkbcommon\. The module also ensures the \libxkbcommon\ library remains loaded for the lifetime of the compose sequencer to prevent use-after-free crashes during window teardown.

dll/src/desktop/shell2/linux/common · high confidence

The Linux desktop shell now features a new windowing backend that automatically selects between X11 and Wayland at runtime, falling back to X11 if Wayland initialization fails. This change introduces a shared resource system for font caching, app data, and system styling across all windows, along with native system icon and style discovery via XDG Desktop Portal and CLI tools. The implementation includes a thread-local window registry for multi-window support, a shared timer implementation using timerfd, and GNOME menu integration via D-Bus.

dll/src/desktop/shell2/linux · high confidence

This change introduces the code generation infrastructure for the new Lua binding, producing a dual-runtime \azul.lua\ file that works with both LuaJIT's built-in \ffi\ and PUC Lua via the \cffi-lua\ rock. The generator handles C-header preprocessing to strip unsupported directives, reorders callback typedefs to satisfy LuaJIT's parsing requirements, and implements lazy function declaration to avoid ctype table overflows. It also emits a managed prelude for host-invoker registration and RefAny user-data handling, along with idiomatic Lua wrappers that expose the C ABI through metatables and methods tables.

_doc/src/codegen/v2/lang\lua · high confidence

A new code generator has been added for the Nim language, producing an \azul.nim\ module that exposes the prebuilt \libazul\ shared library. The generator creates a raw C-ABI layer using Nim's \{.importc, cdecl, dynlib.}\ procs to import functions verbatim, ensuring correct symbol resolution despite Nim's style-insensitive identifiers. It also emits idiomatic wrappers that drop the \Az\ prefix and provide a more natural API (e.g., \button.setButtonType\ instead of \AzButton\_setButtonType\). The implementation handles C structs as \{.bycopy.} object\ records, unions as \{.union.} object\, and enums as \{.pure, size: 4.}\ enums to maintain binary compatibility. Recursive types, generic templates, and destructor/clone traits are excluded from the generated bindings.

_doc/src/codegen/v2/lang\nim · high confidence

The codegen now generates JavaScript bindings for Node.js (\>=16), Bun, and Deno using the koffi FFI library. This adds a new \lang\_node\ module that emits a single \azul.js\ CommonJS file and a \package.json\ manifest (pinning \koffi ^2.7.0\). The bindings support all three runtimes via a unified runtime-detection adapter, providing ES6 wrapper classes with \FinalizationRegistry\ for automatic native resource cleanup, automatic \String\ conversion, and a fluent \.with(opts)\ builder for struct configuration.

_doc/src/codegen/v2/lang\node · high confidence

A new PDF export capability has been added to the Azul desktop library, powered by the \printpdf\ crate. This feature introduces a headless pipeline that converts a styled DOM into PDF bytes without requiring a window or file I/O, supporting multi-page layouts. The API provides both a JSON-based ABI-stable interface (\write\_json\/\read\_json\) for document model exchange and a direct DOM-to-PDF path (\from\_dom\). Additionally, a specialized export method (\from\_styled\_dom\_with\_resources\) allows exporting from within application callbacks by reusing the window's live font manager and image cache, ensuring print-preview parity with the on-screen rendering. The feature is gated by the \pdf\ build flag; if disabled, the API returns empty results with a one-time diagnostic warning.

dll/src/desktop/extra/pdf · high confidence

Added a new code generation module for PHP (\lang\_php\) that produces idiomatic wrapper classes and a static facade (\Azul.php\) for the Azul GUI framework. The bindings require PHP 7.4 or newer with the \ext-ffi\ extension enabled. The generated package includes a \composer.json\ manifest and bundles the PHP glue code separately from the native shared library (\libazul\), which users must place in a location accessible to the dynamic loader. The implementation uses a host-invoker pattern to manage callbacks and user data via \Azul::registerCallback\ and \Azul::refanyCreate\, working around PHP's FFI extension limitations regarding closure-to-function-pointer casting.

_doc/src/codegen/v2/lang\php · high confidence

Added a new code generator for Pascal bindings, producing a single \azul.pas\ unit compatible with Free Pascal 3.0.4+ and Lazarus. The generated unit includes C-ABI type definitions (records, enums, variant records), external function imports, idiomatic class wrappers for heap-allocated types, and a host-invoker callback system that dispatches events to Pascal objects. It also provides a value layer for non-class exports and a minimal Lazarus project file for examples.

_doc/src/codegen/v2/lang\pascal · high confidence

The Python examples directory has been rewritten to provide seven distinct, comment-free demonstrations of the Azul engine's features. These include a basic counter (hello-world), a functional calculator (calc), a virtualized spreadsheet with 1 million rows (infinity), a ribbon UI with themed widgets (widgets), an OpenGL integration demo (opengl), an async slippy map with HTTP tile loading (async), and an XHTML parser example (xhtml). The examples now use the updated \Dom.create\_p\_with\_text\ API and demonstrate modern patterns like theming and async mounting.

examples/python · high confidence

The codegen v2 system now generates idiomatic Racket bindings (\lang\_racket\) for the Azul GUI framework. The generated \azul.rkt\ module exposes the C-ABI of \libazul\ via Racket's \ffi/unsafe\ library, including type definitions (structs, enums, tagged unions), raw FFI function bindings, and a managed-FFI runtime that handles callback invokers and GC-retention to prevent crashes. Idiomatic wrappers (e.g., \dom-add-child\) are also provided for a more natural Racket API.

_doc/src/codegen/v2/lang\racket · high confidence

Added a Scala 'Hello World' example demonstrating a counter UI using the Azul Java bindings, along with a \build.sh\ script that automatically locates the Scala library and JNA jar across Unix and Windows environments to compile and run the application.

examples/scala · high confidence

Added a new code generator for Smalltalk (Pharo) bindings in the \lang\_smalltalk\ module. The generator produces a single Tonel-format source file containing UnifiedFFI primitive methods, type declarations (enums, structs, tagged unions), and idiomatic wrapper classes with automatic garbage-collection finalization. It also generates a Metacello baseline script to simplify package loading for users.

_doc/src/codegen/v2/lang\smalltalk · high confidence

The code generator now produces Swift bindings that map Rust types to native Swift equivalents, such as \String\, \T?\ (Option), \\[T\]\ (Vec), and \throws\ (Result), while handling ownership via \final class\ wrappers and automatic memory management. The output includes a single-file \azul.swift\ module and a complete Swift Package Manager (SwiftPM) structure (\Package.swift\, \module.modulemap\) for easy integration, allowing Swift developers to use the Azul GUI framework with familiar, type-safe APIs.

_doc/src/codegen/v2/lang\swift · high confidence

Added a new code generation target for Visual Basic 6, demonstrating the universal framework's ability to reach legacy Windows ecosystems. This generator produces a complete VB6 project structure, including a main module (\Azul.bas\) with extern declarations and type definitions, individual Class Modules (\.cls\) for disposable types with automatic lifetime management, and a project file (\.vbp\). The implementation handles specific VB6 constraints, such as 32-bit-only execution, UDT passing rules, and the lack of native union types, by emitting appropriate workarounds and comments.

_doc/src/codegen/v2/lang\vb6 · high confidence

The desktop layer now includes a new \app\_icon.rs\ module that resolves icon-registry specs into rendered RGBA images and applies them as the process-wide default window icon (or macOS Dock tile) at runtime, reporting exactly what the platform supported. Additionally, a new \csd.rs\ module automatically injects a custom titlebar with window controls into the user's DOM for frameless windows, while ensuring no titlebar is rendered on mobile platforms.

dll/src/desktop · high confidence

The \doc/src/reftest\ module now includes several new subcommands and capabilities: \apply-midlevel\ provides an interactive, commit-by-commit replay of a reference branch with options for triage, auto-apply, and Telegram integration; \autodebug\ automates reftest bug-finding by launching Chrome via CDP, capturing screenshots at multiple screen sizes, and dispatching parallel agents to analyze and fix failures; \autodoc\ enables parallel, system-level documentation generation from a TOML manifest; \autoreview\ automates code review by dispatching agents to analyze source files and produce quality reports; and \debug\ provides LLM-assisted analysis for layout test failures using the Gemini API. These tools are wired into the reftest pipeline for enhanced CI/CD automation and developer productivity.

doc/src/reftest · high confidence

The \doc/src\ area introduces several new subcommands for the \azul-doc\ CLI. \assemble-context\ generates self-contained context bundles for guide pages, combining machine checks (link validity, API name presence, TODO markers) with source excerpts to assist non-agentic writing models. \autotest\ provides an adversarial test-generation harness that extracts and categorizes Rust functions (parsers, serializers, constructors, etc.) and emits task files for LLM agents to generate targeted unit tests. \e2erun\ enables running e2e JSON scenarios headlessly in a single process with parallel execution, replacing the previous serial CI loop. Additionally, \lint\_derives\ implements a derive-parity lint to verify that every capability declared in \api.json\ is actually reachable from each language binding's generated code.

doc/src · high confidence

A new example crate (examples/azul-widgets) has been added to showcase the Azul widget library. It demonstrates a comprehensive set of UI components including switches, sliders, color pickers, and various input controls. The demo highlights advanced window management features such as frameless, tear-off panels that can be docked into specific zones (VS-style document tabs) and context menus that open from any descendant element. It also includes a Dockerfile for containerized deployment of the demo.

examples/azul-widgets · high confidence

This change introduces dedicated gamepad input backends for Android (JNI), iOS (GCController), and desktop (gilrs), enabling access to hardware features previously unavailable in the engine. On desktop, DualSense and DualShock 4 pads now expose their internal IMU (gyro/accelerometer) and touch surface data via raw HID parsing, along with accurate battery level reporting for wired and wireless states. iOS backends provide similar access to controller motion and touchpad inputs, while the Android backend implements a push-based event model to correctly accumulate state from native input events, fixing issues where partial updates would overwrite other inputs. The implementation includes platform-specific deadzone handling and per-pad calibration for PlayStation controllers to ensure precise sensor data.

dll/src/desktop/extra/gamepad · high confidence

The application now supports real-time motion and environmental sensor data on all major platforms. On Android, a JNI-based backend streams accelerometer, gyroscope, magnetometer, fused orientation, and scalar sensors (light, proximity, barometer, step counter, hinge angle) via a Java helper. On Apple platforms, CoreMotion provides raw and fused motion data, with iOS-specific support for barometer, step counter, and proximity. Linux systems read industrial I/O (iio) sysfs files for the same set of sensors, handling unit conversions for pressure, proximity, and hinge angle. Windows uses WinRT APIs to poll standard sensors and asynchronously resolve pedometer and hinge sensors. All backends normalize data into a common internal format, enabling consistent sensor access across devices.

dll/src/desktop/extra/sensors · high confidence

The \docgen\ crate introduces a comprehensive system for generating the documentation website, including API reference pages, user guides, blog posts, and a donation page. A key addition is the 'agentic release bundle', which automatically generates \llms.txt\, \llms-full.txt\, and a \skill.md\ file to help coding agents (like Claude Code) understand and build with the Azul framework. The system also supports client-side search via generated JSON indexes, handles language-specific installation tabs for shipped bindings, and allows for dynamic content such as version substitution and German-style quote transformation in guide markdown.

doc/src/docgen · high confidence

Added new utility modules (\analyze.rs\ and \string.rs\) within the documentation source to support the docgen crate. The \analyze\ module provides functions to parse Rust type signatures (handling references, pointers, and arrays), identify primitive types, and automatically generate necessary import statements for API documentation by resolving class dependencies. The \string\ module includes helpers for converting snake\_case identifiers to camelCase, stripping function argument types for code generation, and formatting raw documentation comments into HTML by handling code blocks, inline code, bold text, and markdown headings.

doc/src/utils · high confidence

Added five new examples in the \dll/examples\ directory to demonstrate and verify specific capabilities. \appconfig\_double\_drop.rs\ and \css\_double\_drop.rs\ serve as regression tests to verify that \IconProviderHandle\ and \CssPropertyCachePtr\ no longer suffer from double-free errors during destruction. \system\_style.rs\ allows users to inspect the detected system style settings (e.g., KDE/GTK) without launching a window. \transpile\_fn.rs\ demonstrates the \Transpiler\ trait for lifting native functions to WASM, while \video\_codec\_provision.rs\ showcases the API for probing hardware video-decode capabilities, generating installation plans for missing drivers, and handling reboot safety checks.

dll/examples · high confidence

The layout engine now supports two distinct visual themes: 'Flat', a minimal style with plain surfaces and single-weight borders, and 'Flora', a skeuomorphic style featuring depth, shadows, and gradients. These themes are defined in new \flat.rs\ and \flora.rs\ modules, which share a common token vocabulary (e.g., \LIGHT\_PG\, \LIGHT\_INK\) to ensure consistent color usage across widgets. The \UiTheme\ enum in \mod.rs\ allows users to select between these styles, with Flat set as the default.

layout/src/widgets/themes · high confidence

A new headless backend has been added to the DLL, allowing applications to run without a GPU or native window system by setting \AZ\_BACKEND=headless\. This implementation provides a full \PlatformWindow\ experience—handling DOM layout, callbacks, and timers—while rendering through a CPU-based pipeline (\CpuBackend\) instead of WebRender. It includes a robust event injection system for testing, supporting mouse, keyboard, scroll, file drag-and-drop, pen input, gestures, and IME composition, and is designed to consume zero CPU when idle.

dll/src/desktop/shell2/headless · high confidence

The layout/examples directory now includes three new runnable examples. telemetry\_grafana.rs provides a live telemetry demo that exercises the real engine pipeline (XML/CSS parsing, layout, and CPU repaint) and exports metrics to an OTLP endpoint for visualization in Grafana. verify\_update\_manifest.rs acts as a release-signing verification tool that validates update manifests and artifacts against a root public key, ensuring signatures are accepted by the client before publication. xml\_perf\_test.rs offers a benchmark for the XML parser, measuring parsing speed and node counts on provided HTML files.

layout/examples · high confidence

Added a runnable local example in \layout/examples/telemetry-grafana\ that demonstrates a complete telemetry loop: a demo application sends real metrics and logs via OTLP/HTTP JSON to a local OpenTelemetry Collector, which forwards them to VictoriaMetrics and Loki, with a provisioned Grafana dashboard for visualization. The example includes a Docker Compose stack, collector configuration with bearer token authentication, and a helper script to manage the services, allowing users to observe application performance, startup times, and crash data locally.

layout/examples/telemetry-grafana · high confidence

The map module now includes an opt-in \map-tiles\ feature that enables rendering OpenStreetMap-derived vector tiles (MVT) as SVG graphics within the MapWidget. This change introduces a background tile-fetching worker that downloads PBF tile data, decodes it into GeoJSON features using the \td\ crate, and converts those features into SVG paths via a built-in styling engine that supports both a default color palette and custom MapCSS stylesheets. The implementation handles Web Mercator projection, tile coordinate calculation, and asynchronous write-back to the UI thread, allowing for high-performance, scalable map rendering without requiring external JavaScript or browser APIs.

dll/src/desktop/extra/map · high confidence

The \dll/src/desktop/extra\ module introduces a suite of platform-specific capabilities and native integrations. A new \PlatformCapability\ probe system allows applications to check for the availability and backend of features like camera, screen capture, sensors, and geolocation before use, preventing crashes on unsupported hardware. Native backends are added for Surface Pen haptics on Windows, natural scrolling preference reading on macOS and Windows, and window activation (raise) across macOS, Windows, and X11. Additionally, a buffer-reusing \CaptureSlot\ optimizes macOS video capture performance, while a platform-accelerated vImage scaler is introduced for macOS frame resampling. The module also scaffolds WebTransport for real-time communication and exposes ZIP archive handling over the C API.

dll/src/desktop/extra · high confidence

The release deployment process now generates pre-rendered, self-contained archives for language bindings, including a standalone \azul\ Rust crate that includes generated sources directly in \src/\ so rust-analyzer can resolve types without a build script. This replaces the previous requirement for users to clone the repository and run code generation locally, providing one-step install archives (tar.gz) for each language and a unified bundle for all bindings.

doc/src/dllgen · high confidence

The \doc/src/patch\ module introduces a new system for automatically correcting and updating the \api.json\ documentation data by analyzing actual Rust source code. It includes a workspace index (\index.rs\) for fast in-memory type lookups, a fallback search strategy (\fallback.rs\) to locate types when standard metadata fails, and a parser (\parser.rs\) that collects symbol information from the codebase. This infrastructure powers an autofix mechanism that can detect discrepancies between the generated API and the source, allowing it to automatically add missing classes, correct paths, fix type definitions, and update attributes like derives or documentation without manual intervention.

doc/src/patch · high confidence

The layout crate now includes dedicated managers for text-editing changesets, clipboard operations, and device hotplug events. The changeset system introduces a two-phase (create-then-apply) model for text operations, enabling undo/redo, validation, and preventDefault support. The clipboard manager bridges system clipboard interactions with application callbacks for copy, cut, and paste flows. Additionally, a device event manager now handles input device and monitor hotplug events, routing them through the application event filter. These changes consolidate and modernize core input and editing capabilities within the layout subsystem.

layout/src/managers · high confidence

The layout engine introduces a new text shaping and layout system (\text3\) that replaces the previous implementation. This update brings a compact 'dense' text model that significantly reduces memory usage by sharing text strings and glyph data across runs, alongside a complete text editing pipeline supporting multi-cursor operations, selection, and cursor movement. The engine now implements comprehensive Unicode handling, including BiDi reordering, script detection, and CSS Text 3 compliant line-breaking via the Knuth-Plass algorithm, while also introducing a new font caching and eviction strategy to optimize memory pressure.

layout/src/text3 · high confidence

A new Node.js-based end-to-end testing harness has been added to \scripts/e2e-web\ to execute existing desktop E2E JSON scenarios against the web backend (x86-64 lifted to WASM). The harness uses a headless browser via the Chrome DevTools Protocol (CDP) to drive the application, mapping desktop actions like clicks, scrolls, and keyboard input to browser equivalents. It includes a pure-JS PNG diffing engine for visual regression testing against golden screenshots, a settle protocol to wait for WASM loading and async work, and support for web-specific test overrides. This allows developers to verify the web build's behavior and visual output using the same scenario definitions used for the desktop client.

scripts/e2e-web · high confidence

The layout widget library introduces several new UI components: Accordion (collapsible sections), Alert (dismissible status banners), Avatar, Badge (status pills), Backstage (Office-style full-window menu), and Camera (live preview widget). These additions expand the available widget surface for building modern interfaces.

layout/src/widgets · high confidence

A new Hello World example for Node.js has been added to the examples directory. This example demonstrates a basic counter application using the Azul framework, featuring a button that increments a counter and updates the UI, along with a window configuration for title and size.

examples/node · high confidence

The OCaml code generator now emits a full, self-contained Dune project structure, including \dune-project\, \dune\, and \azul.opam\ manifests, alongside the generated OCaml source files. This allows users to build the bindings using standard Dune commands (e.g., \dune exec ./hello\_world.exe\) without manual setup. The generated project includes a \hello\_world\ executable example, links against \ctypes\ and \ctypes-foreign\, and dynamically loads the native \libazul\ library at runtime via \Dl.dlopen\. The generator also handles the splitting of the large binding surface into multiple compilation units to avoid stack overflows during compilation, while maintaining a single \Azul\ facade module for consumers.

_doc/src/codegen/v2/lang\ocaml · high confidence

The OCaml example directory now includes a complete, runnable hello-world application demonstrating the Azul bindings. This includes a \dune\ build manifest configuring the \azul\ library and \hello\_world\ executable with necessary \ctypes\ dependencies, a \dune-project\ file specifying Dune 3.0, and the \hello\_world.ml\ source code which implements a counter UI using the host-invoker pattern, labeled optional arguments, and \RefAny\ for data binding.

examples/ocaml · high confidence

The layout module now includes a comprehensive, opt-in telemetry system that allows applications to report performance metrics, logs, and crash data. Users must explicitly consent via a tiered system (Off, Crashes, Metrics, Full) before any data is collected, with the default state being Off. The system supports uploading data via OTLP/HTTP JSON to a collector, with a fallback email-based crash reporter for environments without a collector. Configuration is managed through layered precedence (environment variables, executable-adjacent pins, per-app files, and machine-wide shared config), ensuring administrators can enforce privacy settings. Metrics are strictly bounded in cardinality to protect privacy, and crash dumps are queued locally for reliable delivery.

layout/src/telemetry · high confidence

Added Perl language support for the Azul framework, including a cpanfile specifying dependencies (FFI::Platypus \>= 2.00, FFI::CheckLib \>= 0.28) and a hello-world example application. The example demonstrates a full GUI interaction using FFI to call into the Azul library, featuring a counter that increments on button click and updates the DOM via registered callbacks.

examples/perl · high confidence

The Perl language bindings have been rewritten to generate a single pure-Perl \Azul.pm\ module using FFI::Platypus 2.x, eliminating the need for XS compilation or a \Makefile.PL\ build step. The generator now emits a \cpanfile\ manifest requiring Perl 5.014 and FFI::Platypus \>= 2.00, and implements a managed-FFI host-invoker pattern that allows Perl callbacks to be safely passed to the native library via pinned closures and a handle table. Idiomatic Perl classes (e.g., \Azul::App\) wrap the raw FFI symbols, providing refcount-driven memory management via \DESTROY\ and a simplified API that drops the \Az\ prefix.

_doc/src/codegen/v2/lang\perl · high confidence

The Ruby binding generator has been rewritten (v2) to produce idiomatic Ruby classes under \module Azul\ that wrap the native C API, dropping the \Az\ prefix and converting method names to snake\_case. The generator now emits a flat gem layout (\lib/azul.rb\ alongside native libraries) with a gemspec that derives its version from \api.json\ rather than hard-coding it. Callbacks are handled via a host-invoker pattern that registers Ruby closures through \Azul.\_register\_callback\, ensuring proper GVL management and reference counting for \RefAny\ objects. The codegen also supports auto-wrapping/unwrapping of \Option\/\Result\ types, derives equality and hash methods from the C API, and surfaces unit enum constants at the top level (e.g., \Azul::Update::RefreshDom\).

_doc/src/codegen/v2/lang\ruby · high confidence

The Rust code generator in the documentation source has been refactored to produce bindings for two distinct linking strategies. The new \static\_binding\ generator creates standalone Rust code with native implementations that call directly into internal types via transmute, intended for static linking. The new \dynamic\_binding\ generator produces code that declares \extern "C"\ functions to call into a pre-compiled DLL at runtime, intended for dynamic linking. Both generators share common utilities for type generation, GL type aliases, and struct/enum definitions via a new \shared\ module, allowing users to choose the linking mode that best fits their build configuration.

doc/src/codegen/v2/rust · high confidence

The eyedropper feature now provides a consistent cross-platform experience for picking screen colors. On macOS, it utilizes the native \NSColorSampler\ to display the system magnifier loupe without requiring screen-recording permissions. On Windows and X11, it captures the screen directly using \BitBlt\ and \XGetImage\ respectively, while Wayland users are prompted via the desktop portal's screenshot interface. In all cases, a fullscreen loupe window with a magnifier overlay is presented to the user, allowing them to hover over pixels and click to select a color, with the result returned to the application.

dll/src/desktop/eyedropper · high confidence

The Linux shell now detects whether a global-menu registrar (such as KDE Global Menu, Unity, or appmenu-gtk) is present on the DBus session bus. If a registrar is found, the application exports its menu bar natively over DBus; otherwise, it injects a software menu bar into the window. This is implemented via a new dynamic-loading module for libdbus-1, allowing the feature to work without compile-time dependencies on the DBus development headers.

dll/src/desktop/shell2/linux/dbus · high confidence

A new Swift example project has been added to the repository, demonstrating a 'Hello World' counter application built against the Azul module. The example includes a \module.modulemap\ to expose the underlying C header (\azul.h\) as a Clang module named \CAzul\, allowing Swift code to import and use the \Azul\ framework. The sample app implements a simple UI with a text label and a button that increments a counter, showcasing the integration of Swift with the Azul layout and callback system.

examples/swift · high confidence

The application now integrates with native system media controls on Windows (SMTC), macOS/iOS (MediaPlayer), Linux (MPRIS), and Android (MediaSession). This allows the app to appear in system UIs (lock screen, notification shade, volume flyout, desktop media widgets) with playback status, track metadata, and album art, and enables receiving transport commands from hardware keys, headsets, and system interfaces. The feature is opt-in and disabled by default; enable it via \AppConfig::expose\_system\_media\_controls\ to register the app as a media player.

_dll/src/desktop/extra/media\keys · high confidence

Applications can now display an icon in the system tray (notification area) on Linux and macOS. On Linux, the tray icon is registered via the StatusNotifierItem D-Bus protocol, supporting icons, tooltips, and context menus (with a fallback to the legacy ContextMenu method if the panel does not support dbusmenu). On macOS, the icon is added to the menu bar using NSStatusItem, supporting icons, tooltips, and menus, with position persistence across launches. Tray events are queued and processed in the main run loop. The Windows backend is currently a stub that reports the tray as unavailable.

dll/src/desktop/tray · high confidence

The web backend now renders the initial HTML page on the server, applying the full CSS cascade and emitting inline styles and pseudo-state rules for the browser. It classifies API functions to include only framework code in the lifted WASM, significantly reducing binary size. A new lift-audit system runs at startup to detect and refuse to serve builds with known lifting defects (such as unresolved imports or stubbed functions). The server serializes the application state (DOM, window state, callbacks) into a hydration payload, which the client-side WASM uses to reconstruct the app and handle events via a lifted event loop.

dll/src/web · high confidence

The WebRender rendering engine has been integrated into the product. This change introduces the core rendering infrastructure, including the API resource management, primitive batching, border and box-shadow rendering, clip handling, and command buffer systems, enabling the application to leverage WebRender for high-performance GPU-accelerated UI rendering.

webrender/core/src · high confidence

The Windows backend in the new shell2 architecture now includes full implementations for accessibility (bridging to UI Automation via accesskit), native clipboard operations, and file drag-and-drop (using OLE IDropTarget for hover and drop events). It also adds runtime-loaded DPI awareness functions (supporting per-monitor DPI on Windows 8.1+) and raw input handling for precise mouse motion.

dll/src/desktop/shell2/windows · high confidence

The Zig code generator now emits a single \azul.zig\ file that embeds the pre-translated C ABI directly from the IR, eliminating the need for \@cImport\ and the 5.6 MB \azul.h\ header, which significantly reduces cold build times. The generated code includes a runtime prelude with \ReflectModel\ for type-safe callback handling and idiomatic wrapper structs that manage memory via \deinit()\. Additionally, a new callback boundary module ensures that failing callbacks degrade gracefully by logging errors through the engine's log sink and returning safe fallback values, rather than aborting the process.

_doc/src/codegen/v2/lang\zig · high confidence

The \azul-doc mobile\ command suite is now available to install, configure, and drive Android and iOS development environments. It includes \mobile install\ and \mobile doctor\ to automatically provision SDKs, NDKs, and emulators/simulators, and \mobile run\ to build and deploy applications to connected devices. The suite also introduces \mobile e2e\ for running end-to-end test scenarios on real devices or via host-side replay, ensuring that input handling and platform glue code are verified outside the in-process engine.

doc/src/mobile · high confidence

The iOS backend now includes a native accessibility bridge that exposes the UI tree to VoiceOver and Switch Control via \UIAccessibilityElement\s, a full \UIPasteboard\ transport for copy/paste operations, and \UITextInput\ conformance to enable IME marked text, selection handles, and the edit menu.

dll/src/desktop/shell2/ios · high confidence

This change introduces the initial macOS implementation for the shell2 windowing system. It adds the core \MacOSWindow\ entry point and a thread-local window registry for multi-window support. Platform-specific modules are added to handle native integration: \accessibility.rs\ bridges Azul's accessibility tree with macOS VoiceOver via \accesskit\_macos\, \menu.rs\ implements native NSMenu creation and action dispatch, \clipboard.rs\ handles system clipboard operations, and \gl.rs\ loads OpenGL function pointers. Low-level FFI bindings for CoreGraphics (\coregraphics.rs\) and CoreVideo display links (\corevideo.rs\) are also included to support monitor identification and VSync synchronization.

dll/src/desktop/shell2/macos · high confidence

The project introduces a suite of pre-build supply-chain gates in \scripts/supply-chain\ to mitigate credential theft and malicious code execution via dependencies. \env\_guard.py\ scans vendored sources to prevent build scripts and proc-macros from reading forbidden environment variables (such as tokens and secrets) or detecting CI environments. \scan\_build\_scripts.py\ enforces a policy (\build-script-policy.toml\) requiring every crate that executes code at build time to be explicitly allowed, audited, and pinned by content digest, while classifying behaviors like network access or shell spawning. \lockfile\_guard.py\ adds version-level integrity checks, including a 14-day publish-age cooldown to defend against compromised maintainer accounts, alongside vendor checksum and yank verification. These gates run automatically in CI and locally via \run\_all.sh\ before any compilation occurs.

scripts/supply-chain · high confidence

The CSS property definitions in \css/src/props\ have been reorganized into a structured module system (\basic\, \layout\, \style\, \property\, \formatter\) to improve maintainability and reduce boilerplate. This change introduces a new \FormatAsCssValue\ trait for zero-allocation CSS serialization and leverages internal macros (\impl\_pixel\_value!\, \impl\_percentage\_value!\) to automatically generate constructors and display implementations for dimension types. The core \CssProperty\ enum and its parser have been consolidated into \property.rs\, which now explicitly maps property names to their types and handles combined shorthand properties (like \border\ and \flex\) through a centralized key map.

css/src/props · high confidence

The \dll\ crate has been restructured to provide a more robust and self-contained build process. A new \build.rs\ script now handles platform-specific configurations, including the embedding of a build identity for the web lift cache, conditional compilation of database and networking engines based on target architecture, and strict validation to prevent conflicting global allocator features. The build logic now explicitly restricts the shared library's exported symbols to the Azul C API, reducing binary bloat and preventing symbol clashes with dependencies like SQLite. Additionally, a new \build\_link.rs\ module centralizes the linking strategy, allowing consumers to control static versus dynamic linking via the \AZ\_LINK\_PATH\ environment variable while ensuring correct library resolution across different platforms. iOS and Android configurations have also been added to support mobile builds.

dll · high confidence

A change to existing behaviour in layout/src/solver3 — 1001 commits (415 fixs), 17 files.

core/src, layout/src, layout/src/solver3 · medium confidence · unverified

The autofix tool in \doc/src/autofix\ has been restructured into a new V2 architecture with dedicated modules for workspace type discovery, API analysis, and diff generation. The \discovery\ module now scans the Rust workspace (azul\_core, azul\_css, azul\_layout) in parallel to build a \WorkspaceIndex\ of type definitions, prioritizing primary crates and blacklisting azul\_dll to avoid circular dependencies. The \analysis\ module introduces an \ApiTypeExtractor\ to parse type references from \api.json\ (handling fn\_args arrays and legacy formats) and a \ReachabilityAnalysis\ that uses BFS to identify unused types by tracing dependencies from public entry points. The \diff\ module compares the discovered workspace types against \api.json\ to generate precise patches for path corrections, type additions/removals, and struct/enum field reordering, while the \function\_diff\ module specifically handles method signature mismatches. This refactoring replaces the previous single-pass logic with a multi-stage pipeline that improves accuracy in detecting drift and generating correct API patches.

doc/src/autofix · high confidence

The C++17 example applications (hello-world, calc, async, infinity, opengl, widgets, xhtml) have been updated to use the C++17 standard library features, specifically replacing C-style string handling with std::string\_view and utilizing string\_view literals (via std::string\_view\_literals). The examples now include the azul17.hpp header instead of azul14.hpp, reflecting the C++17 code generation surface. This includes updates to the async example which demonstrates vector tile loading with HttpClient and ThreadPool, and the calc example which implements a functional calculator UI.

examples/cpp/cpp17 · high confidence

The CI pipeline for building PyPI wheels now includes a fallback mechanism to handle outages at quay.io. A new script, \scripts/ci/pick\_manylinux\_image.sh\, attempts to pull the manylinux image from the primary quay.io registry; if this fails after three attempts, it falls back to a mirrored copy hosted on ghcr.io. This ensures that wheel builds do not fail due to temporary registry downtime, provided the CI environment has a GitHub token with permissions to read and refresh the mirror.

scripts/ci · high confidence

The COBOL example in examples/cobol/hello-world.cob has been updated to explicitly demonstrate that host-invoker function aliases (such as FN-AZ-APP-CREATE and FN-AZ-STRING-FROM-UTF8) are correctly parsed and visible within the COBOL program. This change allows users to verify that the COBOL bindings for the Azul framework are functioning as expected during the smoke test phase.

examples/cobol · high confidence

The debug server implementation has been refactored to eliminate a duplicated 12,000-line operation dispatcher, consolidating the E2E execution engine and assertion logic into \azul\layout::e2e\ and re-exporting them here, which ensures that fixes to debug assertions are no longer silently lost across divergent copies. For lean builds (the default shipped configuration), the debug server is completely removed to reduce binary size and attack surface, but platform logging is now enabled by default via the \plog\\\ macros and \log\\*\ macros, routing traces to the standard \log\ facade so that diagnostic output is visible in production builds without requiring the debug server feature.

_dll/src/desktop/shell2/common/debug\server · high confidence

The documentation pages no longer rely on a Content Delivery Network (CDN) to load Prism.js and Prism.css. Instead, the library files (prism.min.js, prism.min.css) and its MIT license have been vendored directly into the project under doc/templates/prism. This change ensures that code syntax highlighting in the documentation is self-contained and does not depend on external network requests to load the highlighting engine.

doc/templates/prism · high confidence

The project's automation suite has been significantly expanded and refined to support a broader range of languages, platforms, and release channels. New scripts and CI gates now cover end-to-end testing for additional languages (including D, Crystal, Swift, Julia, and others), mobile build pipelines for Android and iOS, and comprehensive release publishing to self-hosted mirrors (Maven, PyPI, NuGet, etc.). The diff also introduces improved artifact size budgeting, dependency justification checks, and screenshot generation tools, ensuring that the growing number of bindings and platforms are rigorously tested and correctly packaged before release.

scripts · high confidence · unverified

The Haskell binding generator now emits a C shim layer (\cshim.rs\) to handle struct-by-value arguments and returns, which GHC's foreign import cannot support directly, and a layout oracle that queries the C compiler for exact \sizeof\, \alignment\, and \offsetof\ values. This ensures that the generated Haskell \Storable\ instances match the C ABI exactly on the target platform, preventing stack overflows and memory corruption in the hello-world example. The generator also produces a Cabal manifest (\cabal.rs\) that lists all generated modules and C sources, and splits the bindings into multiple small modules for parallel compilation.

_doc/src/codegen/v2/lang\haskell · high confidence

The \webrender/core/src/device\ module has been replaced with a new implementation (\gl.rs\) that manages OpenGL context interactions, texture uploads, and shader compilation using a local \GlContext\. This change also introduces \query\_gl.rs\, which provides GPU timer and sampler queries for detailed performance profiling of rendering frames.

webrender/core/src/device · high confidence

The documentation code generation system now exposes a new v2 module, which serves as the primary interface for generating documentation artifacts. This change consolidates the public API of the codegen component to point towards the updated v2 implementation, replacing the previous structure.

doc/src/codegen · medium confidence

The Java hello-world example has been rewritten to use the new App.create(T, layoutFn) API and typed LayoutCallback, replacing the previous pattern. This change aligns the example with the updated code generation for Java, Kotlin, and C\#, ensuring idiomatic usage of the framework's core entry points and callback mechanisms.

examples/java · high confidence

The Kotlin hello-world example has been rewritten to use the new typed LayoutCallback SAM interface and direct Update enum values, replacing previous wrapper-based patterns. This change aligns the Kotlin example with the updated code generation model, ensuring it runs correctly with the new App.create API and typed smart setters.

examples/kotlin · medium confidence

The web backend now performs native code lifting and WebAssembly linking entirely in-process using a new C++ wrapper (azul\_remill) around Remill, LLVM, and LLD. This replaces the previous pipeline that relied on external subprocesses (remill-lift-17, opt, llc, wasm-ld), eliminating the need for external LLVM tools at runtime and reducing per-function lift latency by amortizing architecture loading across batched lifts. The change introduces batched lifting (az\_remill\_lift\_batch) and in-process compilation/linking (az\_remill\_compile\_to\_wasm32\_obj, az\_remill\_wasm\_link), with thread safety managed via serialization due to LLVM's global state.

dll/src/web/cpp · high confidence

The layout engine introduces a new single-pass XML-to-DOM parser that builds an arena-based \FastDom\ directly from tokens, bypassing the previous intermediate \XmlNode\ tree for significantly faster parsing. This new path also extracts \\<style\>\ CSS content inline. Additionally, the SVG rendering subsystem has been refactored to use \agg-rust\ for CPU rasterization and boolean operations, replacing the previous \tiny-skia\ and \resvg\ dependencies, and now supports FXAA post-processing for GPU-rendered SVG textures.

layout/src/xml · high confidence

The \cpurender\ module has been refactored into a new retained-mode compositor that manages a tree of compositing layers, each with its own persistent pixel buffer. This change introduces incremental rendering via per-layer damage tracking, allowing only modified regions to be re-rendered. It supports affine transformations (including perspective) for animated or transformed layers, clip regions for scroll frames and animations, and system-color resolution for gradients. The new architecture also includes SVG rasterization with configurable backdrops and window shaping based on alpha transparency.

layout/src/cpurender · high confidence

The permission subsystem now implements real platform-specific backends for probing and requesting permissions on all supported desktop and mobile platforms. On macOS, it uses TCC and AVFoundation to handle camera, microphone, location, photos, screen capture, and input monitoring. iOS uses Objective-C runtime calls to check and request access for camera, microphone, location, photos, and tracking. Android uses JNI to call Android's runtime permission APIs for camera, microphone, location, photos, contacts, calendar, notifications, Bluetooth, Wi-Fi, and biometrics. Linux uses xdg-desktop-portal for camera and microphone access, with a fallback to auto-grant when no portal is present. Windows reads the registry-based consent store for camera, microphone, location, and screen capture. This replaces the previous stub implementations that returned 'NotDetermined' for all capabilities.

dll/src/desktop/extra/permission · high confidence

The Smalltalk example in the examples directory has been replaced with a Pharo script that serves as a smoke test for the Foreign Function Interface (FFI). This new example demonstrates loading the Azul library (libazul.dylib, libazul.so, or azul.dll) and verifying that the FFI library resolution works correctly, rather than simply printing a static message.

examples/smalltalk · high confidence

A new \unified\ module now provides a target-stable home for feature handles (App, Audio, Video, PDF, SQLite, etc.) to ensure the C-ABI bindings resolve correctly on all platforms. On desktop targets, this module simply re-exports the existing desktop implementations, meaning there is zero behavior change for native users. On WebAssembly (wasm32), it provides \\#\[repr(C)\]\ stubs that match the desktop types' memory layouts, allowing the C-ABI to function without crashing. These wasm stubs are inert—features like audio playback, video decoding, and local databases return empty results or explicit 'no engine' errors—because the actual native backends are not available in the browser.

dll/src/unified · high confidence

The \webrender/core/src/renderer\ module has been significantly reorganized and expanded to support a new GPU cache architecture and enhanced debugging capabilities. A new \GpuCache\ system has been introduced, featuring a \GpuCacheBus\ that allows switching between Pixel Buffer Object (PBO) and shader-based scatter update methods for synchronizing CPU and GPU cache data, improving performance and debugger visibility. A dedicated \DebugRenderer\ has been added to handle on-screen debug overlays, including text rendering via a baked font bitmap and geometric primitives like lines and triangles. The renderer's initialization and configuration have been updated to support these subsystems, including new options for scene builder hooks, async property sampling, and specific GPU capabilities like dual-source blending and texture storage support. Additionally, the \GpuBuffer\ module provides a typed interface for building GPU cache blocks, and the \upload\ module has been refined to handle texture cache uploads with improved batching and staging buffer management.

webrender/core/src/renderer · high confidence

WebRender now compresses all embedded GLSL shader sources using brotli at build time, reducing the raw shader payload from approximately 305KB to around 50KB. A new build script in webrender/core/build.rs handles this compression and generates a runtime decompression helper, while the core documentation has been updated to reflect the current clipping, positioning, blob image, and text rendering architectures.

webrender · high confidence

Added minimal Info.plist and entitlements templates to the scripts/ios directory to support building Azul cdylib-as-iOS-binary applications. The Info.plist includes placeholders for executable name, bundle ID, display name, version, and minimum OS version, while the entitlements file provides a stub for ad-hoc or development signing.

scripts/ios · high confidence

Added C-language conformance test generator; Added CSS reftests for absolute positioning and sizing; Added benchmark for the fast DOM rendering pipeline; Added comprehensive CSS parser and layout unit tests; Added comprehensive test coverage for DOM reconciliation and change detection; Added comprehensive test coverage for core CSS and DOM behavior; Added comprehensive test suite for CSS, DOM, layout, and text processing; Added deterministic in-memory font generation utilities for layout tests; Added memory-leak and crash tests for all language bindings; Added unit tests for layout solver 3 components; Expanded CSS layout and rendering test suite; Expanded E2E test suite for core UI interactions; Expanded layout test coverage for absolute positioning, anonymous boxes, and pagination; New integration and source-scanning tests for windowing backends and lifecycle; Revived dormant text3 layout tests.

The Azul workspace has been reorganized to streamline the core library and update language-specific examples. The \azul-core\ crate is now published as a lean package (version 0.0.16) that excludes test, bench, and example harnesses, and it upgrades its font configuration dependency to \rust-fontconfig\ 5.0. The \azul-css\ crate also updates to version 0.0.16 and introduces a new \io\ feature to control system-style integration tests. Several example projects have been updated to reflect these changes: the C\# example now targets .NET 8, the Go example uses the \azul.rs/ui/go\ module path, and the Kotlin example has been upgraded to Kotlin 2.3.21 and Java 17.

(dependencies) · high confidence

Added a documentation file (\third\_party/WEB\_LIFTER\_INSTALL.md\) explaining how to install the local toolchain (remill, LLVM, LLD, binaryen) required for the web backend's code-lifting feature. The guide details the discovery order for binaries, platform-specific setup steps for macOS/Linux and Windows, and configuration for the optional lift cache via environment variables.

_third\party · high confidence

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

• CAI 56 → 56 (+0.4)
• Rubric changed (rubric-2026.09.10 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 43 → 42 (-0.7)
• Architecture 97 → 98 (+0.7)
• Maturity 73 → 74 (+0.1)
• Readiness 62 → 62 (-0.1)
• Security 60 → 66 (+5.4)
• Event Sourcing 100 → 100 (+0.0)

• Button::dom (cognitive 16) (layout/src/widgets/button.rs)
• ClassTooLong: DisplayList (layout/src/solver3/display_list.rs)
• ClassTooLong: DisplayListBuilder (layout/src/solver3/display_list.rs)
• ClassTooLong: DisplayListGenerator (layout/src/solver3/display_list.rs)
• ClassTooLong: DisplayListItem (layout/src/solver3/display_list.rs)
• ClassTooLong: LayoutWindow (layout/src/window.rs)
• Cpp14Generator::generate (cognitive 16) (doc/src/codegen/v2/lang_cpp/cpp14.rs)
• CssPropertyCache::apply_ua_css (cognitive 64) (core/src/prop_cache.rs)
• CssPropertyCache::apply_ua_css (cyclomatic 25) (core/src/prop_cache.rs)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (doc/src/autofix/mod.rs)
• Duplicated block (10 lines × 2) (doc/src/codegen/v2/lang_go/types.rs)
• Duplicated block (10 lines × 2) (layout/src/widgets/ribbon.rs)
• Duplicated block (10 lines × 2) (layout/src/widgets/text_area.rs)
• Duplicated block (10 lines × 2) (layout/src/widgets/text_area.rs)
• Duplicated block (10 lines × 2) (layout/src/widgets/titlebar.rs)
• Duplicated block (10 lines × 2) (webrender/core/src/render_task_graph.rs)
• Duplicated block (10 lines × 2) (webrender/glyph/src/lib.rs)
• Duplicated block (10 lines × 2) (webrender/swgl/src/shaders/brush_yuv_image_alpha_pass_texture_rect_yuv.rs)
• …and 697 more

• Ambiguous naming for single-item construction. 'from_vec' suggests taking a collection (Vec), but the argument is a single AccessibilityAction. 'from_item' is clearer. Having both suggests 'from_vec' might be a typo or legacy name, or it takes a Vec in a different overload not shown, but the signature shows a single item. This creates confusion about whether to pass a single item or a collection.
• CI installs an unverified third-party binary (.github/workflows/rust.yml)
• Conflicting naming for Option unwrapping. 'into_option' typically implies consuming the wrapper to get the inner value (or the standard Option<T>). 'as_option' usually implies borrowing. However, both signatures return AccessibilityAction (owned), not &AccessibilityAction. This suggests 'as_option' is misnamed or 'into_option' is misnamed. Standard Rust convention is 'into_inner' or 'unwrap' for owned, and 'as_ref'/'as_mut' for borrowed. Using 'as_option' for an owned return is non-standard and confusing.
• ConformancePlan::build (cognitive 33) (doc/src/codegen/v2/conformance/mod.rs)
• ConformancePlan::build (cyclomatic 23) (doc/src/codegen/v2/conformance/mod.rs)
• CssProperty::interpolate (cyclomatic 50) (css/src/props/property.rs)
• CssPropertyCache::normal_props_present (cognitive 20) (core/src/prop_cache.rs)
• DpiFunctions::hwnd_dpi (cognitive 19) (dll/src/desktop/shell2/windows/dpi.rs)
• Duplicated block (10 lines × 2) (dll/src/desktop/shell2/linux/wayland/mod.rs)
• Duplicated block (10 lines × 2) (doc/src/codegen/v2/lang_cpp/cpp20.rs)
• Duplicated block (10 lines × 2) (doc/src/codegen/v2/lang_crystal/model.rs)
• Duplicated block (10 lines × 2) (doc/src/codegen/v2/lang_crystal/wrappers.rs)
• Duplicated block (10 lines × 2) (doc/src/codegen/v2/lang_csharp/wrappers.rs)
• Duplicated block (10 lines × 2) (doc/src/codegen/v2/lang_d/wrappers.rs)
• Duplicated block (10 lines × 2) (doc/src/codegen/v2/lang_kotlin/managed.rs)
• Duplicated block (10 lines × 2) (doc/src/codegen/v2/lang_ocaml/wrappers.rs)
• Duplicated block (10 lines × 2) (doc/src/codegen/v2/lang_odin/types.rs)
• Duplicated block (10 lines × 2) (doc/src/reftest/regression.rs)
• Duplicated block (10 lines × 2) (layout/src/widgets/ribbon.rs)
• Duplicated block (10 lines × 2) (layout/src/widgets/themes/flat.rs)
• …and 710 more

• 300 commits — 172 feature/other, 128 fixes

• doc/src — 101 commits
• doc/guide — 97 commits
• dll/src — 25 commits
• .github/workflows — 20 commits
• (root) — 11 commits
• layout/src — 11 commits
• core/src — 4 commits
• examples/cpp — 3 commits
• (repo) — 2 commits
• dll/build_link.rs — 2 commits
• doc/templates — 2 commits
• examples/assets — 2 commits
• examples/azul-meet — 2 commits
• css/src — 1 commit
• dll/Cargo.toml — 1 commit
• examples/azul-writer — 1 commit
• examples/c — 1 commit
• examples/crystal — 1 commit
• examples/go — 1 commit
• examples/julia — 1 commit

• fix: Fix Java and Kotlin examples to use Update enum directly
• fix: Merge pull request #474 from fschutt/fix/compilation-1009
• fix: Merge pull request #475 from fschutt/fix/docs-update-human
• fix: ci: fix the zig download and the C# doc-comment XML
• fix: codegen(cpp): 3-arg AZ_REFLECT_JSON in every C++ header, Option has_value()/value(), deducing-this builders, toStdExpected fix
• fix: codegen(pascal): PACKENUM 4 ABI fix, typed callback surface, TAzApp<T>, builder chains, string overloads
• fix: codegen: Fix has_wrapper_class to include structs with methods even if they have no delete function
• fix: fix(a11y): hand a waiting adapter the whole tree, never an increment
• fix: fix(animation): a declared transition animates on every toggle, on the CPU renderer too
• fix: fix(api)!: public constructors are named create, and new is rejected
• fix: fix(app): open the windows queued with App::add_window
• fix: fix(autodoc): write the screenshot manifest with portable paths
• fix: fix(autofix): keep the WebTransport event types in the webtransport module
• fix: fix(azul-writer): restore the AzWriter entry point that a merge replaced with the old AzulDoc demo
• fix: fix(bindings): catch at every callback boundary, log, return the fallback
• fix: fix(build): a link-dynamic consumer build no longer overwrites libazul
• fix: fix(codegen): Remove illegal borrow in write_string for Lua bindings
• fix: fix(codegen): Route all Lua aggregates through Byref to fix Linux x64 LuaJIT
• fix: fix(codegen): Vec-typed fields were unreachable from Python
• fix: fix(codegen): bindings reference only symbols libazul exports
• …and 280 more

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

fschutt/azul 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.