moreSwift/swift-cross-ui

SwiftCrossUI is a cross-platform UI framework that provides a SwiftUI-compatible API to render native user interfaces across macOS, Windows, Linux, iOS, tvOS, Android, and even terminal or embedded environments. It achieves this through a modular backend architecture that maps high-level view definitions to platform-specific toolkits like AppKit, WinUI, GTK, and UIKit, while supporting advanced features such as hot reloading, state management, and layout engines. The system also includes tooling to analyze API differences and generate stubs for porting existing SwiftUI applications to these diverse platforms.

39 changes.

The project was rebranded as SwiftCrossUI and fundamentally restructured to support multiple platform backends including GTK, AppKit, Qt, LVGL, and Curses. This period involved a complete rewrite of the view graph and state management systems, introducing macro-based hot reloading and a SwiftUI-like API. Extensive documentation, new example applications, and modular backend architectures were added to facilitate cross-platform development.

28 changes.

This period focused on significantly expanding cross-platform support by introducing new backends for WinUI, Gtk3, and UIKit, alongside a platform-adaptive default selection mechanism. The framework's API was refined with comprehensive view modifiers, environment management, and gesture handling, while the layout engine was redesigned for better space distribution. Additionally, extensive example applications and testing infrastructure were added to validate the new capabilities.

29 changes.

This period focused on significantly expanding the Android backend with native UI controls, lifecycle management, and visual effects, while introducing a modular protocol-based architecture for backend features. The framework also enhanced its developer experience through new macros for hot reloading, observability, and environment handling, alongside tools for API analysis and documentation deployment.

A new ColorsExample application has been added to the Examples directory, providing a visual reference for color handling. The app displays a grid of standard and SCUI-exclusive colors (such as cyan, indigo, mint, pink, and teal) across dark, light, and system color schemes. It includes a toggle to switch between platform-specific system colors and the framework's built-in color definitions, allowing users to compare how colors render under different themes.

Examples/Sources/ColorsExample, Examples/Sources/WebViewExample · high confidence

The ControlFocusabilityTest example application has been added to demonstrate focus state management and modifier usage. The app provides a UI for testing focus behavior across various controls including buttons, menus, toggles, sliders, and text fields, allowing users to toggle focusability and focus effects for each control type.

Examples/Sources/ControlFocusabilityTest · high confidence

New example apps are provided to demonstrate the framework's UI capabilities. The ControlsExample app showcases interactive components including buttons, menus, toggles (switch, button, and checkbox styles), sliders, text fields, secure fields, progress views, pickers with various styles, and date pickers, while also illustrating state persistence via @AppStorage. The NavigationExample app demonstrates hierarchical navigation using NavigationStack and typed NavigationLinks.

Examples/Sources/ControlsExample · high confidence

Introduces a new example application in Sources/Gtk3Example that demonstrates the Swift GTK3 bindings. The app showcases a variety of UI components including labels, sliders, text entries, scrollable viewports, buttons, images, and text views, providing a reference implementation for users building desktop applications with GTK3.

Sources/Gtk3Example · high confidence

A new example application has been added to showcase gradient rendering capabilities. The app provides a user interface to select between linear, radial, and angular gradient types, displaying various configurations of colors and stops for each. It includes platform-specific handling, such as disabling unsupported gradient types on certain backends like WinUI and Gtk, and uses scroll views to present the visual examples.

Examples/Sources/GradientsExample · high confidence

Introduces a new Gtk3 backend to support older Linux distributions that do not have Gtk4 available. This includes the CGtk3 Swift bindings for GTK3, Pango, and Cairo, along with core application components such as the Application class (handling activation, session registration, and file opening), window management, signal handling via GObject, and HiDPI-aware image scaling through Pixbuf and CairoSurface.

Sources/Gtk3 · high confidence

This change introduces a new utility layer within the Gtk3 backend to support older Linux systems. It adds foundational wrappers for GTK3 C APIs, including signal handling (SignalBox, Signals), action management (GAction, GSimpleAction, GActionGroup), and menu construction (GMenu). It also provides property management utilities (GObjectProperty, GValueRepresentable) for binding Swift types to GObject properties, text measurement helpers (Pango), and a text buffer implementation (TextBuffer). These components form the necessary infrastructure for the Gtk3 backend to function correctly on legacy environments.

Sources/Gtk3/Utility · high confidence

New Swift wrappers for Gtk3 datatypes have been added to support older Linux environments. This includes a Color struct with eight-bit initialization and GdkRGBA conversion, an EllipsizeMode enum mapping Pango ellipsize modes, and a Size struct for width/height dimensions.

Sources/Gtk3/Datatypes · high confidence

Introduces a new example application in Sources/GtkExample that demonstrates the library's UI components, including labels, sliders, text entries, scrollable windows, buttons, calendars, images, and text views. The example also conditionally includes a file dialog feature when the FileDialog module is available, providing a comprehensive showcase of the generated wrappers.

Examples/Sources/MusicPlayerExample, Sources/GtkExample · high confidence

A new example application (HoverExample) has been added to showcase the View.onHover modifier. The demo renders a grid of cells that change opacity when hovered, illustrating how to detect hover states and manage animations using state and timers.

Examples/Sources/HoverExample · high confidence

Users can now apply three new types of gradient fills to views: linear, radial, and angular (conic). These new SwiftUI-style view structs allow specifying color stops, center points, and directional parameters (start/end points for linear, radii for radial, and angles for angular) to create complex visual effects across supported backends.

Sources/SwiftCrossUI/Views/Gradients · high confidence

A new NotesExample application is introduced, demonstrating a cross-platform note-taking interface. The app features a sidebar list of notes and a detail view for editing titles and content, utilizing a TextEditor for rich text input. It implements basic state persistence by saving and loading notes to a local JSON file, and includes a slider to control the number of preview lines displayed in the list. The example also showcases adaptive theming for the text editor background.

Examples/Sources/NotesExample · high confidence

