# How to Use @concurrent Functions for Background Processing in Swift 6.2+

> Learn to use Swift's @concurrent functions for efficient background processing. Avoid UI stalls and data-race warnings with this powerful feature.

- Repository: [Thomas Ricouard/Skills](https://github.com/Dimillian/Skills)
- Tags: how-to-guide
- Published: 2026-04-01

---

**Swift 6.2's `@concurrent` attribute runs async functions on the concurrent thread pool without transferring the caller's actor isolation, eliminating UI stalls and data-race warnings while removing the boilerplate required by `Task.detached`.**

The **Dimillian/Skills** repository provides authoritative reference implementations demonstrating how `@concurrent` functions enable safe background processing in modern Swift concurrency. This guide extracts the practical patterns from [`swift-concurrency-expert/references/swift-6-2-concurrency.md`](https://github.com/Dimillian/Skills/blob/main/swift-concurrency-expert/references/swift-6-2-concurrency.md) and [`swift-concurrency-expert/SKILL.md`](https://github.com/Dimillian/Skills/blob/main/swift-concurrency-expert/SKILL.md) to show you exactly how to implement these optimizations.

## What Are @concurrent Functions?

The **`@concurrent`** attribute is a Swift 6.2 feature that forces an annotated async function to execute on the **concurrent thread-pool**, regardless of which actor calls it. Unlike standard async functions that inherit the caller's actor context, `@concurrent` functions immediately hop to a background thread for CPU-intensive work.

According to the repository's concurrency documentation, this attribute serves a critical role in the "approachable concurrency" model: it keeps calling actors (frequently `@MainActor` UI code) free to continue processing events while heavy work executes in parallel.

## Prerequisites for Implementation

### nonisolated Types

To use `@concurrent` effectively, you typically mark the containing type as **`nonisolated`**. This indicates the type has no actor isolation, allowing its members to be called from any actor while the `@concurrent` method itself runs on the background pool.

As implemented in [`swift-concurrency-expert/SKILL.md`](https://github.com/Dimillian/Skills/blob/main/swift-concurrency-expert/SKILL.md) (lines 77-99), the standard pattern requires:
1. Declare the type as `nonisolated` (or use a plain struct)
2. Apply `@concurrent` to the async function
3. Call with `await` from the original actor

### Function Signature Requirements

`@concurrent` functions must be marked **`async`** and are typically called with **`await`**. The compiler guarantees the function executes on the background pool, then returns control to the caller's original actor upon completion.

## Practical Code Examples

### Background Processing with Structs

The canonical `PhotoProcessor` example from [`swift-concurrency-expert/references/swift-6-2-concurrency.md`](https://github.com/Dimillian/Skills/blob/main/swift-concurrency-expert/references/swift-6-2-concurrency.md) (lines 31-34) demonstrates the standard pattern:

```swift
// MARK: - Background worker
nonisolated struct PhotoProcessor {
    // The heavy image‑processing work runs on the concurrent pool
    @concurrent
    func extractSubject(from data: Data) async -> Sticker {
        // … perform CPU‑intensive image analysis …
    }
}

// MARK: - UI‑side caller (main‑actor)
@MainActor
final class StickerModel {
    let processor = PhotoProcessor()

    func makeSticker(from item: PhotosPickerItem) async throws -> Sticker? {
        guard let data = try await item.loadTransferable(type: Data.self) else {
            return nil
        }
        // `await` hops to the background pool, then returns on the main actor
        return await processor.extractSubject(from: data)
    }
}

```

**Key insight:** The `@concurrent` attribute guarantees `extractSubject` runs off the main thread while `StickerModel` stays on the UI thread, preventing frame drops during image analysis.

### Static Helper Methods

You can also apply `@concurrent` to static methods within classes that may be accessed from the main actor:

```swift
class PhotoProcessor {
    static var cache = [String: Sticker]()

    // Background‑only helper – runs on the concurrent pool
    @concurrent
    static func extractSubject(from data: Data) async -> Sticker {
        // Expensive processing here...
    }

    func extractSticker(data: Data, id: String) async -> Sticker {
        if let cached = Self.cache[id] { return cached }
        let result = await Self.extractSubject(from: data)
        Self.cache[id] = result
        return result
    }
}

```

Even though `PhotoProcessor` instances may reside on the main actor, the static `extractSubject` method is forced onto the background pool.

### Standalone Concurrent Functions

For utility functions that don't require a containing type, apply `@concurrent` directly to top-level async functions:

```swift
@MainActor
func fetchRemoteData() async throws -> Data {
    // This call will not block the UI because the heavy work is in a @concurrent function
    return await heavyDownload()
}

@concurrent
func heavyDownload() async -> Data {
    // Simulate a long‑running network or CPU bound task
    try? await Task.sleep(nanoseconds: 2_000_000_000)
    return Data()
}

```

This pattern appears in [`swift-concurrency-expert/SKILL.md`](https://github.com/Dimillian/Skills/blob/main/swift-concurrency-expert/SKILL.md) (lines 94-99) as a migration strategy for moving existing UI-bound code to background processing.

## Key Source Files in Dimillian/Skills

The repository contains definitive reference material for Swift 6.2 concurrency:

- **[`swift-concurrency-expert/references/swift-6-2-concurrency.md`](https://github.com/Dimillian/Skills/blob/main/swift-concurrency-expert/references/swift-6-2-concurrency.md)** — Contains the full semantic description of `@concurrent`, the `PhotoProcessor` example (lines 31-34), and the step-by-step implementation checklist (lines 45-49).

- **[`swift-concurrency-expert/SKILL.md`](https://github.com/Dimillian/Skills/blob/main/swift-concurrency-expert/SKILL.md)** — Provides concise migration guidance and the compact `nonisolated` + `@concurrent` pattern (lines 77-99).

- **[`swift-concurrency-expert/references/approachable-concurrency.md`](https://github.com/Dimillian/Skills/blob/main/swift-concurrency-expert/references/approachable-concurrency.md)** — Explains the broader concurrency model that makes `@concurrent` necessary alongside Swift's default-actor isolation.

## Summary

- **`@concurrent`** forces async functions onto the concurrent thread pool without affecting the caller's actor isolation
- Combine with **`nonisolated`** types to prevent data-race warnings while maintaining clean syntax
- Call **`@concurrent`** functions using standard **`await`** — the compiler handles the thread hop automatically
- Available in **Swift 6.2+** as part of the "approachable concurrency" initiative
- Eliminates boilerplate compared to `Task.detached` while providing stronger compile-time safety guarantees

## Frequently Asked Questions

### What is the difference between @concurrent and Task.detached?

**`@concurrent`** keeps the function structured within the caller's async flow, returning to the original actor after completion, while **`Task.detached`** creates a completely independent task that does not inherit priority or actor context and requires manual coordination. According to the Dimillian/Skills source, `@concurrent` provides the same background execution benefits with less boilerplate and better integration with Swift's structured concurrency.

### Can I use @concurrent with actor-isolated types?

**No.** The function itself cannot be isolated to a specific actor. As shown in [`swift-concurrency-expert/SKILL.md`](https://github.com/Dimillian/Skills/blob/main/swift-concurrency-expert/SKILL.md), you must either mark the containing type as **`nonisolated`** or declare the function on a type that has no actor isolation. Attempting to apply `@concurrent` to an actor-isolated method results in a compiler error because the attribute requires execution on the general concurrent pool rather than a specific actor's executor.

### When should I choose @concurrent over traditional concurrency patterns?

Use **`@concurrent`** when you need **CPU-intensive work** (image processing, data transformation, complex calculations) that must not block the main actor, but where you still want structured concurrency semantics and automatic return to the caller's actor. It is superior to manual `DispatchQueue.global().async` bridges because it integrates with Swift's async/await system and provides compile-time data-race safety.

### Does @concurrent require Swift 6.2 specifically?

**Yes.** The `@concurrent` attribute was introduced in **Swift 6.2** as part of the "approachable concurrency" improvements. Earlier Swift versions require `Task.detached` or manual `nonisolated` async functions to achieve similar background execution, though without the same compiler guarantees about concurrent thread-pool execution.