SwiftData Basics

Reviewed & published by Brayan K

SwiftData (iOS 17+) is Apple's modern, code-first persistence framework. You'll define models with @Model, set up a ModelContainer, fetch with @Query, insert and delete objects, and see how it improves on Core Data.

Part of the free Swift course at LearnCodingFast — hands-on lessons with worked examples and the output they print, plus practice exercises and a quick quiz.

What You'll Learn in This Lesson

• • Define a persistent model with the @Model macro
• • Configure storage with a ModelContainer
• • Fetch and observe data using @Query
• • Insert and delete objects via the ModelContext
• • Read the context from the SwiftUI environment
• • Compare SwiftData with Core Data (iOS 17+)

📊 SwiftData Building Blocks

1️⃣ Define a Model with @Model

A SwiftData model is just a class with the @Model macro. The macro adds persistence and change tracking — no separate model file, no setValue(forKey:).

import SwiftData
import Foundation

// @Model turns a plain Swift class into a persistent SwiftData model.
// No .xcdatamodeld file and no boilerplate — the macro does the work.
@Model
final class Task {
    var title: String
    var isDone: Bool
    var createdAt: Date

    init(title: String, isDone: Bool = false) {
        self.title = title
        self.isDone = isDone
        self.createdAt = Date()
    }
}

let task = Task(title: "Learn SwiftData")
print(task.title)   // Learn SwiftData

2️⃣ Set Up the Container

Attach a ModelContainer once at the app root with .modelContainer(for:). Views then read the active ModelContext from the environment.

import SwiftUI
import SwiftData

// A ModelContainer wires up storage. Attach it once at the app root.
@main
struct TodoApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        // Every model type you persist is listed here.
        .modelContainer(for: Task.self)
    }
}

// Inside a view you reach the context from the environment.
struct ContentView: View {
    @Environment(\.modelContext) private var context
    var body: some View { Text("Ready") }
}

Your turn. Fill in the macro and the model type.

// 🎯 YOUR TURN — replace each ___ then run in Xcode (iOS 17+).
import SwiftData

___                              // 👉 the macro that makes this persistent
final class Note {
    var text: String
    init(text: String) { self.text = text }
}

// Attach storage at the app root:
//   .modelContainer(for: ___.self)   👉 the model type to persist

// ✅ Once filled in, Note becomes a SwiftData model with its own storage.

3️⃣ Query, Insert, and Delete

@Query fetches models with type-safe sorting and keeps the view in sync. Use context.insert(_:) to add and context.delete(_:) to remove.

import SwiftUI
import SwiftData

// @Query fetches models and keeps the view in sync as data changes.
struct TaskList: View {
    @Environment(\.modelContext) private var context

    // Sort and filter declaratively right in the property.
    @Query(sort: \Task.createdAt, order: .reverse) private var tasks: [Task]

    var body: some View {
        List {
            ForEach(tasks) { task in
                Text(task.title)
            }
        }
    }

    func add() {
        context.insert(Task(title: "New task"))   // insert a new object
    }

    func remove(_ task: Task) {
        context.delete(task)                       // delete an object
    }
}

Now you try. Fill in the insert and delete methods.

// 🎯 YOUR TURN — insert then delete.
import SwiftData

@Model final class Item { var name: String; init(name: String) { self.name = name } }

func demo(context: ModelContext) {
    let item = Item(name: "Pen")
    context.___(item)     // 👉 the method that adds the object to the store
    context.___(item)     // 👉 the method that removes the object
}

// ✅ Once filled in: the item is inserted, then deleted.

Pro Tips

• 💡 List every model type in .modelContainer(for:) or it won't be stored.
• 💡 Sort with key paths, e.g. @Query(sort: \Task.title) — type-safe and refactor-friendly.
• 💡 SwiftData often autosaves, so you rarely call save() yourself.
• 💡 Target iOS 17+; fall back to Core Data when you must support older systems.

Common Errors (and the fix)

• Objects never persist — you didn't attach a .modelContainer(for:) for the type.
• "@Model requires a class" — apply the macro to a final class, not a struct.
• List doesn't update — fetch with @Query, not a manual array.
• "Available in iOS 17 or newer" — SwiftData needs an iOS 17+ deployment target.

📋 Quick Reference

Mini-Challenge: SwiftData To-Do

Build a small @Model-backed to-do list with @Query, insert, and delete — and notice how little code it takes.

// 🎯 MINI-CHALLENGE: A tiny SwiftData to-do
// 1. Define an @Model class 'Todo' with title: String and done: Bool.
// 2. In a view, use @Query(sort: \Todo.title) to list all todos.
// 3. Add a button that calls context.insert(Todo(...)) to add one.
// 4. Add swipe-to-delete that calls context.delete(todo).
//
// Reflect: how much less boilerplate is this than the Core Data version?

// your code here

🎉 Lesson Complete!

• ✅ @Model makes a Swift class persistent — no model file
• ✅ A ModelContainer sets up storage at the app root
• ✅ @Query fetches and observes models with type-safe sorting
• ✅ context.insert(_:) and context.delete(_:) add and remove
• ✅ SwiftData is the code-first, less-boilerplate successor to Core Data (iOS 17+)

Practice quiz

Continue this course

• Previous: Persistence with Core Data
• Next: Unit Testing with XCTest — XCTestCase, assertions, async tests and protocol-based mocking

Frequently asked questions

What does the @Model macro do?

@Model attaches to a Swift class and turns it into a persistent SwiftData model. The macro generates the storage and change-tracking code for you at compile time, so you write a plain class with ordinary properties and an initializer. There is no .xcdatamodeld file to maintain, which is the biggest day-to-day difference from Core Data.

What is a ModelContainer and where does it go?

A ModelContainer sets up SwiftData's underlying storage for the model types you list. In a SwiftUI app you usually attach it once at the app root with the .modelContainer(for:) modifier, passing the model types to persist. From there, views read the active ModelContext out of the environment to insert, delete, and save objects.

How is @Query different from @FetchRequest?

Both fetch persistent objects and keep a SwiftUI view in sync, but @Query is the SwiftData equivalent and is more concise. You declare sorting and filtering with type-safe key paths, for example @Query(sort: \Task.createdAt), and it returns a plain Swift array of your model type. @FetchRequest is the older Core Data wrapper using NSSortDescriptor and FetchedResults.

How do I add and remove objects in SwiftData?

Get the ModelContext from the environment, then call context.insert(object) to add a new model and context.delete(object) to remove one. SwiftData tracks these changes and persists them, and any @Query observing that data refreshes the view automatically. SwiftData also autosaves in common setups, so you often do not call save() manually.

Should I use SwiftData or Core Data?

SwiftData is the modern, Swift-first choice for new apps targeting iOS 17 and later: it offers a type-safe, code-first API built on Core Data's proven engine with far less boilerplate. Choose Core Data when you must support older OS versions, need advanced features SwiftData does not yet expose, or are maintaining an existing Core Data codebase.