ReactiveX/RxSwift

This system is the RxSwift reactive programming library, providing a framework for composing asynchronous and event-based programs using observable sequences. It includes core primitives for handling streams of data, traits for type-safe UI bindings in iOS and macOS applications, and utilities for testing and blocking execution. The codebase also encompasses platform-specific abstractions, data structures, and a comprehensive suite of example applications demonstrating reactive patterns.

59 changes.

The project underwent a major structural overhaul to support Swift Package Manager and modernize its build infrastructure, including workspace reorganization and standardized tooling. This period also focused on expanding the RxCocoa and RxSwift libraries with extensive reactive wrappers for UIKit controls, data sources, and concurrency primitives, while significantly enriching the RxExample app with diverse demonstration apps.

31 changes.

This period focused on extending the framework to macOS by adding reactive wrappers for desktop UI controls and a dedicated example application. It also established a robust testing foundation through the new RxTest framework, expanded unit and UI test coverage, and refactored the platform abstraction layer to support Swift Package Manager integration.

23 changes.

This period focused on introducing a comprehensive set of type-safe traits (Driver, Signal, SharedSequence, Infallible) and the RxRelay module to simplify UI binding and error handling. Concurrently, the codebase underwent significant modernization to support Swift 4, adopting new concurrency patterns, renaming APIs for consistency, and adding performance benchmarking infrastructure.

The Rx playground now includes an Introduction page that explains the core concepts of RxSwift, such as Observables, observers, and marble diagrams, and provides initial code examples demonstrating how to create and subscribe to observables.

Rx.playground/Pages/Introduction.xcplaygroundpage · high confidence

The TableViewWithEditingCommands example has been added to the RxExample app, showcasing a reactive implementation of a table view that supports editing commands such as deleting and reordering users. The example features a ViewModel-driven architecture using Observable.system to manage state transitions for favorite and normal user lists, integrates with the RandomUserAPI to fetch user data, and includes a DetailViewController for viewing individual user profiles. This addition provides a concrete demonstration of handling complex UI interactions and data flow in a reactive manner.

RxExample/RxExample/Examples/TableViewWithEditingCommands · high confidence

The RxExample app now includes two new demonstration scenarios for UIPickerView: a 'Convenience extensions' tab showcasing simple bindings for item titles, attributed titles, and custom views, and a 'Custom Adapters' tab demonstrating how to implement a custom data source and delegate adapter for sectioned picker data.

RxExample/RxExample/Examples/UIPickerViewExample · high confidence

The RxExample project now includes a native macOS application, providing users with a dedicated demo environment for the framework on Apple's desktop platform. This addition introduces the core application structure, including the AppDelegate and a Main.storyboard interface featuring an introduction example view controller with interactive elements like text fields, sliders, and buttons to demonstrate reactive bindings.

RxExample/RxExample/macOS · high confidence

Introduces a set of internal data structures to the Platform layer to support the library's reactive primitives. This includes a Bag for storing unordered, unique-keyed elements with optimized fast-path access, an InfiniteSequence for repeating values, a PriorityQueue for ordered element management, and a Queue for FIFO operations. These structures are now available as part of the platform abstraction layer.

Platform/DataStructures · high confidence

A new 'Try Yourself' page has been added to the Rx playground, providing an interactive environment for users to experiment with RxSwift. The page includes setup instructions for building the RxExample-macOS scheme and demonstrates a basic observable sequence using \Observable.just\ and \debug\, allowing users to observe output in the Debug Area.

Rx.playground/Pages/TryYourself.xcplaygroundpage · high confidence

A new playground page has been added to demonstrate RxSwift's connectable operators. It includes runnable examples for \publish\, \replay\, and \multicast\, illustrating how these operators allow sequences to wait for subscribers before emitting elements and how to manage shared state via subjects.

_Rx.playground/Pages/Connectable\_Operators.xcplaygroundpage, Rx.playground/Pages/Transforming\Operators.xcplaygroundpage · high confidence

A new Xcode scheme file has been added for the Preprocessor target, enabling users to build, run, test, profile, and archive the tool directly from the IDE. The scheme is configured to pass command-line arguments pointing to the source root and built products directory when launching, facilitating the generation of preprocessed files.

Preprocessor/Preprocessor.xcodeproj/xcshareddata · high confidence

The Rx playground now includes a dedicated page for Mathematical and Aggregate Operators, providing users with runnable examples and explanations for \toArray\, \reduce\, and \concat\. This addition helps users understand how these operators work by demonstrating their behavior on observable sequences within the interactive playground environment.

_Rx.playground/Pages/Mathematical\_and\_Aggregate\Operators.xcplaygroundpage · high confidence

A new playground page has been added that provides step-by-step instructions for users to enable \RxSwift.Resources.total\ in their projects. The content details the specific configuration changes required for both CocoaPods (adding a \post\_install\ hook to define \TRACE\_RESOURCES\) and Carthage (building with the Debug configuration), allowing users to activate resource tracking for debugging purposes.

_Rx.playground/Pages/Enable\RxSwift.Resources.total.xcplaygroundpage · high confidence

The example application now includes a basic Core Data stack setup. A new workspace file explicitly references the project, and a new Core Data model named 'Test1' has been added with an empty schema (no entities defined). This establishes the foundational data persistence structure for the example app.

RxExample/RxExample.xcodeproj/project.xcworkspace, RxExample/RxExample/RxExample.xcdatamodeld · high confidence

The Rx playground now includes a new 'Creating and Subscribing to Observables' page that demonstrates how to create and subscribe to various Observable sequences, including \never\, \empty\, \just\, \of\, \from\, \create\, \range\, \repeatElement\, \generate\, and \deferred\. This provides users with practical examples of different Observable creation methods and subscription patterns.

_Rx.playground/Pages/Creating\_and\_Subscribing\_to\Observables.xcplaygroundpage · high confidence