A new example application, PathsApp, has been added to demonstrate drawing capabilities. It showcases custom shapes including ArcShape for rendering clockwise and counter-clockwise arcs, and TestCurveShape for cubic curves and rotated rounded rectangles, utilizing the inset modifier for visual styling.

Examples/Sources/PathsExample · high confidence

The SplitExample application has been added to showcase a multi-column navigation interface using the new layout system. It features a ContentView that toggles between a two-column and a three-column NavigationSplitView, allowing users to select subject areas and specific topics to display details. The example utilizes @State for local state management and integrates with the hot-reloadable build system to facilitate rapid UI iteration.

Examples/Sources/SplitExample · high confidence

The ObservableExample now demonstrates the use of Swift's native @Observable macro for state management, replacing previous patterns. The example app includes a main view with interactive controls to modify window and view text, and features an automatic mode that periodically updates these texts using the new observation-based model.

Examples/Sources/ObservableExample · high confidence

The library introduces new Swift-native datatypes in the Gtk wrapper to improve type safety and usability. A \Color\ struct is added to represent RGBA values with helpers for 8-bit conversion and mapping to GDK colors. An \EllipsizeMode\ enum is introduced to map Pango ellipsize modes (none, start, middle, end) to Swift, enabling text truncation control. A \Size\ struct is also added to represent width and height dimensions, conforming to \Sendable\ for thread safety.

Sources/Gtk/Datatypes · high confidence

The Color type now supports adaptive colors that automatically switch between light and dark mode variants, as well as system colors that follow platform-specific design guidelines. Users can create adaptive colors using the new \adaptive(light:dark:)\ initializer or use predefined adaptive color constants like \Color.blue\, \Color.red\, etc. Additionally, the \system(\_:)\ initializer allows creating colors that adapt to each platform's native color palette. The Color struct also includes a \Resolved\ type for obtaining concrete RGBA values in a specific environment.

Sources/SwiftCrossUI/Values/Color · high confidence

Users can now draw basic geometric shapes—Rectangle, Circle, Ellipse, Capsule, and RoundedRectangle—using the new Shape protocol. These shapes support layout sizing and can be modified with fill() and stroke() modifiers to apply colors and stroke styles. The RoundedRectangle implementation uses smooth superellipse approximations for better visual quality, and all shapes support the inset(by:) modifier for resizing.

Sources/SwiftCrossUI/Views/Shapes · high confidence

Users can now run SwiftCrossUI applications in a terminal environment via a new Curses backend. This implementation, built on TermKit, provides a single-window interface with support for vertical and horizontal stacks, text views, and buttons. It includes basic keyboard handling for quitting via Ctrl+C or Escape and ensures UI updates are dispatched to the main thread on Apple platforms.

Sources/CursesBackend · high confidence

Introduces the GYB (Generate Your Boilerplate) code generator tool, including the main entry point script and the core Python implementation for parsing templates and generating source code.

gyb · high confidence

This change introduces new callback infrastructure in the Gtk module, adding a Cancellable wrapper for operation cancellation and a SignalBox system that supports binding Swift closures to GTK signals with up to six arguments. It also provides helper functions to connect and disconnect signals with configurable flags, enabling more robust event handling and resource management for users interacting with GTK components.

Sources/Gtk/Callbacks · high confidence

An example application has been added to demonstrate the use of the .onTapGesture modifier with distinct gesture types (.primary, .secondary, and .longPress). The app displays three interactive targets that increment and show a count when tapped or long-pressed, illustrating how to handle different tap gestures in the UI.

Examples/Sources/TapGesturesExample · high confidence

This change introduces a suite of new view modifiers in the Style directory, allowing users to customize the appearance and behavior of UI elements. Specifically, it adds \buttonStyle\ and \toggleStyle\ to control the visual presentation of interactive controls, \cornerRadius\ to apply rounded corners to views, and \foregroundColor\ to change text and icon colors. It also includes text-specific modifiers: \font\, \fontWeight\, \fontDesign\, \emphasized\, \italic\, \textCase\, and \lineLimit\ for detailed typography control. Additionally, \colorScheme\ is added to set the overall color theme (light/dark) for a view hierarchy.

Sources/SwiftCrossUI/Views/Modifiers/Style · high confidence

The Android backend now provides implementations for a wide range of SwiftCrossUI features, enabling richer user interfaces on Android devices. This includes support for alerts, color resolution (including adaptive colors for light/dark modes), corner radius containers, and custom buttons with various styles. Visual elements are enhanced with gradient support (linear, radial, and angular), image rendering, and path drawing capabilities. User interaction is expanded through selectable lists, date pickers with multiple styles, file open dialogs, and attached popover menus. Additionally, the backend handles essential platform concerns such as activity lifecycle management via a new delegate, locale and calendar detection, and text styling with proper font weight and alignment.

Sources/AndroidBackend · high confidence

Developers can now access underlying AppKit views (such as NSWindow, NSView, NSButton, NSTextField, NSSlider, NSScrollView, NSTableView, NSSplitView, and NSImageView) from SwiftCrossUI views using the new \inspect\ and \inspectWindow\ modifiers. This enables direct interaction with native platform controls for advanced customization or debugging within the AppKit backend.

Sources/AppKitBackend · high confidence

The repository now includes the necessary files in the Pages directory to publish documentation to GitHub Pages. This setup includes a CNAME file pointing to docs.swiftcrossui.dev, a Google site verification file, and an index.html that redirects visitors to the documentation folder, enabling the automated workflow to serve the docs at the specified custom domain.

Pages · high confidence

The view, scene, and table row builders in the SwiftCrossUI Builders module have been updated to support composing up to 20 children (views, scenes, or table columns) instead of the previous limit of 2. This change allows applications to define more complex UI structures, such as multi-window setups with up to 10 scenes or tables with up to 20 columns, without hitting compilation limits.

Sources/SwiftCrossUI/Builders · high confidence

The FontsExample application now includes controls to toggle text emphasis, monospacing, and italics, as well as a picker to adjust text case (uppercase, lowercase, or unset). This allows users to interactively preview how these styling options affect various system font sizes within the example.

