🇺🇸English

Modern Swift (6.2+)

Swift 6.2 introduces strict compile-time concurrency checking with async/await, actors, and Sendable constraints that prevent data races at compile time instead of runtime. This is the foundation of safe concurrent Swift.

Overview

Modern Swift replaces older concurrency patterns (completion handlers, DispatchQueue, locks) with compiler-enforced safety. The core principle: if it compiles with strict concurrency enabled, it cannot have data races.

Quick Reference

Core Workflow

When writing async Swift code:

1. Mark async functions with async, call with await
2. Apply @MainActor to view models and UI-updating code
3. Use actor instead of locks for shared mutable state
4. Check Task.isCancelled or call Task.checkCancellation() in loops
5. Enable strict concurrency in Package.swift for compile-time safety

Reference Loading Guide

ALWAYS load reference files if there is even a small chance the content may be required. It's better to have the context than to miss a pattern or make a mistake.

Common Mistakes

1. @unchecked Sendable as a quick fix — Using @unchecked Sendable to silence compiler errors means you've opted out of safety. If the error persists after @unchecked, your code has a potential data race. Fix the underlying issue instead.

2. Missingawait at call sites — Forgetting await when calling async functions is a compiler error, but checking Task.isCancelled in a loop without calling Task.checkCancellation() silently ignores cancellation.

3. Capturingself in async blocks without weak — Holding a strong reference to in a long-running async task prevents deinit. Always use in closures or use which auto-manages the lifecycle.

Weekly Installs

60

Repository

johnrogers/clau…ineering

GitHub Stars

180

First Seen

Jan 23, 2026

Security Audits

Gen Agent Trust HubPassSocketPassSnykPass

Installed on

codex47

opencode45

claude-code42

gemini-cli41

github-copilot40

cursor36