OpenSwiftUIProject/OpenSwiftUI

OpenSwiftUI is an open-source, cross-platform reimplementation of Apple's SwiftUI framework designed to render user interfaces on non-Darwin systems such as Linux and Windows. It provides a complete UI toolkit featuring a layout engine, a rendering pipeline for Quartz Core or terminal output, and a comprehensive set of view modifiers for styling, animation, and geometry effects. The system supports core SwiftUI capabilities including dynamic content, text formatting, accessibility, and environment-based theming, while maintaining compatibility with Apple's native APIs through platform-specific shims.

58 changes.

This period focused on establishing the foundational architecture of OpenSwiftUI, including the implementation of the core view graph, layout engine, and rendering pipeline. It also involved building essential UI controls, state management systems, and cross-platform integration layers while setting up comprehensive build, testing, and documentation workflows.

102 changes.

This period focused on establishing the foundational rendering engine, including the layout system, animation transactions, and gesture handling infrastructure. It simultaneously implemented the critical hosting layers for iOS, visionOS, and macOS, enabling SwiftUI views to be embedded within UIKit and AppKit applications. The work also introduced essential view modifiers, data binding mechanisms, and platform-specific integration shims to support these core capabilities.

55 changes.

This period focused on introducing the OpenRenderBox (ORB) accelerated rendering backend and expanding the framework's event infrastructure to support complex gestures, hit-testing, and hardware keyboard input. Significant work was also dedicated to enhancing text and localization capabilities, including AttributedString support, while simultaneously broadening non-Darwin platform compatibility through new shims and bundled headers.

This change introduces support for 3D rotation effects in the rendering layer. It adds a new helper for the \\_Rotation3DEffect.Data\ type, implementing equality, hashing, and approximate comparison logic to correctly handle rotation parameters like angle, axis, anchor, and perspective. Additionally, a new \DisplayListUtil\ module is added to facilitate rendering views into display lists and inspecting their content for color properties, enabling more robust testing and verification of visual output.

Sources/OpenSwiftUITestsSupport/Render · high confidence

OpenSwiftUI now includes the \@Bindable\ property wrapper, allowing views to create two-way bindings to mutable properties of objects conforming to the \Observable\ protocol. This new capability enables developers to use the \$\ syntax to pass bindings to controls like \TextField\ and \Toggle\ directly from \@Observable\ models, providing a modern alternative to the legacy \@ObservedObject\ pattern for data-driven UI updates.

Sources/OpenSwiftUICore/Data/Binding · high confidence

This change introduces the macro implementations for the OpenSwiftUI framework, enabling environment variable support via the @Entry property wrapper, preview rendering via the \#Preview macro, and default value handling via @\_\_EntryDefaultValue. The @Entry macro generates the necessary EnvironmentKey conformances and accessors to store and retrieve values in the environment, while the \#Preview macro expands into a DeveloperToolsSupport::PreviewRegistry struct to facilitate preview rendering in Xcode. These macros are registered in the OpenSwiftUIMacrosPlugin and provide the foundational syntax support for state management and UI previewing within the library.

Sources/OpenSwiftUIMacros · high confidence

This change introduces the core implementation for the Anchor API, allowing views to expose specific points or rectangles that can be resolved in other coordinate spaces via GeometryProxy. It adds GeometryReader, enabling content to be defined as a function of its own size and coordinate space, and implements supporting geometry types such as UnitPoint, Axis, Spacing, LayoutTraits, and ProjectionTransform to facilitate advanced layout and alignment calculations.

Sources/OpenSwiftUICore/Layout/Geometry · high confidence

This change introduces new AppKit integration files that enable converting between SwiftUI and AppKit types. Specifically, it adds initializers to create a SwiftUI \Color\ from an \NSColor\ (preserving dynamic appearance adaptability like Dark Mode) and implements \NSColor\ as a \ColorProvider\ to handle resolution in the current environment. It also includes a stub for \NSAppearance\ conversions and updates \ControlSize\ mapping to support the new \.extraLarge\ case available in macOS 26.0.

Sources/OpenSwiftUI/Integration/Graphic/AppKit · high confidence

This change introduces new AppKit overlay files that bridge OpenSwiftUI with native macOS components. It adds NSColor category methods to handle appearance-dependent colors and initializers, NSView extensions to manage mask views, flipped states, and Core Animation layer delegates, and NSWindow utilities to retrieve the underlying Core Graphics display ID. These additions provide the necessary low-level integration points for rendering and window management on macOS.

Sources/COpenSwiftUI/Overlay/AppKit · high confidence

This change introduces a set of Objective-C shim files in the AppKit integration layer to bridge OpenSwiftUI with macOS private APIs. The new headers and implementations expose internal AppKit selectors for gesture recognition (NSGestureRecognizer), view layout and hit-testing (NSView, \_NSConstraintBasedLayoutHostingView), accessibility internals (NSAccessibility), and application lifecycle events (NSApplication). These shims enable the framework to correctly route touch and tap gestures, manage safe area insets, handle layout constraints, and support accessibility features on macOS.

Sources/COpenSwiftUI/Shims/AppKit · high confidence

Added the CGTK target, which provides a Swift module map and header to bridge the GTK 4 library (linking against gtk-4) for use within the project.

Sources/CGTK · high confidence

OpenSwiftUI now supports the \@StateObject\, \@ObservedObject\, and \@EnvironmentObject\ property wrappers, allowing views to automatically update when underlying \ObservableObject\ data changes. This change introduces the necessary Combine integration, including the \AttributeInvalidatingSubscriber\ to handle invalidation and \SubscriptionLifetime\ to manage subscription lifecycles, enabling reactive data binding and state management within the view hierarchy.

Sources/OpenSwiftUICore/Data/Combine · high confidence

This change introduces a comprehensive set of extension methods for CoreGraphics types (CGAffineTransform, CGPoint, CGSize, CGRect) and utility types (Collection, FloatingPoint, NSAttributedString, etc.) within the OpenSwiftUICore utility layer. For geometry types, it adds convenience initializers, transformation checks (isTranslation, isRectilinear), rounding capabilities, and Protobuf serialization support, enabling these structures to be used in animations and data encoding. It also provides mathematical operators, safe collection indexing, and floating-point comparison utilities, forming the foundational math and utility layer required for the UI rendering engine.

Sources/OpenSwiftUICore/Util/Extension · high confidence

New header and implementation files for the OpenSwiftUI\_SPI module introduce a Darwin-only logging facility and a macro for safely invoking Objective-C methods. The \openSwiftUIShimsLog\ function provides a centralized \os\_log\ logger, while the \OPENSWIFTUI\_SAFE\_WRAPPER\_IMP\ macro allows code to dynamically resolve and call selectors with a fallback return value, addressing issues with class versus instance method resolution on Darwin platforms.

_Sources/OpenSwiftUI\SPI/Shims · high confidence

This change introduces the \Divider\ view and the \DividerStyle\ protocol to OpenSwiftUI, allowing users to insert visual separators in layouts. The implementation includes a \plain\ style that renders a colored line with thickness determined by the environment, and a \default\ style that delegates to the plain style. The \Divider\ view respects stack orientation, extending across the minor axis in stacks or rendering horizontally otherwise, and supports customization via the \dividerStyle(\_:)\ modifier.

Sources/OpenSwiftUI/Layout/Separator · high confidence

The Stack example now includes a \DynamicIsland\ view and supporting types (\DynamicIslandExpandedContent\, \DynamicIslandMode\, etc.) that allow developers to preview Live Activity content in expanded, compact, and minimal modes within SwiftUI previews. This adds a new demonstration of how to structure and style Dynamic Island content using the JindoKit SPI, specifically showing a timer/running activity example.

Example/Shared/Layout/Stack · high confidence

Introduces the DynamicContainer layout infrastructure, including the DynamicContainer, DynamicLayoutMap, and DynamicLayoutView components, along with the DynamicContainerAdaptor and DynamicContainerItem protocols. This adds the core mechanism for managing dynamic view lists within the layout system, enabling features like item insertion, removal, and transition handling for dynamic content.

Sources/OpenSwiftUICore/Layout/Dynamic · high confidence

The Entry macro is now available in OpenSwiftUICore, allowing developers to use the @Entry attribute to automatically generate accessor properties and peer keys prefixed with \_\Key\. This macro delegates to the OpenSwiftUIMacros module to provide the underlying implementation.

Sources/OpenSwiftUICore/Macro · high confidence

This change introduces several new view types and properties to the OpenSwiftUI View module. EquatableView and its associated View extension (equatable()) allow developers to prevent child view updates when the view's content remains unchanged, optimizing rendering performance. A new \_CALayerView struct enables the integration of Core Animation layers within the view hierarchy, supporting custom layer updates. Additionally, IdentityLink provides a dynamic property for tracking view identity across updates, while LazyView and ParameterizedLazyView offer mechanisms for deferred view initialization.

Sources/OpenSwiftUI/View · high confidence

Adds the \ForEach\ structure and the \DynamicViewContent\ protocol to OpenSwiftUICore, enabling the generation of views from an underlying collection of identified data. This includes the core \ForEach\ implementation with support for key-path-based or offset-based ID generation, as well as trait keys for managing view content offsets and IDs within the view hierarchy.

Sources/OpenSwiftUICore/View/DynamicViewContent · high confidence

This change introduces new Objective-C overlay files in the COpenSwiftUI Foundation module to provide platform-specific utilities for Darwin targets. It adds an NSObject category that exposes methods to identify OpenSwiftUI instances and perform selector invocations, and implements a helper function to start NSThread instances using the modern startAndReturnError: API when available, falling back to the legacy start method for compatibility.

Sources/COpenSwiftUI/Overlay/Foundation · high confidence

Users can now arrange views in horizontal lines with HStack, vertical lines with VStack, and layered overlays with ZStack, all supporting configurable spacing and alignment. The new zIndex modifier allows explicit control over the front-to-back ordering of overlapping views. Additionally, HStackLayout, VStackLayout, and ZStackLayout are available for use in conditional layouts via AnyLayout.

Sources/OpenSwiftUICore/Layout/Stack · high confidence

The HostingExample application has been added, providing a cross-platform demo app that runs on iOS, visionOS, and macOS. The implementation includes platform-specific entry points (AppDelegate and SceneDelegate for UIKit-based iOS/visionOS, and NSApplicationDelegate for AppKit-based macOS) along with storyboard assets and an Info.plist that registers the Inter font. On iOS and visionOS, the app initializes a navigation controller that automatically pushes a hosting view controller displaying the root ContentView, while on macOS it presents the same ContentView in a centered NSWindow.

Example/HostingExample · high confidence

Introduces the \_IdentifiedViewProxy struct to expose view identification data (identifier, size, position, transform) and adds methods to ViewRendererHost and \_BenchmarkHost for locating views and their state by identifier. This enables internal and benchmark code to find specific views and bindings within the view graph using a breadth-first search and identifier matching.

Sources/OpenSwiftUICore/View/IdentifiedView · high confidence

Developers debugging SwiftUI can now use a new LLDB command, \swiftui-display-list-minimal\, to redirect the display-list output from the verbose full description to a minimal form. This is achieved by patching the \DisplayList.description\ method to branch to \DisplayList.minimalDescription\ at runtime, which reduces console noise without requiring breakpoints. The hook is automatically imported for specific schemes via \.lldbinit-swiftui\ and supports arm64/arm64e targets on iOS 18.5+.

Scripts/LLDB · high confidence

Introduces the \LabelGroup\ view, which allows grouping multiple views to apply hierarchical styling (font and foreground color) based on their nesting level. This includes the \LabelGroupStyle\ protocol for customizing these styles and a default \BodyLabelGroupStyle\ that applies \.body\, \.subheadline\, and \.footnote\ fonts with corresponding primary, secondary, and tertiary colors.

Sources/OpenSwiftUI/View/LabelGroup · high confidence

This change introduces the LabeledContent view, allowing you to pair a label with a value-bearing view in a consistent, context-aware layout. It includes the labelsHidden() modifier to omit labels from controls like Toggle or Picker, and the labelsVisibility(\_:) environment modifier (available in v6.0) to dynamically control label visibility within a view hierarchy. The implementation provides AutomaticLabeledContentStyle, which automatically selects the appropriate presentation (e.g., leading-trailing, columnar, or grouped form) based on the current platform and container context, ensuring labeled content adapts correctly to forms, lists, and toolbars.

Sources/OpenSwiftUI/View/LabelContent · high confidence

OpenSwiftUI now includes the \LazyState\ property wrapper, allowing view state to be initialized lazily only when first accessed rather than immediately upon view creation. This new type conforms to \DynamicProperty\ and is available starting with OpenSwiftUI v5.0, providing a mechanism to defer expensive initialization or handle optional state more efficiently within SwiftUI views.

Sources/OpenSwiftUI/Data/State · high confidence

Introduced NSHostingController, an AppKit view controller that allows OpenSwiftUI view hierarchies to be hosted within macOS applications. This new component provides properties to manage root views, sizing options, safe area regions, and scene bridging (such as toolbars and titles), along with methods to calculate content sizes and trigger rendering, enabling developers to embed SwiftUI-like interfaces into existing AppKit windows and view controllers.

Sources/OpenSwiftUI/Integration/Hosting/AppKit/Controller · high confidence

