Swift 6.0 enterprise development featuring modern concurrency with async/await, SwiftUI for declarative UI, Combine for reactive programming, server-side Swift with Vapor, and enterprise-grade patterns for scalable, performant applications. Context7 MCP integration provides real-time access to official Swift and ecosystem documentation.

Key capabilities:

✅ Swift 6.0 with strict concurrency and actor isolation
✅ Advanced async/await patterns and structured concurrency
✅ SwiftUI 6.0 for declarative UI development
✅ Combine framework for reactive programming
✅ Server-side Swift with Vapor 4.x
✅ Enterprise architecture patterns (MVVM, TCA, Clean Architecture)
✅ Context7 MCP integration for real-time docs
✅ Performance optimization and memory management
✅ Testing strategies with XCTest and Swift Testing
✅ Swift Concurrency with actors and distributed actors

When to Use

Automatic triggers:

Swift 6.0 development discussions
SwiftUI and iOS/macOS app development
Async/await and concurrency patterns
Combine reactive programming
Server-side Swift and Vapor development
Enterprise mobile application architecture

Manual invocation:

Design iOS/macOS application architecture
Implement async/await patterns
Optimize performance and memory usage
Review enterprise Swift code
Implement reactive UI with Combine
Troubleshoot concurrency issues

Technology Stack (2025-11-12)

Component	Version	Purpose	Status
Swift	6.0.1	Core language	✅ Current
SwiftUI	6.0	Declarative UI	✅ Current
Combine	6.0	Reactive programming	✅ Current
Vapor	4.102.0	Server-side framework	✅ Current
Xcode	16.2	Development environment	✅ Current
Swift Concurrency	6.0	Async/await & actors	✅ Current
Swift Testing	0.10.0	Modern testing framework	✅ Current

Quick Start: Hello Async/Await

import Foundation

// Swift 6.0 with async/await
actor GreeterService {
    func greet(name: String) -> String {
        "Hello, \(name)!"
    }
}

// Usage
Task {
    let service = GreeterService()
    let greeting = await service.greet(name: "Swift")
    print(greeting)
}

Level 1: Quick Reference

Core Concepts

Async/Await - Modern concurrency without callbacks
- Function marked with async - Suspends for I/O
- Caller uses await - Waits for result
- Native error handling with throws
- Replaces callbacks and completion handlers
SwiftUI - Declarative UI framework
- State-driven views update automatically
- @State for local state
- @StateObject for ViewModels
- Composable views with modifiers
Combine - Reactive programming
- Publishers emit values
- Operators transform pipelines
- Subscribers receive results
- Error handling with .catch
Actors - Thread-safe state isolation
- Protect mutable state automatically
- Replace locks and semaphores
- @MainActor for UI thread
- Distributed actors for RPC
Vapor - Server-side Swift
- Async route handlers
- Database integration (Fluent)
- Middleware for cross-cutting concerns
- Type-safe API responses

Project Structure

MyApp/
├── Sources/
│   ├── App.swift                 # Entry point
│   ├── Models/                   # Data types
│   ├── Services/                 # Business logic
│   ├── ViewModels/               # UI state management
│   └── Views/                    # SwiftUI components
├── Tests/
│   ├── UnitTests/
│   └── IntegrationTests/
└── Package.swift                 # Dependencies

Level 2: Implementation Patterns

Async/Await Pattern

import Foundation

// Structured async function
func fetchData() async throws -> String {
    let url = URL(string: "https://api.example.com/data")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return String(data: data, encoding: .utf8) ?? ""
}

// Concurrent operations with TaskGroup
func loadMultipleResources() async throws -> (String, String) {
    try await withThrowingTaskGroup(of: (String, String).self) { group in
        group.addTask { ("users", try await fetchUsers()) }
        group.addTask { ("posts", try await fetchPosts()) }

        var results: [String: String] = [:]
        for try await (key, value) in group {
            results[key] = value
        }
        return (results["users"] ?? "", results["posts"] ?? "")
    }
}

SwiftUI State Management

import SwiftUI

@MainActor
class ContentViewModel: ObservableObject {
    @Published var items: [String] = []
    @Published var isLoading = false

    func loadItems() async {
        isLoading = true
        defer { isLoading = false }

        do {
            items = try await fetchItems()
        } catch {
            items = []
        }
    }
}

struct ContentView: View {
    @StateObject private var viewModel = ContentViewModel()