Examples/Sources/FontsExample · high confidence

The Gtk backend now includes generated Swift wrappers for the GTK accessibility API, exposing the \Accessible\ protocol and associated enums (such as \AccessibleRole\, \AccessibleState\, \AccessibleProperty\, and \AccessibleRelation\). This enables applications to integrate with assistive technologies by exposing UI element roles, states, and relationships to screen readers and other AT tools.

Sources/Gtk/Generated · high confidence

Added a new AndroidBackendShim module that provides a C-based bridge for Android logging. This shim exposes an \android\_log\ function to write messages via the Android log system and includes the necessary module map and header files to integrate this functionality into the build.

Sources/AndroidBackendShim · high confidence

This change introduces the initial GTK backend implementation, moving the codebase from Sources/Gtk into SwiftCrossUI. It provides the core infrastructure for GTK-based UI rendering, including the Application and GObject base classes, signal handling with proper memory management (disconnecting handlers in deinit to prevent crashes), error handling via GtkError, and support for file open/save dialogs and URL opening. The implementation also includes basic text wrapping support via PangoWrapMode conversions and memory texture handling for image rendering.

Sources/Gtk · high confidence

This change introduces the foundational GTK widget wrappers for the Linux backend, adding new files under Sources/Gtk/Widgets. It provides Swift wrappers for core containers and UI elements including Box, Grid, Fixed, Paned, ScrolledWindow, Stack, and Dialog (with MessageDialog), as well as controls like ColorButton, Label, Image, Picture, Range, Scale, SpinButton, and a comprehensive TextView. The entry also includes low-level extension utilities for type conversions (gboolean/Bool, Int/Bool) and pointer casting, along with manual additions for specific widget behaviors like file chooser operations and drawing area callbacks.

Sources/Gtk/Widgets · high confidence

Introduces the foundational widget classes for the new Gtk3 backend, including containers (Box, Container, Fixed, Grid, Paned, ScrolledWindow), windows (ApplicationWindow, Dialog, MessageDialog), and controls (ListBox, Menu, TextView, Image, Label, Range/Scale, Spinner). This adds the necessary UI components to support legacy Linux systems running GTK 3.

Sources/Gtk3/Widgets · high confidence

This change introduces the initial set of generated Swift bindings for the Gtk3 library, located in Sources/Gtk3/Generated. The diff adds numerous new files covering core widgets (such as Button, Calendar, and CheckButton), interfaces (like Activatable, Buildable, and CellLayout), and various enumerations (including Align, ArrowType, and BorderStyle). These bindings provide the foundational layer required to support older Linux systems via a dedicated Gtk3 backend.

Sources/Gtk3/Generated · high confidence

This change introduces a new backend implementation for the Gtk3 toolkit, enabling the cross-platform UI framework to run on legacy Linux systems that do not support newer Gtk4 versions. The implementation covers a comprehensive set of UI features including core windowing, alerts, menus, checkboxes, color pickers, adaptive colors, file dialogs, path/shape rendering, scroll containers, secure fields, list views, sheets, sliders, split views, buttons, switches, and progress indicators. It also includes support for opening external URLs, revealing files in the native file manager, and handling incoming URL schemes, providing a complete native widget experience on older Linux distributions.

Sources/Gtk3Backend · high confidence

Developers can now access runtime context and persistent settings using SwiftUI-style property wrappers. The new @Environment wrapper allows views to read values (such as color schemes or file-picking actions) and ObservableObjects from the view hierarchy, replacing the deprecated EnvironmentObject. The @AppStorage wrapper enables declarative persistence of Codable values to disk via a pluggable AppStorageProvider protocol, defaulting to UserDefaults with JSON encoding. These wrappers operate on the new EnvironmentValues container, which supports extensible custom keys and exposes platform actions like file selection, URL opening, and window management.

Sources/SwiftCrossUI/Environment · high confidence

Developers can now use the new @HotReloadable macro on structs and the \#hotReloadable macro for expressions to enable hot reloading of UI components. The @HotReloadable macro generates an entry point that connects to a hot reloading server to receive updated code, while \#hotReloadable wraps specific view expressions to allow them to be refreshed dynamically without restarting the application.

Sources/SwiftCrossUIMacrosPlugin/HotReloading · high confidence

A new command-line tool, APITool, is available to analyze the SwiftCrossUI public API surface against SwiftUI. It provides two main capabilities: diffing the two API surfaces to identify missing SwiftUI APIs, and generating stub files for those missing APIs to facilitate porting from SwiftUI to SwiftCrossUI. The tool runs on macOS, automatically fetching the Xcode developer directory via \xcode-select\ if not specified, and outputs generated stubs to a specified directory.

APITool · high confidence

SwiftCrossUI now includes an \@AppStorage\ property wrapper that persists state to disk, allowing values to survive app launches. This feature supports persistence via string keys or type-safe keys conforming to \AppStorageKey\, and integrates with the environment to allow platform-specific storage providers to be injected. Users can now manage persistent application settings and user preferences directly within their views using this new API.

Sources/SwiftCrossUI/State/AppStorage · high confidence

A new CGtk module has been added to expose GTK4, Pango, and PangoCairo libraries for use by the application. This module provides the necessary bindings and headers to support fine-grained window size control and the new SCUI text layout system, enabling more precise UI rendering and layout capabilities across all platforms.

Sources/CGtk · high confidence

The DummyBackend now provides a concrete, platform-independent implementation of the backend protocol suite, enabling UI logic to be tested without native dependencies. This location contributes the core widget definitions (such as Button, TextField, and Window) and feature-specific handlers (including Checkboxes, Pickers, DatePickers, and ScrollContainers) that allow applications to render and interact with UI elements in a simulated environment.

Sources/DummyBackend · high confidence

SwiftCrossUI now supports a Scenes API that allows applications to define multiple windows, standalone alerts, and menu bar commands. Users can create single windows with \Window\, manage groups of identical windows with \WindowGroup\ (supporting up to 20 scenes), and present modal alerts via \AlertScene\. The API also includes \Commands\ and \CommandMenu\ for configuring menu bar items, with backend-specific implementations handling the actual rendering and interaction.