Introduces a new playground page demonstrating RxSwift error handling operators, including \catchErrorJustReturn\, \catchError\, \retry\, and \retry(maxAttemptCount)\. The page provides interactive examples showing how to recover from error notifications in Observable sequences.

_Rx.playground/Pages/Error\_Handling\Operators.xcplaygroundpage · high confidence

The RxExample app now includes a new GitHub Search Repositories demo. This feature provides a paginated search interface that allows users to query the GitHub API, view results in a table, and automatically load more items as they scroll. The example demonstrates reactive state management, network request handling with retry logic, and UI feedback such as activity indicators and offline status.

RxExample/RxExample/Examples/GitHubSearchRepositories · high confidence

RxCocoa now supports observing properties using Swift KeyPaths in addition to string-based key paths, and introduces a \KVORepresentable\ protocol that allows direct observation of Swift types (such as \Int\, \Bool\, \CGRect\, and \RawRepresentable\ enums) by automatically bridging them to their Foundation KVO equivalents.

RxCocoa/Foundation · high confidence

The RxExample app now includes a new 'Numbers' example that demonstrates combining multiple text inputs using \Observable.combineLatest\. The example features a storyboard with three number-pad text fields and a result label, where the sum of the entered numbers is displayed in real-time via reactive bindings.

RxExample/RxExample/Examples/Numbers · high confidence

The ImagePicker example now demonstrates how to use RxSwift wrappers for UIImagePickerController. It includes a storyboard and view controller that allow users to capture photos from the camera, select images from the photo library, or crop existing images. The implementation uses \UIImagePickerController.rx.createWithParent\ to handle presentation and dismissal, binding the selected or edited image directly to an image view via reactive bindings.

RxExample/RxExample/Examples/ImagePicker · high confidence

The RxExample app now includes a new Simple Validation example that demonstrates how to validate user input in real-time using RxSwift. The example features a form with username and password fields, where validation rules (minimum length of 5 characters) are applied reactively. Validations are combined to enable or disable a 'Do something' button only when all inputs are valid, and validation status messages are displayed dynamically. This serves as a practical reference for implementing reactive form validation patterns in iOS applications.

RxExample/RxExample/Examples/SimpleValidation · high confidence

Introduces a new command-line tool that processes \.tt\ template files to generate Swift source code. The tool scans a source directory for templates, parses content between \\<%\ and \%\>\ delimiters to inject code or escape text, and writes the resulting Swift files to a derived data directory.

Preprocessor/Preprocessor · high confidence

Introduces the API implementation for the Wikipedia Image Search example, including the WikipediaAPI protocol and DefaultWikipediaAPI class which fetches search results and article content via the Wikipedia REST API. The change also adds data models for WikipediaSearchResult and WikipediaPage, utilizing RxSwift's Observable types for asynchronous data handling and JSON parsing.

RxExample/RxExample/Examples/WikipediaImageSearch/WikipediaAPI · high confidence

Introduces the \SearchResultViewModel\ for the Wikipedia Image Search example, which manages the display of search results by fetching article content to extract image URLs and generating a title string that reflects loading states or errors. The view model uses \Driver\ streams to expose the title and image URLs, handles background scheduling for API calls, and implements retry logic based on network reachability to ensure robust data fetching.

RxExample/RxExample/Examples/WikipediaImageSearch/ViewModels · high confidence

The RxExample project now includes defined Xcode schemes for the iOS app, iOS unit tests, iOS UI tests, macOS app, and macOS UI tests. These scheme files configure build, test, launch, profile, analyze, and archive actions, enabling developers to directly run, test, and build the example applications within Xcode.

RxExample/RxExample.xcodeproj/xcshareddata · high confidence

The RxCocoa library now exposes specific type aliases for table view cell lifecycle events, including \WillDisplayCellEvent\ and \DidEndDisplayingCellEvent\, which are used to define the structure of data passed when cells appear or disappear. These new event types are available for iOS, tvOS, and visionOS platforms, enabling more precise handling of cell display interactions in reactive bindings.

RxCocoa/iOS/Events · high confidence

The RxExample app now includes a suite of service implementations to demonstrate advanced reactive patterns. The ActivityIndicator service allows monitoring sequence computation states to drive UI loading indicators. The ImageService implements a two-level caching strategy (in-memory and disk) with automatic retry logic that leverages the new ReachabilityService to resume downloads when network connectivity is restored. The ReachabilityService wraps system network status changes into reactive streams, while helper types like DownloadableImage and extensions for UIImageView simplify displaying content or offline placeholders. Additional services include GeolocationService for location tracking, HtmlParsing for extracting URLs, and Wireframe for abstracting UI interactions like alerts and URL opening.

RxExample/RxExample/Services · high confidence

The GitHub sign-up example now includes a new implementation (GitHubSignupViewController2) that demonstrates using \Driver\ for text inputs and validation outputs, while switching login tap events to use \Signal\ instead of \Driver\. This provides users with a parallel reference for handling user interactions where immediate, non-replayable events (like taps) are better suited to \Signal\, contrasting with the shared, replayable nature of \Driver\ used for UI state.

RxExample/RxExample/Examples/GitHubSignup/UsingDriver · high confidence

This change introduces new reactive data source implementations for UIKit collection views, table views, and picker views within RxCocoa. For collection and table views, it adds \RxCollectionViewReactiveArrayDataSource\ and \RxTableViewReactiveArrayDataSource\, which bind sequences of items to the UI and include a workaround for an iOS 10 layout bug by invalidating the layout after reloading data. For picker views, it adds \RxPickerViewAdapter\ and related variants (string, attributed string, and custom view adapters) that allow binding item sequences to the picker component. All new data sources conform to \SectionedViewDataSourceType\ and provide \model(at:)\ accessors.

RxCocoa/iOS/DataSources · high confidence

