OpenSwiftUIProject/OpenSwiftUI
51.4
Adequate · 15 November 2026
217.4k
lines of production code
Swift
primary language
5
measurements over time
What this system is
Features
Add 3D rotation effect support and display list utilities
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
Add @Bindable property wrapper for Observable objects
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
Add @Entry, \#Preview, and @\_\_EntryDefaultValue macros
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
Add Anchor, GeometryReader, and Layout Geometry APIs
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
Add AppKit color and appearance conversion support
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
Add AppKit overlay helpers for NSColor, NSView, and NSWindow
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
Add AppKit private API shims for gesture, layout, and accessibility support
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. Also in this area: Enhanced macOS window management and new accessibility, styling, and gesture capabilities; New accessibility actions and focus state support.
Sources/COpenSwiftUI/Shims/AppKit · high confidence
Add CGTK target
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
Add Combine-based property wrappers for observable objects
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
Add CoreGraphics geometry and utility extension implementations
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
Add Darwin-specific logging and method invocation shims
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
Add Divider and DividerStyle support
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
Add Dynamic Island preview components to the Stack example
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
Add DynamicContainer support
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
Add EditMode support and List style contexts
This change introduces the \EditMode\ enum and its associated environment value, allowing views to detect and react to editing states (inactive, transient, active) via the \editMode\ environment key. It also adds the \EditModeScopeModifier\ to manage edit mode scope within view hierarchies. Additionally, new style context structs are defined for various list styles (Plain, Sidebar, Inset, Grouped, etc.) and labeled content styles, laying the groundwork for list appearance customization, although the actual rendering implementations for these styles remain unimplemented stubs.
Sources/OpenSwiftUI/View/List · high confidence
Add Entry macro support
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
Add EquatableView, \_CALayerView, IdentityLink, and LazyView
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. Also in this area: 3 commits (1 fix) modifying Sources; Enhanced macOS window management and new accessibility, styling, and gesture capabilities; Implemented SymbolEffect APIs and MappedViews infrastructure; New accessibility actions and focus state support.
Sources/OpenSwiftUI/View · medium confidence · unverified
Add ForEach view support
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
Add Foundation overlay support for NSObject and NSThread
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
Add Geometry Effect example views
The Example project now includes shared SwiftUI views demonstrating various geometry effects, including offset, rotation, 3D rotation, matched geometry effects (with and without clip shapes), projection transforms, repeating scale/rotation effects, and visual geometry effects. These examples serve as both documentation and test cases for the rendering of these specific visual transformations.
Example/Shared/Render/GeometryEffect · high confidence
Add HStack, VStack, ZStack, and zIndex support
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
Add HostingExample app with iOS, visionOS, and macOS support
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
Add IdentifiedViewProxy and identifier lookup mechanisms
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
Add LLDB hook to print SwiftUI display lists minimally
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
Add Label view and LabelStyle support
This change introduces the \Label\ view and the \LabelStyle\ protocol to OpenSwiftUI, enabling developers to create standard UI components that combine an icon with a title. The implementation includes built-in styles such as \.automatic\, \.iconOnly\, \.titleOnly\, and \.titleAndIcon\, along with context-aware defaults for containers like lists, sidebars, and toolbars. An example view is also added to demonstrate these styling options.
Example/Shared/View/Label · high confidence
Add Label view and LabelStyle system
Introduces the \Label\ view and the \LabelStyle\ protocol, enabling users to create composite UI elements with an icon and a title. The diff adds built-in styles including \DefaultLabelStyle\ (which adapts to contexts like lists, toolbars, and swipe actions), \TitleAndIconLabelStyle\, \TitleOnlyLabelStyle\, and \IconOnlyLabelStyle\. It also includes an \EffectiveLabelStyle\ environment value for tracking the active style and a \FallbackLabelStyle\ that adjusts based on button border shapes.
Sources/OpenSwiftUI/View/Label · high confidence
Add LabelGroup view and styling support
Introduces the \LabelGroup\ view, which allows grouping multiple views and automatically applying hierarchical styling (font and foreground color) based on each view's position in the group. The default \BodyLabelGroupStyle\ applies \.body\, \.subheadline\, and \.footnote\ fonts with corresponding primary, secondary, and tertiary colors for the first three levels. This enables consistent visual hierarchy for lists of labels or text elements without manual styling.
Sources/OpenSwiftUI/View/LabelGroup · high confidence
Add LabeledContent view and label visibility controls
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. Also in this area: Enhanced macOS window management and new accessibility, styling, and gesture capabilities; New accessibility actions and focus state support.
Sources/OpenSwiftUI/View/LabelContent · high confidence
Add LazyState property wrapper for deferred initialization
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
Add NSHostingController for AppKit integration
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
Add OpenSwiftUI compatibility to Example/Shared views
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
Add OpenSwiftUI\_SPI utility infrastructure
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
Add PlatformViewRepresentable support for integrating UIKit and AppKit views
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
Add ProgressView support
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. Also in this area: Add Label view and style support, implement FocusableViewResponder, and remove legacy accessibility modifiers.
Sources/OpenSwiftUI/View/Control/ProgressView · high confidence
Add Protobuf encoding and decoding support for Foundation types
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
Add Quartz Core overlay shims for macOS
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
Add SensoryFeedback API support
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
Add Slider control with customizable styles
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. Also in this area: Enhanced macOS window management and new accessibility, styling, and gesture capabilities; Add Label view and style support, implement FocusableViewResponder, and remove legacy accessibility modifiers.
Sources/OpenSwiftUI/View/Control/Slider · high confidence
Add Spacer support for flexible layout spacing
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
Add StaticIf conditional view logic and Visibility enum
This change introduces the \StaticIf\ view and modifier, which allows conditionally rendering different views or applying modifiers based on stable view inputs such as interface idioms or style contexts, enabling framework-level optimizations. It also adds the \Visibility\ enum (\automatic\, \visible\, \hidden\) to control the display state of UI elements, supporting APIs like list row separators and confirmation dialog titles.
Sources/OpenSwiftUICore/View/Configuration · high confidence
Add SymbolEffect APIs for pulse, breathe, and bounce animations
Users can now apply animated effects to SF Symbols using the new \symbolEffect\ view modifier. This change introduces the \SymbolEffect\ struct with built-in configurations for pulse, breathe, and bounce animations, allowing developers to control speed, repeat counts, and delays. The \View\ extension provides modifiers to apply these effects continuously or trigger them on value changes, integrating with the attribute graph to append effects to the environment for rendering.
Sources/OpenSwiftUI/Render/SymbolEffect · high confidence
Add TestingHost example app with platform-specific app delegate support
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
Add TimelineView and Always-On Display support for iOS and visionOS
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
Add ToggleState enum for managing toggle states
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
Add UIKit color and interface style conversion support
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
Add UIKit update cycle integration and hosting view abstraction
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
Add UIKit view and view controller representable protocols
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
Add ViewModifier protocol and implementation
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
Add ViewThatFits layout and JindoTripleVStack SPI
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
Add \_printChanges and \_logChanges debugging APIs for views and modifiers
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
Add accessibility heading levels and text content types
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
Add alignment layout and guide infrastructure
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
Add appearance animation support for view modifiers
Introduces the \appearanceAnimation\ modifier to views, allowing animations to trigger when a view appears or disappears. This new API supports specific visual effects including opacity, offset, scale, and rotation, and offers two strategies for controlling the animation timing: \withAnimation\ and \animationValue\.
Sources/OpenSwiftUICore/Animation · high confidence
Add coordinate space and position layout modifiers
Users can now name a view's coordinate space using the \coordinateSpace(name:)\ and \coordinateSpace(\:)\ modifiers, allowing gestures and other views to reference positions relative to that specific view. Additionally, the new \position(\:)\ and \position(x:y:)\ modifiers allow you to fix the center of a view at a specific point within its parent's coordinate space.
Sources/OpenSwiftUI/Layout/Modifier · high confidence
Add core accessibility automation types and link destination support
This change introduces foundational support for accessibility automation and secure link handling. It adds the \LinkDestination\ view modifier in \OpenSwiftUICore\, enabling applications to open URLs via environment actions while distinguishing between sensitive and standard links. Additionally, it defines the \AXAutomationType\ enumeration in the accessibility shims, mapping UI elements to specific automation roles, and provides a private interface for \AXChartDescriptor\ to facilitate chart accessibility data exchange on Darwin platforms.
_Sources/OpenSwiftUICore/View/Control, Sources/OpenSwiftUI\SPI/Shims/Accessibility · high confidence
Add core animation types and completion APIs
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
Add core gesture and input event types
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
Add custom layout examples to the shared library
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
Add generic Codable support utilities and wrappers
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
Add image rendering and conversion examples to the shared example project
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
Add internal build detection and protocol descriptor utilities
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
Add internal tracing infrastructure for debugging view lifecycle and layout
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
Add keyboard shortcut support and radio group styling for Pickers
Users can now assign keyboard shortcuts to specific options within a Picker using the new \pickerKeyboardShortcut\ view modifier, enabling faster navigation via key combinations. Additionally, the \RadioGroupPickerStyle\ has been introduced to render Picker selections as a radio-button-like group, providing a distinct visual style for mutually exclusive options.
Sources/OpenSwiftUI/View/Control/Picker · high confidence
Add layout direction support for internationalization
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
Add layout edge and inset types
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
Add macOS-specific text field scrolling customization and stub TextField view
This change introduces a new \textFieldScrollingDisabled\ modifier for macOS that allows users to control whether a text field's content scrolls, alongside the underlying \TextFieldIsScrollableKey\ environment value. It also adds the initial stub implementation for the \TextField\ view struct and its format-based initializer, which currently trigger unimplemented failures, and includes an environment update hook for \NSTextField\ on macOS.
Sources/OpenSwiftUI/View/TextField · high confidence
Add navigation infrastructure for title and depth management
This change introduces the foundational infrastructure for SwiftUI navigation views within the OpenSwiftUI framework. It adds \NavigationAuthority\ to manage navigation stack depth and \NavigationLink\ stubs to support link-based navigation. Crucially, it implements \NavigationTitleKey\ and \NavigationSubtitleKey\ as \HostPreferenceKey\ types, enabling the propagation of navigation bar titles and subtitles through the view hierarchy. The \NavigationTitleStorage\ struct handles the merging of title attributes (such as title mode, icon view, and visibility) to ensure the correct display state is applied to the navigation bar.
Sources/OpenSwiftUI/View/Navigation · high confidence
Add observation-based example views for color and counter state
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
Add onPreferenceChange, transformPreference, and preference modifiers
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
Add onReceive view modifier for Combine publishers
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
Add platform-agnostic test helpers for UIHostingController layout and lifecycle
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
Add platform-specific overlay shims for accessibility, display, and testing
This change introduces a suite of new C/Objective-C shim files in the Sources/COpenSwiftUI/Overlay directory to bridge OpenSwiftUI with underlying platform frameworks. On macOS, it adds accessibility request diagnostics (AXRequest), NSColor and NSView helper methods, a custom CoreVideo DisplayLink manager for screen refresh synchronization, and QuartzCore transaction helpers. On iOS and visionOS, it provides CoreUI idiom mapping, UIKit view creation utilities, and a testing swizzling layer that overrides UIScreen scale and UICollectionView animations to stabilize UI tests. Also in this area: New accessibility actions and focus state support.
Sources/COpenSwiftUI/Overlay/UIKit · high confidence
Add runtime support for conditional and tuple type introspection
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
Add spring loading behavior support for drag-and-drop interactions
Users can now control how views respond to spring loading during drag-and-drop operations on iOS and macOS. This change introduces the \springLoadingBehavior(\_:)\ view modifier, allowing developers to explicitly enable, disable, or defer to automatic spring loading for specific views. It also adds the \springLoaded()\ modifier for custom interaction handling and exposes the behavior via environment values, enabling fine-grained control over navigation or presentation effects triggered by brief pauses or force clicks during a drag.
Sources/OpenSwiftUI/Event · high confidence
Add stdout renderer with terminal view mode
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
Add support for identifying views with unique identifiers
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
Add tappablePadding modifier for expanding tap targets
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
Add variable blur effect with image masking
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
Add visionOS hover effect infrastructure
Introduces the core types and protocols for custom hover effects on visionOS, including the \CustomHoverEffect\ protocol, \HoverEffectContent\ for defining visual changes, and supporting context structures like \HoverEffectContext\ and \HoverEffectInfo\ to manage phases, groups, and animations.
Sources/OpenSwiftUICore/Render/HoverEffect · high confidence
Added CALayer extensions for animation control and view testing
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
Added InterfaceIdiom support for platform-specific view selection
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
Added Link view for URL navigation
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
Added Quartz Core private API shims for advanced rendering and animation
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
Added SPI shims for CoreUI, MobileGestalt, and kdebug to support Xcode 26 SDK
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
Added SymbolEffect SPI implementation
The internal rendering layer for SymbolEffects now includes a new \\_SymbolEffect\ struct that defines the core data model for various symbol animations. This change introduces support for specific effect types including pulse, breathe, bounce, wiggle, rotate, variable color, scale, and hidden states, along with configurable options for speed, repeat counts, and delays. Users can now leverage these underlying structures to drive symbol animations within the framework.
Sources/OpenSwiftUICore/Render/SymbolEffect · high confidence
Added UIKit and system-private API shims for gesture, layout, and event handling
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
Added ViewStyle API support
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
Added ViewThatFits layout example
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
Added accessibility overlay support for traits, chart descriptors, and runtime symbols
This change introduces new accessibility infrastructure within the OpenSwiftUI\_SPI overlay, adding support for accessibility traits (such as Button, Link, Image, and Map), chart descriptor unarchiving, and dynamic loading of private framework symbols like AXRuntime and AccessibilitySharedSupport. These additions enable more granular accessibility descriptions and interactions for UI elements, particularly on Darwin platforms.
_Sources/OpenSwiftUI\SPI/Overlay/Accessibility · high confidence
Added animation completion callbacks
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
Added async renderer example with transition crash reproduction
The AsyncRendererExample view was added to the shared examples to demonstrate async rendering behavior, specifically including a RenderCrashTransition that forces an update to inherited view content during a transition phase to reproduce a previous crash in DisplayList.ViewUpdater.
Example/Shared/Render/Async · high confidence
Added coordinate space layout infrastructure
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
Added date formatting and localization infrastructure
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
Added example views for GeometryActionModifier and GeometryReader
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
Added example views for ViewModifier behaviors
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
Added gradient color space interpolation support
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. Also in this area: Gradient rendering and paint support added.
Sources/OpenSwiftUICore/Graphic/Gradient · high confidence
Added macOS CoreVideo DisplayLink overlay implementation
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
Added macOS hosting view and controller configuration options
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
Added non-Darwin dyld shims with Xcode 26 SDK version support
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
Added non-Darwin platform shims for CoreFoundation, Color, Font, and Text APIs
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
Added scroll position and target management infrastructure
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
Added shared animation, layout, and data examples
The Example project now includes a suite of shared SwiftUI views demonstrating various framework capabilities. These include animation behaviors such as logical completion, color transitions, elastic easing, repetition, and springs; timeline-based animations for dynamic colors and clocks; transaction-based animation modifications; data observation patterns; dynamic layout views; safe area insets; and dynamic ForEach content updates.
Example/Shared/Layout/Dynamic, Example/Shared/Layout/Modifier, Example/Shared/View/DynamicContentView · high confidence
Added timeline scheduling infrastructure for animation updates
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
Added visual effect system with geometry proxy support
The \VisualEffect\ protocol and its implementations have been added to the rendering core, enabling views to be visually transformed without affecting layout. This includes the \visualEffect(\_:)\ modifier, which allows developers to apply effects using a \GeometryProxy\ to access layout information, and supports chaining effects via \concat\, \rendererEffect\, and \geometryEffect\. The \EmptyVisualEffect\ struct serves as the base for these transformations, and the \VisualEffectModifier\ handles the integration with the attribute graph system.
Sources/OpenSwiftUICore/Render/VisualEffect · high confidence
Addition of Animatable protocol and view modifiers
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
Adds Dynamic Type, text formatting, and layout environment support
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
Adds core view input/output infrastructure and predicate system
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
Adds layout modifiers for frame, padding, and safe area insets
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
Adds macOS accessibility request diagnostics and private attribute storage
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
Adds onAppear, onDisappear, background, overlay, and onChange view modifiers
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
AppKit gesture, key, and focus event integration
On macOS, OpenSwiftUI now bridges native AppKit input events to its internal event system. This adds an AppKit gesture recognizer that translates mouse clicks, drags, magnification, and rotation into OpenSwiftUI gesture events, and converts NSEvent key presses and modifier flags into the framework's key event model. Additionally, an NSView responder is introduced to handle hit-testing, visibility checks, and focus management, enabling proper keyboard navigation and focus ring behavior within SwiftUI views on macOS.
Sources/OpenSwiftUI/Event/Platform/AppKit · high confidence
AsyncImage view and platform-specific image provider implementations
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
Bidirectional bridging of UIKit traits to SwiftUI environment values
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
Bundled non-Darwin CoreFoundation and dispatch compatibility headers
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
Comprehensive Color system implementation with accent color and matrix support
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
Core View system and modifiers implemented
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
Dynamic and resolvable text content support
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
Expanded ShapeStyle capabilities with foreground, background, and material support
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
Expanded Text view capabilities with line limits, date formatting, and image attachments
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
Implement archivable views and modifiers
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. Also in this area: Enhanced macOS window management and new accessibility, styling, and gesture capabilities.
Sources/OpenSwiftUI/View/ArchivedView · high confidence
Implement standard Button styles and interactions
Adds the core implementation for SwiftUI Button controls, including the \Button\ view itself and several standard styles: \bordered\, \borderedProminent\, and \borderless\. This change introduces platform-specific rendering for macOS (via \AppKitButton\ and \AppKitButtonStyle\) and iOS/visionOS (via \BorderedButtonStyle\_Phone\ and \BorderlessButtonStyleBase\), along with support for \ButtonRole\ (destructive/cancel), \ButtonBorderShape\ (capsule, circle, rounded rectangle), and \ButtonRepeatBehavior\ for long-press actions.
Sources/OpenSwiftUI/View/Control/Button · high confidence
Initial Display List rendering engine and Quartz Core hosting layer support
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
Initial OpenSwiftUI documentation added
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
Initial UIKit hosting infrastructure for iOS and visionOS
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
Initial benchmarking infrastructure added
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
Initial implementation of the OpenSwiftUI Graph system
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
Initial support for hosting SwiftUI views in AppKit on macOS
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
Introduce ContainerValues API for scoped view data sharing
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
Introduce OpenSwiftUI app lifecycle and platform-specific launchers
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
Introduce OpenSwiftUIBridge for type interoperability
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
Introduce PlatformItemList infrastructure for list item metadata and styling
This change adds the internal \PlatformItemList\ framework within OpenSwiftUI, establishing the data structures and view modifiers required to manage complex list items. It introduces the \PlatformItemList\ struct and its \Item\ type to hold detailed metadata such as attributed text, images, selection behaviors, accessibility properties, and keyboard shortcuts. The implementation includes \PlatformItemListFlags\ to categorize item attributes (e.g., selection, text, layout, accessibility) and a \PlatformItemListGenerator\ to process view content into these structured items. Additionally, it adds \WidgetAuxiliaryViewMetadata\ to handle rich text and graphic metadata for widget views, and \IncludesStyledTextModifier\ to track styled text requirements in the graph inputs.
Sources/OpenSwiftUI/Integration/PlatformItemList · high confidence
Introduce Tuist-based project generation for the Example app
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
Introduce View Alias system for indirect view composition
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
Introduce core DynamicView infrastructure and ID-based view identity
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
Introduce focus management system with @FocusState and focus modifiers
This change adds the core infrastructure for managing focus within OpenSwiftUI views. It introduces the @FocusState property wrapper, allowing developers to bind and control which view currently holds focus, along with the .focused() and .focusable() view modifiers to mark views as focus targets and define their interactions. The implementation includes the internal FocusStore and FocusItem structures to track focus state across the view graph, platform-specific responders for handling focus events on iOS, visionOS, and macOS, and support for focus effects like the default focus ring on macOS.
Sources/OpenSwiftUI/Event/Focus · high confidence
Introduce internal infrastructure for archived view hierarchies
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
Introduces OpenSwiftUI\_SPI module with platform shims and SDK support
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
Introduces Update coordination system for view updates
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
Introduces container-relative shapes and comprehensive shape rendering infrastructure
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
New CoreGraphics SPI overlays for path, color, image, and view management
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
New Font API surface and CoreText resolution implementation
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
New SwiftUI SPI interfaces for layout, preferences, and rendering
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
New Text view examples for layout, formatting, and typography
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
New accessibility action modifiers and user settings support
This change introduces new SwiftUI modifiers for defining and grouping accessibility actions, including \accessibilityAction\ for single actions and \accessibilityActions(category:)\ for grouped actions, along with supporting types like \AccessibilityActionKind\ and \AccessibilityActionCategory\. It also adds \AccessibilityCore.UserSettings\ support to expose system accessibility preferences (such as Reduce Motion, Reduce Transparency, and VoiceOver status) into the environment, and implements \accessibilityDirectTouch\ to allow views to bypass assistive technology touch handling. Also in this area: Enhanced macOS window management and new accessibility, styling, and gesture capabilities.
Sources/OpenSwiftUI/Accessibility · high confidence
New accessibility core types and platform support
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
New build, documentation, and XCFramework automation scripts
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
New cycle detection and structured logging infrastructure
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
New environment keys and modifiers for window state, view enablement, and privacy redaction
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. Also in this area: 2 commits (1 fix) modifying Sources; New physical button press gesture, focus event proxy, and refined control size support.
Sources/OpenSwiftUICore/Data/EnvironmentKeys · medium confidence · unverified
New example apps for benchmarking and state management patterns
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
New example views and tests for Link, Slider, Stepper, and TextSelection
The Example app now includes demonstration views and snapshot tests for the Link, Slider, Stepper, and TextSelection components. LinkExample showcases various link initializers, button styles (default, automatic, plain, bordered, custom, and explicit link), appearance modifiers (tint, foreground style), and the new .link ShapeStyle. SliderExample demonstrates continuous and stepped sliders with value labels and editing state feedback. StepperExample illustrates bounded values, custom increment/decrement actions, fractional steps, and control sizes. TextSelectionExample and its associated interaction tests verify text selection behavior, including inheritance, disabling, and layout wrapping. Also in this area: Added example views for ProgressView, Toggle, and conditional content.
Example/Shared/View · high confidence
New example views for CAHostingLayer and color representables
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
New geometry effect APIs for View, VisualEffect, and HoverEffectContent
This change introduces a suite of new geometry effect modifiers across the View, VisualEffect, and HoverEffectContent APIs. For Views, you can now apply 2D and 3D rotations (rotationEffect, rotation3DEffect), scaling (scaleEffect), offsets (offset), and arbitrary affine or projection transforms (transformEffect, projectionEffect). A new ignoredByLayout() modifier allows effects to apply only during rendering, preventing layout shifts during transitions. These capabilities are also extended to VisualEffect (v5.0+) and HoverEffectContent (v6.0+), with deprecated aliases provided for older naming conventions.
Sources/OpenSwiftUI/Render/GeometryEffect · high confidence
New geometry effect modifiers and transitions
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
New gesture and keyboard interaction examples
Added example views demonstrating DragGesture, SpatialTapGesture, and TapGesture interactions, along with a KeyPress example that showcases keyboard focus management and key event handling (down, repeat, up phases) for Space, Return, and Escape keys.
Example/Shared/Event · high confidence
New gesture recognition primitives and modifiers added to OpenSwiftUI
This change introduces a comprehensive set of new gesture types and supporting infrastructure to the OpenSwiftUI event system. Users can now utilize new gesture recognizers including DragGesture, PanGesture, SpatialTapGesture, and \_ButtonGesture (enabling press-and-release interactions with optional pressing state callbacks). The update also adds GestureState for tracking transient UI state during gestures, a hitTestingLayoutGesture modifier for rebinding hit-test events in layouts, and a handGestureShortcut modifier for watchOS hand-gesture shortcuts. Supporting infrastructure includes EventDirections for constraining gesture axes, LayoutGestureModifier for routing events through layouts, and MultiEventListener for handling multiple concurrent events.
Sources/OpenSwiftUI/Event/Gesture · high confidence
New gesture system infrastructure and modifiers
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
New graphics rendering primitives and filter infrastructure
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
New layout geometry and transform types for view positioning and alignment
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
New layout system and view modifiers
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
New rendering effects for blur, clipping, shadows, and opacity
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. Also in this area: New view modifiers for spring loading, coordinate spaces, compositing groups, and blend modes.
Sources/OpenSwiftUICore/Render/RendererEffect · high confidence
New rendering infrastructure and stdout renderer support
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
New responder infrastructure for hit-testing and content shapes
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. Also in this area: Enhanced macOS window management and new accessibility, styling, and gesture capabilities; New accessibility actions and focus state support.
Sources/OpenSwiftUI/Event/Responder · high confidence
New system timer, date offset, and date reference format styles
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
New toolbar title display modes and bridging infrastructure
This change introduces the \toolbarTitleDisplayMode\ modifier and the \ToolbarTitleDisplayMode\ type, allowing users to control how toolbar titles are displayed (e.g., \.large\, \.inlineLarge\, \.inline\, \.automatic\) on iOS, tvOS, and watchOS. It also adds internal infrastructure for toolbar item bridging (\ToolbarItemBridgingOptions\, \AllowsToolbarItemBridgingModifier\) and dynamic toolbar style contexts (\ToolbarStyleContextModifier\) to support more flexible toolbar layouts and styling. Also in this area: Enhanced macOS window management and new accessibility, styling, and gesture capabilities.
Sources/OpenSwiftUI/View/Toolbar · high confidence
New transaction-based animation control APIs
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
New typesetting language and line-height configuration APIs
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
New utility and shim infrastructure in OpenSwiftUICore/Util
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
New utility data structures and caching mechanisms
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
New view insertion and removal transitions
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
New view modifiers for tasks, geometry actions, and hidden state
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
New visual and color effect APIs for views and styles
This change introduces a suite of new rendering effects in the RendererEffect module, allowing developers to apply visual transformations to views. Users can now apply blur, brightness, contrast, grayscale, hue rotation, and saturation effects via the VisualEffect extension. Additionally, opacity control is expanded to include a repeating opacity animation helper for views, opacity support for hover effects (on non-iOS/macOS/watchOS/tvOS platforms), and opacity modifiers for ShapeStyle, including support for arrays of opacity values.
Sources/OpenSwiftUI/Render/RendererEffect · high confidence
New visual effect examples for blend modes, compositing, and color adjustments
The example app now includes dedicated views demonstrating several rendering capabilities: \BlendModeExample\ and \VisualRendererEffectExample\ showcase standard and extended blend modes (including \extendedBlendMode\), while \CompositingGroupExample\ illustrates how \compositingGroup()\ affects overlapping shapes and text. Additionally, \ColorEffectExample\ provides interactive previews for brightness, contrast, grayscale, hue rotation, and saturation (both as direct view modifiers and via \visualEffect\), and \VariableBlurEffectExample\ demonstrates masked variable blur.
Example/Shared/Render/RendererEffect · high confidence
Repository initialization with build, documentation, and contribution configuration
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
Scene-level modifiers for lifecycle, environment, preferences, and external events
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
Support for @Environment with Observable objects
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
Support for LocalizedStringResource in Text views
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
Support for Text.LineStyle conversion between OpenSwiftUI and UIKit
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
Support for custom alignment guides on views
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
Support for displaying AttributedString content in Text views
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
Behavioural changes
1 commit (0 fixes) modifying Example
A change to existing behaviour in Example — 1 commit, 4 files: “feat(material): add material APIs and rendering support (\#1253)” (refs \#1253). Also in this area: Gradient rendering and paint support added; Added shared animation, layout, and data examples.
Example/Shared/Animation/Timeline, Example/Shared/Graphics, Example/Tests/OpenSwiftUIUITests/Shape · medium confidence · unverified
1 commit (0 fixes) modifying Example, Sources
A change to existing behaviour in Example, Sources — 1 commit, 6 files: “feat(event): add macOS responder command support (\#1245)” (refs \#1245).
Sources/OpenSwiftUI/Event/Command · medium confidence · unverified
1 commit (0 fixes) modifying Example/Shared/Animation/Animatable
A change to existing behaviour in Example/Shared/Animation/Animatable — 1 commit, 1 file: “feat(animatable): add unanimatable view modifier (\#1097)” (refs \#1097).
Example/Shared/Animation/Animatable · medium confidence · unverified
1 commit (0 fixes) modifying Example/Shared/Animation/Transition
A change to existing behaviour in Example/Shared/Animation/Transition — 1 commit, 1 file: “feat: implement content transition APIs and backend descriptors (\#1237)” (refs \#1237).
Example/Shared/Animation/Transition · medium confidence · unverified
1 commit (0 fixes) modifying Sources/COpenSwiftUI, Sources/COpenSwiftUI/Public, Sources/OpenSwiftUI\_SPI/Public
A change to existing behaviour in Sources/COpenSwiftUI, Sources/COpenSwiftUI/Public, Sources/OpenSwiftUI\_SPI/Public — 1 commit, 7 files: “feat: add public Clang modules and Metal headers (\#1232)” (refs \#1232).
_Sources/COpenSwiftUI, Sources/COpenSwiftUI/Public, Sources/OpenSwiftUI\SPI/Public · medium confidence · unverified
1 commit (0 fixes) modifying Sources/OpenSwiftUI/View/Help, Sources/OpenSwiftUI/View/Section
A change to existing behaviour in Sources/OpenSwiftUI/View/Help, Sources/OpenSwiftUI/View/Section — 1 commit, 14 files: “feat: add Section view APIs (\#1244)” (refs \#1244).
Sources/OpenSwiftUI/View/Help, Sources/OpenSwiftUI/View/Section · medium confidence · unverified
1 commit (0 fixes) modifying Sources/OpenSwiftUI/View/Subview, Sources/OpenSwiftUICore/View/Subview
A change to existing behaviour in Sources/OpenSwiftUI/View/Subview, Sources/OpenSwiftUICore/View/Subview — 1 commit, 7 files: “feat: add subview and section extraction APIs (\#1243)” (refs \#1243).
Sources/OpenSwiftUI/View/Subview, Sources/OpenSwiftUICore/View/Subview · medium confidence · unverified
13 commits (6 fixes) modifying Sources/OpenSwiftUI/View/Toggle
A change to existing behaviour in Sources/OpenSwiftUI/View/Toggle — 13 commits (6 fixs), 9 files: “fix: use module selectors in Example observation models (\#1236)”; “feat(button): implement button styles and interactions (\#1138)”; “Fix Toggle size issue (\#610)”; and 10 more (refs \#1236, \#1138, \#610, \#887, \#605, …).
Sources/OpenSwiftUI/View/Toggle · medium confidence · unverified
2 commits (1 fix) modifying Example/Shared/Extension
A change to existing behaviour in Example/Shared/Extension — 2 commits (1 fix), 1 file: “fix: use module selectors in Example observation models (\#1236)”; “Add UIImage/NSImage ImageProvider implementation (\#822)” (refs \#1236, \#822).
Example/Shared/Extension · medium confidence · unverified
2 commits (1 fix) modifying Sources/OpenSwiftUI/Animation/Animatable
A change to existing behaviour in Sources/OpenSwiftUI/Animation/Animatable — 2 commits (1 fix), 2 files: “Update AnimatableAttribute implementation (\#387)”; “fix: align soft-deprecated API availability (\#1233)” (refs \#387, \#1233).
Sources/OpenSwiftUI/Animation/Animatable · medium confidence · unverified
2 commits (1 fix) modifying Sources/OpenSwiftUI/Event/InputEvent
A change to existing behaviour in Sources/OpenSwiftUI/Event/InputEvent — 2 commits (1 fix), 2 files: “feat(event): add key press APIs and keyboard shortcut bindings (\#1067)”; “fix: preserve platform deprecation versions (\#1238)” (refs \#1067, \#1238).
Sources/OpenSwiftUI/Event/InputEvent · medium confidence · unverified
2 commits (1 fix) modifying Sources/OpenSwiftUI/View/Scroll
A change to existing behaviour in Sources/OpenSwiftUI/View/Scroll — 2 commits (1 fix), 2 files: “fix: use module selectors in Example observation models (\#1236)”; “feat(focus): connect keyboard actions and platform focus (\#1183)” (refs \#1236, \#1183).
Sources/OpenSwiftUI/View/Scroll · medium confidence · unverified
3 commits (0 fixes) modifying Example/Shared/Animation/Animation
A change to existing behaviour in Example/Shared/Animation/Animation — 3 commits, 5 files: “Add Shared assets for Example project (\#813)”; “Add previews for shared examples (\#1032)”; “chore: update animation example” (refs \#813, \#1032).
Example/Shared/Animation/Animation · medium confidence · unverified
3 commits (1 fix) modifying Sources
A change to existing behaviour in Sources — 3 commits (1 fix), 34 files: “feat: add subview and section extraction APIs (\#1243)”; “feat: add Section view APIs (\#1244)”; “fix(font): apply requested system font weights (\#1242)” (refs \#1243, \#1244, \#1242). Also in this area: Add accessibility, modifiers, and focus support for platform items.
Sources/OpenSwiftUI/Integration/PlatformItems · medium confidence · unverified
3 commits (1 fix) modifying Sources/OpenSwiftUI/Layout/Edge
A change to existing behaviour in Sources/OpenSwiftUI/Layout/Edge — 3 commits (1 fix), 1 file: “fix: use module selectors in Example observation models (\#1236)”; “Add ViewThatFits interface (\#225)”; “Update version information (\#523)” (refs \#1236, \#225, \#523).
Sources/OpenSwiftUI/Layout/Edge · medium confidence · unverified
3 commits (1 fix) modifying Sources/OpenSwiftUI/Macro
A change to existing behaviour in Sources/OpenSwiftUI/Macro — 3 commits (1 fix), 1 file: “feat: add public Clang modules and Metal headers (\#1232)”; “fix(preview): add native visionOS Preview support (\#1179)”; “Add OpenSwiftUI Preview macro support (\#1018)” (refs \#1232, \#1179, \#1018).
Sources/OpenSwiftUI/Macro · medium confidence · unverified
4 commits (0 fixes) modifying Example/Shared/Animation/Transaction
A change to existing behaviour in Example/Shared/Animation/Transaction — 4 commits, 1 file: “Add Shared assets for Example project (\#813)”; “Add previews for shared examples (\#1032)”; “chore(example): restore Text and Button in examples (\#1147)”; and 1 more (refs \#813, \#1032, \#1147).
Example/Shared/Animation/Transaction · medium confidence · unverified
7 commits (1 fix) modifying Sources/OpenSwiftUI/Event/HitTest
A change to existing behaviour in Sources/OpenSwiftUI/Event/HitTest — 7 commits (1 fix), 4 files: “fix: use module selectors in Example observation models (\#1236)”; “feat(event): add hit-test diagnostics (\#1072)”; “feat: add FeatureFlags shim with SwiftUI domain fallback”; and 4 more (refs \#1236, \#1072, \#1069, \#1148, \#1151, …).
Sources/OpenSwiftUI/Event/HitTest · medium confidence · unverified
7 commits (2 fixes) modifying Sources/OpenSwiftUI/Integration
A change to existing behaviour in Sources/OpenSwiftUI/Integration — 7 commits (2 fixs), 4 files: “fix: use module selectors in Example observation models (\#1236)”; “Move interpose hooks to OpenSwiftUI\_SPI with improved diagnostics (\#839)”; “feat(preview): implement PreviewProvider APIs (\#1175)”; and 4 more (refs \#1236, \#839, \#1175, \#833, \#1179, …).
Sources/OpenSwiftUI/Integration · medium confidence · unverified
8 commits (1 fix) modifying Sources/OpenSwiftUI/Event/Platform/UIKit
A change to existing behaviour in Sources/OpenSwiftUI/Event/Platform/UIKit — 8 commits (1 fix), 13 files: “fix: use module selectors in Example observation models (\#1236)”; “feat: add public Clang modules and Metal headers (\#1232)”; “feat(event): add UIKit gesture containers and hosting view inputs (\#1068)”; and 5 more (refs \#1236, \#1232, \#1068, \#1119, \#1183, …).
Sources/OpenSwiftUI/Event/Platform/UIKit · medium confidence · unverified
Add CoreText SPI shims for font and text composition support
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
Add module map for OpenSwiftUISymbolDualTestsSupport
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
Add private CoreServices shims for URL opening configuration
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
Adds localized date formatting configuration resources
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
Complete ViewGraph lifecycle and rendering infrastructure
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
Corrects cubic animation interpolation and refines macOS symbol rendering
Animations using UnitCurve now use a more robust Newton's method with bisection fallback for cubic interpolation, ensuring smoother and more accurate easing curves. On macOS, named SF Symbols are now rendered with proper layering, orientation handling, and style-aware coloring via the RenderBox integration, replacing the previous stub implementation. Additionally, SymbolRenderingMode now correctly maps to the underlying ORBSymbolRenderingMode enum, fixing issues where symbols were not respecting the intended monochrome, multicolor, or hierarchical display modes. Also in this area: Comprehensive Color system implementation with accent color and matrix support.
Sources/OpenSwiftUICore/Graphic/Appearance · high confidence
Enhanced macOS window management and new accessibility, styling, and gesture capabilities
macOS applications now support configurable window defaults, allowing developers to set initial size and position via new scene modifiers, with the window controller handling placement and title bar appearance. Accessibility is expanded with the addition of \accessibilityAdjustableAction\ for VoiceOver adjustments, along with modifiers for selectable text and slider marks. The \Link\ view has been refactored to use a button-based implementation with dedicated styles, and the \Slider\ control has been updated to a new style configuration API with improved accessibility support. Additionally, a new \LongPressGesture\ phase modifier and \allowsWindowActivationEvents\ view modifier have been added to support advanced gesture and window activation behaviors. Also in this area: New accessibility actions and focus state support; Fixes image environment override issue in Text view.
Sources/OpenSwiftUI/View/Text · medium confidence
Expanded Image rendering capabilities with HDR, vector glyphs, and platform integration
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
Expanded UIFoundation shims for advanced text layout and rendering
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
Implement State property wrapper with Observation support
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
Implement VariadicView children management and graph integration
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
Introduce LayoutComputer and UnaryLayoutView for layout engine abstraction
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
Introduce OpenRenderBox (ORB) rendering backend for DisplayList views
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
Introduce platform hosting infrastructure and background transparency controls
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
Introduces new View Responder architecture for hit-testing and content shape handling
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
Introduction of semantic versioning for conditional feature availability
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
Lazy container context tracking infrastructure added
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
Migration of build configuration to xcconfig files with updated platform availability
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
Moved OpenURLAction to OpenSwiftUICore with updated system handling
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
New CI infrastructure for UI test validation and binary release management
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. Also in this area: Binary releases now validate Swift module versions against source; Improved CI test validation and framework dependency checks; Themed release titles and AI-generated highlights.
Scripts/CI · high confidence
New build configuration files for testing and example targets
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
New environment system implementation with caching and observation support
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
New event binding and dispatch infrastructure for gestures
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
Platform-specific URL handling and core glue implementation
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
Support for system accent colors and named colors on macOS and visionOS
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
Tuist build scripts now enforce persistent local caching with remote caching disabled
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
Updated DynamicProperty implementation to version 6.5.4
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
Fixes
3 commits (2 fixes) fixing Sources/OpenSwiftUI/View/Control/Stepper
A fix in Sources/OpenSwiftUI/View/Control/Stepper — 3 commits (2 fixs), 6 files: “fix: use module selectors in Example observation models (\#1236)”; “feat: implement Stepper (\#1220)”; “fix: align soft-deprecated API availability (\#1233)” (refs \#1236, \#1220, \#1233).
Sources/OpenSwiftUI/View/Control/Stepper · medium confidence · unverified
Add dladdr-based symbol path resolution shim for non-Darwin platforms
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
Test coverage
1 commit adding/updating tests in (repo-wide); 2 commits adding/updating tests in Example/Tests/OpenSwiftUIInteractionTests/Event; 2 commits adding/updating tests in Example/Tests/OpenSwiftUIUITests/Animation, Example/Tests/OpenSwiftUIUITests/View/DynamicViewContent; 2 commits adding/updating tests in Example/Tests/OpenSwiftUIUITests/Layout; 2 commits adding/updating tests in Example/Tests/OpenSwiftUIUITests/View/Image; 3 commits adding/updating tests in Example/Tests/OpenSwiftUIInteractionTests/View; 3 commits adding/updating tests in Example/Tests/OpenSwiftUIUITests/View/LabeledContent; 4 commits adding/updating tests in Example/Tests/OpenSwiftUIInteractionTests/Data; 4 commits adding/updating tests in Example/Tests/OpenSwiftUIUITests/Graphic; 5 commits adding/updating tests in Example/Tests/OpenSwiftUIInteractionTests/InteractionTests; 5 commits adding/updating tests in Example/Tests/OpenSwiftUIUITests/Render/GeometryEffect; 5 commits adding/updating tests in Example/Tests/OpenSwiftUIUITests/Render/RendererEffect; 6 commits adding/updating tests in Example/Tests/OpenSwiftUIUITests/View; 8 commits adding/updating tests in Example/Tests/OpenSwiftUIUITests/UITests; Add test stubs for FlexFrameLayout and ViewGeometry; 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; New CI test coverage for Swift interface normalization, binary release integrity, and optional workflow dispatch.
Dependencies
Add benchmarking and update example project dependencies
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 cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 58 → 51 (-6.6)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 66 → 64 (-2.0)
- Architecture 89 → 90 (+0.1)
- Maturity 81 → 84 (+2.4)
- Readiness 45 → 44 (-0.9)
- Security 64 → 41 (-23.7)
- Performance 80 → 94 (+14.4)
Resolved (51)
- Duplicated block (11 lines × 2) (Example/Project.swift)
- Duplicated block (12 lines × 2) (Sources/OpenSwiftUI/Integration/Representable/AppKit/NSViewControllerRepresentable.swift)
- Duplicated block (12 lines × 2) (Sources/OpenSwiftUI/View/Control/SensoryFeedback/UIKit/UIKitSensoryFeedbackCache.swift)
- Duplicated block (12 lines × 2) (Sources/OpenSwiftUICore/Event/Gesture/ExclusiveGesture.swift)
- Duplicated block (12–13 lines × 3) (Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift)
- Duplicated block (13 lines × 2) (Sources/OpenSwiftUICore/Data/Preference/PreferenceTransformModifier.swift)
- Duplicated block (13 lines × 2) (Sources/OpenSwiftUICore/View/Image/Image.swift)
- Duplicated block (13 lines × 4) (Sources/OpenSwiftUICore/Layout/Edge/EdgeInsets.swift)
- Duplicated block (14 lines × 2) (Sources/OpenSwiftUICore/Layout/Modifier/FrameLayout.swift)
- Duplicated block (14 lines × 2) (Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewPlatform.swift)
- Duplicated block (18 lines × 2) (Sources/OpenSwiftUICore/Layout/Layout.swift)
- Duplicated block (19 lines × 2) (Example/Project.swift)
- Duplicated block (19 lines × 2) (Sources/OpenSwiftUICore/View/Text/Text/Text+View.swift)
- Duplicated block (21 lines × 2) (Sources/OpenSwiftUICore/Graphic/GraphicsConversions.swift)
- Duplicated block (24 lines × 2) (Sources/OpenSwiftUICore/View/Text/Localized/Text+Localized.swift)
- Duplicated block (28–29 lines × 2) (Sources/OpenSwiftUICore/View/Text/Text/Text+View.swift)
- Duplicated block (29 lines × 2) (Sources/OpenSwiftUICore/Graphic/Color/SystemColors.swift)
- Duplicated block (5 lines × 2) (Sources/OpenSwiftUI/View/Container/TraitValues.swift)
- Duplicated block (5 lines × 2) (Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewModel.swift)
- Duplicated block (5 lines × 4) (Sources/OpenSwiftUICore/Layout/Stack/HStack.swift)
- …and 31 more
New (478)
- ClassTooLong: _UIHostingView (Sources/OpenSwiftUI/Integration/Hosting/UIKit/View/UIHostingView.swift)
- ContentTransition.rbTransition (cognitive 20) (Sources/OpenSwiftUICore/Animation/Transition/ContentTransition.swift)
- CoreMaterialCache.load (cognitive 37) (Sources/OpenSwiftUICore/Shape/ShapeStyle/Material/CoreMaterialDefinitions.swift)
- CoreMaterialCache.load (cyclomatic 28) (Sources/OpenSwiftUICore/Shape/ShapeStyle/Material/CoreMaterialDefinitions.swift)
- CoreMaterialCache.loadEffects (cognitive 20) (Sources/OpenSwiftUICore/Shape/ShapeStyle/Material/CoreMaterialDefinitions.swift)
- Duplicated block (10 lines × 2) (Sources/OpenSwiftUICore/Graphic/GraphicsFilter.swift)
- Duplicated block (12 lines × 2) (Sources/OpenSwiftUI/Integration/Representable/AppKit/NSViewControllerRepresentable.swift)
- Duplicated block (12 lines × 2) (Sources/OpenSwiftUI/View/Control/SensoryFeedback/UIKit/UIKitSensoryFeedbackCache.swift)
- Duplicated block (12 lines × 2) (Sources/OpenSwiftUICore/Event/Gesture/ExclusiveGesture.swift)
- Duplicated block (12–13 lines × 3) (Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift)
- Duplicated block (13 lines × 4) (Sources/OpenSwiftUICore/Layout/Edge/EdgeInsets.swift)
- Duplicated block (14 lines × 2) (Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewPlatform.swift)
- Duplicated block (18 lines × 2) (Sources/OpenSwiftUICore/Layout/Layout.swift)
- Duplicated block (19 lines × 2) (Sources/OpenSwiftUICore/View/Text/Text/Text+View.swift)
- Duplicated block (20 lines × 2) (Sources/OpenSwiftUICore/Data/Preference/PreferenceTransformModifier.swift)
- Duplicated block (22 lines × 2) (Sources/OpenSwiftUICore/Graphic/GraphicsConversions.swift)
- Duplicated block (24 lines × 2) (Sources/OpenSwiftUICore/View/Text/Localized/Text+Localized.swift)
- Duplicated block (28–29 lines × 2) (Sources/OpenSwiftUICore/View/Text/Text/Text+View.swift)
- Duplicated block (3–5 lines × 3) (Sources/OpenSwiftUI/View/Control/ProgressView/CircularProgressViewStyle.swift)
- Duplicated block (4–6 lines × 5) (Sources/OpenSwiftUI/Layout/Modifier/CoordinateSpaceModifier.swift)
- …and 458 more
Changes since last survey
- 17 commits — 11 feature/other, 6 fixes
By area
- Sources/OpenSwiftUI — 6 commits
- Sources/OpenSwiftUICore — 5 commits
- (root) — 2 commits
- Example/Shared — 1 commit
- Example/Tests — 1 commit
- Scripts/normalize_swiftinterface.js — 1 commit
- Tests/OpenSwiftUICompatibilityTests — 1 commit
Notable commits
- fix: fix(appkit): require a screen for asynchronous rendering
- fix: fix(font): apply requested system font weights (#1242)
- fix: fix: align soft-deprecated API availability (#1233)
- fix: fix: keep visionOS hosting backgrounds transparent (#1252)
- fix: fix: preserve platform deprecation versions (#1238)
- fix: fix: use module selectors in Example observation models (#1236)
- change: chore: bump development version to 0.26.0
- change: docs: record Swift 6.5 interface normalization cleanup
- change: feat(event): add macOS responder command support (#1245)
- change: feat(example): add gradient showcase
- change: feat(material): add material APIs and rendering support (#1253)
- change: feat: add Section view APIs (#1244)
- change: feat: add labeled content text initializers (#1239)
- change: feat: add public Clang modules and Metal headers (#1232)
- change: feat: add subview and section extraction APIs (#1243)
- change: feat: implement content transition APIs and backend descriptors (#1237)
- change: perf: disable private imports by default (#1255)
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
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.
About this page
- The score is its most recent published measurement, taken on 15 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 808ef19d5658a05ebbdfd60fe431d7559e8bc9cf — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-3c33c1882dc1.