Understanding Copy on Write (CoW) in Swift

A Comprehensive Guide to Copy on Write for Better Performance

Copy on Write in Swift is one of the most powerful optimization techniques that makes value types both safe and efficient. If you’ve ever wondered how Swift’s Array, String, Dictionary, and Set can be value types without killing performance, Copy-on-Write (CoW) is the secret.

In this in-depth guide, you’ll learn exactly how Copy on Write works in Swift, why Apple uses it, how to implement it in your own types, its performance benefits, and common pitfalls to avoid.

Not a member? No worry be a friend and for friends we have friend link here

What is Copy on Write (CoW)?

Copy-on-Write is a resource management technique where multiple variables share the same underlying storage in memory until one of them needs to modify it. Only at the moment of mutation does the system create a private copy.

This clever approach gives developers:

• True value type semantics: Safety and predictability.
• Reference type performance: Shared memory until mutation occurs.

It is the main reason why Swift collections feel incredibly lightweight even though they are technically value types.

Value Types vs Reference Types Quick Recap

TypeBehavior on AssignmentUse CaseValue (struct)Creates a copySafety, predictabilityReference (class)Shares the same instanceShared mutable state

Without optimizations like CoW, duplicating large value types would be extremely expensive. CoW solves this problem elegantly by delaying the copy until it’s absolutely necessary.

How Copy on Write Works in Swift

Swift’s standard library natively implements Copy on Write for:

• Array
• String
• Dictionary
• Set
• Data

The Mechanism

1. Shared Storage: When you assign or pass a collection, the underlying storage is shared (a very cheap reference-copy operation).
2. Mutation Check: When you attempt to mutate the value, Swift checks the unique reference status using isKnownUniquelyReferenced().
3. Shared Storage → Copy: If the storage is shared by multiple variables, Swift makes a deep copy just before mutation.
4. Unique Storage → In-place: If the storage is unique to that variable, mutation happens in place (extremely fast).

Copy on Write in Action: Code Example

Consider the following snippet demonstrating how arrays share memory until a change is made:

// Helper function to check memory address
func address<T>(of value: T) -> String {
    let pointer = Unmanaged.passUnretained(value as AnyObject).toOpaque()
    return String(describing: pointer)
}

var fruits1 = ["Apple", "Banana", "Mango", "Orange"]
var fruits2 = fruits1                    // No copy happens here

print("Before mutation:")
print("fruits1 address:", address(of: fruits1))
print("fruits2 address:", address(of: fruits2)) // Will match fruits1
fruits2.append("Grapes")                 // Copy-on-Write triggered here
print("\nAfter mutation:")
print("fruits1 address:", address(of: fruits1))
print("fruits2 address:", address(of: fruits2)) // Will be different

Result:

Before mutation:
fruits1 address: 0x00000001057f02c0
fruits2 address: 0x00000001057f02c0

After mutation:
fruits1 address: 0x0000000105f58cc0
fruits2 address: 0x0000000105f593e0

Note: If you run this code, you will see that both arrays point to the exact same memory address before mutation, and split into different addresses immediately after.

Implementing Copy on Write in Custom Structs

CoW is not automatic for custom structs. If you have a large custom struct, you need to implement this behavior manually using a reference type wrapper.

Complete Implementation Example:

// 1. Reference type to hold the actual data
final class Storage<T> {
    var data: T

    init(data: T) {
        self.data = data
    }
}

// 2. Value type wrapper implementing Copy on Write
struct CowBox<T> {
    private var storage: Storage<T>

    init(_ value: T) {
        self.storage = Storage(data: value)
    }

    var value: T {
        get {
            storage.data
        }
        set {
            // Check if more than one variable points to this storage
            if !isKnownUniquelyReferenced(&storage) {
                storage = Storage(data: newValue)   // Shared -> Perform deep copy
            } else {
                storage.data = newValue             // Unique -> Mutate in-place
            }
        }
    }
}

Usage:

var box1 = CowBox([1, 2, 3, 4, 5])
var box2 = box1 // Shared storage under the hood

box2.value.append(6)   // CoW triggers: Only box2 gets modified!

Performance Benefits & Real-World Use Cases

Why use CoW?

• Avoids unnecessary deep copies: Drastically cuts down on redundant CPU cycles.
• Excellent memory efficiency: Keeps your memory footprint low, especially with large collections.
• Enables safe functional programming patterns: You can pass variables around freely without worrying about unexpected side effects or manual performance tuning.
• Reduces memory bandwidth usage: Optimizes execution in performance-critical hot paths.

Real-world applications:

• Image processing and graphic-heavy applications
• Text and document editors handling massive strings
• Data-heavy view models in complex UI architectures
• Advanced caching layers

Common Pitfalls & Gotchas

While CoW is incredibly powerful, keep these nuances in mind:

• Nested Reference Types: If your struct contains a standard class, modifying properties inside that class will not trigger CoW.
• Small Data Overhead: For tiny structs (e.g., a simple Point struct with X and Y coordinates), the overhead of reference counting and tracking allocation can actually make CoW slower than a direct value copy.
• Accidental Copies in Loops: Modifying a value repeatedly inside a loop when it’s accidentally shared can result in thrashing memory with constant re-allocations.
• Thread Safety: CoW relies on reference counting, which is inherently atomic, but the actual data mutation inside your custom types is not thread-safe by default.
• Debugging Visibility: It can be difficult to track exactly when and where memory allocations are happening without profiling tools.

Best Practices

• Size Matters: Only implement custom CoW for large, heavy, or deeply nested value types.
• Keep it Final: Always mark your underlying storage class as final to avoid dynamic dispatch overhead.
• Profile Early and Often: Use Xcode Instruments (specifically the Allocations instrument) to measure memory before and after custom implementations.
• Leverage Modern Swift: Consider creating a reusable @CowProperty property wrapper to clean up your boilerplate code.
• API Design: Prefer exposing pure value semantics in your public APIs to ensure predictable consumer behavior.

Conclusion

Copy on Write is a brilliant showcase of Swift’s underlying philosophy: Safety without sacrificing performance. It bridges the gap between value types and reference types, allowing developers to enjoy clean, race-condition-free code while maintaining blazing-fast runtime efficiency.

Mastering how CoW works under the hood gives you a massive advantage when designing scalable data models and handling heavy collections in your Swift apps.