This change introduces three new protocols—RxCollectionViewDataSourceType, RxTableViewDataSourceType, and RxPickerViewDataSourceType—within the RxCocoa iOS protocols module. These protocols mark their respective UIKit data sources (UICollectionViewDataSource, UITableViewDataSource, UIPickerViewDataSource) as reactive, enabling them to be used with bindTo methods. The protocols are conditionally compiled for iOS, tvOS, and visionOS (with UIPickerView restricted to iOS and visionOS), providing a standardized interface for observing data source events in these view types.

RxCocoa/iOS/Protocols · high confidence

The RxExample project now includes reactive wrappers for CLLocationManager and UIImagePickerController, allowing developers to observe location events (such as updates, failures, heading changes, and region monitoring) and image picker interactions (such as media selection and cancellation) as observable streams. These extensions, located in RxExample/Extensions, provide a convenient way to integrate CoreLocation and UIKit image picking functionality with the reactive programming model within example applications.

RxExample/Extensions · high confidence

Introduces new Reactive extensions for macOS UI components, enabling reactive binding and event handling for NSButton (tap events, state), NSControl (generic control events, custom property bindings), NSSlider (value), NSTextField (text, delegate proxy), NSTextView (string, delegate proxy with Swift 5.2+ compatibility fix), and NSView (alpha value binding).

RxCocoa/macOS · high confidence

The RxExample app now includes a new demonstration of a sectioned table view. This example showcases how to use RxDataSources with SectionModel to display grouped data, bind items to the table view, handle row selection via alerts, and disable the default swipe-to-delete gesture.

RxExample/RxExample/Examples/SimpleTableViewExampleSectioned · high confidence

The RxSwift library now includes the \Infallible\ trait, a new observable-like type that is guaranteed never to emit error events. This allows developers to model sequences that cannot fail, simplifying error handling in specific scenarios. The implementation provides a full suite of operators including \combineLatest\ (with arity helpers up to 8 sources and collection support), \zip\, and standard transformations like \map\, \filter\, and \distinctUntilChanged\. It also supports Swift Concurrency via an \async/await\ compatible \values\ property and offers safe subscription methods that omit error callbacks.

RxSwift/Traits/Infallible · high confidence

Adds a new AsyncSubject class that emits only the last value (and completion/error) from the source observable, providing a new way to handle final state notifications. The existing BehaviorSubject, PublishSubject, and ReplaySubject implementations are also updated with improved thread-safety locking, explicit disposal handling via the \isDisposed\ property, and synchronization tracking for debugging, ensuring more reliable concurrent access and clearer disposal semantics for users.

RxSwift/Subjects · high confidence

Adds the RxBlocking module, providing a set of blocking operators (toArray, first, last, single, and materialize) that allow developers to synchronously consume Observable sequences. This is primarily intended for unit testing and demonstration purposes, enabling synchronous verification of reactive streams without requiring asynchronous test harnesses.

RxBlocking · high confidence

Adds the foundational observer classes \ObserverBase\ and \AnonymousObserver\ to handle event dispatching and resource tracking, while introducing \TailRecursiveSink\ to optimize operators like \concat\ by preventing stack overflows and memory leaks during the processing of non-terminating sequences.

RxSwift/Observers · high confidence

This change adds the foundational \RxCocoa/Common\ components that power reactive UI bindings. It introduces \ControlTarget\ to handle UIKit and Cocoa control events, and a refactored \DelegateProxy\ system (including \DelegateProxyType\ and \SectionedViewDataSourceType\) to safely intercept and observe delegate and data source methods. Additionally, it provides new \bind(to:)\ extension methods for \Observable\ and \Infallible\ sequences, enabling direct binding to observers and relays, while also adding \TextInput\ wrappers for \UITextField\, \UITextView\, and \NSTextField\ to unify reactive text handling across platforms.

RxCocoa/Common · high confidence

Adds several new scheduler classes to the RxSwift library to provide more granular control over execution contexts. This includes ConcurrentDispatchQueueScheduler and SerialDispatchQueueScheduler for wrapping GCD queues with optional Quality of Service (QoS) and leeway settings, ConcurrentMainScheduler for optimized main-thread subscription, and OperationQueueScheduler for NSOperationQueue-based scheduling. Additionally, the update introduces VirtualTimeScheduler, HistoricalScheduler, and their associated converters to support deterministic time-based testing and simulation, along with RecursiveScheduler and SchedulePeriodicRecursive to handle recursive and periodic task scheduling patterns.

RxSwift/Schedulers · high confidence

RxCocoa introduces two new traits, ControlEvent and ControlProperty, to provide strict, type-safe abstractions for UI control interactions. ControlEvent represents one-way event streams (such as button taps) that guarantee delivery on the main scheduler, completion upon deallocation, and no errors. ControlProperty represents two-way bindings for control values (such as text fields), ensuring stateful replay of the last value, main-scheduler delivery, and safe error handling in debug builds. These traits replace ad-hoc Observable usage for UI controls, offering a more predictable and safer API for binding user interface state and events.

RxCocoa/Traits · high confidence

A new RxRelay framework has been added, providing error-safe wrappers for RxSwift subjects. This includes BehaviorRelay, PublishRelay, and ReplayRelay, which prevent termination via error or completion events. The module also introduces convenient extension methods on ObservableType to bind sequences directly to multiple relays of any type, and adds support for converting relays to Infallible sequences.

RxRelay · high confidence

This change introduces the foundational Objective-C runtime components for RxCocoa, specifically adding \\_RXDelegateProxy\, \\_RXKVOObserver\, and \\_RXObjCRuntime\. The \\_RXDelegateProxy\ provides a mechanism to intercept and forward delegate method calls, enabling reactive observation of delegate protocols without modifying original classes. The \\_RXKVOObserver\ encapsulates Key-Value Observing logic to allow reactive binding to property changes. These files establish the low-level runtime support required for RxCocoa's reactive extensions.

RxCocoa/Runtime · high confidence