Sources/SwiftCrossUI/Scenes · high confidence

SwiftCrossUI is introduced as a new cross-platform UI framework, providing the core \App\ protocol and \\_App\ runtime to manage the scene graph, state observation, and backend execution. The framework integrates \swift-log\ for structured logging and introduces \HotReloadable\ and \hotReloadable\ macros to encapsulate hot-reloading boilerplate, allowing developers to easily enable live code reloading. It also includes support for extracting application metadata from Swift Bundler and provides a global logger instance shared across backends.

Sources/SwiftCrossUI · high confidence

The GtkCodeGen tool now includes a new internal parser (GIR.swift) that reads GObject Introspection Repository XML files to automatically generate Swift wrapper code for Gtk classes, interfaces, and enums. This replaces manual wrapper creation with an automated pipeline that handles type mapping, signal handling, and property accessors, significantly reducing the effort required to support new Gtk components.

Sources/GtkCodeGen · high confidence

Adds a new LVGL-based backend that allows SwiftCrossUI applications to render on LVGL-compatible displays. This implementation supports core UI components including vertical and horizontal stacks, text labels, and buttons, enabling the counter example to run without padding. The backend operates as a single-window environment and handles main-thread execution appropriately for Apple platforms.

Sources/LVGLBackend · high confidence

Users can now run the application on Linux and other platforms using a new Qt5 backend, implemented via the Qlift bindings. This addition provides support for core UI components including windows, vertical and horizontal stacks, text views, buttons, and sliders, enabling the CounterExample to run on Qt-enabled systems.

Sources/QtBackend · high confidence

This change adds a new experimental backend for Windows desktop applications, built on the WinUI framework and Windows App SDK. It enables cross-platform UI development for Windows by providing native implementations for core controls (Button, TextField, SecureField, Slider, List, ScrollView, Image, Shape), layout containers (HStack, VStack, ZStack, Group, NavigationSplitView, SplitView), and advanced features such as alerts, sheets, color pickers, gradients, and file dialogs. The backend also supports inspection modifiers for accessing underlying native widgets, adaptive color schemes, and single-instance app activation with URL scheme handling.

Sources/WinUIBackend · high confidence

The framework now supports a scene preferences system that allows scenes to propagate values, such as menu commands, up the scene hierarchy. This is implemented via new types in the scene graph: \SceneGraphNode\ manages persistent scene state and updates, \SceneNodeUpdateResult\ captures the outcome of an update including preference values, and \ScenePreferenceValues\ holds specific preferences like commands which are automatically merged from child scenes. This enables UI elements like menu bars to be driven by scene-level data rather than just view-level state.

Sources/SwiftCrossUI/Scenes/Graph · high confidence

The GTK backend now includes a new type-safe CSS utility layer (CSSBlock, CSSProperty, CSSProvider) that allows developers to apply styles programmatically rather than relying solely on raw CSS strings. This system supports common styling properties such as colors, padding, opacity, borders, and font attributes, providing a safer and more integrated way to customize the appearance of UI components within the application.

Sources/Gtk/Utility/CSS · high confidence

The macro plugin now provides two new macros: @Entry, which allows defining custom properties for EnvironmentValues and AppStorage with automatic accessor generation and support for implicitly unwrapped optionals, and @CastBackend, which enables casting backend implementations to specific protocols within function bodies while handling widget type casting.

Sources/SwiftCrossUIMacrosPlugin · high confidence

Added a new example application demonstrating the ForEach view modifier with a list of items that supports appending, inserting, removing, and reordering elements via a slider and buttons.

Examples/Sources/ForEachExample · high confidence

This change introduces a suite of new utility classes and protocols in the Gtk backend to simplify interaction with GObject-based libraries. It adds a \@GObjectProperty\ property wrapper and \GValueRepresentable\ protocol, allowing Swift types like \Int\, \Bool\, \String\, and \Double\ to be easily mapped to and from GObject properties. Additionally, it provides wrappers for core GTK/GIO types including \GAction\, \GSimpleAction\, \GMenu\, \GDateTime\, \GFile\, \GListModel\, and \Pango\ text layout, along with a \TextBuffer\ implementation for text editing support.

Sources/Gtk/Utility · high confidence

This change introduces a suite of new environment actions in the \SwiftCrossUI/Environment/Actions\ module, enabling cross-platform interactions directly from view code. Users can now present alerts via \PresentAlertAction\, dismiss presentation contexts with \DismissAction\, and close windows using \DismissWindowAction\. File system interactions are supported through \PresentSingleFileOpenDialogAction\ and \PresentFileSaveDialogAction\ for opening and saving files, as well as \RevealFileAction\ to highlight files in the system file manager. Additionally, \OpenURLAction\ allows launching external URLs, \OpenWindowAction\ supports multi-window navigation, and \PickerSupportedAction\ enables checking picker style compatibility.

Sources/SwiftCrossUI/Environment/Actions · high confidence

This update introduces several new view modifiers to the SwiftCrossUI library, allowing developers to react to user interactions and state changes. You can now use \onTapGesture\ to handle primary, secondary, and long-press taps (with the legacy \onClick\ modifier marked as deprecated), \onHover\ to detect when a pointer enters or leaves a view, and \onChange\ to execute an action whenever a specific \Equatable\ value changes. Additionally, \onSubmit\ enables handling of text field submissions (e.g., pressing Enter), and \onOpenURL\ allows the app to respond to system URL requests. These modifiers are implemented as new view modifiers in the \Handlers\ directory, integrating with the backend's gesture and environment systems.

Sources/SwiftCrossUI/Views/Modifiers/Handlers · high confidence

The layout system now supports several new view modifiers that give you finer control over sizing and positioning. You can enforce a specific aspect ratio with \aspectRatio\, lock a view to its ideal dimensions (or lock individual axes) with \fixedSize\, and define precise or flexible size constraints (min, ideal, max) with the updated \frame\ modifier. Additionally, \layoutPriority\ allows you to influence how a parent layout allocates space to this view, while \background\ and \overlay\ modifiers now support ViewBuilder syntax for stacking content.

