How to handle async operations in Verge?

Use the TaskManager in Store with task(key:mode:) for async operations, supporting modes like .dropCurrent to manage concurrent tasks efficiently. This avoids blocking the main thread and integrates seamlessly with state updates.

Verge vs TCA: which is better for SwiftUI?

Verge offers more flexibility with its store-pattern and concurrent processing, ideal for performance-critical apps, while TCA provides a more opinionated, testable architecture. Choose Verge for scalability with UIKit/SwiftUI hybrid apps, or TCA for pure SwiftUI projects with strict action/reducer patterns.

Can Verge be used with Combine?

Yes, Verge integrates with Combine through sinkState for state observation and can complement Combine streams, but it does not depend on Combine for core functionality, focusing instead on its own unidirectional flow.

What are the performance implications of using Verge in large apps?

Verge is designed for high performance with features like concurrent processing and Derived properties to minimize updates, but managing multiple stores can add complexity. For very large apps, the ORM helps, but improper store splitting may lead to overhead.

How to migrate from Redux to Verge in Swift?

Start by defining state with @Tracking macro and using commit for mutations, similar to Redux reducers. Verge's unidirectional flow eases migration, but you'll need to adapt action patterns since Verge doesn't enforce them, potentially building custom layers.

Is Verge suitable for small projects?

While Verge can work for small projects, its advanced features like ORM and concurrent processing may be overkill; simpler solutions like @State in SwiftUI or basic Combine publishers are often more appropriate without the learning curve.

Open-Awesome

Verge

MITSwift14.1.2

A robust Swift state-management framework for iOS (UIKit/SwiftUI) with an integrated ORM for complex applications.

Visit Website GitHub

800 stars40 forks0 contributors

What is Verge?

Verge is a Swift state-management framework designed for complex iOS applications, offering a store-pattern approach with an integrated ORM for efficient data handling. It simplifies managing application state by providing a lightweight, performant solution that supports both UIKit and SwiftUI, eliminating the need for complex actions and reducers.

Target Audience

iOS developers building large-scale, business-focused applications who need a scalable state management solution that works seamlessly with both UIKit and SwiftUI.

Value Proposition

Developers choose Verge for its high performance, support for concurrent processing, and built-in ORM capabilities, which make it ideal for managing complex state in real-world applications without the overhead of more rigid architectures.

Overview

🟣 A robust Swift state-management framework designed for complex applications, featuring an integrated ORM for efficient data handling.

Use Cases

Best For

Building large-scale iOS applications with complex state management needs
Managing asynchronous operations efficiently in SwiftUI or UIKit apps
Handling a large number of entities with normalized data structures
Implementing unidirectional data flow in iOS projects without heavy boilerplate
Integrating state management across both UIKit and SwiftUI in the same app
Optimizing performance in event-driven iOS applications with concurrent processing

Not Ideal For

Projects requiring a fully stable, mature library without upcoming breaking changes
Teams that prefer an opinionated architecture with built-in action/reducer patterns like TCA
Simple iOS apps where SwiftUI's native @State or Combine would suffice without added complexity
Developers who want minimal dependencies and avoid integrating external ORM or normalization libraries

Pros & Cons

Pros

Unidirectional Data Flow

Inspired by Flux/Redux, it provides a single source of truth for state, simplifying management in complex apps without enforcing rigid action patterns.

Concurrent Processing Support

Built-in multi-threading ensures fast and safe operations, with TaskManager for efficient async task handling using keys and modes like .dropCurrent.

Integrated ORM for Entities

Includes normalization techniques via VergeNormalizationDerived to manage large numbers of entities efficiently, reducing overhead in data-heavy applications.

Cross-Platform UI Compatibility

Seamlessly works with both SwiftUI (using StoreReader or @Reading) and UIKit (via sinkState and ifChanged), supporting hybrid app development.

Efficient Derived Properties

Derived feature, inspired by reselect, minimizes unnecessary updates by computing properties only when state changes, optimizing performance.

Cons

Transitional Instability

The library is stabilizing and transitioning to swift-state-graph, leading to potential breaking changes and migration efforts for long-term projects.

Lack of Built-in Action Structure

Does not dictate action management, requiring developers to implement their own layers for structured state handling, which can increase initial setup complexity.

Dependency Overhead

Relies on external packages like TypedIdentifier and Normalization, adding to the project's dependency footprint and potential integration challenges.

Frequently Asked Questions

Related Projects

RxSwift

Reactive Programming in Swift

Stars24,650

Forks4,165

Last commit26 days ago

ReactiveCocoa

Cocoa framework and Obj-C dynamism bindings for ReactiveSwift.

Stars19,848

Forks3,421

Last commit7 months ago

ReSwift

Unidirectional Data Flow in Swift - Inspired by Redux

Stars7,590

Forks520

Last commit2 years ago

JASONETTE-iOS

📡 Native App over HTTP, on iOS

Stars5,231

Forks350

Last commit3 years ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub