New framework for Swift gains popularity among iOS developers

New framework for Swift (iOS/macOS) gains popularity

The Swift ecosystem continues to actively develop, and a new player has appeared on the horizon that is rapidly capturing the attention of iOS/macOS developers. We are talking about the SwiftAct framework (a conditional name, for example — ed.), which promises to simplify the creation of reactive and high-performance applications for all Apple platforms. According to recent community surveys, interest in this tool has grown by 40% over the last three months, and the number of projects on GitHub using it has doubled.

What is SwiftAct and why is it needed?

SwiftAct is positioned as a lightweight alternative to Combine and partially RxSwift, but with a focus on asynchrony and clean architecture. Unlike traditional approaches, this framework uses the latest Swift Concurrency features (async/await, actors) out of the box, without requiring the developer to write boilerplate code for thread management.

Key features of SwiftAct:

• Reactivity without pain: Automatic subscription to model state changes. The developer only needs to mark a property with the @Observable attribute, and the UI in SwiftUI will update itself.
• Built-in networking: The Networking module supports async/await, automatic serialization into Codable, and request retries on errors.
• Modularity: The framework is split into independent modules (Core, UI, Networking, Storage) that can be selectively included without bloating the binary.
• macOS support: Unlike many iOS-oriented solutions, SwiftAct is fully compatible with AppKit and Catalyst.

Why are developers switching to it?

The main reason is lowering the entry barrier. Previously, creating a reactive application required learning Combine (with its complex Publisher/Subscriber system) or integrating the heavy RxSwift, whereas SwiftAct offers an intuitive syntax reminiscent of working with regular properties.

Here is an example provided by one enthusiast blogger:

// Old approach with Combineclass ViewModel {    @Published var text = ""    var cancellables = Set<AnyCancellable>()        func fetch() {        api.fetchText()            .sink { [weak self] value in                self?.text = value            }            .store(in: &cancellables)    }}

// New approach with SwiftActclass ViewModel {    @Observable var text = ""        func fetch() async {        text = await api.fetchText()  // simple and clear    }}

As you can see, the code has become more concise, and memory management and unsubscription from streams happen automatically.

Disadvantages and risks

Despite the enthusiasm, experts warn: the framework is still young. Version 1.0 was released only six months ago, and the community has not yet built up an extensive knowledge base. Critical bugs may occur when working with multithreading in complex projects. Additionally, for production projects with strict stability requirements, it is still recommended to stick with Combine or TCA (The Composable Architecture).

Prospects

Nevertheless, the trend is obvious: developers are tired of complexity and want to write less code while getting more functionality. SwiftAct has already been adopted by large companies such as (conditionally) "Yandex.Maps" and "Tinkoff" (in pilot projects), which speaks to trust in the technology