The RxSwift/Concurrency module now includes a suite of new types to manage thread safety and asynchronous execution. This introduces the \AsyncLock\ class, which queues and executes actions sequentially to prevent race conditions, and establishes a foundational \Lock\ protocol backed by \RecursiveLock\ (aliased as \SpinLock\). Additionally, new protocols such as \LockOwnerType\, \SynchronizedDisposeType\, \SynchronizedOnType\, and \SynchronizedUnsubscribeType\ provide standardized, thread-safe interfaces for disposing observers and handling events, ensuring that internal state modifications are protected by locks.

RxSwift/Concurrency · high confidence

The RxDataSources library now includes a new Differentiator module that provides the core logic for computing changes between sectioned data sets. This addition introduces foundational types such as \SectionModel\ and \AnimatableSectionModel\ to represent data, along with \ItemPath\ and \Changeset\ to describe specific insertions, deletions, and moves. The \Diff\ algorithm within this module calculates these changesets by comparing section identities and item equatability, enabling efficient, animated updates for table and collection views.

RxExample/RxDataSources/Differentiator · high confidence

The RxExample application now includes two new demonstration projects: an API Wrappers example that showcases reactive bindings for standard UIKit controls (such as buttons, text fields, and switches) and CoreLocation, and a Wikipedia Image Search example that demonstrates searching Wikipedia and displaying results in a table view.

RxExample/RxExample/Examples/APIWrappers · high confidence

The RxExample app now includes a Calculator demo that showcases reactive state management using a feedback loop pattern. The implementation features a \CalculatorState\ enum to track operands and operators, a \CalculatorCommand\ enum for user inputs, and a \CalculatorViewController\ that binds UI button taps to state transitions via \Observable.system\. This example demonstrates how to manage complex UI state and user interactions in a functional reactive way.

RxExample/RxExample/Examples/Calculator · high confidence

A new playground page has been added to demonstrate RxSwift combining operators, including startWith, merge, zip, combineLatest, switchLatest, and withLatestFrom. The page provides interactive examples for each operator, showing how to combine multiple observable sequences into a single output.

_Rx.playground/Pages/Combining\Operators.xcplaygroundpage · high confidence

The RxExample app now includes a Geolocation example that demonstrates how to track device location using CoreLocation and bind the results to the UI. The example features a view controller that displays latitude and longitude coordinates, handles cases where geolocation is disabled by showing a specific view, and provides buttons to open the app's system preferences. This serves as a practical reference for implementing location-based reactive bindings in iOS applications.

RxExample/RxExample/Examples/GeolocationExample · high confidence

The GitHubSignup example now includes two distinct implementations for signing up on GitHub: one using vanilla RxSwift observables and another using the Driver abstraction. This addition is accompanied by supporting infrastructure, including new protocols for API and validation services, default implementations for these services, and custom binding extensions to simplify UI updates for validation results.

RxExample/RxExample/Examples/GitHubSignup · high confidence

The RxExample app now includes a new demonstration located at \UsingVanillaObservables\ that shows how to implement a GitHub sign-in flow using standard RxSwift observables rather than Driver types. This example features a view model (\GithubSignupViewModel1\) that transforms input sequences (username, password, login taps) into output observables (validation results, sign-in status) and a corresponding view controller (\GitHubSignupViewController1\) that binds these outputs to UI elements like text fields and buttons, illustrating a reactive MVVM pattern without explicit state management.

RxExample/RxExample/Examples/GitHubSignup/UsingVanillaObservables · high confidence

The RxExample app now includes a new 'Partial Updates' example that showcases reactive data binding for UITableView and UICollectionView. This example demonstrates how to use RxDataSources to handle both animated partial updates and full reloads, featuring a UI with two side-by-side tables and a collection view to visualize the differences in update behaviors.

RxExample/RxExample/Examples/TableViewPartialUpdates · high confidence

RxCocoa introduces the \Signal\ trait, a specialized observable type that guarantees no errors, delivers events on the main thread, and uses a reference-counted sharing strategy. This change adds \asSignal()\ extension methods to \ControlEvent\, \ObservableConvertibleType\, and \PublishRelay\, allowing developers to easily convert UI control events and other observables into this safer, main-thread-bound trait. Additionally, the \Signal\ type now supports emitting values directly to multiple observers or relay instances via new \emit\ overloads, simplifying subscription patterns for UI state propagation.

RxCocoa/Traits/Signal · high confidence

A new SupportCode.swift file has been added to the Rx.playground/Sources directory, providing shared utilities for the playground examples. This includes an \example\ function to wrap and print headers for code snippets, a \delay\ helper for asynchronous execution on the main thread, and a \playgroundShouldContinueIndefinitely\ function that configures the playground to run indefinitely when executed in an Xcode playground environment.

Rx.playground/Sources · high confidence

The repository now includes a comprehensive suite of shell and Swift scripts to standardize local development and CI workflows. \scripts/all-tests.sh\ provides a unified entry point to run tests across iOS, macOS, tvOS, watchOS, visionOS, and Linux, with support for specific targets like SPM and Mac Catalyst. \scripts/common.sh\ handles simulator management, Xcode version detection, and build execution. New packaging scripts (\make-xcframeworks.sh\, \package-spm.swift\) automate the creation of multi-platform xcframeworks and Swift Package Manager source structures. Quality assurance is enforced via \validate-headers.swift\ for code style, \validate-markdown.sh\ for documentation links, and \validate-playgrounds.sh\ for playground validation, while \update-jazzy-config.rb\ and \update-jazzy-docs.sh\ streamline documentation generation.

scripts · high confidence

RxCocoa now provides reactive proxy classes for a wider range of UIKit components, enabling you to observe and bind delegate and data source events for \UICollectionView\, \UITableView\, \UIPickerView\, \UISearchBar\, \UISearchController\, \UITabBar\, \UITabBarController\, \UINavigationController\, \NSTextStorage\, and \WKWebView\. This includes new support for the iOS 10+ prefetching data source protocols on tables and collections, as well as reactive wrappers for navigation controller and web view delegate methods.

RxCocoa/iOS/Proxies · high confidence