    var body: some View {
        NavigationView {
            VStack {
                if viewModel.isLoading {
                    ProgressView()
                } else {
                    List(viewModel.items, id: \.self) { item in
                        Text(item)
                    }
                }
            }
            .navigationTitle("Items")
            .task {
                await viewModel.loadItems()
            }
        }
    }
}

Actor Isolation Pattern

// Thread-safe counter
actor CounterService {
    private var count: Int = 0

    func increment() { count += 1 }
    func decrement() { count -= 1 }
    func getCount() -> Int { count }
}

// Usage (automatically thread-safe)
Task {
    let counter = CounterService()
    await counter.increment()
    let value = await counter.getCount()
}

Vapor Server Route

import Vapor

func routes(_ app: Application) throws {
    // GET /api/users
    app.get("api", "users") { req async -> [String: String] in
        return ["status": "success"]
    }

    // POST /api/users
    app.post("api", "users") { req async -> HTTPStatus in
        // Save user
        return .created
    }
}

Level 3: Advanced Topics

Concurrency Best Practices

Prefer async/await over Combine for sequential operations
Use actors for mutable shared state (not locks)
Mark UI code @MainActor to ensure main thread
Handle cancellation properly in long-running tasks
Avoid blocking operations (no sleep, no synchronous I/O)

Performance Optimization

Memory: Use value types (struct) by default
CPU: Profile with Xcode Instruments
Rendering: Keep SwiftUI view body pure
Networking: Implement request caching
Database: Use connection pooling in Vapor

Security Patterns

Input validation: Always validate user input
Error handling: Don't expose internal errors to users
Encryption: Use CryptoKit for sensitive data
Authentication: Implement JWT or OAuth2
SQL injection prevention: Use parameterized queries

Testing Strategy

Unit tests: Pure functions with XCTest
Integration tests: Database and API tests
UI tests: SwiftUI view behavior
Mocking: Use protocols for dependency injection

Context7 MCP Integration

Get latest Swift documentation on-demand:

# Access Swift documentation via Context7
from context7 import resolve_library_id, get_library_docs

# Swift Language Documentation
swift_id = resolve_library_id("swift")
docs = get_library_docs(
    context7_compatible_library_id=swift_id,
    topic="structured-concurrency",
    tokens=5000
)

# SwiftUI Documentation
swiftui_id = resolve_library_id("swiftui")
swiftui_docs = get_library_docs(
    context7_compatible_library_id=swiftui_id,
    topic="state-management",
    tokens=4000
)

# Vapor Framework Documentation
vapor_id = resolve_library_id("vapor")
vapor_docs = get_library_docs(
    context7_compatible_library_id=vapor_id,
    topic="routing",
    tokens=3000
)

Related Skills & Resources

Language Integration:

Skill("moai-context7-lang-integration"): Latest Swift/Vapor documentation

Quality & Testing:

Skill("moai-foundation-testing"): Swift testing best practices
Skill("moai-foundation-trust"): TRUST 5 principles application

Security & Performance:

Skill("moai-foundation-security"): Security patterns for Swift
Skill("moai-essentials-debug"): Swift debugging techniques

Official Resources:

Troubleshooting

Problem: Sendable conformance error Solution: Implement Sendable protocol or use @Sendable closure

Problem: Actor isolation violation Solution: Use nonisolated for safe properties or proper await calls

Problem: Memory leaks in closures Solution: Capture [weak self] to break retain cycles

Problem: SwiftUI view not updating Solution: Ensure state changes happen on @MainActor

Changelog

** .0** (2025-11-12): Enterprise upgrade - Progressive Disclosure structure, 90% content reduction, Context7 integration
v3.0.0 (2025-03-15): SwiftUI 5.0 and Combine 6.0 patterns
v2.0.0 (2025-01-10): Basic Swift 5.x patterns
v1.0.0 (2024-12-01): Initial release

Resources

For working examples: See examples.md

For API reference: See reference.md

For advanced patterns: See full SKILL.md in documentation archive

Last updated: 2025-11-18 | Maintained by moai-adk team

Field	Value
Skill Name	moai-lang-swift
Version	4.0.0 (2025-11-12)
Allowed tools	Read, Bash, Context7 MCP
Auto-load	On demand when keywords detected
Tier	Language Enterprise
Context7 Integration	✅ Swift/SwiftUI/Vapor/Combine

moai-lang-swift

Swift - Enterprise

Metadata

What It Does