Sources/SwiftCrossUI/Views/Modifiers/Layout · high confidence

The \Sources/SwiftCrossUI/Values\ module now includes a comprehensive set of new types that support the library's layout system and UI modifiers. This introduces \Alignment\ and \StackAlignment\ for positioning views, \Font\ with \TextStyle\ and \DeviceClass\ for dynamic, platform-aware typography, and \ColorScheme\ for light/dark mode support. It also adds foundational types for geometry (\GeometryProxy\, \UnitPoint\), gradients (\Gradient\), paths (\Path\, \AffineTransform\), and state management (\AppPhase\, \ScenePhase\, \Focus\, \Focusability\). These values enable the new layout engine and modifiers like \lineLimit\, \textCase\, and \menuOrder\.

Sources/SwiftCrossUI/Values · high confidence

The \Sources/SwiftCrossUI/Views/Modifiers/Lifecycle\ location now provides four new view modifiers that allow developers to hook into the view lifecycle. \onAppear\ executes an action just before the view is rendered on screen, while \onDisappear\ triggers an action when the view is removed (leveraging \deinit\ propagation). A new \onCommit\ modifier runs an action before the view is committed to the backend. Additionally, the \task\ modifier enables starting asynchronous work tied to the view's lifetime, with support for an optional \id\ parameter to automatically cancel and restart the task when that value changes.

Sources/SwiftCrossUI/Views/Modifiers/Lifecycle · high confidence

The \Sources/SwiftCrossUI/Scenes/Modifiers\ directory now includes new modifiers that allow developers to configure scene-level behavior. The \commands\ modifier enables adding items to the system menu bar. The \environment\ and \transformEnvironment\ modifiers allow updating scene environment values. Additionally, new modifiers \defaultLaunchBehavior\, \defaultSize\, and \windowResizability\ let you control how windows are sized, launched, and resized by default.

Sources/SwiftCrossUI/Scenes/Modifiers · high confidence

This change introduces a suite of new View modifiers in the SwiftCrossUI library, enabling developers to manage UI state and presentation more effectively. Users can now present modal alerts with \alert(\:)\ and conditional sheets with \sheet(isPresented:onDismiss:content:)\, including support for sheet detents, corner radius, and background customization. Focus management is enhanced with \focused(\:)\ and \focusable(\:)\ modifiers for binding focus state to views. Environment and state persistence are supported via \environment(\:)\, \appStorageProvider(\:)\, and \preference(key:value:)\. Additional modifiers include \disabled(\:)\ for controlling interactivity, \help(\:)\ for tooltips, \textSelectionEnabled(\:)\ for text control, \menuOrder(\:)\ for menu sorting, and \scrollDismissesKeyboard(\:)\ for keyboard behavior. Debugging and inspection capabilities are added through \inspect(\:)\ and \inspectWindow(\:)\ modifiers.

Sources/SwiftCrossUI/Views/Modifiers · high confidence

The DefaultBackend module now automatically selects the appropriate UI backend based on the current platform at compile time. It supports AppKit, Gtk, Gtk3, WinUI, Qt, Curses, UIKit, and Android backends, ensuring that applications using this module will link against the correct platform-specific implementation without manual configuration.

Sources/DefaultBackend · high confidence

The PortingKit now includes generated enum stubs (e.g., LayoutDirection, ControlSize, BlendMode) that conform to Swift protocols like Hashable and CaseIterable, enabling consistent type usage across platforms. Additionally, it provides platform-specific extensions: on Apple platforms, it adds Equatable conformance to CGRect, CGPoint, and CGSize, and exposes a ControlSize.allCases property that dynamically includes platform-specific sizes (like .large on macOS 11+ and .extraLarge on iOS 17+) based on availability checks. It also introduces basic struct stubs for Anchor and PencilSqueezeGestureValue.

_Sources/\SwiftCrossUIPortingKit · high confidence

The project has been renamed from SwiftGtkUI to SwiftCrossUI, expanding from a single-Gtk focus to a cross-platform framework supporting macOS (AppKit), Windows (WinUI), Linux (Gtk), Android, and iOS/tvOS (UIKit) via a DefaultBackend abstraction. The repository now includes a comprehensive README detailing backend requirements, a new documentation site at docs.swiftcrossui.dev, and a Code of Conduct. Development tooling has been standardized with SwiftFormat and SwiftLint configurations, and the project structure now separates examples into a subpackage to reduce clutter. Initial commit artifacts like the MIT License, Dockerfile, and vcpkg configuration are also included.

(repo-wide) · high confidence

The plugin now supports Swift's native @Observable macro by introducing the ObservableObjectMacro. When applied to a class, this macro automatically conforms the type to SwiftCrossUI.ObservableObject and injects the @SwiftCrossUI.Published wrapper into public, non-static, non-private var properties that are not already published or marked with ObservationIgnored, enabling seamless integration with the framework's observation system.

Sources/SwiftCrossUIMacrosPlugin/Observability · high confidence

The SwiftCrossUI documentation has been reorganized into structured categories (such as Controls, Layout, Navigation, and State) and significantly expanded with new articles. Key additions include a detailed guide on hot reloading setup and state persistence, an explanation of the AppBackend protocol refactor into modular BackendFeatures, and comprehensive setup tutorials for Linux, macOS, and Windows development environments.

Sources/SwiftCrossUI/SwiftCrossUI.docc · high confidence

This change introduces the UIKit backend, enabling cross-platform applications to run on iOS, tvOS, and Mac Catalyst. It provides native rendering for core UI components including buttons, text fields, lists, and alerts, and supports advanced features such as keyboard toolbars, file pickers, and various gradient types (linear, radial, angular). The implementation also includes inspection modifiers for accessing underlying native UIKit views, adaptive color resolution, and configurable keyboard dismissal behaviors.

Sources/UIKitBackend · high confidence