RxCocoa adds reactive extensions for a wide range of UIKit components, enabling users to bind properties and observe events using the reactive paradigm. New features include \isAnimating\ for UIActivityIndicatorView, \isNetworkActivityIndicatorVisible\ and lifecycle notification wrappers (e.g., \didEnterBackground\) for UIApplication, \tap\ for UIBarButtonItem and UIButton, and \primaryAction\ for UIButton on tvOS. The update also introduces \items\ binding and delegate wrappers for UICollectionView and UIPickerView, \controlEvent\ and \controlProperty\ helpers for UIControl, and reactive wrappers for UIDatePicker, UIGestureRecognizer, UINavigationController, UIRefreshControl, UIScrollView, UISearchBar, UISearchController, UISegmentedControl, UISlider, UIStepper, UISwitch, UITabBar, and UITabBarController. Additionally, NSTextStorage now exposes a delegate wrapper for text editing events.

RxCocoa/iOS · high confidence

A new macOS command-line tool named 'Preprocessor' has been added to the project. Built with Swift 5.0 and targeting macOS 10.13, this utility is packaged as a standalone executable (tool product type) rather than a framework or iOS app, providing a dedicated command-line interface for preprocessor functionality.

Preprocessor/Preprocessor.xcodeproj · high confidence

This release introduces RxDataSources version 3.0.0, providing reactive, sectioned data sources for iOS and tvOS table and collection views. The library adds \TableViewSectionedDataSource\ and \CollectionViewSectionedDataSource\ for static data binding, along with \RxTableViewSectionedAnimatedDataSource\ and \RxCollectionViewSectionedAnimatedDataSource\ to handle animated insertions, deletions, and moves. It includes a configurable \AnimationConfiguration\ struct, reactive \UIPickerView\ adapters, and extensions to make \Int\, \String\, \Float\, and \Double\ types identifiable for use in sectioned views.

RxExample/RxDataSources/RxDataSources · high confidence

This change introduces the foundational types and core behaviors for the RxSwift reactive library. It establishes the core reactive primitives, including the \Observable\ and \Observer\ protocols, the \Event\ enum for sequence events, and the \Disposable\ system for resource management. It adds the \Binder\ type to enforce safe UI binding rules, such as preventing error propagation and ensuring main-thread execution. The update also introduces Swift Concurrency support, allowing developers to bridge RxSwift sequences with modern \async/await\ patterns via \AsyncThrowingStream\ and \AsyncSequence\. Additionally, it provides global hooks for error handling and subscription callstack recording, and implements the \GroupedObservable\ type to support the \groupBy\ operator.

RxSwift · high confidence

This change introduces the RxTest framework, providing the core components for testing reactive sequences. It adds \ColdObservable\ and \HotObservable\ to simulate observable streams, \TestableObserver\ to capture emitted events, and \Recorded\ structs to timestamp values. The framework also includes \XCTest\ extensions with \XCTAssertEqual\ overloads for comparing event sequences (including \SingleEvent\, \MaybeEvent\, and \CompletableEvent\) and factory methods in \Recorded+Event.swift\ to simplify creating test data.

RxTest · high confidence

This change introduces the SharedSequence trait in RxCocoa, providing a type-safe observable sequence that never fails and delivers events on a customizable scheduler. It includes core operators (map, filter, compactMap, zip, combineLatest), conversion methods (asSharedSequence), and a new async/await bridge (values property) for Swift Concurrency, enabling seamless integration with modern async code.

RxCocoa/Traits/SharedSequence · high confidence

The Rx framework's umbrella header (Rx.h) has been removed. This file previously served as the central import point for the framework's public API, exposing version information and aggregating public headers. Its deletion indicates a structural change to how the framework is consumed or distributed, likely requiring consumers to import specific sub-headers directly rather than relying on a single umbrella file.

Rx · high confidence

The Rx.xcworkspace has been reorganized to support the new Swift Package Manager integration by referencing Package.swift and consolidating the project structure. It now includes the main Rx.xcodeproj, a Preprocessor project, and the RxExample project, while also organizing documentation and build scripts into dedicated groups within the workspace.

Rx.xcworkspace · high confidence

The library now includes a new SwiftSupport.swift file that defines type aliases and extensions specifically for Swift 4, such as mapping IntMax to Int64 and RxAbstractInteger to FixedWidthInteger, while adding a toIntMax() helper for signed integers. This change enables the library to compile and function correctly on Swift 4, replacing previous Swift 3.0-specific compiler conditionals.

RxSwift/SwiftSupport · high confidence

The RxRelay module now includes a PrivacyInfo.xcprivacy file declaring no data tracking or collection, satisfying Apple's privacy requirements. Additionally, several source files (BehaviorRelay, Observable+Bind, PublishRelay, ReplayRelay, Utils) have been converted to symbolic links pointing to ../../RxRelay/, indicating a restructuring of the source layout.

Sources/RxRelay · high confidence

A new \Dependencies.swift\ file has been added to the Examples directory to consolidate service instantiation for the example app. This singleton class provides shared access to core components including a \URLSession\, a \MainScheduler\, a background work scheduler backed by an \OperationQueue\, a \Wireframe\, and a \ReachabilityService\. This change simplifies how these services are accessed within the example code, moving them from scattered locations into a single, centralized location for easier management and demonstration of RxSwift patterns.

RxExample/RxExample/Examples · high confidence

The core data structure implementations (Bag, InfiniteSequence, PriorityQueue, and Queue) have been moved from the RxSwift module to the Platform module. This change updates the internal file organization and import paths, ensuring these foundational utilities are now sourced from the Platform layer rather than the main RxSwift namespace.

RxSwift/Platform/DataStructures · high confidence

The \Driver\ trait in RxCocoa has been updated to allow subscribing to multiple observers, \BehaviorRelay\, and \ReplayRelay\ instances in a single call via the \drive\ method family. This change simplifies binding logic by enabling developers to push events to several targets simultaneously without manual iteration or separate subscription calls, while maintaining the requirement that these operations occur on the main thread.

