axiom-swift-concurrency

Fix Swift data races by implementing actor isolation to synchronize concurrent access to shared mutable state. Actors ensure data access is properly isolated, preventing crashes and maintaining thread-safe code execution without manual locking mechanisms.

Async/await in Swift enables non-blocking operations by suspending execution until asynchronous tasks complete. This pattern replaces completion handlers, allowing sequential code structure while maintaining responsive main threads and preventing main thread blocking.

Use @MainActor to ensure UI updates are thread-safe when performing operations that modify interface elements. It guarantees execution on the main thread, preventing concurrent access violations and ensuring user interface changes happen safely without blocking.

Progressively adopt Swift strict concurrency by incrementally introducing Sendable types, actor isolation, and async/await. This approach allows converting single-threaded code to concurrent execution while addressing data races and actor isolation errors systematically.

Swift requires Sendable types for concurrent code to guarantee thread-safe data passing across actor boundaries. Sendable conformance verifies types can be safely shared between concurrent execution contexts without introducing data races.

Yes, you can resolve actor isolation errors progressively without a full rewrite. The Skill provides solutions for incremental adoption, allowing you to isolate specific shared mutable state and adopt async/await locally while maintaining existing architecture.