The \Sources/Example/main.swift\ file and the \App.swift\ file containing the \App\ protocol and its \main()\ execution logic have been deleted from the \SwiftGtkUI\ source tree. This removes the built-in example application and the high-level \App\ abstraction that previously handled GTK application initialization, window creation, and root view mounting, requiring users to manage application entry points and GTK setup directly or through other means.

Sources/SwiftGtkUI · high confidence

The legacy \Button\, \HStack\, \View\, and \Component\ types in \Sources/SwiftGtkUI/Components\ have been removed. This eliminates the previous simple struct-based UI model (including the \Component\ enum and \View\ protocol) in preparation for the new result-builder-based view system.

Sources/SwiftGtkUI/Components · high confidence

The AppKit backend's feature implementations have been reorganized into a dedicated file per feature within the \Sources/AppKitBackend/Features\ directory. This change introduces new Swift files for specific capabilities such as Alerts, AngularGradients, ApplicationMenus, Checkboxes, ColorPickers, and others, each implementing the corresponding \BackendFeatures\ protocol extension. This structural change improves code maintainability by isolating feature-specific logic into separate files while preserving the existing functionality of the AppKit backend.

Sources/AppKitBackend/Features · high confidence

The monolithic AppBackend protocol has been split into a composition of smaller, focused protocols (such as Core, Containers, Controls, FocusHandling, and FileDialogs) under the BackendFeatures namespace. This modularization allows backends to implement only the features they support, enables incremental backend development via BaseStubs, and introduces new capabilities like focus management, file dialogs, and menu implementation styles while deprecating the old AppBackend typealias in favor of FullAppBackend.

Sources/SwiftCrossUI/Backend · high confidence

The backend feature implementations in \Sources/SwiftCrossUI/Backend/BackendFeatures\ have been reorganized from a monolithic structure into distinct, file-per-feature protocols (e.g., \Alerts\, \ColorPickers\, \Buttons\, \ScrollContainers\). This change introduces a modular architecture where each UI capability is defined by its own protocol, simplifying the implementation of custom backends by allowing developers to conform only to the features they support, while providing a \BaseStubs\ protocol with default crash-on-call implementations to guide new backend development.

Sources/SwiftCrossUI/Backend/BackendFeatures · high confidence

The GTK helper libraries in Sources/Gtk3CHelpers and Sources/GtkCHelpers now include C++ linkage guards (extern "C") around their headers to ensure valid compilation in C++ modes. Additionally, explicit C symbols (SHIM\_G\_CONNECT\_AFTER, SHIM\_G\_CONNECT\_SWAPPED, SHIM\_G\_APPLICATION\_HANDLES\OPEN) are introduced to resolve missing symbol errors on macOS where Swift bindings previously failed to locate these G\\* enum members.

Sources/Gtk3CHelpers, Sources/GtkCHelpers · high confidence

The macro plugin now includes new utility extensions to support internal macro logic. TypeExtension adds an isOptional property to detect optional types by checking for trailing question marks or Optional\<\> syntax. VariableExtension adds a hasMacroApplication method to check if a variable has a specific macro attribute applied, which is necessary for correctly handling namespaced macro applications.

Sources/SwiftCrossUIMacrosPlugin/Utils · high confidence

The AdvancedCustomizationExample app now showcases how to access and modify underlying native widgets using the new inspect modifiers, allowing developers to apply platform-specific styling (such as text selection, button colors, and slider ticks) directly to native controls like Text, Button, Slider, TextField, ScrollView, and List. It also introduces custom native button implementations that bridge to native UI components (NSButton, UIButton, WinUI Button, Gtk Button, Android Button) across supported backends, demonstrating how to embed and style native views within the cross-platform UI.

Examples/Sources/AdvancedCustomizationExample · high confidence

The Android backend now implements a suite of native UI controls—including alerts, buttons, text fields, pickers, sliders, and scroll views—replacing previous stubs with real Android widgets. It also adds support for advanced visual features like gradients, paths, and corner radius clipping, while introducing a new Activity lifecycle listener to properly handle app state transitions and safe-area insets.

Sources/AndroidBackend/Kotlin · high confidence

The internal view graph system has been completely rewritten to support a new layout engine, improved hot reloading, and multiple UI backends. This change introduces a new type-erased node structure (\AnyViewGraphNode\, \ErasedViewGraphNode\) to decouple view implementations from backend specifics, and replaces the previous state management approach with a new \@State\ property wrapper system. The update also implements a new layout priority system, bottom-up view updates, and a snapshotting mechanism (\ViewGraphSnapshotter\) to preserve state during hot reloads. Users will experience faster layout calculations and more reliable hot reloading, but this is a breaking change that requires updating view implementations to use the new state and layout APIs.

Sources/SwiftCrossUI/ViewGraph · high confidence

The CounterExample application has been updated to use the new @State property wrapper for managing the counter value, replacing previous state management approaches. The app now utilizes the @HotReloadable modifier and \#hotReloadable view builder to enable live code reloading during development, allowing users to see changes immediately without restarting the application. The interface displays a counter with increment and decrement buttons within a horizontally stacked layout.

Examples/Sources/CounterExample · high confidence

The WindowingExample app now includes dedicated demo views for file dialogs, alerts, sheets, and multi-window management. Users can interact with \FileDialogDemo\ to test file selection and saving, \AlertDemo\ to trigger error alerts, and \SheetDemo\ to explore sheet presentations including nested sheets and ephemeral sheets with automatic dismissal. Additionally, \OpenWindowDemo\ and \TertiaryWindowView\ demonstrate opening and dismissing multiple window instances, allowing users to verify multi-window support and singleton window behavior in the current backend.

Examples/Sources/WindowingExample · high confidence

The Greeting Generator example has been refactored to demonstrate the framework's new state management and environment value features. It now utilizes the @State property wrapper for managing local variables like the input name and greeting list, and implements the @Entry macro to define a custom environment key (latestGreeting) for passing data to child views. The UI also incorporates the new .textSelectionEnabled modifier to control text selection on the latest greeting display and uses the updated \#hotReloadable macro with a trailing view builder closure.