RxCocoa/Traits/Driver · high confidence

Adds the internal Objective-C runtime support headers (\_RX.h, \_RXDelegateProxy.h, \_RXKVOObserver.h, \_RXObjCRuntime.h) and the main RxCocoaRuntime.h umbrella header to the public include directory. These headers expose the low-level mechanisms for delegate proxying, KVO observation, and method swizzling that the RxCocoa library relies on to bridge UIKit and RxSwift.

Sources/RxCocoaRuntime/include · high confidence

The \RxSwift/Disposables\ module has been restructured to introduce a suite of new disposable implementations, including \AnonymousDisposable\, \BinaryDisposable\, \BooleanDisposable\, \CompositeDisposable\, \RefCountDisposable\, \ScheduledDisposable\, \SerialDisposable\, \SingleAssignmentDisposable\, and \SubscriptionDisposable\. These types are now accessed via a centralized \Disposables\ utility struct, which provides static factory methods (e.g., \Disposables.create()\, \Disposables.create(with:)\, \Disposables.create(\:\:)\) for constructing disposables, replacing previous instance-based or scattered initialization patterns. \DisposeBag\ has been updated to support these new types and includes convenience initializers for variadic disposables and arrays, along with a function builder for cleaner syntax.

RxSwift/Disposables · high confidence

The Bag implementation now uses a specialized, inlined dispatch function that optimizes the common case where only a single observer is registered, avoiding unnecessary loop iterations. This change improves performance for event emission and disposal operations by reducing overhead in the most frequent execution path.

RxSwift/Extensions · high confidence

The Platform module now provides a unified abstraction for low-level concurrency and threading operations across supported operating systems. It introduces AtomicInt, a lock-based atomic integer implementation that ensures thread safety and conforms to Sendable, replacing previous atomic dependencies. RecursiveLock is abstracted to use NSRecursiveLock directly, with optional resource tracking enabled via TRACE\_RESOURCES. Thread-local storage access is platform-specific: Darwin systems use the threadDictionary via CoreFoundation, while Linux uses the Foundation threadDictionary. Additionally, DispatchQueue extensions provide a reliable method to detect the main thread using DispatchSpecificKey, improving dispatch queue detection logic.

Platform · high confidence

The files in the RxSwift/Platform directory have been converted into symbolic links pointing to their counterparts in the parent Platform directory. This structural change unifies the platform-specific implementations (such as Darwin and Linux variants) and atomic operations, ensuring that the codebase uses a single source of truth for these core platform utilities rather than maintaining separate copies in each location.

RxSwift/Platform · high confidence

The Rx.playground workspace has been restructured to explicitly define its page order and enable rendered markup output. The contents.xcplayground file now lists specific operator pages (such as Combining, Transforming, Filtering, and separate Error Handling and Debugging pages) and sets the display mode to 'rendered' with 'buildActiveScheme' enabled, ensuring that users see live, rendered documentation and code execution results when opening the playground.

Rx.playground · high confidence

The RxExample/Playgrounds location now includes an Info.plist with package type FMWK and a Swift source file that explicitly exports RxSwift via @\_exported import. This change addresses previous issues with playgrounds when using a wrapping dynamic framework, ensuring the necessary module visibility for the playground environment.

RxExample/Playgrounds · high confidence

The PrimitiveSequence traits in RxSwift now integrate with Swift's modern concurrency model and update their public API for consistency. Users can now bridge Single, Maybe, and Completable sequences to async/await using new \create\ factory methods and \value\ async properties, allowing seamless interoperability with structured concurrency. Additionally, the library modernizes its method signatures to follow Swift naming conventions (e.g., \subscribe(on:)\ replaces \subscribeOn\, \catch(\:)\ replaces \catchError(\:)\) and introduces a new \andThen\ operator on Completable to chain subsequent sequences. These changes also include stricter type safety, such as marking event enums as \@frozen\ and migrating Single's error handling to use Foundation's \Result\ type.

RxSwift/Traits/PrimitiveSequence · high confidence

The files in Sources/RxBlocking have been converted from standalone source files to symbolic links pointing to their counterparts in the parent RxBlocking directory. This structural change consolidates the implementation, meaning updates to the core blocking observables, operators, and platform-specific primitives (such as AtomicInt, RecursiveLock, and RunLoopLock) in the shared location will automatically apply to this module, ensuring consistency across the library.

Sources/RxBlocking · high confidence

The Rx playground's navigation structure has been updated to improve logical flow and clarity. Combining Operators and Transforming Operators have been reordered, with Combining Operators now appearing before Transforming Operators. Filtering and Conditional Operators have been merged into a single entry, while Error Handling and Debugging Operators have been split into distinct pages for better separation of concerns.

_Rx.playground/Pages/Table\_of\Contents.xcplaygroundpage · high confidence

The internal scheduler implementation in RxSwift has been rewritten to use \DispatchSource\ timers instead of the previous approach, introducing new internal types like \DispatchQueueConfiguration\, \InvocableType\, and \ScheduledItem\. This change addresses scheduler stability issues introduced in Swift 3.0 and libdispatch updates, ensuring that scheduled tasks (relative and periodic) are correctly managed and cancelled without leaking references or failing to fire.

RxSwift/Schedulers/Internal · high confidence

The RxCocoa framework bundle now includes an explicit Info.plist and umbrella header (RxCocoa.h) to define bundle metadata and import core internal headers (\_RX.h, etc.). The RxCocoa.swift module entry point explicitly exports the RxRelay module, making Relay functionality available to consumers importing RxCocoa. It also initializes the RxCocoaError enum with specific cases (such as invalidOperation, castingError, and errorDuringSwizzling) and provides their debug descriptions, establishing the foundation for error reporting in UI bindings.

RxCocoa · high confidence