A new example view demonstrating the usage of named colors (specifically 'custom') across different color schemes (light and dark) and contrast levels (standard and increased) has been added to the Shared Graphics examples. This file also includes a SwiftUI Preview, allowing developers to quickly visualize the named color behavior in the canvas.

Example/Shared/Graphics · high confidence

The Example/Shared module now supports rendering via OpenSwiftUI alongside standard SwiftUI. ContentView, FlowerView, and associated platform type aliases use conditional compilation (\#if OPENSWIFTUI) to import the correct framework, enabling the example app to demonstrate OpenSwiftUI-specific features like TintShapeStyle and vector glyph support.

Example/Shared · high confidence

This change introduces a new set of utility components within the OpenSwiftUI\_SPI module to support core runtime operations. It adds CoreGlue for initializing OpenSwiftUI glue classes, MovableLock for thread-safe synchronization with main-thread execution support, and TLS (Thread-Local Storage) helpers for managing per-thread geometry, transaction, and layout data. Additionally, it provides Interpose hooks to handle type description and protocol conformance fallbacks between SwiftUI and OpenSwiftUI, ProtocolDescriptor exports for view and style modifiers, PathData for path storage abstraction, and RenderUtil for frame rate management.

_Sources/OpenSwiftUI\SPI/Util · high confidence

This change introduces the \PlatformViewRepresentable\ protocol and its supporting infrastructure (including \PlatformViewHost\, \PlatformViewCoordinator\, and layout options) to enable embedding native UIKit and AppKit views within the OpenSwiftUI view hierarchy. It provides the foundational bridging layer that allows developers to wrap existing platform-specific views and view controllers, handling lifecycle management, environment propagation, and layout constraints through a unified interface that abstracts away the underlying iOS/macOS implementation details.

Sources/OpenSwiftUI/Integration/Representable/Platform · high confidence

Introduces the ProgressView control, enabling users to display both determinate (percentage-based) and indeterminate (spinning) progress indicators. The implementation includes linear and circular styles, date-relative progress views for timers, and platform-specific rendering via AppKit on macOS and UIKit on iOS/visionOS.

Sources/OpenSwiftUI/View/Control/ProgressView · high confidence

OpenSwiftUICore now includes a new Protobuf implementation that allows encoding and decoding data using the Protocol Buffers format. This change introduces \ProtobufEncoder\ and \ProtobufDecoder\ structs, along with the \ProtobufMessage\ protocol, enabling types to serialize themselves to and from protobuf representations. Specifically, Foundation types \URL\, \UUID\, \Data\, and \Locale\ now conform to \ProtobufMessage\, allowing them to be directly encoded and decoded. Additionally, a \CodableByProtobuf\ protocol and \ProtobufCodable\ property wrapper are provided to integrate this functionality with Swift's existing \Codable\ system.

Sources/OpenSwiftUICore/Data/Protobuf · high confidence

The library now includes overlay headers and implementations for Quartz Core on macOS, specifically introducing the CAChameleonLayer class and a shim for the internal \_CATransactionCompletionItem function. These additions provide the necessary bindings to support newer SDK features and internal transaction completion mechanisms within the SwiftUI rendering pipeline.

Sources/COpenSwiftUI/Overlay/QuartzCore · high confidence

Adds the \sensoryFeedback\ view modifier, enabling developers to trigger haptic feedback on iOS, macOS, and watchOS when state values change. The implementation supports various feedback types including success, warning, error, selection, alignment, impact (with configurable weight and intensity), and path completion, with platform-specific handling via AppKit, UIKit, and WatchKit.

Sources/OpenSwiftUI/View/Control/SensoryFeedback · high confidence

Introduces the \Slider\ view for selecting values from a bounded linear range, supporting labels, step increments, and editing change callbacks. The implementation includes an \AnySliderStyle\ wrapper and a \SliderStyleKey\ environment value, allowing users to apply custom or default system slider styles to the control.

Sources/OpenSwiftUI/View/Control/Slider · high confidence

This change introduces the \Spacer\ view and related layout primitives (\\_HSpacer\, \\_VSpacer\, \\_TextBaselineRelativeSpacer\) to the OpenSwiftUI core layout system. Users can now insert flexible, expandable space within stacks (such as \HStack\ or \VStack\) to push sibling views apart or align content, with support for specifying minimum lengths along specific axes or the major axis of the containing stack.

Sources/OpenSwiftUICore/Layout/Separator · high confidence

The framework now supports the \StaticIf\ view, which allows conditionally rendering different views or applying modifiers based on stable view inputs such as interface idioms or style contexts, enabling more optimized view hierarchy decisions. Additionally, the \Visibility\ enum has been introduced, providing \automatic\, \visible\, and \hidden\ cases to control the display state of UI elements like list row separators or dialog titles.

Sources/OpenSwiftUICore/View/Configuration · high confidence

The Example/TestingHost directory now includes a new host application (TestingHostApp.swift) and its associated entitlements file. This app serves as a testing harness that conditionally imports OpenSwiftUI or SwiftUI and configures the appropriate app delegate (NSApplicationDelegate for macOS, UIApplicationDelegate for iOS) using the new adaptor patterns. The iOS delegate includes logic to disable hardware keyboards in the simulator, while the entitlements file configures sandboxing and file access permissions for the test environment.

Example/TestingHost · high confidence

Introduces the \TimelineView\ API, allowing views to update their content based on a provided schedule (such as periodic intervals or specific dates) with a context that includes the current date and update cadence. This change also implements Always-On Display support for iOS and visionOS by integrating with the BacklightServices framework, enabling pre-rendered frames and timeline invalidation for features like clock faces or calendar events when the device is in low-power display mode.

Sources/OpenSwiftUI/Animation/Timeline · high confidence

Introduces the \Toggle\ view component and the \SwitchToggleStyle\ for iOS and visionOS, allowing users to create switch-style toggles with label support and tint customization. The implementation includes the \ToggleStyle\ protocol and configuration, enabling custom toggle appearances and behaviors across supported platforms.

Sources/OpenSwiftUI/View/Toggle · high confidence

The Toggle view now includes a new ToggleState enum with cases for on, off, and mixed states. This enum provides methods to toggle between states and determine the state based on a collection of bindings, enabling more robust state management for toggle components.

Sources/OpenSwiftUICore/View/Toggle · high confidence

Developers can now seamlessly convert between UIKit and OpenSwiftUI types. This change introduces initializers to create an OpenSwiftUI \Color\ from a \UIColor\ (preserving dynamic traits like Dark Mode) and vice versa, as well as conversions between \ColorScheme\ and \UIUserInterfaceStyle\. This enables better interoperability when integrating UIKit components with OpenSwiftUI views.

Sources/OpenSwiftUI/Integration/Graphic/UIKit · high confidence

This change introduces a new set of Objective-C shim files in the COpenSwiftUI UIKit overlay to bridge specific UIKit behaviors for iOS and VisionOS. It adds helper functions to access the default UIContentSizeCategory, determine if a UIColor depends on the trait collection, and create custom UIViews with specific layers. Additionally, it includes a testing infrastructure that uses Objective-C method swizzling to override UIScreen scale and content margins, as well as UICollectionView animation behaviors, to support stable UI testing environments.

Sources/COpenSwiftUI/Overlay/UIKit · high confidence

This change introduces a new mechanism for synchronizing SwiftUI updates with the UIKit run loop via the \UIKitUpdateCycle\ API, allowing OpenSwiftUI to register pre-commit observers that flush updates at the appropriate time in the rendering pipeline. It also adds the \UIHostingViewable\ protocol to abstract the underlying \UIHostingController\ implementation, enabling the hosting layer to function without direct SDK dependencies on \UIHostingController\ (supporting platforms like watchOS where it is unavailable) and providing secure hosting controller variants.

Sources/OpenSwiftUI/Integration/Hosting/UIKit · high confidence

This change introduces the \UIViewRepresentable\ and \UIViewControllerRepresentable\ protocols in the OpenSwiftUI UIKit integration layer, enabling developers to embed existing UIKit \UIView\ and \UIViewController\ instances directly within OpenSwiftUI view hierarchies. These protocols provide the standard lifecycle methods (\make...\, \update...\, \dismantle...\) and coordinator support required to bridge UIKit components into the OpenSwiftUI environment on iOS and visionOS.

Sources/OpenSwiftUI/Integration/Representable/UIKit · high confidence

Introduces the \ViewModifier\ protocol and its core implementation in \Sources/OpenSwiftUICore/Modifier\, enabling users to create reusable modifiers that can be applied to any view. This includes the internal \\_ViewModifier\_Content\ structure and extension methods that handle view and view-list generation, forming the foundation for applying custom styling and behavior changes to SwiftUI views.

Sources/OpenSwiftUICore/Modifier · high confidence

Users can now use the \ViewThatFits\ view to adapt content to available space by selecting the first child view that fits within the proposed size on specified axes. Additionally, the \JindoTripleVStack\ layout is available as a SPI, allowing views to be arranged in leading, center, trailing, bottom, and notch regions with configurable horizontal sizing and spacing. The diff also adds conversion extensions between \EdgeInsets\ and \NSDirectionalEdgeInsets\ for platform compatibility.

Sources/OpenSwiftUI/Layout · high confidence

Developers can now use the new \\_printChanges()\ and \\_logChanges()\ static methods on \View\ and \ViewModifier\ to identify which dynamic properties triggered a body refresh. \\_printChanges()\ outputs the names of changed properties (including \@self\ and \@identity\ markers) directly to the console, while \\_logChanges()\ records this information at the info level to the \org.OpenSwiftUIProject.OpenSwiftUI\ subsystem under the category "Changed Body Properties".

Sources/OpenSwiftUI/View/Debug · high confidence

This change introduces new accessibility modifiers for Text views, allowing developers to specify heading hierarchy (h1–h6) and text content types (such as plain, console, messaging, or source code) to improve navigation and presentation for assistive technologies.

Sources/OpenSwiftUICore/View/Text/Accessibility · high confidence

This change introduces the core layout alignment system in OpenSwiftUICore. It adds the \AlignmentID\ protocol and built-in \HorizontalAlignment\/\VerticalAlignment\ guides, enabling custom alignment logic. It also implements \\_AlignmentLayout\, a unary layout that positions a single child view based on specified horizontal (\TextAlignment\) and vertical (\\_VAlignment\) guides, and defines the \TextAlignment\ enum (leading, center, trailing) with serialization support.

Sources/OpenSwiftUICore/Layout/Alignment · high confidence

The animation system now supports a broader range of visual transitions, including Bezier-based easing (easeIn, easeOut, easeInOut), Spring animations, and custom animation definitions via the CustomAnimation protocol. Users can also configure animations to repeat, delay, or change speed, and can now receive callbacks when animations complete using the new AnimationListener and AnimationCompletion APIs.

Sources/OpenSwiftUICore/Animation/Animation · high confidence

This change introduces the foundational event structures for user interaction in OpenSwiftUI, including hover, key, magnify, rotate, touch, and transform events. It also adds the \ModifierKeySource\ protocol and \ModifierKeyMonitor\ to track modifier key states, enabling the framework to handle complex input scenarios like keyboard shortcuts and multi-touch gestures.

Sources/OpenSwiftUI/Event/Event · high confidence

The Example/Shared/Layout/CustomLayout directory now includes four new Swift files demonstrating custom layout implementations: FlowLayout (a flow-based layout with configurable spacing and alignment), MyViewThatFitByLayout (a layout that selects the first subview fitting within constraints), MyViewThatFitExample (a demo view for the fitting layout), and MyZStack (a ZStack-like layout supporting alignment guides and text baselines). These files provide reusable layout components and demo views for the example project.

Example/Shared/Layout/CustomLayout · high confidence

This change introduces new files in the Codable module to support flexible data encoding and decoding. It adds an AnyCodable type for handling arbitrary Codable values, a CodableAttributedString wrapper for attributed strings, and a suite of helper protocols and property wrappers (CodableByProxy, ProxyCodable, CodableRawRepresentable, JSONCodable) that enable custom types to be encoded via proxy objects or raw values.

Sources/OpenSwiftUICore/Data/Codable · high confidence

OpenSwiftUI now supports direct hardware keyboard interaction through the new \onKeyPress\ view modifier, which allows views to react to key-down, key-up, and key-repeat events with granular control over event consumption. Additionally, the \keyboardShortcut\ modifier is implemented for both Views and Scenes, enabling developers to bind specific key combinations to control actions or scene management commands, including support for internationalization and localization of shortcut keys.

Sources/OpenSwiftUI/Event/InputEvent, Sources/OpenSwiftUI/View/Control/Picker · high confidence

Users can now call the new \ignoredByLayout()\ method on any \GeometryEffect\ to ensure its transform is applied only during rendering, not during layout calculations. This allows visual transformations (like scaling or rotation) to occur without altering the view's frame or position in the layout hierarchy, which is particularly useful for disabling layout shifts during transitions.

Sources/OpenSwiftUI/Render/GeometryEffect · high confidence

The Example/Shared/View/Image directory now includes several new SwiftUI view examples demonstrating image handling capabilities. These include AsyncImageExample for loading remote images, ImageConversionsExample for converting between platform-specific image types (UIImage/NSImage) and SwiftUI Image, NamedImageExample showcasing decorative images and rendering modes (original vs. template), VariableImageExample demonstrating system images with dynamic variable values (like signal strength or battery), and SunsetSceneExample which combines various image and shape elements into a complex animated scene.

Example/Shared/View/Image · high confidence

The framework introduces the foundational types for managing view focus, including the \FocusState\ property wrapper for binding focus state to view models, the \FocusedValue\ property wrapper and \FocusedValueKey\ protocol for sharing data with the currently focused view, and internal support structures like \FocusStore\, \FocusGroup\, and \FocusStoreLocation\. This change establishes the core mechanism for focus handling within the event system, though several components are currently marked as work-in-progress.

Sources/OpenSwiftUI/Event/Focus · high confidence

This change introduces the internal foundation for accessibility modifiers in OpenSwiftUI. It adds the \AccessibilityConfigurationModifier\ protocol to standardize how accessibility configurations are applied to views. Specifically, it implements \AccessibilityLabelModifier\ to support the \accessibilityLabel()\ view modifier, allowing users to set custom accessibility labels. Additionally, it includes \AccessibilityButtonShapeModifier\, which currently acts as a pass-through but is structured to support future button shape visibility controls.

Sources/OpenSwiftUI/Accessibility/Modifier · high confidence

This change introduces utility functions to detect Apple internal builds via system security policies and provides protocol descriptors for Scene, Commands, and ObservableObject. These utilities support internal feature gating and runtime protocol resolution within the OpenSwiftUI framework.

Sources/COpenSwiftUI/Util · high confidence

This change introduces a new internal tracing subsystem within OpenSwiftUICore to help developers debug view rendering, layout, and state changes. It adds dedicated trace modules for custom events (tracking observable updates, transactions, actions, graph operations, and animations), layout operations (size calculations, child geometries, and cache lookups), and view reuse (tracking cache hits, misses, and mismatch failures). Additionally, it provides signpost-based tracing for body execution and dynamic property link creation/updates, along with support for descriptive dynamic property values in trace output.

Sources/OpenSwiftUICore/Tracing · high confidence

OpenSwiftUI now supports left-to-right and right-to-left layout directions to accommodate different languages and locales. The system automatically adjusts view positioning based on the user's locale, and developers can override this behavior using the \layoutDirection\ environment modifier or read the current direction via \EnvironmentValues\. Additionally, a new \LayoutDirectionBehavior\ enum allows views and shapes to explicitly control whether they should mirror their content when the layout direction changes, supporting both fixed and conditional mirroring strategies.

Sources/OpenSwiftUICore/Layout/Direction · high confidence

The layout system now includes explicit definitions for \Edge\ (top, leading, bottom, trailing), \AbsoluteEdge\ (top, left, bottom, right), and \EdgeInsets\ to manage spacing and positioning. This introduces support for locale-aware leading/trailing edges and provides the underlying data structures for view insets and edge-based layout calculations.

Sources/OpenSwiftUICore/Layout/Edge · high confidence

The Example/Shared/Data location now includes ObservationExample.swift, which introduces two new previewable views: ObservationColorExample and ObservationCounterExample. These views demonstrate the use of the @Observable macro for managing reactive state, allowing users to toggle a color between red and blue or increment a counter via tap gestures within the example project.

Example/Shared/Data · high confidence

This change introduces the core implementation for the preference system in OpenSwiftUICore (audited for 6.5.4). It adds the \View.onPreferenceChange\ modifier, allowing views to execute an action when a specific preference key's value changes, and the \View.transformPreference\ modifier, which enables transforming preference values before they are passed up the view hierarchy. Additionally, it implements the \View.preference\ modifier for writing values, along with the underlying infrastructure including \PreferenceKey\, \PreferenceCombiner\, \PreferenceList\, and \PreferenceBridge\ to manage value aggregation, bridging between view graphs, and host-readable preferences.

Sources/OpenSwiftUICore/Data/Preference · high confidence

Users can now subscribe to Combine publishers directly within SwiftUI views using the new \onReceive\ modifier. This change introduces the \SubscriptionView\ component, which wraps a content view and attaches a subscriber to a given publisher, executing a provided action whenever the publisher emits a value. The implementation ensures that actions are dispatched on the main thread, logging a runtime issue if updates originate from background threads, thereby enabling reactive data binding patterns consistent with Apple's SwiftUI API.

Sources/OpenSwiftUI/View/Combine · high confidence

This change introduces new test support utilities in the Integration module to facilitate testing SwiftUI views across iOS, visionOS, and macOS. It adds PlatformAlias.swift to define platform-specific type aliases (e.g., UIHostingController vs NSHostingController) and PlatformHostingControllerHelper.swift, which provides helper functions like triggerLayout and triggerLayoutWithWindow. These helpers allow test authors to instantiate hosting controllers, trigger layout passes, and manage window lifecycles safely using async/await and confirmation patterns, ensuring consistent behavior regardless of the target platform.

Sources/OpenSwiftUITestsSupport/Integration · high confidence

New runtime files (ConditionalMetadata.swift, TupleTypeDescription.swift, TypeConformance.swift) introduce the ability to inspect and project conditional types (such as Optional and \_ConditionalContent) and tuple types at runtime. This enables the framework to correctly handle and render views that depend on conditional content or tuple structures by providing descriptors and conformance checks for these complex types.

Sources/OpenSwiftUICore/Runtime · high confidence

The Renderer directory now includes a new Stdout example package that enables the OpenSwiftUI stdout renderer, allowing apps to output display-list commands or render a single-frame ANSI terminal view directly to standard output. This feature supports a terminal view mode that maps logical surfaces into terminal cells with solid color backgrounds and text content, configurable via terminal size and color modes (monochrome, ANSI 16/256, truecolor). The example demonstrates this on macOS using the AttributeGraph backend and on Linux using the Compute backend, with specific test coverage for both display-list and terminal output modes.

Renderer · high confidence

This change introduces the internal infrastructure for the \\_identified(by:)\ view modifier, allowing views to be uniquely identified within the view hierarchy. It adds \IdentifiedModifier\ to wrap views with a specific identifier, \IdentifiedViewTree\ to manage the resulting tree structure of identified proxies, and \IdentifiedViewsKey\ to handle preference reduction for these identifiers. This enables the framework to track and manipulate specific views by their unique keys.

Sources/OpenSwiftUI/View/IdentifiedView · high confidence

Users can now use the new \tappablePadding\ view modifier to increase the interactive tap area of a view without altering its visual layout. This modifier applies padding around the content, makes the entire padded area tappable via \onTapGesture\, and then removes the visual padding, allowing for more accessible touch targets in UI components.

Sources/OpenSwiftUIExtension · high confidence

Users can now apply a variable blur effect to views using the new \variableBlur(maxRadius:mask:opaque:)\ modifier, which allows an image to act as a mask to control the blur intensity across the view. This capability is supported by new internal types (\VariableBlurEffect\, \VariableBlurStyle\) and a base \BlurStyle\ struct that handles radius, opacity, and dithering settings, with serialization support via Protobuf.

Sources/OpenSwiftUICore/Graphic/BlurStyle · high confidence

Users can now position the center of a view at a specific coordinate in its parent's coordinate space using the new \.position(\_:)\ and \.position(x:y:)\ modifiers, which accept a \CGPoint\ or separate x and y offsets respectively.

Sources/OpenSwiftUI/Layout/Modifier · high confidence

This change introduces SPI (System Private Interface) additions to \CALayer\ within the QuartzCore overlay, enabling OpenSwiftUI to manage layer behavior more precisely. Specifically, it adds a \setNoAnimationDelegate\ method that suppresses implicit Core Animation transitions by assigning a custom delegate, which is useful for ensuring deterministic rendering during updates. Additionally, it exposes properties for \viewTestProperties\ and \displayListID\ to support internal view testing and display list tracking mechanisms.

_Sources/OpenSwiftUI\SPI/Overlay/QuartzCore · high confidence

OpenSwiftUI now supports edit mode for List views, allowing users to enable editing states (inactive, transient, active) via the \editMode\ environment value. This change introduces the \EditMode\ enum and the \EditModeScopeModifier\ view modifier, enabling built-in views like \List\ with \ForEach\ to provide delete and move controls when configured with \onDelete\ or \onMove\ modifiers. It also allows custom views to react to edit mode, such as switching between read-only and editable fields, and works in conjunction with \EditButton\ to toggle the state.

Sources/OpenSwiftUI/View/List · high confidence

Developers can now track transient state during user interactions using the new @GestureState property wrapper, which automatically resets to its initial value when a gesture ends. Additionally, the library now supports SpatialTapGesture, allowing views to recognize tap events and report their location via the onTapGesture modifier, with support for specifying tap counts and coordinate spaces.

Sources/OpenSwiftUI/Event/Gesture · high confidence

This change introduces the \InterfaceIdiom\ protocol and associated types (such as \carPlay\, \mac\, \phone\, \watch\, etc.) to enable views to adapt to specific device idioms. It includes the \InterfaceIdiomPredicate\ for conditional view rendering and updates \\_GraphInputs\ to track the current interface idiom, defaulting to \mac\ or \pad\ on macOS, \phone\ on iOS/visionOS, and \nokit\ otherwise.

Sources/OpenSwiftUICore/View/InterfaceIdiom · high confidence

Introduced the \Link\ view in OpenSwiftUI, allowing users to create navigable controls that open a specified URL when tapped or clicked. The view accepts a destination URL and a label (which can be a string, localized key, or custom view) and delegates the actual opening behavior to the \openURL\ environment value, enabling customization via \OpenURLAction\.

Sources/OpenSwiftUI/View/Control/Link · high confidence

This change introduces a set of Objective-C shims in the QuartzCore shim directory to expose private Core Animation APIs required for OpenSwiftUI's rendering pipeline. Specifically, it adds support for \CABackdropLayer\ for backdrop effects, \CAFilter\ with its associated input keys and types for image processing (such as blur and color adjustments), and extended \CALayer\ properties like \allowsDisplayCompositing\, \allowsGroupBlending\, and \contentsSwizzle\ for fine-grained control over layer rendering and alpha handling. It also includes \CAPresentationModifier\ and \CAPresentationModifierGroup\ to enable direct, shared-memory-based modification of layer properties for efficient, off-main-thread animation updates, as well as private \CADisplayLink\ and \CATransaction\ methods to support high-frame-rate rendering and background context activation.

_Sources/OpenSwiftUI\SPI/Shims/QuartzCore · high confidence

This update adds new shim headers and implementations for CoreUI (including UIUserInterfaceIdiom mapping and display gamut detection), MobileGestalt (device capability queries), and kdebug (kernel tracing), enabling OpenSwiftUI to interface with the Xcode 26 SDK's private frameworks and system APIs.

(repo-wide) · high confidence

This update adds a comprehensive set of header and implementation shims in Sources/COpenSwiftUI/Shims/UIKit (alongside HIServices, QuartzCore, and UserActivity) to bridge OpenSwiftUI with private UIKit APIs. These shims provide access to gesture recognizer containers and registration, hit-testing contexts, constraint-based layout hosting views, scroll and transform events, and UI update cycles, enabling the framework to integrate deeply with iOS input and layout systems.

Sources/COpenSwiftUI/Shims/UIKit · high confidence

The framework now supports the ViewStyle API, introducing new protocols and types such as StyleContext, StyleModifier, and StyleableView. This enables views to be styled using a configuration-based approach, allowing for more flexible and composable styling logic. Users can now apply styles to views that conform to StyleableView, with the framework handling the application of style modifiers and configurations.

Sources/OpenSwiftUICore/View/Style · high confidence

An example demonstrating the ViewThatFits layout has been added to the Shared Layout section. It shows how to conditionally display different view arrangements (a combined text and progress bar, a progress bar only, or text only) based on available horizontal space.

Example/Shared/Layout · high confidence

Developers can now register callbacks that execute once animations finish using the new \withAnimation\ overload and \Transaction.addAnimationCompletion\ method. The \AnimationCompletionCriteria\ enum allows choosing between \.logicallyComplete\ (firing when logical transitions end, ignoring long tails) and \.removed\ (firing only after all animation resources are fully cleaned up).

Sources/OpenSwiftUI/Animation/Animation · high confidence

This change introduces the core types and protocols for the layout coordinate space system, including \CoordinateSpace\, \CoordinateSpaceProtocol\, and specific implementations like \GlobalCoordinateSpace\, \LocalCoordinateSpace\, and \NamedCoordinateSpace\. It also adds \ScrollCoordinateSpace\ support, enabling views to define and reference named coordinate spaces (such as scroll view bounds) for geometric conversions, which is a prerequisite for features like \GeometryReader\ frame queries relative to specific ancestors.

Sources/OpenSwiftUICore/Layout/CoordinateSpace · high confidence

This change introduces the foundational types and platform integration required for accessibility features. It adds the \LinkDestination\ control in \OpenSwiftUICore\ to handle URL opening logic, including support for sensitive URLs. It also adds Objective-C and C headers and implementations in \OpenSwiftUI\_SPI\ to bridge to Apple's private accessibility frameworks (\AXRuntime\ and \AccessibilitySharedSupport\), defining accessibility traits (\AXOpenSwiftUITraits\) and automation types (\AXAutomationType\) to expose UI element properties to assistive technologies.

_Sources/OpenSwiftUICore/View/Control, Sources/OpenSwiftUI\_SPI/Overlay/Accessibility, Sources/OpenSwiftUI\SPI/Shims/Accessibility · high confidence

The framework now includes a new date provider system and localization support within the Foundation overlay. This adds \BaseDateProvider\, \DateProvider\, and \TimeIntervalProvider\ classes to handle date formatting, time intervals, and calendar unit alignment, along with a \DateFormattingContext\ to manage reference dates and display preferences. Additionally, new \Localization\ utilities enable localized string resolution and sentence boundary detection, allowing date and text content to be properly adapted to the user's locale.

_Sources/OpenSwiftUI\SPI/Overlay/Foundation · high confidence

New example views have been added to the Shared Layout Geometry section to demonstrate the usage of \GeometryActionModifier\ and \GeometryReader\. The \GeometryActionModifierExample\ view illustrates how to observe geometry changes and update state dynamically, while the \GeometryReaderExample\ view shows how to size subviews relative to their parent container.

Example/Shared/Layout/Geometry · high confidence

The Example/Shared/View directory now includes new demonstration views for several SwiftUI components. ProgressViewExample showcases various ProgressView initializers, including determinate and indeterminate states, custom labels, timer-based progress, and Foundation Progress integration. ToggleExample demonstrates the Toggle view with state binding. Additionally, ConditionalContentExample, EquatableDemoView, and NamespaceExample provide examples for conditional view content, the @Equatable macro, and namespace-based animations respectively, all accompanied by SwiftUI previews.

Example/Shared/View · high confidence

The Example project now includes shared SwiftUI view modifiers demonstrating specific behaviors: \AppearanceActionModifierExample\ shows view lifecycle events, \PreferenceActionModifierExample\ and \TransactionalPreferenceActionModifierExample\ illustrate preference change handling (including transactional support), and \ValueActionModifierExample\ demonstrates value change observation. These examples serve as usage references for the ViewModifier API.

Example/Shared/ViewModifier · high confidence

New example views demonstrating tap gesture handling have been added to the shared examples. The SpatialTapGestureExample shows how to capture the location of a spatial tap to change a circle's color, while the TapGestureExample demonstrates double-tap detection to cycle through a set of colors on an image.

Example/Shared/Event · high confidence

Users can now specify how colors in a gradient are interpolated using three distinct modes: device, linear, and perceptual. This is implemented via the new \Gradient.ColorSpace\ struct and the underlying \ResolvedGradient\ logic, allowing for more accurate or perceptually uniform color transitions depending on the selected space.

Sources/OpenSwiftUICore/Graphic/Gradient · high confidence

The hit-testing subsystem now includes diagnostic tracing capabilities that log detailed, recursive descriptions of hit-test results, including view properties like frame, visibility, and opacity, to aid in debugging interaction issues. Additionally, responder-based hit-testing is now supported on macOS, allowing views that rely on the responder chain for event handling to correctly participate in hit-testing logic, with the behavior controllable via feature flags or user defaults.

Sources/OpenSwiftUI/Event/HitTest · high confidence

This change introduces a new C-based overlay implementation for CoreVideo's DisplayLink on macOS, providing the underlying mechanism for frame-synced display updates. The new \DisplayLink.c\ and \DisplayLink.h\ files in \Sources/COpenSwiftUI/Overlay/CoreVideo\ implement the \DisplayLinkCreate\, \DisplayLinkDestroy\, and time-management APIs required to integrate with the system's display refresh cycle, enabling SwiftUI rendering to synchronize with the screen's vertical blanking interval.

Sources/COpenSwiftUI/Overlay/CoreVideo · high confidence

Introduced \NSHostingSceneBridgingOptions\ and \NSHostingSizingOptions\ for macOS, allowing developers to configure how SwiftUI hosting views and controllers interact with AppKit windows. \NSHostingSceneBridgingOptions\ enables automatic population of window titles, subtitles, and toolbars from SwiftUI modifiers, while \NSHostingSizingOptions\ provides control over how content size constraints (minimum, ideal, maximum, and preferred) are reflected in Auto Layout.

Sources/OpenSwiftUI/Integration/Hosting/AppKit · high confidence

This change introduces platform-shim implementations for dyld private APIs in Sources/OpenSwiftUI\_SPI/Shims/dyld, enabling OpenSwiftUI to function on non-Darwin operating systems. The new dyld\_Private.c file provides stub implementations for functions like dyld\_get\_active\_platform and dyld\_program\_sdk\_at\_least, returning safe defaults (e.g., DYLD\_PLATFORM\_UNKNOWN or true) when not on Darwin. Additionally, the header file updates version constants to include Xcode 26 series versions (macOS 26.0–26.5 and iOS 26.0–26.5), ensuring compatibility with the latest SDK toolchains.

_Sources/OpenSwiftUI\SPI/Shims/dyld · high confidence

This change introduces a new \Shim\ directory containing platform-specific compatibility layers for non-Darwin environments (e.g., Linux). It adds \CFCompatObject\ to enable CoreFoundation object identity and hashing without the Objective-C runtime, implements \NDColor\ to replace \CGColor\ for color resolution, provides placeholder \CTFont\ and \CTFontDescriptor\ classes when CoreText is unavailable, and implements \NSParagraphStyle\ and related text layout enums to support text styling and rendering on non-Apple platforms.

Sources/OpenSwiftUICore/Shim · high confidence

This change introduces the foundational types and graph inputs required for the new scroll position API. It adds \ScrollPosition\ and \ScrollTarget\ structs, along with supporting protocols like \Scrollable\ and \ScrollStateRequest\. The implementation includes graph input keys to track scroll state and anchors, and extends \Transaction\ with new properties such as \scrollTargetAnchor\, \disablesPageScrollAnimations\, and \scrollContentOffsetAdjustmentBehavior\ to control scrolling behavior and animations.

Sources/OpenSwiftUICore/View/Scroll · high confidence

New example views have been added to the shared Example project to demonstrate specific UI behaviors. These include DynamicLayoutViewExample for conditional view rendering, InsetViewModifierExample for safe area insets on all edges, and ForEachExample which showcases dynamic data updates in ForEach loops, static ranges, key-path based iteration, and non-constant range handling.

Example/Shared/Layout/Dynamic, Example/Shared/Layout/Modifier, Example/Shared/View/DynamicContentView · high confidence

The library now includes the core types required for timeline-based animations, specifically the \TimelineSchedule\ protocol and its conforming implementations (\AlignedTimelineSchedule\, \TimerTimelineSchedule\, and \TimerIntervalTimelineSchedule\). This change introduces the ability to define custom schedules that provide sequences of dates for \TimelineView\ updates, supporting both normal and low-frequency modes to optimize performance on devices like watchOS.

Sources/OpenSwiftUICore/Animation/Timeline · high confidence

This change introduces the core \Animatable\ protocol and supporting types (such as \VectorArithmetic\, \AnimatablePair\, and \AnimatableArray\) that enable view properties to be animated. It also adds the \unanimatable()\ view modifier, which allows developers to disable animations for specific views, and implements the necessary view and view modifier integration points to process animatable data within the rendering graph.

Sources/OpenSwiftUICore/Animation/Animatable · high confidence

This change introduces core utilities for text rendering in the \Sources/OpenSwiftUICore/View/Text/Util\ directory. It adds \DynamicTypeSize\ and the deprecated \ContentSizeCategory\ enums to handle scalable content sizes, along with the \dynamicTypeSize\ environment key and \.dynamicTypeSize()\ view modifier. It implements \EnvironmentConfigurableFormatter\ to sync Foundation formatters (like \DateFormatter\ and \NumberFormatter\) with environment values such as locale and time zone. Additionally, it provides \ScaledMetric\ for scaling numeric values based on text style, \ParagraphTypesetting\ for controlling text layout, \WritingMode\ for horizontal/vertical text direction, and \ReducedTimelineSchedule\ to manage update schedules for dynamic text attributes.

Sources/OpenSwiftUICore/View/Text/Util · high confidence

Introduces the foundational types for view graph inputs and outputs, including the \\_ViewInputs\ and \\_ViewOutputs\ structs which manage attributes like environment, transaction, and preferences. Adds the \ViewInputPredicate\ protocol and its implementations (\ViewInputFlag\, \InvertedViewInputPredicate\, \OrOperationViewInputPredicate\) to enable conditional logic based on graph inputs. Also adds \CustomViewCountCache\ for tracking view counts during enumeration and platform-specific output helpers for ZStack and root geometry transforms.

Sources/OpenSwiftUICore/View/Input · high confidence

This change introduces the underlying layout implementations for several core view modifiers. It adds \FrameLayout\ to support the \frame(width:height:alignment:)\ API, allowing views to be positioned within a fixed-size invisible frame. It includes \PaddingLayout\ to handle the \padding\ modifier, enabling specific or default padding on view edges. Additionally, it implements \InsetViewModifier\ to support the \safeAreaInset\ API, which allows content to be anchored to specific edges while adjusting the view's safe area and insetting the main content accordingly.

Sources/OpenSwiftUICore/Layout/Modifier · high confidence

This change introduces new internal support for accessibility diagnostics and private attribute management on macOS. It adds a C function to detect whether the current client is making an accessibility request, allowing for better debugging of accessibility interactions. Additionally, it implements private Objective-C extensions on \NSObject\ to store accessibility-related data, such as default action blocks, link rotor information, and attribute lock sources, using associated objects to maintain state without modifying the original class definitions.

Sources/COpenSwiftUI/Overlay/Accessibility · high confidence

OpenSwiftUI now supports several new view modifiers that allow developers to react to view lifecycle events and layer content. The \onAppear\ and \onDisappear\ modifiers enable actions to be triggered when a view enters or leaves the interface. Developers can now layer secondary content behind or in front of primary views using \background\ and \overlay\, with support for alignment and style modifiers. Additionally, the \onChange\ modifier allows closures to execute when a specific value changes, facilitating reactive updates based on state or environment changes.

Sources/OpenSwiftUICore/Modifier/ViewModifier · high confidence

This change introduces the AsyncImage view, allowing users to load and display images from URLs with support for custom placeholders and phase-based content updates. It also adds ImageProvider implementations for UIImage and NSImage, enabling seamless integration of UIKit and AppKit image types into OpenSwiftUI views, along with the necessary VectorImageLayer support for NSImage rendering on macOS.

Sources/OpenSwiftUI/View/Image · high confidence

On iOS and visionOS, OpenSwiftUI now supports a bidirectional bridge between UIKit traits (via \UITraitCollection\) and SwiftUI environment values. This allows environment values conforming to \UITraitBridgedEnvironmentKey\ to be read from and written to the underlying UIKit trait collection, ensuring that changes in one system are reflected in the other. The implementation includes new files (\Environment+UITraitKey.swift\, \PlatformEnvironment.swift\, \UIKitEnvironment.swift\) that define the bridging protocol, configure platform-specific environment defaults, and handle the resolution and synchronization of traits like layout direction, size category, and color scheme between the two frameworks.

Sources/OpenSwiftUI/Data/Environment · high confidence

The SwiftCorelibs module now ships with a bundled set of C headers for CoreFoundation (including CFArray, CFDictionary, CFData, CFNumber, CFCharacterSet, and CFBase) and Grand Central Dispatch (dispatch, os). These headers provide the necessary type definitions and API stubs to support non-Darwin platforms (Linux, WASI, Windows) without requiring the full Swift toolchain headers to be present locally. Users can opt to use their local Swift toolchain headers instead by setting the OPENSWIFTUI\_LIB\_SWIFT\_PATH environment variable, which overrides the bundled headers.

Sources/SwiftCorelibs · high confidence

This change introduces a complete Color rendering infrastructure within OpenSwiftUICore, replacing previous stubs with a fully functional system. Users can now utilize the new Color.accentColor static property to apply the system or app-defined accent color to views, and the View.accentColor modifier to customize this theme color for specific view hierarchies. The implementation adds support for ColorMatrix filters, allowing for complex RGBA color transformations, and establishes robust conversion pathways between OpenSwiftUI Color and platform-specific types like CGColor and UIKit/AppKit colors. Additionally, the system now properly resolves ColorScheme and ColorSchemeContrast environment values, ensuring that views correctly adapt to light/dark modes and accessibility contrast settings.

Sources/OpenSwiftUICore/Graphic/Color · high confidence

The View module now provides the foundational infrastructure for the OpenSwiftUI view hierarchy. This includes the View protocol with its body and rendering lifecycle (\_makeView, \makeViewList), along with core view types such as EmptyView, Group, TupleView, and OptionalView. The ViewBuilder result builder is implemented to support conditional logic (buildIf, buildEither) and multi-statement closures. Additionally, view modifiers like tag(\:) and \_untagged() are available for managing view traits and selection state, and a new ConditionalGraphicsView protocol allows views to opt into a graphics-renderer body path.

Sources/OpenSwiftUICore/View · high confidence

The Text view now supports dynamic, resolvable string attributes that update automatically based on time and context. Users can display live dates, countdown timers, progress intervals, and other time-sensitive data that refreshes in the UI without manual intervention. This enables text elements to show current time, formatted date intervals, and progress percentages that update in real-time.

Sources/OpenSwiftUICore/View/Text/Resolve · high confidence

The ShapeStyle system now supports a richer set of styling options, including hierarchical foreground styles (primary, secondary, tertiary, etc.) and context-aware background styles that adapt to light/dark modes and platform-specific colors. Users can now apply blend modes to shape styles, use materials (like regularMaterial) for blurred backgrounds, and define custom drop or inner shadows. The implementation also introduces type-erased AnyShapeStyle for flexible style handling and anchored styles for precise coordinate mapping.

Sources/OpenSwiftUICore/Shape/ShapeStyle · high confidence

The Text view now supports advanced formatting and layout controls. Users can cap or range-limit text lines using the new lineLimit modifiers, which apply to individual Text instances within a hierarchy. Date values can be displayed using predefined styles (time, date, relative, offset, timer) or custom FormatStyles, including attributed styles. Text views can now wrap Image instances for inline attachment, and support concatenation via the + operator. Additional features include text selection control, text scaling, justification, and custom attributes for extensibility.

Sources/OpenSwiftUICore/View/Text/Text · high confidence

This change introduces the internal infrastructure for archiving SwiftUI views and modifiers, enabling the framework to serialize and deserialize view states. It adds the \\_ArchivableView\ and \\_ArchivableViewModifier\ protocols, along with supporting types like \ArchivableFactory\, \ArchivableDisplayList\, and \ArchivableLayoutComputer\, which handle the encoding of view hierarchies into display lists and layout data. This foundation allows views to be preserved and restored, a capability required for features like view state persistence or deep linking.

Sources/OpenSwiftUI/View/ArchivedView · high confidence

This change introduces the core Display List rendering infrastructure for OpenSwiftUI, including the \DisplayList\ data structure, animation system, and platform-specific rendering backends. It adds \CAHostingLayer\ and \CAHostingLayerEvent\ to enable rendering SwiftUI views into Quartz Core layers, supporting mouse events and layer updates. The diff also includes a \DisplayListStdoutRenderer\ for terminal-based debugging output, a \DisplayListPrinter\ for serialization, and initial support for async layer updates and platform effects.

Sources/OpenSwiftUICore/Render/DisplayList · high confidence

Added the initial documentation structure for OpenSwiftUI, including the main module overview, an introductory tutorial, and the documentation bundle configuration (Info.plist). This provides users with foundational guides on declaring user interfaces, managing data flow, and composing views across platforms.

Sources/OpenSwiftUI/OpenSwiftUI.docc · high confidence

OpenSwiftUI now provides the foundational classes to host SwiftUI views within UIKit applications on iOS and visionOS. This change introduces \UIHostingController\ and \\_UIHostingView\ (along with supporting types like \UIHostingViewBase\ and \UIHostingControllerSizingOptions\), enabling developers to embed OpenSwiftUI content in standard UIKit view hierarchies. The implementation includes basic view lifecycle management, environment propagation, and sizing options, serving as the core integration layer for UIKit-based apps.

Sources/OpenSwiftUI/Integration/Hosting/UIKit/View · high confidence

A new Benchmarks directory has been introduced to support performance testing, including a sample Swift benchmark using the Benchmark library, an Xcode workspace configuration, and VS Code launch settings for running the OpenSwiftUIBenchmark executable in both Debug and Release modes.

Benchmarks · high confidence

This change introduces the core Graph infrastructure for OpenSwiftUI, including the \GraphHost\ for managing view lifecycle and transactions, \\_GraphInputs\ for handling environment and phase data, and \GraphReuse\ logic to optimize view updates by reusing existing graph nodes. It also adds \\_GraphValue\ as a transient reference to values in the view hierarchy's dataflow graph, establishing the foundation for the framework's rendering and state management engine.

Sources/OpenSwiftUICore/Graph · high confidence

This change introduces the foundational structure for the Button control and its styling system in OpenSwiftUI. It adds the \Button\ view type, \ButtonRole\ (destructive, cancel), and the \ButtonStyle\ and \PrimitiveButtonStyle\ protocols along with their configuration structs. It also defines the \ControlSize\ enum (mini, small, regular, large, extraLarge) and the corresponding \controlSize\ environment key and view modifier. While the core types and styling infrastructure are now present, the actual rendering logic is currently stubbed out (returning \EmptyView\ or using abstract methods), with specific styles like \BorderlessButtonStyle\ marked as work-in-progress.

Sources/OpenSwiftUI/View/Control/Button · high confidence

This change introduces the \NSHostingView\ class, allowing OpenSwiftUI view hierarchies to be embedded directly into AppKit applications on macOS. The new view acts as a bridge between the SwiftUI rendering engine and the AppKit view system, handling layout constraints, intrinsic content sizing, and event delivery. Users can now integrate SwiftUI components into existing macOS interfaces, such as custom controls or window content views, leveraging the standard AppKit layout and event mechanisms.

Sources/OpenSwiftUI/Integration/Hosting/AppKit/View · high confidence

OpenSwiftUI now provides a \ContainerValues\ system that allows views to share data with their direct container views, similar to preferences but with stricter scoping. Developers can define custom values using the \ContainerValueKey\ protocol and the \@Entry\ macro, then set them on child views using the new \.containerValue(\:\:)\ modifier. These values are accessible to the immediate parent container (such as a \Group(subviews:)\) but do not escape or merge across intermediate containers, ensuring predictable data flow for complex view hierarchies.

Sources/OpenSwiftUI/View/Container, Sources/OpenSwiftUICore/View/Container · high confidence

This change adds the foundational app lifecycle support for OpenSwiftUI, introducing the \App\ protocol and \AppGraph\ to manage the application's root scene and state. It provides platform-specific launchers for macOS (AppKit) and iOS/visionOS (UIKit) that initialize the \AppGraph\ and connect it to the native application delegates. Additionally, it implements \UIApplicationDelegateAdaptor\ and \NSApplicationDelegateAdaptor\ property wrappers, allowing developers to inject and manage native app delegates within the OpenSwiftUI \@main\ app declaration, and adds a \StdoutApp\ renderer for non-GUI environments.

Sources/OpenSwiftUI · high confidence

The new OpenSwiftUIBridge module provides a \Bridgeable\ protocol and concrete implementations to convert between SwiftUI and OpenSwiftUI types. This enables bidirectional conversion for \Color\ and \Color.Resolved\ values, as well as placeholder support for \EnvironmentValues\, allowing developers to mix and match components from both frameworks.

Sources/OpenSwiftUIBridge · high confidence

The Example app now uses Tuist for project generation, replacing the previous manual Xcode project setup. This change introduces a new build workflow managed by \Project.swift\ and \Tuist.swift\, supporting multi-platform deployment targets (iOS 18.0, macOS 15.0, visionOS 2.0) and distinct build configurations for SwiftUI and OpenSwiftUI modes. It adds configurable support for debug UI inspector servers (LookInside and LookIn) via environment variables, integrates with the \mise\ tool for dependency and toolchain management, and includes a \setup.sh\ script to streamline the generation process with optional Compute backend support.

Example · high confidence

Added the \ViewAlias\ protocol and associated \viewAlias\ and \optionalViewAlias\ modifiers to \Sources/OpenSwiftUI/View/Configuration\, enabling developers to define placeholder views that are replaced by specific source views at render time. This change also includes the \OptionalViewAlias\ property wrapper for conditionally accessing these aliases and extends \ViewInputPredicate\ support, allowing for more flexible view hierarchy composition and reuse patterns within the framework.

Sources/OpenSwiftUI/View/Configuration · high confidence

This change adds the foundational implementation for dynamic views in OpenSwiftUICore, introducing the \DynamicView\ protocol and its internal containers (\DynamicViewContainer\, \DynamicViewList\) to manage view hierarchy updates and subgraph lifecycle. It also adds \AnyView\ for type-erased views, \IDView\ to bind view identity to a specific ID (resetting state when the ID changes), and \DebugReplaceableView\ to support Xcode Previews in debug builds. These components enable dynamic content rendering and identity tracking within the view graph.

Sources/OpenSwiftUICore/View/DynamicView · high confidence

This change adds the foundational types and environment bindings for accessibility support in OpenSwiftUI. It introduces \AccessibilityTechnologies\ to represent assistive features (VoiceOver, Switch Control, etc.) and exposes their status via new \EnvironmentValues\ properties like \accessibilityVoiceOverEnabled\ and \accessibilityLargeContentViewerEnabled\. The diff also adds \AccessibilityNode\ and \AccessibilityNodeList\ structures to manage the accessibility tree, \AccessibilityFocus\ for tracking focus states, and \AccessibilityAdditions\ to link platform elements to these nodes. Additionally, it implements \AccessibilityCore.UserSettings\ to resolve system accessibility preferences (such as Reduce Motion and Differentiate Without Color) into the environment.

Sources/OpenSwiftUI/Accessibility · high confidence

This change adds the core internal types and protocols required to support view archiving in OpenSwiftUI. It introduces \ArchivedViewInput\ to manage configuration flags (such as stable IDs and precise text layout) and deployment version compatibility, \ArchivedViewCore\ to handle metadata serialization, and the \ConditionallyArchivableView\ protocol to allow views to provide an alternate \archivedBody\ when in an archived state. These components form the foundation for serializing and deserializing view hierarchies, though the actual writing logic remains a stub.

Sources/OpenSwiftUICore/View/Archive · high confidence

This change adds the OpenSwiftUI\_SPI module, providing a new layer of shims and base definitions to safely wrap private Darwin APIs and support newer SDK versions. The module includes \OpenSwiftUIBase.h\ and \OpenSwiftUITargetConditionals.h\ to define macros for Xcode 26 and 27 SDK additions, as well as visionOS support. It also introduces specific shim headers and implementations for CoreGraphics (e.g., \CGImageGetHeadroom\), GraphicsServices (e.g., \\_SimulatorSystemRootDirectory\), and various other private frameworks like QuartzCore, CoreFoundation, and Accessibility, ensuring compatibility and stability when accessing these internal APIs.

_Sources/OpenSwiftUI\SPI · high confidence

Adds the \Update.swift\ file in \Sources/OpenSwiftUICore/Data\, implementing the core coordination logic for view updates. This includes thread-safe locking via \MovableLock\, depth tracking for nested update scopes, and action queuing/dispatching mechanisms. It provides APIs like \begin()\, \end()\, \perform()\, and \syncMain()\ to manage the lifecycle of update transactions and ensure actions are executed on the main thread, forming the foundation for the view update cycle.

Sources/OpenSwiftUICore/Data · high confidence

Users can now use \.containerShape\ to define a shape that automatically adapts to its container's insets, allowing child views to share the same rounded or custom geometry. This change also adds the \FillStyle\ API for controlling even-odd fill rules and antialiasing, implements the \InsettableShape\ protocol with \strokeBorder\ convenience methods for standard shapes like \Rectangle\ and \RoundedRectangle\, and establishes the core \Path\ storage and \ShapeLayer\ rendering logic required to display these shapes on screen.

Sources/OpenSwiftUICore/Shape · high confidence

This change introduces a comprehensive set of new SPI overlay files in the CoreGraphics module to bridge OpenSwiftUI with platform-specific UIKit and AppKit rendering systems. It adds path manipulation utilities including a parser for SVG-like path strings and rounded rectangle creation, a unified color abstraction layer that resolves between NSColor and UIColor based on the target system, and platform-agnostic image handling for template modes and orientation. Additionally, it provides a CoreGraphics context provider for text rendering, shadow management via NSShadow, and a centralized view function layer that abstracts subview insertion, geometry updates, and display calls across UIView, NSView, and CALayer hierarchies.

_Sources/OpenSwiftUI\SPI/Overlay/CoreGraphics · high confidence

This change introduces the core implementation for the Font API in OpenSwiftUICore, adding new files such as Font.swift, CustomFont.swift, SystemFont.swift, and TextStyle.swift. It provides public static methods to create system fonts (e.g., .largeTitle, .body) and custom fonts (e.g., .custom(\_:size:)), along with modifiers for styling (e.g., .bold, .italic, .monospacedDigit). The implementation relies on CoreText for font resolution, utilizing private CoreText APIs to handle font descriptors, weights, and design traits, effectively bridging OpenSwiftUI's Font type with platform-specific font rendering.

Sources/OpenSwiftUICore/View/Text/Font · high confidence

This change introduces new Swift interface definitions for the \SwiftUI\_SPI\ module, exposing several internal and platform-specific APIs. It adds the \JindoTripleVStack\ layout modifier (available on iOS 16.1+, tvOS 18.0+, watchOS 11.0+) with configuration options for notch handling and horizontal sizing, along with view modifiers like \jindoPosition\ and \jindoVerticalPlacement\. It also exposes the \onPreferenceChange\ view modifier (iOS 18.2+, macOS 15.2+) for handling preference updates with transactions, the \CAHostingLayer\ class for UIKit/AppKit integration (iOS 18.0+), and low-level rendering primitives including \DisplayList\ and \ViewGraph\ for accessing the view graph and display list outputs.

Example/Modules/Platform · high confidence

The example app now includes dedicated playgrounds for the Text view, demonstrating specific layout and typography features. Users can explore line limiting with the \reservesSpace\ option, custom font handling via an Inter font playground, and text layout behaviors like avoiding orphans and push-out. Additionally, examples cover foreground styling, standard date formatting, and system-specific format styles such as timers, stopwatches, and date offsets.

Example/Shared/View/Text · high confidence

This change introduces the foundational accessibility infrastructure for OpenSwiftUI, adding core types and platform support. It includes new files for managing activation points, announcement priorities, chart descriptors, custom content, and data series configurations. The update also establishes the \AccessibilityEnvironment\ to expose system preferences (such as Reduce Motion and Invert Colors) and implements the \AccessibilityCombinable\ protocol to handle the merging of accessibility attributes across view hierarchies.

Sources/OpenSwiftUICore/Accessibility · high confidence

Added a collection of new SwiftUI view examples in the Example/Shared/Animation directory to demonstrate various animation capabilities. These include ViewUnanimatableExample for the .unanimatable() view modifier, AnimationCompleteExample for logical and removal completion criteria, ColorAnimationExample for property-based animations, ElasticEaseInEaseOutAnimationExample for custom easing curves, RepeatAnimationExample for repeating animations, SpringAnimationExample for spring physics, TransactionExample for transaction-based animation overrides, and Timeline views (AnimatedColorTimelineView, BreathingColorView, ColorCodedClockView) for time-driven animations.

Example/Shared/Animation · high confidence

The repository now includes a comprehensive set of shell scripts to streamline development and release workflows. \build.sh\ and \test.sh\ provide simple entry points for building and testing the project, including Linux support via \swiftly\. \build\_xcframework.sh\ and \build\_xcframework\_slice.sh\ automate the creation of XCFrameworks using Tuist, supporting multiple SDKs, architectures, and the Compute backend. Documentation workflows are enhanced with \build-documentation.sh\ for single-version DocC builds, \preview-documentation.sh\ for local multi-version site previews, and \extract-documentation-symbol-graphs.sh\ for managing versioned symbol graphs. Additionally, \update-gh-pages-documentation.sh\ handles publishing to GitHub Pages, and \sync\_launchagent.sh\ assists in setting up the development environment on macOS.

Scripts · high confidence

The Log module now includes a CycleDetector that warns users when views or values attempt to update multiple times per frame or cycle between duplicate values, helping identify performance issues and infinite update loops. A new Logging implementation provides a unified logging API that supports both Swift Log and os\_log backends, with specific channels for internal errors, external warnings, and event debugging. Additionally, a Signposts module introduces structured performance tracing via kdebug and os\_signpost for key rendering and update phases, enabling better profiling of UI behavior.

Sources/OpenSwiftUICore/Log · high confidence

OpenSwiftUI now exposes several new environment keys and view modifiers to improve control over UI state and privacy. Developers can use the new \appearsActive\ and \isEnabled\ environment values to adjust view styling based on window focus and interactivity. The framework introduces the \privacySensitive()\ modifier and \RedactionReasons\ (including \privacy\, \placeholder\, \invalidated\, and \screencaptureProhibited\) to allow views to be automatically redacted or obscured in response to system privacy settings or screen capture attempts. Additionally, new window environment keys (\windowAppearsFocused\, \windowAppearsMain\, etc.) are available to query window state, and \isLuminanceReduced\ helps adapt UI brightness for low-light environments.

Sources/OpenSwiftUICore/Data/EnvironmentKeys · high confidence

The Example app now includes dedicated entry points for performance benchmarking and modern state management. Users can run the BenchmarkApp to measure rendering performance of specific views, or launch ObservableExampleApp and ObservableObjectExampleApp to see how the framework handles the Observation and Combine state management patterns respectively, with support for both UIKit and AppKit delegates.

Example/Example · high confidence

Added two new example components in the shared integration area: CAHostingLayerExample, which demonstrates rendering SwiftUI content via a custom Core Animation hosting layer with platform-specific layout updates, and ColorRepresentableExample, which provides UIViewRepresentable/NSViewRepresentable and UIViewControllerRepresentable/NSViewControllerRepresentable wrappers that render a red background. These examples are available as SwiftUI previews and support both UIKit and AppKit platforms.

Example/Shared/Integration · high confidence

This change introduces the core implementation for several view geometry effects in OpenSwiftUICore, including \rotationEffect\, \rotation3DEffect\, \scaleEffect\, and \offset\. It also adds the \matchedGeometryEffect\ API, allowing views to synchronize their geometry (position, size, or clip rect) across different parts of the view hierarchy using namespaces. Additionally, corresponding transition types (\ScaleTransition\, \OffsetTransition\) are provided to animate views using these effects.

Sources/OpenSwiftUICore/Render/GeometryEffect · high confidence

The gesture subsystem in OpenSwiftUICore has been significantly expanded with the addition of core infrastructure and a wide range of new gesture types and modifiers. Users can now utilize type-erased gestures via AnyGesture, combine gestures exclusively with ExclusiveGesture, and apply modifiers such as delayed, duration, coordinate space, category, and event filtering. The update also introduces new primitive gestures like DistanceGesture and EventListener, along with callback handling via CallbacksGesture, providing a more comprehensive and flexible gesture recognition API.

Sources/OpenSwiftUICore/Event/Gesture · high confidence

This change introduces the core data structures and conversion logic for the new graphics rendering pipeline. It adds the \BackdropEffect\ struct for managing backdrop styling, the \GraphicsFilter\ enum to define supported visual effects (such as blur, color matrix, and hue rotation), and the \Shader\ struct for shader-based effects. Additionally, it provides \GraphicsConversions\ to map these internal filters to Quartz Core filters and \CatalogLookup\ to handle asset resolution based on environment values like color scheme and contrast.

Sources/OpenSwiftUICore/Graphic · high confidence

The layout system now exposes new internal types—\ViewDimensions\, \ViewFrame\, \ViewGeometry\, \ViewSize\, and \ViewTransform\—to manage how views are sized, positioned, and aligned. \ViewDimensions\ and \ViewSize\ provide access to a view's size and alignment guides within its own coordinate space, enabling custom alignment calculations. \ViewGeometry\ combines origin and dimensions to represent a view's position in its parent's coordinate space, including support for right-to-left layout adjustments. \ViewFrame\ represents the view's frame as a \CGRect\ with animation support. \ViewTransform\ handles coordinate-space conversions, allowing views to report their position and size relative to specific coordinate spaces (e.g., global, local, or custom spaces) via translations, affine transforms, and scroll geometry.

Sources/OpenSwiftUICore/Layout/View · high confidence

The layout engine has been updated to support dynamic layout switching via AnyLayout, constrain view dimensions with aspectRatio and fixedSize, and control space apportionment with layoutPriority. Additionally, views can now extend beyond screen boundaries using the ignoreSafeArea modifier, which adjusts the proposed layout area to ignore safe area insets on specified edges.

Sources/OpenSwiftUICore/Layout · high confidence

This change introduces the platform-specific event binding bridges and gesture recognizers for macOS (AppKit) and iOS/visionOS (UIKit). On macOS, it adds AppKitEventBindingBridge and AppKitGestureRecognizer to handle mouse, magnify, and rotate events, along with NSViewResponder for hit-testing. On iOS/visionOS, it adds UIKitEventBindingBridge, UIKitGestureRecognizer, UIKitHoverGestureRecognizer, and UIKitKeyPressResponder to handle touch, pan, scroll, and key press events, including gesture container management and modifier key handling. These components bridge native platform events to the OpenSwiftUI event system.

Sources/OpenSwiftUI/Event/Platform · high confidence

The Example/Shared/Render directory now includes new SwiftUI view examples demonstrating specific rendering capabilities: async renderer transitions (including a custom transition to exercise inherited view updates), geometry effects (offset, rotation, and 3D rotation), matched geometry effects with clip shapes, and variable blur effects. These examples serve as visual tests and documentation for these rendering features within the shared example project.

Example/Shared/Render · high confidence

The \RendererEffect\ directory now includes implementations for several view modifiers that alter how views are rendered. Users can apply a Gaussian blur with \blur(radius:opaque:)\, clip views to specific shapes or frames using \clipShape(\:style:)\ and \clipped(antialiased:)\, and add customizable shadows with \shadow(color:radius:x:y:)\. Additionally, view transparency is controlled via the \opacity(\:)\ modifier, and a new \foregroundLayer()\ modifier is available for iOS 2.0+ to isolate foreground rendering.

Sources/OpenSwiftUICore/Render/RendererEffect · high confidence

This change introduces the core rendering engine components for OpenSwiftUI, including the \PlatformDrawable\ protocol and \PlatformDrawableContent\ for managing display list rendering, \RasterizationOptions\ for configuring color modes and acceleration flags, and the \RendererLeafView\ protocol for generating display lists from leaf views. It also adds a new \stdout\ renderer option via \\_RendererConfiguration\, allowing users to output display lists as text or a terminal-cell canvas for debugging, and provides a \ViewRendererVendor\ API to detect whether the app is using OpenSwiftUI or Apple's native SwiftUI renderer at runtime.

Sources/OpenSwiftUICore/Render · high confidence

This change introduces the underlying responder classes and view modifiers that enable custom hit-testing regions and platform view integration. It adds the \contentShape\ and \contentShape(\_:eoFill:)\ view modifiers (along with their \\_ContentShapeModifier\ and \\_ContentShapeKindModifier\ implementations) to define arbitrary shapes for interaction testing, and introduces \PlatformViewResponderBase\ to bridge OpenSwiftUI views with UIKit/AppKit platform views for hit-testing. It also adds \AnyDragResponder\ and \AllowsWindowActivationEventsResponder\ to support drag interactions and window activation event handling.

Sources/OpenSwiftUI/Event/Responder · high confidence

The Text view now supports three new system format styles for displaying time-based data: \SystemFormatStyle.Timer\ for countdown/stopwatch displays, \SystemFormatStyle.DateOffset\ for showing a date's offset from an anchor, and \SystemFormatStyle.DateReference\ for relative date formatting. These styles integrate with the new \TimeDataSource\ and \TimeDataSourceStorage\ protocols to provide live, automatically updating values in Widgets, Live Activities, and watchOS Complications. The implementation also adds support for calendar-dependent formatting, capitalization context awareness, size-adaptive field removal, and safe serialization for archived view inputs.

Sources/OpenSwiftUICore/View/Text/FormatStyle · high confidence

This change introduces the \Transaction\ structure and the \transaction(\:)\ view modifier, providing a new mechanism to pass and mutate animation context within the view hierarchy. Users can now use \.transaction { ... }\ to modify animation properties (such as adding delays or changing animation types) for specific views, or use the value-based \.transaction(value:\:)\ modifier to apply transformations only when a specific value changes. This replaces or augments the older \.animation(\_:)\ modifier, which is now deprecated in favor of these more flexible transaction-based approaches.

Sources/OpenSwiftUICore/Animation/Transaction · high confidence

Developers can now control text layout behavior for specific scripts using the new \typesettingLanguage\ and \typesettingLanguageAwareLineHeightRatio\ modifiers on \View\ and \Text\. These additions allow applications to specify an explicit language for typesetting (e.g., Thai) to ensure correct line height, line breaking, and spacing, or to customize the language-aware line-height ratio, addressing issues where text scripts differ from the device's UI language.

Sources/OpenSwiftUICore/View/Text/Typesetting · high confidence

This change introduces a comprehensive set of new utility files and shims to the OpenSwiftUICore/Util module, establishing foundational support for accessibility, attribute graph operations, and cross-platform compatibility. Key additions include AccessibilityShims for chart descriptors and custom content, AttributeGraphAdditions for async attributes and default rules, and CoreGlue for platform-specific layout and view generation. The update also adds Debugger detection, CoreSystemUtils for platform identification (Catalyst, UIKit, AppKit), and various Foundation and StandardLibrary extensions for date, duration, and floating-point handling. Additional utilities cover thread safety (ThreadSpecific, AtomicBox), run loop management, feature flags, and debugging descriptions (CustomRecursiveStringConvertible, SExpPrinter).

Sources/OpenSwiftUICore/Util · high confidence

This change introduces a suite of new internal utility types to the Data/Util module, including AnyHashable2 for flexible hashable value storage, BitVector and BitVector64 for efficient bit manipulation, BloomFilter for probabilistic set membership testing, and ObjectCache with an LRU eviction policy for thread-safe key-value caching. It also adds ConcatenatedCollection for treating two collections as one, InlineArray (ArrayWith2Inline) for optimized small-array storage, Stack for LIFO operations, StrongHash for cryptographic hashing, and ScrapeableContent support for view content scraping, alongside PropertyList improvements for property management.

Sources/OpenSwiftUICore/Data/Util · high confidence

The \View.transition\ modifier now supports a comprehensive set of built-in animation effects for when views appear or disappear. Users can apply \.slide\ for a standard leading-to-trailing slide, \.move(edge:)\ to slide from a specific edge, \.push(from:)\ for a navigation-style slide with fade, \.blur(radius:)\ for a fade-and-blur effect, and \.blurReplace\ for a combined scale-blur animation. Additionally, transitions can be combined using \.combined(with:)\ or configured with different insertion and removal behaviors via \.asymmetric(insertion:removal:)\, and custom animations can be attached using \.animation(\_:)\.

Sources/OpenSwiftUICore/Animation/Transition · high confidence

OpenSwiftUI now supports the \.task\ modifier to run asynchronous code before a view appears (and restart it when an ID changes), the \.geometryAction\ modifier to execute logic when a view's geometry changes, and the \.hidden\ modifier to hide content while optionally preserving preference values. These additions expand the available declarative APIs for handling side effects and layout-driven updates.

Sources/OpenSwiftUI/Modifier/ViewModifier · high confidence

The repository is initialized with essential configuration files that define the project's build and documentation workflows. A \.swiftformat\ file enforces code style rules, while \.codecov.yml\ configures coverage reporting to ignore test files. Documentation is managed via \.vdc.json\ for VersionedDocC, which sets up versioned API documentation for modules like OpenSwiftUI, OpenAttributeGraph, and OpenObservation. Project management is handled by \Tuist.swift\ and \mise.toml\ files, which configure the Tuist build system and tool versions. Additionally, \CONTRIBUTING.md\ and \AGENTS.md\ provide guidelines for developers and AI agents on how to build, test, and contribute to the project.

(repo-wide) · high confidence

OpenSwiftUI now supports applying modifiers directly to Scenes, enabling developers to manage scene lifecycle, environment, and routing without wrapping content in views. You can now use \onAppear\ and \onDisappear\ to run code when a scene becomes active or inactive, and \onChange\ to react to value changes (with a new two-parameter signature providing both old and new values, replacing the deprecated single-parameter version). Environment management is extended via \environment\, \environmentObject\, and \transformEnvironment\ to inject or modify values for the entire scene hierarchy. Preferences can be set or transformed at the scene level using \preference\ and \transformPreference\. Additionally, \handlesExternalEvents\ allows scenes to declare which external URLs or user activities should trigger the opening of a new scene instance.

Sources/OpenSwiftUI/Modifier/SceneModifier · high confidence

OpenSwiftUI now allows views to read objects conforming to the new \Observable\ protocol from the environment using the \@Environment\ property wrapper, in addition to the existing \ObservableObject\ support. This change introduces \Environment+Observation.swift\ to provide initializers for \@Environment\ that accept \Observable\ types (including optional variants) and adds a corresponding \.environment(\_:)\ view modifier to inject these objects into the view hierarchy. Internal utilities in \ObservationUtils.swift\ handle the integration with the observation tracking system, ensuring that views automatically update when the underlying observable state changes.

Sources/OpenSwiftUICore/Data/Observation · high confidence

Text views now support initialization with \LocalizedStringResource\ (available from OpenSwiftUI v4.0), allowing developers to display localized strings defined via the Foundation \LocalizedStringResource\ API. This includes a new initializer \Text(\_ resource: LocalizedStringResource)\ and compiler support for appending \LocalizedStringResource\ instances within string interpolations, enabling seamless integration of modern localization resources into UI text components.

Sources/OpenSwiftUICore/View/Text/Localized · high confidence

Users can now convert between OpenSwiftUI's Text.LineStyle and UIKit's NSUnderlineStyle. This change adds initializer extensions that allow wrapping an NSUnderlineStyle into a Text.LineStyle and vice versa, facilitating interoperability when bridging text styling between the two frameworks.

Sources/OpenSwiftUI/Integration/Graphic/Platform · high confidence

Developers can now use the \\#Preview\ macro and \\_previewVC()\ helper to render OpenSwiftUI views directly in Xcode Previews. This change adds bridging shims that wrap OpenSwiftUI views in standard AppKit or UIKit hosting controllers, enabling seamless preview integration on macOS, iOS, tvOS, and watchOS.

Sources/OpenSwiftUI/Integration · high confidence

Users can now control how navigation titles appear in toolbars using the new \toolbarTitleDisplayMode\ modifier. This change introduces \ToolbarTitleDisplayMode\ with options such as \.large\, \.inlineLarge\, and \.inline\, allowing titles to be displayed prominently below content, inline within the toolbar, or in a smaller centered format. The implementation includes \NavigationTitleKey\ and \NavigationTitleStorage\ to manage title state and preference reduction, along with \VersionSeedTracker\ to detect changes in preference values and trigger updates when the display mode or title content changes.

Sources/OpenSwiftUI/Data/Util, Sources/OpenSwiftUI/View/Navigation, Sources/OpenSwiftUI/View/Toolbar · high confidence

Developers can now use the \alignmentGuide\ modifier on views to define custom horizontal or vertical alignment offsets. By providing a closure that computes a value based on \ViewDimensions\, views can be precisely positioned relative to one another within stacks and other layout containers, enabling more complex and fine-grained UI arrangements.

Sources/OpenSwiftUI/Layout/Alignment · high confidence

Text views can now be initialized with an AttributedString, allowing users to display rich, styled text where attributes (such as color, bolding, and links) take precedence over view modifiers. This change introduces the necessary infrastructure to resolve AttributedString content into native attributed strings, supporting Foundation attributes like inline presentation intents and links, as well as Markdown syntax for styling localized strings.

Sources/OpenSwiftUICore/View/Text/AttributedString · high confidence

This change introduces a new set of header shims in the CoreText shim layer to bridge Apple's private CoreText APIs for OpenSwiftUI. Specifically, it adds declarations for CTAdaptiveImageGlyph (enabling adaptive image glyphs on macOS 15+/iOS 18+), CTCompositionLanguage (supporting language-specific text composition for Japanese and Chinese variants), CTFontLegibilityWeight (mapping to Accessibility Bold Text settings), and CoreTextSPI (providing functions like CTFontDescriptorCreateWithAttributesAndOptions and font metrics helpers like CoreFontGetLineHeight). These shims enable the framework to resolve text styles, measure NSAttributedString, and handle font rendering details that rely on these private APIs.

_Sources/OpenSwiftUI\SPI/Shims/CoreText · high confidence

A module map file has been added to the OpenSwiftUISymbolDualTestsSupport source directory, defining the module and exporting all its contents. This change supports the build system's ability to recognize and link the module correctly, particularly in the context of the new Tuist-based single XCFramework build configuration.

Sources/OpenSwiftUISymbolDualTestsSupport · high confidence

Added Objective-C shim headers for private CoreServices APIs (\LSApplicationWorkspace\ and \\_LSOpenConfiguration\) to support advanced URL opening capabilities. These shims expose the \openURL:configuration:completionHandler:\ method on the application workspace, allowing the framework to pass configuration options (such as sensitivity flags and target connection endpoints) when opening URLs, which is required for the updated \OpenURLAction\ handling.

Sources/COpenSwiftUI/Shims/CoreServices · high confidence

A new localization resource file (CoreDateProvider.strings) has been added to configure specific date and interval formatting behaviors, such as controlling punctuation in weekday names, whitespace requirements for designators, and the display of hyphens in date intervals.

_Sources/OpenSwiftUI\SPI/Resources · high confidence

The ViewGraph subsystem in OpenSwiftUICore has been audited and completed for version 6.5.4, introducing a full event lifecycle and rendering pipeline. This change adds the \ViewGraphFeature\ protocol and \ViewGraphFeatureBuffer\ to manage graph-wide behaviors, \ViewGraphGeometryObservers\ to track and notify layout size changes, and the \ViewRendererHost\ protocol to coordinate updates for root views, environment, transforms, and focus. It also establishes the \ViewGraphRender\ and \ViewRenderingPhase\ structures to handle display list rendering and asynchronous update states, ensuring the view graph correctly manages its outputs and delegates.

Sources/OpenSwiftUICore/View/Graph · high confidence

The \AnimatableModifier\ and \\_AnimatableView\ protocols in the OpenSwiftUI animation system are now deprecated in favor of using \Animatable\ directly. This change updates the internal view and modifier creation logic to align with the modern animation API, ensuring that developers migrate away from the older protocol definitions while maintaining compatibility through the existing \\_makeView\ and \\_makeViewList\ implementations.

Sources/OpenSwiftUI/Animation/Animatable · high confidence

The Image view now supports high dynamic range (HDR) content via the new \allowedDynamicRange\ modifier and \Image.DynamicRange\ API, enabling proper rendering of extended range images. It also adds native support for vector glyphs (SF Symbols) and vector layers through the \GraphicsImage\ contents model, allowing for scalable system graphics. Platform-specific image handling is improved with the introduction of \CorePlatformImage\ for Darwin systems and comprehensive \CGImage\ conversion initializers that support orientation, scale, and accessibility labels. Additionally, image rendering behavior is enhanced with explicit control over interpolation quality, antialiasing, and resizing modes (tile/stretch).

Sources/OpenSwiftUICore/View/Image · high confidence

This update adds a comprehensive set of Objective-C shims to the UIFoundation module to support modern text layout, paragraph styling, and graphics context handling. The changes introduce support for adaptive image glyphs, Markdown presentation intents, and detailed paragraph styles including horizontal alignment, line break strategies, and text encapsulation. Additionally, it provides safe wrappers for Core Text and string drawing operations, new geometry value helpers, and the infrastructure for custom text graphics context providers, enabling more precise control over text measurement, drawing, and layout in OpenSwiftUI.

_Sources/OpenSwiftUI\SPI/Shims/UIFoundation · high confidence

The State property wrapper in OpenSwiftUICore has been updated to support the new Observation framework, allowing views to react to changes in stored values using the modern @Observable macro. This change introduces a new internal storage mechanism (StoredLocation) that manages value updates and notifies observers, ensuring that view hierarchies update correctly when state changes. Users can now store observable objects in State and have subviews automatically refresh when those objects' properties change, provided the subviews read the relevant properties.

Sources/OpenSwiftUICore/Data/State · high confidence

The VariadicView subsystem now includes the core \_VariadicView\_Children implementation, enabling the framework to properly manage and render arbitrary numbers of child views within layouts like HStack and VStack. This change adds the necessary View protocol conformance to Children, allowing them to be processed by the AttributeGraph system via ForEach, and implements the RandomAccessCollection logic to correctly index and access individual child elements, including their traits and view IDs.

Sources/OpenSwiftUICore/View/VariadicView · medium confidence

The layout system now uses a new \LayoutComputer\ struct to wrap layout engines, providing a unified interface for layout calculations such as size fitting, spacing, and child geometry retrieval. This change introduces \DerivedLayoutEngine\ to delegate common layout behaviors and supports tracing via \TracingLayoutEngineBox\ for debugging. Additionally, \UnaryLayoutView\ is added to handle layout computation for single-child views, supporting both standard and position-aware placement contexts to correctly manage geometry, position, and safe area insets within the attribute graph.

Sources/OpenSwiftUICore/Layout/LayoutComputer · high confidence

The DisplayList rendering system now supports an accelerated OpenRenderBox (ORB) backend alongside the existing CoreGraphics path. On both macOS and iOS/visionOS, drawing views are instantiated as ORBDrawingView when hardware acceleration is available and supported, falling back to CGDrawingView otherwise. This change introduces the OpenRenderBoxView and OpenRenderBoxLayer base classes to manage the ORB layer lifecycle and asynchronous rendering, and updates the platform-specific view definitions (AppKit and UIKit) to wire up ORB support, including specific hit-testing views for shapes and proper layer configuration for accelerated drawing.

Sources/OpenSwiftUI/Render/DisplayList · high confidence

This change adds the internal \PlatformItemList\ infrastructure required to render list items with platform-specific styling and behavior. It introduces the \PlatformItemListGenerator\ to construct item graphs, \PlatformItemListFlags\ to control which item attributes (such as selection, text, layout, and accessibility) are processed, and an \IncludesStyledTextModifier\ to enable styled text support. Additionally, it implements the \WidgetAuxiliaryViewMetadata\ API, allowing widgets to expose detailed text and graphic metadata (including dates, attachments, and colors) for auxiliary views.

Sources/OpenSwiftUI/Integration/PlatformItemList · high confidence

This change adds new internal platform integration files to the hosting layer. It introduces \HostingViewTransparentBackgroundReason\ to track specific reasons for transparent backgrounds (such as Catalyst sidebar or list item backgrounds), establishes a \HostingViewRegistry\ to manage active hosting views, and adds environment value support for managed and supplied bridges within \HostingControllerUtilities\. These additions provide the underlying infrastructure for managing view hosting states and background rendering behaviors on the platform.

Sources/OpenSwiftUI/Integration/Hosting/Platform · medium confidence

The event responder system in OpenSwiftUICore has been restructured with a new class hierarchy (ViewResponder, MultiViewResponder, LeafViewResponder) and supporting types (ResponderNode, ContentShapeKinds, ContentPathObserver). This change implements the underlying mechanics for hit-testing, including platform-specific defaults for visionOS, and enables content shape modifiers to influence interaction, drag previews, context menus, hover effects, and accessibility visuals. Users will see more accurate and flexible hit-testing behavior and support for defining custom shapes for various UI interactions.

Sources/OpenSwiftUICore/Event/Responder · high confidence

The library now uses a semantic versioning system (v1 through v7) to manage feature availability, allowing components to enable or disable functionality based on the SDK version the app was built with or its deployment target. This change introduces a \Feature\ protocol and \SemanticFeature\ types that map specific UI behaviors—such as navigation view layouts, list styling, and accessibility options—to specific OS releases (e.g., iOS 18.0 for v6), ensuring that new behaviors are only active when the underlying platform supports them.

Sources/OpenSwiftUICore/Semantic · high confidence

The layout system now includes internal infrastructure to track when a view is being laid out within a lazy container. A new \IsInLazyContainer\ flag and corresponding extensions on \\_GraphInputs\, \\_ViewInputs\, and \\_ViewListInputs\ allow the layout engine to identify and handle lazy container contexts, which is a prerequisite for supporting \ForEach\ within lazy containers.

Sources/OpenSwiftUICore/Layout/LazyContainer · high confidence

Build settings previously managed in the project file have been moved to a structured set of xcconfig files in Configurations/Shared. This change introduces specific configurations for OpenSwiftUI and SwiftUI targets across debug and release schemes, establishing a minimum deployment target of iOS 18.0 and macOS 15.0. It also updates the availability macros to support the latest platform versions, including iOS 26, macOS 26, tvOS 26, watchOS 26, and visionOS 26, ensuring the library correctly exposes features available on these future OS releases.

Configurations/Shared · high confidence

The OpenURLAction implementation has been relocated to the OpenSwiftUICore module, centralizing the logic for handling URL opening actions. This change updates the underlying system handling mechanism for the action, ensuring that both default and custom URL handlers are processed through the core event system. Users relying on the @Environment(\\.openURL) modifier or custom OpenURLAction instances will see their URL opening behavior managed by this new core location, which supports the standard Result types (handled, discarded, systemAction) for controlling flow.

Sources/OpenSwiftUICore/Event/SystemEvent · medium confidence

The CI pipeline now includes dedicated scripts to validate UI test execution and handle binary releases. A new \check\_uitest\_selection.sh\ script verifies that UI tests actually ran and distinguishes between expected snapshot recording issues and unexpected failures, while \collect\_uitest\_failures.sh\ extracts and organizes reference and failed snapshot images from test logs. Additionally, \release.js\ and \update\_binary\_package.sh\ automate the creation of release drafts, validate artifact integrity via SHA-256 digests, and update the binary package repository with code-signed XCFrameworks and macro sources.

Scripts/CI · high confidence

Added xcconfig files to define build settings for the Example, HostingExample, TestingHost, and UI/Interaction test targets, including bundle identifiers and code signing entitlements. Introduced an Info.plist for the OpenSwiftUI framework that exposes build metadata such as the AG backend, renderer backend, library type, and local dependency usage via build-time variables. Configured the test targets to enable Swift modules, include availability macros, and link necessary bridging headers and entitlements.

Configurations · high confidence

The environment subsystem has been replaced with a new implementation that introduces \CachedEnvironment\ for optimized attribute caching and animated frame handling, alongside \EnvironmentKey\ and \DerivedEnvironmentKey\ protocols to support custom and dynamically computed environment values. This change adds the \@Environment\ property wrapper for reading values, \transformEnvironment\ for modifying existing values, and \environment(\:\:)\ for setting them, while integrating with the \OpenObservation\ framework to ensure views automatically update when environment data changes.

Sources/OpenSwiftUICore/Data/Environment · high confidence

The event handling system in OpenSwiftUICore has been restructured to support a new event binding and dispatch model. This change introduces core types such as \Event\, \EventBinding\, and \EventID\, along with a dedicated \EventBindingManager\ that tracks active gesture bindings and coordinates event dispatch to responder nodes. The update also adds specific event types for user interactions, including \MouseEvent\, \PanEvent\, and \PhysicalButtonEvent\, and provides a comprehensive set of debug triggers (via the \OpenSWIFTUI\_EVENT\_DEBUG\ environment variable) to log event phases, bindings, and gesture states for troubleshooting.

Sources/OpenSwiftUICore/Event/Event · high confidence

The \OpenSwiftUIGlue\ class now provides concrete implementations for opening URLs, delegating to \UIApplication.shared.open\ on iOS/tvOS, \NSWorkspace.shared.open\ on macOS, and handling sensitive URLs via \LSApplicationWorkspace\ on iOS and visionOS. Additionally, the \OpenSwiftUIGlue2\ class implements platform-specific logic for detecting status bar visibility and configuring default environment values, establishing the foundational glue between OpenSwiftUI and the underlying platform APIs.

Sources/OpenSwiftUI/Util · high confidence

OpenSwiftUI now resolves system accent colors and CoreUI named colors on macOS and visionOS. On macOS, the library integrates with native APIs to detect hardware accent settings and map standard accent names (such as red, orange, or multicolor) to the corresponding system catalog colors. Additionally, it enables dynamic resolution of named colors by bridging to UIKit on iOS/visionOS and AppKit on macOS, ensuring that named colors respect the current trait collection and appearance environment.

Sources/OpenSwiftUI/Graphic · high confidence

The Tuist build infrastructure has been updated to ensure that local compilation caching is always enabled and persistent, while remote caching is explicitly disabled. The \tuist\_xcodebuild\ helper in \Scripts/Tuist/common.sh\ now passes specific environment variables (\COMPILATION\_CACHE\_ENABLE\_CACHING=YES\, \COMPILATION\_CACHE\_KEEP\_CAS\_DIRECTORY=YES\, \COMPILATION\_CACHE\_REMOTE\_SERVICE\_PATH=\) to Xcode, guaranteeing that build artifacts are stored locally in DerivedData regardless of the CI or local environment. This change is accompanied by a new test suite in \Scripts/Tuist/Tests/common-tests.sh\ that verifies the build commands include these caching flags and that remote cache setup commands are not executed.

Scripts/Tuist · high confidence

The DynamicProperty subsystem in OpenSwiftUICore has been updated to align with the 6.5.4 specification. This includes a complete reimplementation of the core DynamicProperty protocol, the \_DynamicPropertyBuffer for managing property state, and the UnsafeHeterogeneousBuffer for underlying storage. The update introduces new capabilities such as the \DynamicPropertyBehaviors\ option set (supporting \allowsAsync\ and \requiresMainThread\), enhanced tracing support via \traceMountedProperties\, and improved logging for changed body properties. Additionally, the \Namespace\ property wrapper has been updated to match the new behavior, ensuring consistent identifier generation and lifecycle management.

Sources/OpenSwiftUICore/Data/DynamicProperty · high confidence

A new C shim layer (OpenSwiftUI\_CSymbols) has been added to provide a portable way to resolve the file path of a symbol given its memory address. The implementation uses the standard dladdr function, which resolves the previously reported build issues on non-Darwin platforms where this functionality was missing or broken.

_Sources/OpenSwiftUI\SPI/Shims/CSymbols · high confidence

Resolves a bug where UIImage to Image environment overrides were not handled correctly. The change introduces a new \TypesettingConfiguration\ file that bridges UIKit's \UITraitCollection\ to OpenSwiftUI's typesetting language settings, ensuring that the system's typesetting language is properly read from and written to mutable traits.

Sources/OpenSwiftUI/View/Text · medium confidence

Add test stubs for FlexFrameLayout and ViewGeometry; Added CI test suites for release, interaction, and optional workflows; Added gesture debug data print tree stub; Added internal test infrastructure and benchmarking support; Added internal test infrastructure for performance and view testing; Added test stubs for BidirectionalCollection insertion sort and CGSize extension; Added test stubs for CodableEffectAnimation and VelocitySampler; Added test stubs for ColorMatrix, CatalogLookup, and GraphicsContext; Added test stubs for DisplayList, CAFrameRateRange, and Rotation3DEffect; Added test stubs for ImageOrientation and AccessibilityText APIs; Added test stubs for SwiftUI internal data structures and Foundation types; Added test support data structures and helpers; Added test support for runtime issue tracking and AIGC tagging; Expanded UI and interaction test coverage for OpenSwiftUI; Expanded test coverage for OpenSwiftUI compatibility and bridge APIs.

This change introduces a new Benchmarks package (using package-benchmark 1.20.0) and updates the Example project's dependency manifest to include swift-snapshot-testing 1.19.3, swift-syntax 603.0.2, and other libraries, while also adding a new StdoutRenderer example.

(dependencies) · high confidence

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

• CAI 54 → 50 (-4.0)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 64 → 64 (-0.2)
• Architecture 94 → 90 (-4.1)
• Maturity 81 → 81 (+0.0)
• Readiness 59 → 45 (-14.4)
• Security 39 → 41 (+2.0)
• Performance 71 (new)

• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (35 lines × 3) (Example/Example/ExampleApp.swift)
• Duplicated block (6 lines × 2) (Sources/OpenSwiftUICore/View/Text/AttributedString/Text+AttributedString.swift)
• Duplicated block (7–13 lines × 2) (Sources/OpenSwiftUICore/View/Archive/ConditionallyArchivableView.swift)
• FixmeComment (Example/OpenSwiftUIUITests/Layout/AspectRatioLayoutUITests.swift)
• FixmeComment (Example/OpenSwiftUIUITests/Layout/AspectRatioLayoutUITests.swift)
• FixmeComment (Example/OpenSwiftUIUITests/Layout/AspectRatioLayoutUITests.swift)
• FixmeComment (Example/OpenSwiftUIUITests/Layout/FixedSizeLayoutUITests.swift)
• FixmeComment (Example/OpenSwiftUIUITests/Render/GeometryEffect/MatchedGeometryEffectUITests.swift)
• FixmeComment (Example/OpenSwiftUIUITests/Shape/ShapeStyle/BackgroundStyleUITests.swift)
• FixmeComment (Example/OpenSwiftUIUITests/UITests/SnapshotTesting+Testing.swift)
• FixmeComment (Example/OpenSwiftUIUITests/UITests/SnapshotTesting+Testing.swift)
• FixmeComment (Example/OpenSwiftUIUITests/View/Image/AsyncImageUITests.swift)
• FixmeComment (Example/OpenSwiftUIUITests/View/ProgressViewUITests.swift)
• FixmeComment (Sources/OpenSwiftUICore/Shape/Path.swift)
• FixmeComment (Sources/OpenSwiftUIExtension/TappablePadding.swift)
• FixmeComment repeated across 43 files (Example/OpenSwiftUIUITests/Graphic/Color/ColorUITests.swift)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 198 more

• AttributedString.isStyled (cognitive 16) (Sources/OpenSwiftUICore/View/Text/AttributedString/Text+AttributedString.swift)
• AttributedString.isStyled (cyclomatic 17) (Sources/OpenSwiftUICore/View/Text/AttributedString/Text+AttributedString.swift)
• AttributedString.redact (cognitive 16) (Sources/OpenSwiftUICore/View/Text/AttributedString/Text+AttributedString.swift)
• ChangedBodyProperty.swift.changedBodyProperties (cognitive 36) (Sources/OpenSwiftUICore/Data/DynamicProperty/ChangedBodyProperty.swift)
• ChangedBodyProperty.swift.changedBodyProperties (cyclomatic 21) (Sources/OpenSwiftUICore/Data/DynamicProperty/ChangedBodyProperty.swift)
• ClosestFitCache.callAsFunction (cognitive 17) (Sources/OpenSwiftUICore/View/Text/Text/Text+SizeFitting.swift)
• Coverage not measured — Swift suite
• CustomRecursiveStringConvertible.swift.colorNameForColorComponents (cognitive 67) (Sources/OpenSwiftUICore/Util/CustomRecursiveStringConvertible.swift)
• CustomRecursiveStringConvertible.swift.colorNameForColorComponents (cyclomatic 66) (Sources/OpenSwiftUICore/Util/CustomRecursiveStringConvertible.swift)
• Dependency not covered by the committed resolution: lookinserver
• Dependency not covered by the committed resolution: lookinside-release
• Dependency not covered by the committed resolution: opencombine
• Dependency not covered by the committed resolution: opencombine
• Dependency not covered by the committed resolution: swift-crypto
• Dependency not covered by the committed resolution: swift-log
• Dependency not covered by the committed resolution: versioneddocc
• Dictionary.transferAttributedStringStyles (cognitive 34) (Sources/OpenSwiftUICore/Util/StandardLibraryAdditions.swift)
• Dictionary.transferAttributedStringStyles (cyclomatic 30) (Sources/OpenSwiftUICore/Util/StandardLibraryAdditions.swift)
• Duplicated block (10 lines × 2) (Sources/OpenSwiftUICore/Layout/AspectRatioLayout.swift)
• Duplicated block (10 lines × 2) (Sources/OpenSwiftUICore/Layout/Edge/EdgeInsets.swift)
• …and 279 more

• 36 commits — 20 feature/other, 16 fixes

• Sources/OpenSwiftUICore — 10 commits
• Sources/OpenSwiftUI — 5 commits
• (root) — 3 commits
• Renderer/Stdout — 3 commits
• Scripts/CI — 3 commits
• Tests/OpenSwiftUICoreTests — 3 commits
• Example/Tests — 2 commits
• Example/Modules — 1 commit
• Example/Shared — 1 commit
• Example/Tuist — 1 commit
• Sources/COpenSwiftUI — 1 commit
• Sources/OpenSwiftUIExtension — 1 commit
• Sources/OpenSwiftUIMacros — 1 commit
• Sources/OpenSwiftUI_SPI — 1 commit

• fix: fix(compute): adopt observer removal fix (#1107)
• fix: fix(extension): support OpenSwiftUI tappable padding (#1102)
• fix: fix(gesture): prevent layout gesture reset crashes (#1085)
• fix: fix(gesture): restore double-tap recognition (#1095)
• fix: fix(gesture): restore iOS gesture container handling (#1088)
• fix: fix(hosting): hide private platform overrides from module interfaces (#1089)
• fix: fix(hosting): restore SwiftUI renderer subview overrides
• fix: fix(identity): correct seed allocation and restore IdentityLink (#1093)
• fix: fix(macros): support availability attributes on previews (#1105)
• fix: fix(observation): restore body updates for observable state (#1104)
• fix: fix(path): implement containment and path transforms (#1098)
• fix: fix(release): handle draft release lookups
• fix: fix(release): sync OpenObservation macro sources (#1106)
• fix: fix(tests): isolate feature user defaults (#1103)
• fix: fix(text): set async thread flags for text filters (#1111)
• fix: test: fix frame sizing and view graph test isolation (#1090)
• change: chore(compute): bump to 0.6.0 and restore binary default (#1115)
• change: chore: disable gesture container feature temporary
• change: chore: update animation example
• change: docs: update platform support status
• …and 16 more

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

OpenSwiftUIProject/OpenSwiftUI 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.