Examples/Sources/GreetingGeneratorExample · high confidence

The GtkBackend has been reorganized into a modular file-per-feature structure, introducing support for new UI components including alerts, color pickers, date pickers, secure fields, and file dialogs. Existing features like menus, lists, and gradients have been refined, and critical stability fixes address issues such as alert shortcut conflicts and window resizing behavior.

Sources/GtkBackend · high confidence

SwiftCrossUI now uses a new \@State\ property wrapper as the primary mechanism for managing view state, replacing the previous \StateProperty\ approach. This change introduces a \Binding\ type for two-way data flow, a \Bindable\ wrapper for interacting with \@Observable\ models, and a \Publisher\ system with update merging to prevent main thread saturation. It also adds support for \ObservableObject\ via the \@Published\ wrapper, \FocusState\ for input focus management, and the \@Entry\ macro for custom environment and app storage values.

Sources/SwiftCrossUI/State · high confidence

The library has adopted a new layout system, requiring the re-implementation of core views including ScrollView, Picker, Slider, TextField, Toggle, Button, Image, and stacks (HStack, VStack, ZStack). This change updates the view lifecycle to use a computeLayout and commit model, improves performance, and ensures alignment with SwiftUI APIs. Additionally, new views such as ColorPicker, ContentUnavailableView, DatePicker, Divider, and GeometryReader have been added, while existing views like AnyView and EitherView have been refactored to support the new system and hot reloading.

Sources/SwiftCrossUI/Views · high confidence

The Gtk3 backend now includes a new type-safe CSS utility layer (CSSBlock, CSSProperty, CSSProvider) that allows styles to be applied programmatically rather than through raw strings. This enables precise control over visual properties such as colors, fonts, borders, and opacity, which supports the new system color scheme awareness (e.g., cursor and progress bar colors) and fixes styling issues in components like alerts.

Sources/Gtk3/Utility/CSS · high confidence

The Random Number Generator example has been updated to use the new @State property wrapper for view model state and the @HotReloadable macro, enabling live code reloading during development. The app structure now leverages the DefaultBackend and includes a custom View.help modifier on the min/max sliders to provide user guidance, while the ViewModel utilizes the new @ObservableObject macro to manage the random number range and color selection state.

Examples/Sources/RandomNumberGeneratorExample · high confidence

The layout engine in SwiftCrossUI has been refactored to support a new priority-based system for distributing space within stacks. This change introduces dedicated types for managing layout state, including \LayoutPriorityGroup\ for grouping children by priority, \StackLayoutCache\ for caching layout calculations, and \ViewLayoutResult\ for passing sizing and preference data. The \LayoutSystem\ now handles size rounding with warnings for infinite values and implements logic to redistribute available space in fixed-size stacks during the commit phase, addressing previous layout issues. Additionally, new structs like \Position\, \ProposedViewSize\, and \ViewSize\ provide a more robust foundation for handling view dimensions and proposals, enabling more accurate and performant layout calculations across different orientations and axes.

Sources/SwiftCrossUI/Layout · high confidence

The \Gtk.swift\ file containing type aliases for \SwiftGtk\ components (such as \GtkApplication\, \GtkBox\, and \GtkButton\) has been removed, along with the \GtkContainer+Component.swift\ extension that previously handled the mapping of abstract UI components (views, buttons, stacks) to GTK widgets. This change eliminates the legacy abstraction layer that automatically converted high-level component definitions into GTK containers and widgets, indicating a shift in how the UI framework manages component rendering and structure.

Sources/SwiftGtkUI/Gtk · high confidence

The SpreadsheetExample app has been updated to manage its internal data (the list of Person records and the greeting message) using the @State property wrapper. This change simplifies the example by removing the need for an explicit backend typealias, allowing the app to handle state locally within the view hierarchy rather than relying on external backend configuration for this specific demo.

Examples/Sources/SpreadsheetExample · high confidence

The repository's Scripts directory has been consolidated into a unified set of shell scripts that standardize how developers format, generate code, test, and preview documentation. The new format.sh script enforces a minimum SwiftFormat version (0.59.0) and integrates ktfmt for Kotlin files, while generate.sh orchestrates code generation for GTK, Gyb templates, and the Porting Kit via the APITool. Additionally, ensure\_docc.sh manages a custom DocC fork with WebP support for local documentation previews, and test.sh ensures only the relevant test product is built.

Scripts · high confidence

The StressTestExample has been updated to use the new List view for tab selection and supports hot reloading via the \#hotReloadable macro. The example now relies on the DefaultBackend, removing the need for explicit backend typealiases, and allows backend configuration via the SCUI\_BACKEND environment variable. Additionally, the example generates 1000 entries for stress testing and includes identifiable requirements for ForEach to ensure correct element state.

Examples/Sources/StressTestExample · high confidence

The documentation resources for SwiftCrossUI have been updated to reflect current tooling and platform requirements. The quick-start guide now instructs users to update their swift-bundler templates before creating a new project and demonstrates running the application on both native and simulator targets. Platform-specific tutorials have been refreshed to specify Swift version 6.3.1, include instructions for installing the Windows SDK on Windows, and provide detailed steps for setting up a Linux development environment with necessary packages and VM sharing configurations.

Sources/SwiftCrossUI/SwiftCrossUI.docc/Resources · high confidence

The file Sources/Gtk/Gsk/PathBuilder.swift was added, but all code within it is commented out. This means the PathBuilder class, which would wrap GSK path builder functions (move, line, curve, appendRect, appendCircle, appendArc), is not currently active or compiled. Users cannot use this specific path building functionality through this file in its current state.

Sources/Gtk/Gsk · high confidence

Add layout performance benchmarks for complex view hierarchies; Added UI tests for stack layout behavior and positioning; Added ViewGraphHelpers for UI test layout computation; Added regression test for Gtk3 layout consistency; Added test suite for SwiftCrossUI macros, gradients, and layout components.