The RxCocoa runtime headers have been reorganized into a new public umbrella header (RxCocoaRuntime.h) and several private implementation headers (\_RX.h, \_RXDelegateProxy.h, \_RXKVOObserver.h, \_RXObjCRuntime.h). This change introduces a new error-handling macro, RX\_THROW\_ERROR, replacing the previous RX\_SAFE\_ERROR, and adds conditional compilation support via DISABLE\_SWIZZLING to control Objective-C runtime swizzling behavior. The delegate proxy interface is also refined with new methods for managing selector wiring and message forwarding.

RxCocoa/Runtime/include · high confidence

The RxCocoa source directory has been restructured so that most files are now symbolic links pointing to their actual locations within the RxCocoa module (e.g., under Traits, iOS, macOS, or Common subdirectories), rather than being standalone source files. This change consolidates the physical file layout while maintaining the public API surface. Additionally, a \PrivacyInfo.xcprivacy\ file has been added to the module to declare that no private data is tracked or collected, ensuring compliance with modern App Store privacy requirements.

Sources/RxCocoa · high confidence

The RxExample application has been reorganized to support both iOS and macOS platforms, featuring separate Info.plist configurations and platform-specific type aliases for application and view controller classes. A new feedback loop system has been introduced, providing \react\ and \system\ helper functions that allow examples to manage state and effects using observable sequences, alongside utility extensions for application state detection and two-way binding operators that properly handle text input marked states.

RxExample/RxExample · high confidence

The RxExample iOS application has been restructured to provide a cleaner entry point and improved developer experience. A new AppDelegate now registers the RxImagePickerDelegateProxy and, in debug builds, periodically prints resource usage statistics to stdout to aid in leak detection. The app's navigation has been modernized by introducing a BaseNavigationController that programmatically configures UINavigationBar appearances for iOS 13+, replacing previous storyboard-based styling. The main interface is now driven by a new Main.storyboard and RootViewController, which serves as the central hub for various examples including GitHub signup, validation, and geolocation subscriptions.

RxExample/RxExample/iOS · high confidence

The RxExample project configuration file has been updated to register a comprehensive set of example source files, view controllers, storyboards, and resources. This includes specific examples for GitHub search and signup, calculator, geolocation, image picker, and table/collection view data sources, along with their associated assets and framework dependencies (RxSwift, RxCocoa, RxTest).

RxExample/RxExample.xcodeproj · high confidence

The RxSwift/Observables module introduces several new operators including \compactMap\, \asSingle\, \asMaybe\, \amb\, \debounce\, and \buffer(timeSpan:count:scheduler:)\, while also adding \withUnretained\ for \ObservableType\ and \SharedSequence\. Existing APIs have been renamed to follow modern Swift conventions, such as \catchErrorJustReturn\ to \catchAndReturn\, \catchError\ to \catch\, \elementAt\ to \element(at)\, \subscribeOn\ to \subscribe(on)\, and \observeOn\ to \observe(on)\. The \shareReplayLatestWhileConnected\ and \shareReplay\ operators are deprecated in favor of the new \share(replay:scope:)\ operator. Additionally, the module includes fixes for deadlocks in \merge\ and \share\ operators, improvements to \refCount\ for synchronous resubscribing, and a migration from \RxAtomic\ to \NSLock\ for atomic operations.

RxSwift/Observables · high confidence

The Sources/RxSwift directory has been restructured to use symbolic links pointing to implementation files in subdirectories (such as Observables, Schedulers, Disposables, and Traits), simplifying the module's public interface. Additionally, a PrivacyInfo.xcprivacy file has been added to declare that no data collection or tracking APIs are used, ensuring compliance with modern iOS privacy requirements.

Sources/RxSwift · high confidence

The RxTest module has been restructured to support Swift Package Manager by converting source files into symbolic links that point to their original locations within the RxTest directory tree. This change aligns the module layout with SPM requirements without altering the underlying implementation logic, ensuring the test utilities remain accessible while improving build system compatibility.

Sources/RxTest · high confidence

The TestScheduler API has been updated to support Swift 4 and modernize its interface. The \start\ method family now accepts explicit \created\, \subscribed\, and \disposed\ virtual time parameters, replacing older signatures that relied on implicit defaults or fewer arguments. Additionally, time-related APIs have migrated from \Foundation.TimeInterval\ to \DispatchTimeInterval\ for better consistency with Swift concurrency primitives, and internal types like \NSDate\ have been renamed to \Date\.

RxTest/Schedulers · high confidence

The SimpleTableViewExample now demonstrates a more concise API for populating table views by passing the cell type directly to \rx.items(cellIdentifier:cellType:)\, removing the need for separate cell registration logic. Additionally, the example showcases the new \itemAccessoryButtonTapped\ observable, allowing users to easily handle taps on the accessory button (such as the detail disclosure button) within the table view cells.

RxExample/RxExample/Examples/SimpleTableViewExample · high confidence

The repository now includes standardized configuration files to ensure consistent code formatting, linting, and development workflows. A \.editorconfig\ file enforces indentation and whitespace rules, while \.swiftformat\ and \.swiftlint.yml\ define code style and static analysis constraints. Tooling versions are pinned via \.ruby-version\ (3.3.0) and \.swift-version\ (6.1), and a \mise.toml\ file manages development dependencies like \swiftformat\ and \xcbeautify\. Additionally, a \Dangerfile\ automates pull request checks for changelog entries and branch targeting, and a \Makefile\ provides a convenient command for running the formatter.

(repo-wide) · high confidence

The Debugging Operators playground page has been updated to use the current RxSwift API, specifically replacing the deprecated \NopDisposable.instance\ with \Disposables.create()\ and referencing \RxSwift.Resources.total\ instead of the old \resourceCount\ property. This ensures the debugging examples for operators like \debug\ and resource tracking compile and run correctly with the latest framework version.

_Rx.playground/Pages/Debugging\_Operators.xcplaygroundpage, Rx.playground/Pages/Filtering\_and\_Conditional\Operators.xcplaygroundpage · high confidence

The Xcode project schemes in Rx.xcodeproj have been regenerated to support Xcode 12.5 and update the iOS deployment target to version 9. This change ensures that the build, test, and launch configurations for frameworks like RxSwift, RxCocoa, and RxRelay, as well as the platform-specific test suites (iOS, macOS, tvOS), are correctly configured for the newer toolchain and minimum OS requirements.

Rx.xcodeproj/xcshareddata/xcschemes · high confidence

The 'Working with Subjects' playground page has been updated to align with the 3.0.0.alpha.1 API changes. This includes removing the deprecated \Variable\ type and replacing the old Disposable API with the new \DisposeBag\ pattern. The examples for \PublishSubject\, \ReplaySubject\, and \BehaviorSubject\ now demonstrate the current observer subscription methods and event handling conventions.

_Rx.playground/Pages/Working\_with\Subjects.xcplaygroundpage · high confidence

The Wikipedia Image Search example in the RxExample app has been updated to use modern RxSwift and RxCocoa APIs, replacing older patterns with \rx.items(cellIdentifier:cellType:)\ for table view population and \rx.modelSelected\ for row selection. The view controllers and cells now explicitly manage memory using \DisposeBag\s and handle network errors gracefully by using a reachability service to display placeholders when connectivity is lost, ensuring a more robust user experience during image loading.

RxExample/RxExample/Examples/WikipediaImageSearch/Views · high confidence

The Rx.xcodeproj project file has been updated to object version 55, reflecting changes in the Xcode project schema. The workspace configuration now includes an IDEWorkspaceChecks.plist file to manage workspace state. The project file itself has been significantly expanded to include build file references for a wide range of new and existing source files, including AsyncSubject, Infallible types, various UI extensions (WKWebView, UIPickerView, UISearchController, etc.), and their corresponding test files, indicating a substantial addition of source code and test coverage within this project location.

Rx.xcodeproj · high confidence

The macOS introduction example has been updated to use the new \bind(to:)\ API instead of the deprecated \bindTo\, and now utilizes \NSTextView.string\ extensions for two-way binding between text views and a relay. The example also demonstrates combining text inputs for calculation and speech synthesis, ensuring the UI reflects the latest RxSwift/RxCocoa API conventions.

RxExample/RxExample/Examples/macOS simple example · high confidence

Added the IDEWorkspaceChecks.plist file to the workspace shared data to configure Xcode workspace settings, specifically enabling the IDEDidComputeMac32BitWarning flag to manage 32-bit architecture warnings.

Rx.xcworkspace/xcshareddata · high confidence

Added UI automation tests for the RxExample app; Added blocking tests for Observable operators; Added macOS UI test suite; Added micro-optimization benchmarking tools; Added performance benchmarks for RxSwift subjects and operators; Added test mock for sectioned view data sources; Added test mock implementations for RxSwift observables and subjects; Added test symlinks for Platform module components; Added tests for Relay binding and ReplayRelay behavior; Added unit tests for RxCocoa core components and delegate proxies; Adds mock implementations and test utilities for the RxExample iOS app; Adds test helper utilities and virtual scheduler implementation; Adds unit tests for location and image picker extensions; Establishes RxTest test infrastructure and utilities; Expanded test coverage for RxSwift core primitives and concurrency safety; Unified test runner for Swift Package Manager integration; Updated performance test baselines for benchmark regression detection.

This change introduces official Swift Package Manager (SPM) support via a new Package.swift file, defining libraries such as RxSwift, RxRelay, RxBlocking, and RxTest with dynamic variants, while restricting RxCocoa to Darwin platforms. It also adds a Gemfile and Gemfile.lock to integrate the Danger gem for CI automation, establishing the foundational build and dependency infrastructure for the project.

(dependencies) · high confidence

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

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

• Code Health 90
• Architecture 99
• Maturity 59
• Readiness 55
• Security 96
• Domain Modelling 88

• 300 commits — 236 feature/other, 64 fixes

• (root) — 80 commits
• RxSwift/Observables — 20 commits
• RxSwift/Traits — 19 commits
• Tests/RxSwiftTests — 18 commits
• Rx.xcodeproj/project.pbxproj — 16 commits
• docs/Classes — 15 commits
• .github/workflows — 12 commits
• RxCocoa/Traits — 10 commits
• RxCocoa/iOS — 9 commits
• Sources/AllTestz — 9 commits
• Documentation/GettingStarted.md — 6 commits
• RxSwift/Observable+Concurrency.swift — 6 commits
• RxSwift/Schedulers — 6 commits
• Rx.xcodeproj/xcshareddata — 5 commits
• RxCocoa/Common — 5 commits
• RxExample/RxExample — 5 commits
• Documentation/SwiftConcurrency.md — 4 commits
• Rx.playground/Pages — 4 commits
• RxCocoa/Foundation — 4 commits
• Tests/RxCocoaTests — 4 commits

• fix: 6.7.0 Spec Fixes
• fix: Add regression test for the merge lock-inversion deadlock
• fix: Add regression tests for the ReplaySubject, Connection and Zip lock-inversion deadlocks
• fix: Disposal fixes and AsyncSequence bridging
• fix: Fix AsyncSequence.asObservable() to always use Task.detached
• fix: Fix CI (#2518)
• fix: Fix CI for Xcode 15.3 & iOS 17
• fix: Fix DelegateProxy crash by implementing methodSignatureForSelector (#2546)
• fix: Fix Infallible CombineLatest arity helpers (#2520)
• fix: Fix Observable values terminal race (#2728)
• fix: Fix Podspec workflow
• fix: Fix RxExample warnings
• fix: Fix SPM tests
• fix: Fix Swift 6.2 weak mutability warning in Binder (#2677)
• fix: Fix SwiftLint build phase warning (#2490)
• fix: Fix Xcode 12 test failures
• fix: Fix build issue for watchOS
• fix: Fix carthage setting of readme
• fix: Fix compilation for < Swift 6.2, add CI for Xcode 16 (#2688)
• fix: Fix concurrent share subscriptions (#2719)
• …and 280 more

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

ReactiveX/RxSwift 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.