The project has been renamed to SwiftCrossUI and restructured to support multiple platform backends (AppKit, UIKit, WinUI, Gtk, Gtk3, Android) alongside a DefaultBackend that adapts to the current platform. The package manifest now targets macOS, iOS, tvOS, Mac Catalyst, and visionOS, and includes dependencies on swift-syntax, swift-macro-toolkit, swift-image-formats, swift-winui, swift-benchmark, swift-mutex, XMLCoder, and swift-docc-plugin. The APITool subpackage was added with dependencies on swift-argument-parser, swift-macro-toolkit, and swift-syntax. The Examples subpackage was separated into its own package, depending on SwiftCrossUI, DefaultBackend, and swift-miniaudio, with optional SwiftBundlerRuntime for hot reloading on macOS and Linux. The Package.resolved file was updated to version 3 format with pinned dependency versions.

(dependencies) · high confidence

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

• CAI 52 → 49 (-2.6)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 89 → 89 (-0.2)
• Architecture 91 → 90 (-0.3)
• Maturity 61 → 61 (-0.1)
• Readiness 36 → 35 (-0.3)
• Security 54 → 54 (+0.0)
• Performance 61 (new)

• Change-coupling hub: GtkBackend.swift → WindowGroup.swift, Menu.swift, Toggle.swift, UIKitBackend+Control.swift (Sources/GtkBackend/GtkBackend.swift)
• ClassTooLong: DummyBackend (Sources/DummyBackend/DummyBackend.swift)
• Documentation: no installation or build instructions (README.md)
• FileTooLong: DummyBackend/DummyBackend.swift (Sources/DummyBackend/DummyBackend.swift)
• FixmeComment (Sources/DummyBackend/DummyBackend.swift)
• Hotspot: APITool/Sources/APITool/Analyzer.swift (APITool/Sources/APITool/Analyzer.swift)
• Hotspot: Sources/GtkBackend/GtkBackend.swift (Sources/GtkBackend/GtkBackend.swift)
• Hotspot: Sources/GtkCodeGen/GtkCodeGen.swift (Sources/GtkCodeGen/GtkCodeGen.swift)
• Low cohesion: Button (LCOM4 10) (Sources/DummyBackend/DummyBackend.swift)
• Low cohesion: Slider (LCOM4 5) (Sources/DummyBackend/DummyBackend.swift)
• Low cohesion: TextField (LCOM4 6) (Sources/DummyBackend/DummyBackend.swift)
• No assertions: testHStack (Tests/SwiftCrossUITests/StackContextRendersDifferently.swift)
• No assertions: testVStack (Tests/SwiftCrossUITests/StackContextRendersDifferently.swift)
• No assertions: testZStack (Tests/SwiftCrossUITests/StackContextRendersDifferently.swift)
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #2

• Change coupling: DummyBackend.swift ↔ Gtk3Backend.swift (Sources/DummyBackend/DummyBackend.swift)
• Change coupling: DummyBackend.swift ↔ WinUIBackend.swift (Sources/DummyBackend/DummyBackend.swift)
• Change-coupling hub: GtkBackend.swift → DummyBackend.swift, WindowGroup.swift, Menu.swift, Toggle.swift, UIKitBackend+Control.swift (Sources/GtkBackend/GtkBackend.swift)
• Coverage not measured — Swift suite
• Dependency not covered by the committed resolution: androidkit
• Dependency not covered by the committed resolution: swift-java
• Duplicated block (10 lines × 2) (Examples/Sources/SplitExample/SplitApp.swift)
• Duplicated block (11 lines × 2) (Examples/Sources/AdvancedCustomizationExample/AdvancedCustomizationApp.swift)
• Duplicated block (16 lines × 2) (Sources/Gtk3Backend/Helpers/CustomColorButton.swift)
• Duplicated block (19 lines × 2) (Sources/AppKitBackend/Helpers/NSObservableSecureTextField.swift)
• Duplicated block (6 lines × 2) (Sources/AppKitBackend/Helpers/Conversions.swift)
• Duplicated block (7 lines × 2) (Sources/SwiftCrossUI/Scenes/Modifiers/SceneEnvironmentModifier.swift)
• Duplicated block (8 lines × 2) (Examples/Sources/NotesExample/NotesApp.swift)
• FixmeComment (Sources/DummyBackend/UnimplementedFeatures.swift)
• Inconsistent parameter naming for resize handler setters. One uses 'ofWindow' and the other 'ofSplitView'. While the types differ, the naming convention is not uniform compared to other methods like 'setWindowEnvironmentChangeHandler(of:)' vs 'setResizeHandler(ofSplitView:)'.
• Inconsistent parameter naming for size setting operations. The window size setter uses 'ofWindow' as the first parameter label, the spinner uses 'ofProgressSpinner', and the generic widget uses 'of'. This breaks the pattern established by other methods like 'setTitle(ofWindow:to:)' and 'setChild(ofWindow:to:)' which are consistent, but the generic 'setSize' is ambiguous.
• Locale.windowsCurrent (cyclomatic 20) (Sources/WinUIBackend/WindowsLocale.swift)
• No assertions: testHStack (Tests/SwiftCrossUITests/Layout/StackContextRendersDifferently.swift)
• No assertions: testVStack (Tests/SwiftCrossUITests/Layout/StackContextRendersDifferently.swift)
• No assertions: testZStack (Tests/SwiftCrossUITests/Layout/StackContextRendersDifferently.swift)
• …and 5 more

• 5 commits — 4 feature/other, 1 fixes

• (root) — 1 commit
• .github/workflows — 1 commit
• Sources/AppKitBackend — 1 commit
• Sources/DummyBackend — 1 commit
• Sources/SwiftCrossUI — 1 commit

• fix: AppKitBackend: Fix dim menu item rendering (fixes #777) (#779)
• change: AndroidBackend: Work around swiftbuild-specific compilation error (#782)
• change: CI: Improve Gtk Binding linting job (only fail on generated changes) (#780)
• change: Docs: Expand hot reloading docs to explain setup, usage, and state persistence (#785)
• change: Reorganize DummyBackend into a file per backend feature (#783)

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

moreSwift/swift-cross-ui 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.