Apple’s WWDC 2025 wasn’t just about new products—it was a blueprint for the next generation of app development. From the sleek visual language of Liquid Glass to privacy-first on-device AI, Apple made it clear: apps should feel alive, intelligent, and deeply integrated across devices.

This article breaks down the biggest developer updates from Apple’s 2025 Platform State of the Union, explains what they mean in plain English, and shows how you can apply them in your own apps—whether you build for iOS, macOS, visionOS, or all three.

1. A New Design Standard: What is Liquid Glass?

One of the most visible—and beautiful—announcements was the introduction of Liquid Glass, a modern design system that redefines how apps look and feel on Apple devices.

Key Takeaways:

• Transparent, glass-like UI layers that adapt to content and light

• UI elements now float, bend, and shimmer based on user interaction

• Built to work across iPhone, iPad, Mac, Watch, and Vision Pro

• Out-of-the-box support in SwiftUI, UIKit, and AppKit with no code changes

Imagine the feel of frosted glass—not just as a texture, but as a living interface. That’s Liquid Glass.

You can test it now simply by recompiling in Xcode 26. No redesign needed unless you want to fully customize it.

2. Meet Apple Intelligence: Your AI Co-Pilot

Apple took a bold step away from cloud-based LLMs with the launch of Apple Intelligence—a private, fast, and offline AI engine that runs right on the device.

Why It Matters:

• You get a powerful language model on-device, ready to use

• Apple provides a new Foundation Models framework for tasks like:

  • Summarizing content

  • Generating text

  • Creating structured data

  • Tagging and tool-calling

• No privacy concerns, server costs, or rate limits

Plus, Apple made integrating AI shockingly simple. With just a few lines of Swift, you can bring real intelligence into your app—whether it’s generating travel plans, helping users write journal entries, or powering smart recommendations.

3. Xcode 26: Now with Built-In AI and More

Apple’s developer toolkit just got way more powerful—and more human.

New in Xcode 26:

• ChatGPT-style assistant, built-in

• Inline previews, bug fixes, refactoring suggestions

• Smart code generation from text or drawings

• Ability to scrub through prompt history and go back in time

• Integrates with OpenAI, Claude, and even local models

You don’t need an API key to get started. Xcode’s AI tools are built right into the beta.

Whether you want to generate SwiftUI views or explain legacy code, you now have a teammate that never sleeps.

4. Swift 6.2: Performance without Sacrifice

Apple continues to push the Swift language forward, and Swift 6.2 brings serious performance improvements—especially for memory-heavy or system-level apps.

Notable Additions:

• Inline Arrays: faster data storage without heap memory

• Span type: a safe way to access raw memory

• WebAssembly support for browser deployment

• Improved C++ and JavaScript interop

• Better concurrency defaults and MainActor behavior

This release shows Swift is no longer just an iOS language—it’s a powerful systems language ready for servers, browsers, and beyond.

5. SwiftUI: Cleaner Code, Faster Performance

SwiftUI got a major tune-up in 2025, making it even more robust for modern apps.

What’s New:

• Full support for rich text editing using AttributedString

• Native WebView and programmatic browser control

• Gorgeous new 3D charting APIs via RealityKit

• Dramatically improved list performance—up to 6x faster

• New APIs for drag and drop, scene management, and SwiftData subclassing

If you’ve been waiting to go all-in on SwiftUI—this is your moment.

6. Spatial Apps Are the Future: visionOS 26

Apple’s spatial computing platform is becoming more developer-friendly—and more magical.

New Capabilities:

• Volumetric layouts with SwiftUI

• Shared spatial windows and world anchors

• Automatically persistent widgets

• Convert 2D images into 3D environments using AI

• FaceTime spatial personas for shared AR experiences

This opens the door for apps that feel more like environments than screens.

7. Gaming on Apple Devices? It’s Happening.

Yes, real gaming is coming to Mac—and Apple’s not joking anymore.

With Metal 4, Apple is embracing GPU-powered realism and AI-enhanced visuals.

Metal 4 Highlights:

• Neural rendering and lighting via shaders

• MetalFX upscaling and frame interpolation

• Game Porting Toolkit v2: port PC games faster than ever

• PlayStation VR2 controller support for Vision Pro

• Full cloud saves with the new GameSave framework

Cyberpunk 2077 now runs at 60 FPS on MacBook M4. That alone says it all.

8. Smarter System Integration with App Intents

Apple is making your app more discoverable than ever—with or without a homescreen tap.

App Intents Framework Now Works In:

• Spotlight search

• Control Center buttons

• Lock Screen widgets

• Siri & Shortcuts

You can also use Visual Intelligence APIs to recognize content in photos and link users directly into your app—even if it’s closed.

This makes your app’s features feel like part of the OS itself.

The post What Apple’s WWDC 2025 Means for Developers: Liquid Glass, On-Device AI, and the New Era of App Design appeared first on AppMakers.Dev.

Model
final class Motivation: Identifiable {
    
    var id: UUID?
    var message: String?
    var timestamp: Date?

    init(message: String?, timestamp: Date = .now) {
        self.id = UUID()
        self.message = message
        self.timestamp = timestamp
    }
}

import SwiftData

@main
struct ConfigurableWidgetsApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .modelContainer(for: [Motivation.self])
    }
}

import SwiftUI
import SwiftData

struct ContentView: View {
    
    @Environment(\.modelContext) private var modelContext
    @Query(sort: \Motivation.timestamp, order: .reverse) private var motivations: [Motivation]
    
    @State private var showAllUsedAlert = false
    
    let motivationSamples = [
        "Keep going!",
        "You got this!",
        "Make it happen!",
        "Dream big, act bigger.",
        "Stay hungry, stay foolish.",
        "Progress, not perfection.",
        "Push beyond limits.",
        "Your only limit is you.",
        "Success is a habit.",
        "Discipline > Motivation.",
        "Every step counts.",
        "Don’t stop now.",
        "You were made for more.",
        "Do it scared.",
        "Tiny wins every day.",
        "No zero days.",
        "Trust the process.",
        "The future is yours to shape.",
        "Create your own momentum.",
        "Consistency is your superpower."
    ]

    var body: some View {
            NavigationStack {
                List {
                    ForEach(motivations) { motivation in
                        VStack(alignment: .leading) {
                            Text(motivation.message ?? "No message")
                                .font(.headline)
                            if let timestamp = motivation.timestamp {
                                Text(timestamp.formatted(date: .abbreviated, time: .shortened))
                                    .font(.caption)
                                    .foregroundStyle(.gray)
                            }
                        }
                        .padding(.vertical, 4)
                    }
                    .onDelete(perform: deleteItems)
                }
                .navigationTitle("Your Motivations")
                .toolbar {
                    ToolbarItem(placement: .bottomBar) {
                        Button(action: addItem) {
                            Label("Add Motivation", systemImage: "plus.circle.fill")
                                .font(.headline)
                        }
                    }
                }
                .alert("All Motivations Added", isPresented: $showAllUsedAlert) {
                    Button("OK", role: .cancel) {}
                } message: {
                    Text("You've already added all available motivation samples.")
                }
            }
        }

    private func addItem() {
        
        // Check which messages are not yet in the list
        let existingMessages = Set(motivations.compactMap { $0.message })
        let availableMessages = motivationSamples.filter { !existingMessages.contains($0) }

        // If no new messages left, show alert
        guard let newMessage = availableMessages.randomElement() else {
            showAllUsedAlert = true
            return
        }

        let newMotivation = Motivation(message: newMessage)
        modelContext.insert(newMotivation)
        try? modelContext.save()
        
    }

    private func deleteItems(at offsets: IndexSet) {
        
        for index in offsets {
            let item = motivations[index]
            modelContext.delete(item)
            try? modelContext.save()
        }
        
    }
    
}

struct MotivationEntity: AppEntity {
    var id: String
    var message: String

    static var typeDisplayRepresentation: TypeDisplayRepresentation = "Motivation"
    static var defaultQuery = MotivationQuery()

    var displayRepresentation: DisplayRepresentation {
        DisplayRepresentation(
            title: LocalizedStringResource("\(message)"),
            subtitle: LocalizedStringResource("\(id)")
        )
    }
}

struct MotivationQuery: EntityQuery {
    
    func suggestedEntities() async throws -> [MotivationEntity] {
        return try await fetchMotivations()
    }

    func defaultResult() async -> MotivationEntity? {
        return try? await fetchMotivations().first
    }

    func entities(for identifiers: [String]) async throws -> [MotivationEntity] {
        let motivations = try await fetchMotivations()
        return motivations.filter { identifiers.contains($0.id) }
    }

    private func fetchMotivations() async throws -> [MotivationEntity] {
        let container = try ModelContainer(for: Motivation.self)
        let context = ModelContext(container)
        let results = try context.fetch(FetchDescriptor<Motivation>())

        return results.compactMap {
            guard let id = $0.id?.uuidString, let message = $0.message else { return nil }
            return MotivationEntity(id: id, message: message)
        }
    }
}

struct ConfigurationAppIntent: WidgetConfigurationIntent {
    
    static var title: LocalizedStringResource = "Choose Motivation"
    static var description = IntentDescription("Pick a motivation message to show in your widget.")

    @Parameter(title: "Motivation")
    var motivation: MotivationEntity?
    
}

struct SimpleEntry: TimelineEntry {
    let date: Date
    let configuration: ConfigurationAppIntent
}

struct Provider: AppIntentTimelineProvider {

... }

func placeholder(in context: Context) -> SimpleEntry {
    SimpleEntry(date: .now, configuration: ConfigurationAppIntent())
}

func snapshot(for configuration: ConfigurationAppIntent, in context: Context) async -> SimpleEntry {
    SimpleEntry(date: .now, configuration: configuration)
}

func timeline(for configuration: ConfigurationAppIntent, in context: Context) async -> Timeline<SimpleEntry> {
    let entry = SimpleEntry(date: .now, configuration: configuration)
    return Timeline(entries: [entry], policy: .never)
}

/// The actual content shown in the widget on the Home Screen
struct ConfigurableWidgetEntryView: View {
   
    var entry: Provider.Entry

    var body: some View {
        ZStack {

            VStack(alignment: .leading, spacing: 8) {
                // Main motivation text
                Text(entry.configuration.motivation?.message ?? "Test")
                    .font(.headline)
                    .lineLimit(3)
                    .minimumScaleFactor(0.5)
                    .bold()
                    .multilineTextAlignment(.leading)

                Spacer()

                // Optional timestamp (can remove in production)
                Text(entry.date, style: .time)
                    .font(.caption2)
                    .foregroundStyle(.gray)
            }
            .padding()
        }
    }
    
}

struct ConfigurableWidget: Widget {
    
    let kind: String = "ConfigurableWidget"

    var body: some WidgetConfiguration {
        AppIntentConfiguration(
            kind: kind,
            intent: ConfigurationAppIntent.self,
            provider: Provider()
        ) { entry in
            ConfigurableWidgetEntryView(entry: entry)
                .containerBackground(Color(.systemBackground), for: .widget)
        }
    }
    
}

#Preview(as: .systemSmall) {
    ConfigurableWidget()
} timeline: {
    SimpleEntry(date: .now, configuration: .sampleMotivation1)
    SimpleEntry(date: .now, configuration: .sampleMotivation2)
}

extension ConfigurationAppIntent {
    
    /// Sample configuration using a fake MotivationEntity
    fileprivate static var sampleMotivation1: ConfigurationAppIntent {
        let intent = ConfigurationAppIntent()
        intent.motivation = MotivationEntity(
            id: UUID().uuidString,
            message: "Push beyond limits."
        )
        return intent
    }

    fileprivate static var sampleMotivation2: ConfigurationAppIntent {
        let intent = ConfigurationAppIntent()
        intent.motivation = MotivationEntity(
            id: UUID().uuidString,
            message: "The future is yours to shape."
        )
        return intent
    }
}

struct MotivationQuery: EntityStringQuery {

    func entities(matching string: String) async throws -> [MotivationEntity] {
          let motivations = try await fetchMotivations()
          return motivations.filter {
              $0.message.localizedCaseInsensitiveContains(string)
          }
      }

@Model
final class Motivation: Identifiable {
    
    var id: String?
    var message: String?
    var timestamp: Date?
    
    var isFavorite: Bool?
    var backgroundColorHex: String?

    init(message: String?, timestamp: Date = .now, isFavorite: Bool = false, backgroundColorHex: String? = nil) {
        
        self.id = UUID().uuidString
        self.message = message
        self.timestamp = timestamp
        self.isFavorite = isFavorite
        self.backgroundColorHex = backgroundColorHex
        
    }
    
}

struct MotivationEntity: AppEntity {
    
    var id: String
    var message: String
    var isFavorite: Bool
    var backgroundColorHex: String?
    
    static var typeDisplayRepresentation: TypeDisplayRepresentation = "Motivation"
   
    static var defaultQuery = MotivationQuery()
    
    var displayRepresentation: DisplayRepresentation {
        DisplayRepresentation(
            title: LocalizedStringResource("\(message)"),  
            subtitle: LocalizedStringResource(isFavorite ? "⭐️ \(id)" : "\(id)")   
        )
    }
}

        return results.compactMap {
               guard let id = $0.id, let message = $0.message else { return nil }
               return MotivationEntity(
                   id: id,
                   message: message,
                   isFavorite: $0.isFavorite ?? false,
                   backgroundColorHex: $0.backgroundColorHex
               )
           }

extension ConfigurationAppIntent {
    
    /// Preview: Configuration with sample motivation 1
    fileprivate static var sampleMotivation1: ConfigurationAppIntent {
        let intent = ConfigurationAppIntent()
        intent.motivation = MotivationEntity(
            id: UUID().uuidString,
            message: "Push beyond limits.", isFavorite: true, backgroundColorHex: "#D3D3D3"
        )
        return intent
    }

    /// Preview: Configuration with sample motivation 2
    fileprivate static var sampleMotivation2: ConfigurationAppIntent {
        let intent = ConfigurationAppIntent()
        intent.motivation = MotivationEntity(
            id: UUID().uuidString,
            message: "The future is yours to shape.", isFavorite: false, backgroundColorHex: "#FFFFFF"
        )
        return intent
    }
}

struct ConfigurableWidgetEntryView: View {
   
    var entry: Provider.Entry

    var body: some View {
        ZStack {
            VStack(alignment: .leading, spacing: 8) {

                // Motivation message text (user-selected)
                Text(entry.configuration.motivation?.message ?? "Stay motivated!")
                    .font(.headline)
                    .lineLimit(3)
                    .minimumScaleFactor(0.5)
                    .bold()
                    .multilineTextAlignment(.leading)

                Spacer()
                
                HStack {
                    
                    // Timestamp (optional: shows when widget was last updated)
                    Text(entry.date, style: .time)
                        .font(.caption2)
                        .foregroundStyle(.gray)
                    
                    Spacer()
                    
                    if entry.configuration.motivation?.isFavorite == true {
                                     Text("⭐️")
                                         .font(.caption)
                                         .foregroundStyle(.yellow)
                                 }
                    
                }
            }
            .padding()
        }
    }
}

extension Color {
    init(hex: String) {
        let hex = hex.trimmingCharacters(in: CharacterSet.alphanumerics.inverted)
        var int = UInt64()
        Scanner(string: hex).scanHexInt64(&int)
        
        let r, g, b: UInt64
        switch hex.count {
        case 6: // RGB (24-bit)
            (r, g, b) = ((int >> 16) & 0xFF, (int >> 8) & 0xFF, int & 0xFF)
        default:
            (r, g, b) = (255, 255, 255)
        }

        self.init(.sRGB, red: Double(r) / 255, green: Double(g) / 255, blue: Double(b) / 255)
    }
}

struct ConfigurableWidget: Widget {
    
    // Unique identifier for this widget
    let kind: String = "ConfigurableWidget"

    var body: some WidgetConfiguration {
        AppIntentConfiguration(
            kind: kind,
            intent: ConfigurationAppIntent.self,  // Our custom intent with motivation
            provider: Provider()                  // The logic that supplies timeline entries
        ) { entry in
            ConfigurableWidgetEntryView(entry: entry)
                .containerBackground(Color(hex: entry.configuration.motivation?.backgroundColorHex ?? "#D3D3D3"), for: .widget) 
        }
    }
}

 ZStack {
                            if let hex = motivation.backgroundColorHex {
                                Color(hex: hex)                                    .cornerRadius(8)
                            }

                                HStack {
                                    
                                    VStack(alignment: .leading, spacing: 8) {
                                        
                                        Text(motivation.message ?? "No message")
                                            .font(.headline)
                                            .foregroundStyle(.primary)
                                        
                                        if let timestamp = motivation.timestamp {
                                            Text(timestamp.formatted(date: .abbreviated, time: .shortened))
                                                .font(.caption)
                                                .foregroundStyle(.gray)
                                        }
                                        
                                    }
                                 
                                    Spacer()
                                    
                                    if motivation.isFavorite == true {
                                        Spacer()
                                        Text("⭐️")
                                            .foregroundStyle(.yellow)
                                            .font(.headline)
                                    }
                                }
                                .background(Color(hex: motivation.backgroundColorHex ?? "F1F1F1"))

                               
                            .padding(20)
                        }
                        .listRowInsets(EdgeInsets())
                        .listRowBackground(Color.clear)

struct MotivationRowView: View {
    @Bindable var motivation: Motivation
    @Environment(\.modelContext) private var modelContext

    var body: some View {
        VStack(alignment: .leading, spacing: 6) {
            HStack {
                Text(motivation.message ?? "No message")
                    .font(.headline)
                    .foregroundStyle(.primary)
                    .lineLimit(2)

                if motivation.isFavorite == true {
                    Spacer()
                    Text("⭐️")
                        .foregroundStyle(.yellow)
                }
            }

            if let timestamp = motivation.timestamp {
                Text(timestamp.formatted(date: .abbreviated, time: .shortened))
                    .font(.caption)
                    .foregroundStyle(.gray)
            }

            // Inline Color Picker
            ColorPicker(motivation.backgroundColorHex ?? "#FFFFFF", selection: Binding(
                get: {
                    Color(hex: motivation.backgroundColorHex ?? "#FFFFFF")
                },
                set: { newColor in
                    motivation.backgroundColorHex = newColor.toHex()
                    try? modelContext.save()
                }
            ))
            .font(.caption)
        }
        .padding()
        .background(
            Color(hex: motivation.backgroundColorHex ?? "#F2F2F7")
                .cornerRadius(10)
        )
    }
}

ForEach($motivations) { $motivation in
     MotivationRowView(motivation: motivation)
                        .listRowBackground(Color.clear)
}
.onDelete(perform: deleteItems)

   func toHex() -> String {
        let uiColor = UIColor(self)
        var r: CGFloat = 0, g: CGFloat = 0, b: CGFloat = 0, a: CGFloat = 0
        uiColor.getRed(&r, green: &g, blue: &b, alpha: &a)
        return String(format: "#%02X%02X%02X", Int(r * 255), Int(g * 255), Int(b * 255))
    }

ColorPicker("Background Color", selection: Binding(
    get: {
        Color(hex: motivation.backgroundColorHex ?? "#FFFFFF")
    },
    set: { newColor in
        motivation.backgroundColorHex = newColor.toHex()
        try? modelContext.save()

        // Reload widget
        WidgetCenter.shared.reloadAllTimelines()
    }
))
.font(.caption)

.onChange(of: scenePhase) { oldPhase, newPhase in
            
            if newPhase == .background { 
                
                // Optional
                WidgetCenter.shared.reloadAllTimelines()
            }
            
        }

// MARK: - Shared Model Container
/// Singleton container for shared access across app and widget
class SharedModelContainer {
    
   static let shared = SharedModelContainer()
   
   let container: ModelContainer
   
   private init() {
       // Configure the container for shared access via App Group
       let schema = Schema([Motivation.self])
       let modelConfiguration = ModelConfiguration(schema: schema, groupContainer: .identifier("group.com.adelmaer.ConfigurableWidgetsApp"))
       
       do {
           container = try ModelContainer(for: schema, configurations: modelConfiguration)
       } catch {
           fatalError("Could not create ModelContainer: \(error)")
       }
   }
}

import SwiftUI
import SwiftData
import WidgetKit

@main
struct ConfigurableWidgetsAppApp: App {
    
    @Environment(\.scenePhase) private var scenePhase

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .modelContainer(SharedModelContainer.shared.container)
        .onChange(of: scenePhase) { _, newPhase in
            if newPhase == .background {
                WidgetCenter.shared.reloadAllTimelines()
            }
        }
    }
}

struct ToggleMotivationIsFavoriteIntent: AppIntent {
    
    static var title: LocalizedStringResource = "Toggle Favorite Status"
    static var description = IntentDescription("Toggle favorite status for a motivation message")
    
    @Parameter(title: "Motivation")
    var motivation: MotivationEntity
    
    init(motivation: MotivationEntity) {
          self.motivation = motivation
      }

    init() {}

    func perform() async throws -> some IntentResult {
       
        let modelContext = ModelContext(SharedModelContainer.shared.container)
        let id = motivation.id
        
        // Find and update the motivation
        guard let motivation = try! modelContext.fetch(
            FetchDescriptor<Motivation>(
                predicate: #Predicate { $0.id == id }
            )).first else {
            return .result()
        }
        
        // Toggle favorite status
        motivation.isFavorite = !(motivation.isFavorite ?? false)
        
        // Save changes
        try? modelContext.save()
        
        // Refresh widget
        WidgetCenter.shared.reloadAllTimelines()
        
        return .result()
  
    }

}

struct ToggleFavoriteButton: View {
    let motivation: MotivationEntity
    
    var body: some View {
        Button(
            intent: ToggleMotivationIsFavoriteIntent(motivation: motivation)
        ) {
            Image(systemName: motivation.isFavorite ? "star.fill" : "star")
                .foregroundStyle(motivation.isFavorite ? .yellow : .gray)
                .contentTransition(.symbolEffect(.replace))
        }
        .buttonStyle(.plain)
    }
    
}

if let motivation = entry.configuration.motivation {
    ToggleFavoriteButton(motivation: motivation)
}

struct ConfigurationAppIntent: WidgetConfigurationIntent {
    static var title: LocalizedStringResource = "Choose Motivation"
    static var description = IntentDescription("Pick a motivation message to show in your widget.")

    @Parameter(title: "Motivation")
    var motivation: MotivationEntity?

    @Parameter(title: "Show Timestamp")
    var showTimestamp: Bool?
}

if entry.configuration.showTimestamp ?? false {
    Text(entry.date, style: .time)
        .font(.caption2)
        .foregroundStyle(.gray)
}

    /// Preview: Configuration with sample motivation 1
    fileprivate static var sampleMotivation1: ConfigurationAppIntent {
        let intent = ConfigurationAppIntent()
        intent.motivation = MotivationEntity(
            id: UUID().uuidString,
            message: "Push beyond limits.",
            isFavorite: true,
            backgroundColorHex: "#D3D3D3"
        )
        intent.showTimestamp = true
        return intent
    }

The post How to Build a SwiftUI Widget with App Intents and SwiftData ( Configurable Widget ) appeared first on AppMakers.Dev.

🔗 Download the full commented source code (Xcode Project) for this Tutorial

🧰 Getting Started — Create a Fresh SwiftUI Project

Open Xcode and start a new app:

• Go to File → New → Project → App

• Name your project something like WidgetApp

• Interface: SwiftUI

• Language: Swift

Save the project and move on to the next step.

➕ Add the Widget Extension

Now it’s time to add a widget target:

• File → New → Target

• Select Widget Extension

• Uncheck the options:

  • Live Activity

  • Control

  • Configuration App Intent

• Name it something like WidgetAppWidget

• Confirm and activate the new scheme if prompted.

🔍 Understand the Auto-Generated Files

Xcode will create two key files:

AppWidgetBundle.swift – Entry Point

This struct defines your widget bundle and serves as the extension’s entry:

import WidgetKit
import SwiftUI

@main
struct AppWidgetBundle: WidgetBundle {
    var body: some Widget {
        AppWidget()
    }
}

• The @main attribute designates this as the starting point of your widget extension.

• You can group multiple widgets into this bundle in future updates.

AppWidget.swift – The Core Widget File

This file contains everything your widget needs:

• A data model (SimpleEntry)

• A timeline provider

• A view for the widget UI

• The actual widget struct with configuration

• A #Preview section to test in Xcode

📦 1. Define the Widget’s Data Model

The SimpleEntry struct represents the snapshot of data shown at each update:

struct SimpleEntry: TimelineEntry {
    let date: Date
    let emoji: String
}

• date: Tells the system when to show this entry.

• emoji: Temporary example content — later, we’ll replace it with a message and background color.

🧠 2. Implement the TimelineProvider

The TimelineProvider tells WidgetKit what to display and when. It includes three main functions:

struct Provider: TimelineProvider {
   // 1️⃣ func placeholder(in context: Context) -> SimpleEntry { … }
   // 2️⃣ func getSnapshot(in context: Context, completion: @escaping (SimpleEntry) -> ()) { … }
   // 3️⃣ func getTimeline(in context: Context, completion: @escaping (Timeline<SimpleEntry>) -> ()) { … }
}

1️⃣ placeholder(in:)

Shows temporary content in the widget gallery.

func placeholder(in context: Context) -> SimpleEntry {
    SimpleEntry(date: Date(), emoji: "😀")
}

2️⃣ getSnapshot(in:)

Provides a static snapshot of data.

func getSnapshot(in context: Context, completion: @escaping (SimpleEntry) -> ()) {
    let entry = SimpleEntry(date: Date(), emoji: "😀")
    completion(entry)
}

3️⃣ getTimeline(in:)

Generates a list of timeline entries.

func getTimeline(in context: Context, completion: @escaping (Timeline<Entry>) -> ()) {
    var entries: [SimpleEntry] = []

    let currentDate = Date()
    for hourOffset in 0 ..< 5 {
        let entryDate = Calendar.current.date(byAdding: .hour, value: hourOffset, to: currentDate)!
        let entry = SimpleEntry(date: entryDate, emoji: "😀")
        entries.append(entry)
    }

    let timeline = Timeline(entries: entries, policy: .atEnd)
    completion(timeline)
}

🖼️ 3. Create the Widget UI with SwiftUI

Use SwiftUI to define how your widget appears on the home screen.

struct AppWidgetEntryView : View {
    var entry: Provider.Entry

    var body: some View {
        VStack {
            Text("Time:")
            Text(entry.date, style: .time)
            Text("Emoji:")
            Text(entry.emoji)
        }
    }
}

🧱 4. Configure the Widget Structure

This section ties everything together and registers the widget with iOS.

struct AppWidget: Widget {
    let kind: String = "AppWidget"

    var body: some WidgetConfiguration {
        StaticConfiguration(kind: kind, provider: Provider()) { entry in
            if #available(iOS 17.0, *) {
                AppWidgetEntryView(entry: entry)
                    .containerBackground(.fill.tertiary, for: .widget)
            } else {
                AppWidgetEntryView(entry: entry)
                    .padding()
                    .background()
            }
        }
        .configurationDisplayName("My Widget")
        .description("This is an example widget.")
    }
}

👀 5. Previewing Your Widget

SwiftUI’s new #Preview lets you simulate the widget in Xcode.

#Preview(as: .systemSmall) {
    AppWidget()
} timeline: {
    SimpleEntry(date: .now, emoji: "😀")
    SimpleEntry(date: .now, emoji: "🤩")
}

🎯 Make It Useful — Show Random Motivational Quotes

Let’s make this widget more inspiring.

Instead of an emoji, we’ll show motivational quotes every 10 minutes and change background colors.

🛠 Update SimpleEntry

struct SimpleEntry: TimelineEntry {
    let date: Date
    let message: String
    let color: Color
}

🧠 Update Provider

Add sample messages and colors:

let messages = [
    "Keep going 💪", "You're doing great!", "Just one more step 🚶",
    "Stay focused 🎯", "You’ve got this 🔥", "Make it count 💥",
    "Smile, breathe, move 🌿", "Every moment matters ⏳"
]

let backgroundColors: [Color] = [
    .blue, .green, .orange, .pink, .purple, .yellow, .teal, .mint
]

let defaultColor: Color = .gray
let defaultMessage = "Keep going 💪"

Update placeholder and getSnapshot:

func placeholder(in context: Context) -> SimpleEntry {
    SimpleEntry(date: Date(), message: defaultMessage, color: defaultColor)
}

func getSnapshot(in context: Context, completion: @escaping (SimpleEntry) -> ()) {
    let entry = SimpleEntry(date: Date(), message: defaultMessage, color: defaultColor)
    completion(entry)
}

Update getTimeline:

func getTimeline(in context: Context, completion: @escaping (Timeline<Entry>) -> ()) {
    var entries: [SimpleEntry] = []
    let currentDate = Date()

    for minuteOffset in 0 ..< 6 {
        let entryDate = Calendar.current.date(byAdding: .minute, value: minuteOffset * 10, to: currentDate)!
        let message = messages.randomElement() ?? defaultMessage
        let backgroundColor = backgroundColors.randomElement() ?? defaultColor
        let entry = SimpleEntry(date: entryDate, message: message, color: backgroundColor)
        entries.append(entry)
    }

    let timeline = Timeline(entries: entries, policy: .atEnd)
    completion(timeline)
}

🎨 Redesign the Widget View

struct AppWidgetEntryView : View {
    var entry: Provider.Entry

    var body: some View {
        ZStack {
            VStack(spacing: 10) {
                Text(entry.message)
                    .font(.headline)
                    .multilineTextAlignment(.center)
                    .minimumScaleFactor(0.5)
                    .lineLimit(1)
                    .foregroundStyle(.primary)

                Text(entry.date, style: .time)
                    .font(.caption)
                    .foregroundStyle(.secondary)
            }
        }
    }
}

⚙️ Update Widget Config

struct AppWidget: Widget {
    let kind: String = "AppWidget"

    var body: some WidgetConfiguration {
        StaticConfiguration(kind: kind, provider: Provider()) { entry in
            let backgroundColor = entry.color.opacity(0.25)

            if #available(iOS 17.0, *) {
                AppWidgetEntryView(entry: entry)
                    .containerBackground(backgroundColor, for: .widget)
            } else {
                AppWidgetEntryView(entry: entry)
                    .padding()
                    .background(backgroundColor)
            }
        }
        .configurationDisplayName("Motivational Widget")
        .description("This Widget Will Keep You Motivated")
    }
}

🧪 Preview It

#Preview("Small Widget", as: .systemSmall) {
    AppWidget()
} timeline: {
    SimpleEntry(date: .now, message: "Keep going 💪", color: .orange)
    SimpleEntry(date: .now, message: "Stay focused 🎯", color: .purple)
}

📱 Test on a Real Device

1. Run your main app target on a real device.

2. Long-press the Home Screen → Tap “+” → Search for your widget → Add.

3. Optionally tap and edit the widget for configuration.

Note: App Groups aren’t required if your widget shows static or internal data only.

✅ Final Notes

• Code is tested on Xcode 16.2 and iOS 18.2 (as of June 2025)

• Always check compatibility with newer Xcode versions

• If you run into issues, let us know via comments

DOWNLOAD SOURCE CODE FOR THIS TUTORIAL

The post Build Your First Widget in SwiftUI — A Guide with Source Code appeared first on AppMakers.Dev.

Whether you’re a developer, tech enthusiast, or just want to know what’s coming to your devices later this year, this article walks you through every major WWDC 2025 keynote announcement — in order, with clear, quick summaries for each product update.

🤖 Apple Intelligence: On-Device AI for Everyone

Apple unveiled Apple Intelligence, its new on-device AI system that works across iPhone, iPad, and Mac:

• Smart replies, Genmoji, and Image Playground built directly into apps

• Visual lookups and content summaries through Visual Intelligence

• New Foundation Model API lets developers use Apple’s AI in their own apps

✨ The New Look: Liquid Glass Design Language

One of the standout updates from the WWDC 2025 keynote was the debut of Liquid Glass — Apple’s first major UI redesign since iOS 7:

• Fluid, translucent layers that adapt to light and motion

• New tab bars, animated icons, and responsive UI components

• Customizable widget styles and multiple new icon looks

This redesign rolls out across iOS 26, iPadOS 26, macOS Tahoe, visionOS 26, and more.

📱 iOS 26: Smarter, Sleeker, and AI-Powered

Apple is skipping version 19 and jumping straight to iOS 26, which brings:

• Redesigned lock screen with dynamic 3D time displays

• New Camera app UI and Photos with spatial visual memories

• Safari gets an edge-to-edge layout and floating tab bar

• FaceTime, Phone, and Messages see major redesigns

• Genmoji upgrades and smart emoji creation

• Live translation in Messages, FaceTime, and Phone

• Visual Intelligence adds tap-to-search and contextual suggestions

🎵 Apple Music & Maps Improvements

• AutoMix: DJ-style transitions between tracks

• Translated lyrics and pronunciation help

• New Maps features like visited place history and smarter routing

💳 Wallet + Apple Pay Upgrades

• Support for digital IDs, in-person rewards, and installment payments

• AI-powered order tracking and real-time boarding info in Wallet

🎮 All-New Games App

A new hub for Apple gaming across platforms:

• Play Together multiplayer challenges

• Apple Arcade integration

• Controller support and synced progress on iPhone, iPad, and Mac

⌚ watchOS 26: Personalized and Proactive

Apple Watch gets smarter with:

• Liquid Glass UI for the smaller screen

• Workout Buddy AI coach

• Wrist Flick gesture for hands-free interaction

• Notes app and improved Smart Stack predictions

• Live Translation directly on the watch

📺 tvOS 26: Shared Experiences and Smarter UI

• New design language for Apple TV

• Auto-profile loading

• Shared music queue and real-time emoji reactions

• iPhone karaoke mic support with Apple Music Sing

💻 macOS Tahoe: Power Meets Personalization

macOS 26, aka Tahoe, brings:

• Liquid Glass across Finder, Menu Bar, and Dock

• Custom folder icons with colors and emoji

• iPhone-style Phone app and Hold Assist

• Spotlight overhaul: Quick Keys, clipboard history

• Smart automations using Apple Intelligence + Shortcuts

• New gaming capabilities with Metal 4 and Game Overlay

🥽 visionOS 26: Spatial Becomes Practical

Updates to Apple Vision Pro include:

• Persistent widgets and floating apps

• Spatial Scenes from your photo library

• Shared movie watching and workspaces

• Stylus support (Logitech Muse) and PSVR2 controller support

• Adobe Premiere support for spatial video editing

📝 iPadOS 26: Full Multitasking Power

Apple calls it the biggest iPadOS update ever:

• Resizable windows, Exposé view, tiling, minimize/restore

• Mac-style Menu Bar on iPad

• Better Files app with list views and Dock folders

• Preview app for PDFs and image markup

• High-quality screen/audio recording with AirPods

• Background Tasks as Live Activities

• New tools for creators and productivity workflows

🔧 Developer Tools and Xcode Updates

• Foundation Model API for private, on-device AI

• Expanded SwiftUI capabilities

• App Intents for smarter system integration

• Icon Composer for dynamic icon creation

• ChatGPT-powered code assistant in Xcode 16

🗓 Release Schedule

• Developer betas: Available now

• Official releases: Fall 2025, with all OS versions jumping to 26

🧠 Final Thoughts: A New Era Begins

The WWDC 2025 keynote was more than just feature updates — it marked a dramatic shift in how Apple sees its platforms evolving. With Apple Intelligence woven throughout every device, a bold new Liquid Glass interface, and the power tools developers have been asking for, this year’s WWDC sets Apple up for a smarter, more connected ecosystem.

Watch the official WWDC 2025 Keynote Video here 

The post WWDC 2025 Keynote Recap: All the Biggest Announcements from iOS 26 to Apple Intelligence appeared first on AppMakers.Dev.

Step 1: Create a New Xcode Project

1. Open Xcode and create a new SwiftUI project.
2. Name your project. In this example, we’ll call it “Xcode To Github Demo App.”

Step 2: Add Your GitHub Account to Xcode

1. In Xcode, navigate to Xcode > Settings (or Preferences, depending on your macOS version).
2. Go to the Accounts tab.
3. Click the + button to add a new account, and select GitHub.
4. Enter your GitHub username.
5. You’ll need a personal access token to authenticate. Let’s generate one.

Step 3: Generate a Personal Access Token on GitHub

1. Log in to your GitHub account, tap on your profile icon and go to Settings.
2. Scroll down and select Developer settings (on the left).
3. In the left-hand menu, click Personal access tokens > Tokens (classic).
4. Click Generate new token, and confirm by entering your GitHub password.
5. Name your token (e.g., “Xcode”), and set an expiration date or choose No expiration.
6. Check all the scopes to grant full access, then click Generate token.
7. Copy the generated token.

Step 4: Link the Token with Xcode

1. Go back to Xcode, paste the token in the Token field, and click Sign In.
2. Now your GitHub account is linked to Xcode.

Step 5: Set Up Source Control in Xcode

1. In Xcode, go to Settings > Source Control > Git.
2. Set up your Author Name and Email (use your GitHub username and the email associated with your GitHub account).

Step 6: Create a New Git Repository and Push Project to Github

1. Close the Settings window.
2. Tap Command+2 to open Navigator’s Source Control and select Repositories.
3. Tap on the Xcode To Github Demo App in repository and tap “Xcode To Github Demo App” Remote
4. Choose the Github Account, Set repository name if needed, Set Visibility (Public or Private), write Description if needed
5. Tap Create 
6. Optional: If you don’t see Repository in your Navigator you can try to tap Integrate > New Git Repository to create one and after that follow the steps 1-5 of Step 6

Step 7: Check repository on Github

1. Go Github > Your Repositories and check if the new repository appeared

Step 8: Make Changes and Commit Them

1. Let’s make a simple change in the project:
   • For example, update the text in ContentView.swift from “Hello, World!” to “Hello Github”
2. Go to Source Control > Commit, and you’ll see the change highlighted.
3. Add a commit message (e.g., “Changed ContentView Message to Hello Github“), and click Commit.
4. If it asks to Stage, tap Stage all and commit (You should stage changes before committing)

Step 9: Push the Commit to GitHub

1. After committing the changes, go to Source Control > Push.
2. Select the origin (by default, it’s the main branch).
3. Leave include tags unchecked, we will discuss this checkbox later
4. Click Push, and your changes will be uploaded to GitHub.

Step 10: Verify the Changes on GitHub

1. Go to your GitHub repository and refresh the page.
2. You should see the recent commits and changes in the project files.
3. You should check Activity section of your project on Github to see the latest commit

How to Tag Your commit in Xcode and Provide a Version (e.g., 1.0.0) for your Commit

Tagging helps mark specific points in your project history, such as a release version.

1. Go to Source Control > Branches.
2. Right click on main and select Tag “main”
3. Add version number, for example1.0.0 and a message
   
4. Make some changes into your project
5. Go to Integrate > Push and check include tags
6. Go to Github > Releases > check tags

How to Fetch changes from Remote

1. Go to Github into your Project repository and tap Create Readme file there
2. Fill in Readme file with some text, for example:

   # README
   
   Demo App to show how to Connect Xcode Project to Github
   
   ## Overview
   
   Learn Daily
   
   ### Section header
   
   Some Section Text here
   

3. Now go to Xcode and tap Pull to get changes from Github.

Understanding Staging, Amending, and Committing Changes

Xcode uses Git’s staging area to manage changes, allowing you to control exactly what goes into each commit. Here’s how to work with staging and amending:

What is Staging?

Staging means preparing specific changes to be included in your next commit. In Xcode:

• Staged Changes: These are the changes you have selected to commit. They will be included in the next commit you make.
• Unstaged Changes: These changes are not yet prepared for committing. You can choose to stage them by checking the boxes next to the file names in the commit window.

How to Stage Changes in Xcode:

1. View the Changes: Go to Source Control > Commit to see the list of changed files.
2. Stage the Files: Check the box next to each file you want to include in your commit.
3. Unstage if Necessary: Uncheck any files you don’t want to commit yet.

Amending a Commit

Sometimes you need to make small changes to the last commit without creating a new commit. Here’s how to amend in Xcode:

1. Make the Desired Changes: Modify the files you want to update.
2. Go to the Commit Window: Source Control > Commit.
3. Select “Amend Previous Commit”:
   • At the bottom of the commit window, you’ll see an option labeled “Amend Previous Commit.”
   • Check this box to modify the last commit instead of creating a new one.
   • Update the commit message if necessary, and click Commit.

Example Use Cases:

• Staging: Useful for breaking larger changes into smaller, logical commits.
• Amending: Helps fix mistakes in the last commit, such as forgetting a file or making a typo in the commit message.

The post How to upload your Xcode Project to Github – Tutorial appeared first on AppMakers.Dev.

Step 1: Defining the Recipe Model

Setup a Recipe model that represents a dish with a name, cooking time, and ingredients.

import Foundation
import SwiftData

@Model
class Recipe {

    @Attribute(.unique) var id: UUID
    var name: String?
    var cookingTime: Int // in minutes
    var ingredients: [String]

    init(id: UUID = UUID(), name: String? = nil, cookingTime: Int, ingredients: [String]) {
        self.id = id
        self.name = name
        self.cookingTime = cookingTime
        self.ingredients = ingredients
    }
}

This model defines each recipe with a unique ID, name, cooking time, and a list of ingredients. With this setup, you can now store recipes in SwiftData and use them in your app.

Step 2: Creating Sample Data for Previews

Now, let’s generate sample data using ModelContainer. You’ve written a method to insert sample recipes into a ModelContainer for use in previews.

import Foundation
import SwiftData

let sampleRecipes = [
    Recipe(name: "Spaghetti Bolognese", cookingTime: 45, ingredients: ["Spaghetti", "Minced Beef", "Tomato Sauce"]),
    Recipe(name: "Grilled Cheese Sandwich", cookingTime: 10, ingredients: ["Bread", "Cheese", "Butter"]),
    Recipe(name: "Beef Wellington", cookingTime: 120, ingredients: ["Beef Tenderloin", "Puff Pastry", "Mushrooms", "Dijon Mustard"])
]

extension Recipe {
    @MainActor static func makeSampleRecipes(in container: ModelContainer) {
        
        let context = container.mainContext
        
        // Check if there are any existing recipes in the database
           let existingRecipesCount = (try? context.fetch(FetchDescriptor()))?.count ?? 0
           guard existingRecipesCount == 0 else {
               // If there are existing recipes, do not create new ones
               return
           }
           
           // Sample data to create
           let recipes = [
               Recipe(name: "Spaghetti Bolognese", cookingTime: 45, ingredients: ["Spaghetti", "Minced Beef", "Tomato Sauce"]),
               Recipe(name: "Grilled Cheese Sandwich", cookingTime: 10, ingredients: ["Bread", "Cheese", "Butter"]),
               Recipe(name: "Beef Wellington", cookingTime: 120, ingredients: ["Beef Tenderloin", "Puff Pastry", "Mushrooms", "Dijon Mustard"])
           ]
           
           // Insert the sample recipes into the context
           for recipe in recipes {
               context.insert(recipe)
           }
           
           // Save the context to persist the new data
           try? context.save()
        
    }
}

This method defines three recipes and inserts them into the ModelContainer. The @MainActor annotation ensures this method runs on the main thread, which is essential for interacting with SwiftData.

Step 3: Implementing the RecipeSampleData for Previews

The RecipeSampleData structure serves as a PreviewModifier to create in-memory sample data. This makes it easy to display recipes in SwiftUI previews.

import SwiftUI
import SwiftData

struct RecipeSampleData: PreviewModifier {
    static func makeSharedContext() throws -> ModelContainer {
        let config = ModelConfiguration(isStoredInMemoryOnly: true)
        let container = try ModelContainer(for: Recipe.self, configurations: config)
        Recipe.makeSampleRecipes(in: container) // Load sample recipes
        return container
    }
    
    func body(content: Content, context: ModelContainer) -> some View {
        content.modelContainer(context)
    }
}

extension PreviewTrait where T == Preview.ViewTraits {
    @MainActor static var sampleRecipeData: Self = .modifier(RecipeSampleData())
}

This modifier creates a ModelContainer configured for in-memory storage. The makeSampleRecipes method loads sample recipes into the container, and the modifier applies this data to any view using the .modelContainer() modifier.

Step 4: Creating Recipe Views with Sample Data

Now let’s integrate this sample data into a few SwiftUI views.

Recipe List View

The RecipeListView displays a list of recipes loaded from SwiftData. The @Query property wrapper retrieves the recipes, and the list is built dynamically.

import SwiftUI
import SwiftData

struct RecipeListView: View {
    @Query private var recipies: [Recipe]
    @Environment(\.modelContext) private var context
    
    var body: some View {
       
        List {
            ForEach(recipies) { recipe in
              
                VStack(alignment: .leading) {
                    Text(recipe.name ?? "")
                           .font(.headline)
                       Text("Cooking Time: \(recipe.cookingTime) mins")
                           .font(.subheadline)
                   }
            }
        } .task {
            
               Recipe.makeSampleRecipes(in: context.container)
        }
    }
}

#Preview(traits: .sampleRecipeData) {
    RecipeListView()
}

In this example, the @Query property wrapper retrieves all Recipe objects from the ModelContainer, which are then displayed in a List using SwiftUI. The preview uses .sampleRecipeData to load in-memory recipes for testing the UI.

Recipe Detail View

For more detailed recipe information, the RecipeDetailView displays the name, cooking time, and ingredients of a single recipe. This view doesn’t query for data but accepts a Recipe object as a parameter.

import SwiftUI
import SwiftData

struct RecipeDetailView: View {
    let recipe: Recipe

    var body: some View {
        VStack(alignment: .leading, spacing: 10) {
            Text(recipe.name ?? "No Name")
                .font(.largeTitle)
            Text("Cooking Time: \(recipe.cookingTime) mins")
                .padding(.bottom)
            Text("Ingredients:")
            ForEach(recipe.ingredients, id: \.self) { ingredient in
                Text(ingredient)
            }
        }
        .padding()
    }
}

#Preview(traits: .sampleRecipeData) {
    @Previewable @Query var recipes: [Recipe]  // Query sample recipes
    RecipeDetailView(recipe: recipes.first!)
}

In this view, the recipe’s details are displayed, including the name, cooking time, and ingredients. The preview fetches the first recipe from the sample data.

Step 5

Now let’s connect our ListView with a DetailView using a NavigationLink inside a NavigationStack

import SwiftUI
import SwiftData

struct RecipeListView: View {
    @Query private var recipies: [Recipe]
    @Environment(\.modelContext) private var context
    
    var body: some View {
       
        NavigationStack {
            List {
                ForEach(recipies) { recipe in
                    NavigationLink(destination: RecipeDetailView(recipe: recipe)) {
                        
                        // Recipe Row
                        VStack(alignment: .leading) {
                            Text(recipe.name ?? "")
                                .font(.headline)
                            Text("Cooking Time: \(recipe.cookingTime) mins")
                                .font(.subheadline)
                        }
                    }
                }
            } .task {
                
                Recipe.makeSampleRecipes(in: context.container)
                
            }
        }
    }
}

#Preview(traits: .sampleRecipeData) {
    RecipeListView()
}

Key Differences Between Preview and @Previewable

1. Preview with Traits (.sampleRecipeData):
   • Best for views that query data using SwiftData.
   • Automatically loads sample data into the view’s query and binds it to the UI.
   • No need to manually pass data; the query handles it for you.
2. @Previewable:
   • Best for views that rely on models passed in as parameters (e.g., detail views).
   • Allows you to create sample data and pass it directly to the view.
   • You have full control over what specific data is provided for the preview.

Conclusion

By using SampleData and the @Previewable macro, you can easily preview recipe data within your SwiftUI views. Whether you’re working with data that relies on queries or views that require individual models, SwiftData provides an efficient way to prototype and test your app in Xcode.

The post Learn how to work with Xcode Previews in SwiftData App appeared first on AppMakers.Dev.

Step 1: Define the Entity

First, we need to define a Task entity that we will use to store our task data in SwiftData.

import Foundation
import SwiftData

@Model
class Task {
    @Attribute(.unique) var id: UUID
    var title: String?
    var isCompleted: Bool

    init(id: UUID = UUID(), title: String? = nil, isCompleted: Bool = false) {
        self.id = id
        self.title = title
        self.isCompleted = isCompleted
    }
}

In this code, we define the Task model with an id, title, and isCompleted property. The @Model attribute is used to make this class a SwiftData model.

Step 2: Create the Task List View

Next, we’ll create a SwiftUI view that displays a list of tasks, each with a toggle for marking them as completed or not.

import SwiftUI
import SwiftData

struct TaskListView: View {
    @Query(sort: \Task.title) private var tasks: [Task]
    @Environment(\.modelContext) private var context
    
    var body: some View {
        List {
            ForEach(tasks) { task in
                HStack {
                    Text(task.title ?? "")
                        .font(.title2)
                        .foregroundColor(task.isCompleted ? .green : .black)
                    
                    Spacer()
                    
                    Toggle("", isOn: Bindable(task).isCompleted)
                   
                }
            }
            .onDelete(perform: deleteTask)
        }
        .task {
            
            for task in sampleTasks {
                context.insert(task)
            }
            
        }
        .navigationTitle("Tasks")
    }
    
    private func updateTaskCompletion(_ task: Task, newValue: Bool) {
        task.isCompleted = newValue
        try? context.save()
    }
    
    private func deleteTask(at offsets: IndexSet) {
        for index in offsets {
            context.delete(tasks[index])
        }
        try? context.save()
    }
}

In this view, each task can be marked as completed by toggling a switch, and we handle saving this state with SwiftData.

Step 3: Preview with SwiftData Context

To make the preview functional, we need to set up a SwiftData context. We’ll use the PreviewModifier protocol to create a shared context that holds some sample data.

import Foundation
import SwiftUI
import SwiftData

let sampleTasks = [
    Task(title: "Buy Groceries"),
    Task(title: "Walk the Dog", isCompleted: true),
    Task(title: "Complete SwiftUI Project")
]

struct SampleTaskData: PreviewModifier {
    static func makeSharedContext() throws -> ModelContainer {
        let container = try ModelContainer(for: Task.self, configurations: ModelConfiguration(isStoredInMemoryOnly: true))

        for task in sampleTasks {
            container.mainContext.insert(task)
        }
        
        return container
    }

    func body(content: Content, context: ModelContainer) -> some View {
        content.modelContainer(context)
    }
}

extension PreviewTrait where T == Preview.ViewTraits {
    static var sampleTaskData: Self = .modifier(SampleTaskData())
}

In this example, the SampleTaskData struct conforms to PreviewModifier, providing a shared SwiftData context with in-memory tasks for the preview.

Step 4: Add a Preview #Preview(traits:

Now, let’s create a dynamic preview

#Preview(traits: .sampleTaskData) {
    TaskListView()
}

Step 5. Add @Previewable to Preview

Now, we’ll use the @Previewable attribute inside the #Preview macro to interact with the Task completion status dynamically.

#Preview("Dynamic Task Preview") {
    @Previewable @State var isTaskCompleted = false
    let sampleTask = Task(title: "Complete SwiftUI Project", isCompleted: isTaskCompleted)
    
    return HStack {
        Text(sampleTask.title ?? "")
            .font(.title2)
            .foregroundColor(sampleTask.isCompleted ? .green : .black)
        
        Spacer()
        
        Toggle("", isOn: $isTaskCompleted)
    }
}

In this preview:

• The @Previewable attribute tags the isTaskCompleted state variable.
• This allows you to toggle the state of isTaskCompleted directly in the Xcode preview and see real-time changes.
• The task’s completion status will update dynamically as you interact with the toggle in the preview.

This tutorial demonstrated how to display sample SwiftData in SwiftUI with PreviewModifier and @Previewable

The post How to display sample SwiftData in SwiftUI with PreviewModifier appeared first on AppMakers.Dev.

This article will break down the key differences between structs and classes in modern SwiftUI development and how SwiftData influences these choices.

The Basics: Structs vs. Classes

Structs

• Value types: Structs are copied when passed or assigned to new variables.
• Immutable by default: Changes to a struct instance do not affect other copies.
• No ARC (Automatic Reference Counting): Structs are more lightweight, and Swift can optimize them for better performance.
• Better for simple data: Ideal for models that represent small, self-contained pieces of data.

Classes

• Reference types: Classes are passed by reference, meaning changes made to one instance affect all references to it.
• Mutable by nature: Changes can propagate across references, which is useful when you need shared state.
• Managed by ARC: Classes come with ARC, which tracks and manages the lifecycle of objects.
• Better for shared or complex data: Ideal for cases where objects need to be shared across different parts of your app or involve relationships.

SwiftUI: Using Structs for Models

In most SwiftUI applications, structs are the default choice for models. Since SwiftUI is designed around declarative programming principles, structs’ value semantics align perfectly with SwiftUI’s philosophy.

Here’s an example of using a struct for a simple Person model:

struct Person {
    var name: String
    var age: Int
}

Why Use Structs in SwiftUI?

1. Performance: Structs are faster and more efficient due to their value semantics.
2. Predictability: Since structs are copied when passed, each instance is independent, which makes it easier to reason about your code.
3. Concurrency Safety: Structs’ immutability (unless explicitly mutable) helps avoid issues when working with concurrency.

In simple terms, structs are great for SwiftUI models when you:

• Don’t need shared state between views or components.
• Are modeling simple data that doesn’t rely on persistence frameworks like SwiftData.

SwiftData and the Case for Classes

While structs are great for lightweight models, the need for classes becomes apparent when working with SwiftData (or other persistence frameworks, like Core Data). SwiftData requires reference semantics, making classes necessary for models to ensure data consistency and lifecycle management.

Here’s an example of a Person model in SwiftData:

import SwiftData

@Model
class Person {
    var name: String
    var age: Int
    
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}

Why Use Classes with SwiftData?

1. Reference Semantics: SwiftData needs objects to be shared across multiple components. If you update the Person class in one part of the app, the changes will automatically reflect everywhere it is referenced.
2. Persistence: SwiftData (and Core Data) manages object graphs, relationships, and persistence through reference types.
3. Complex Relationships: If your model has relationships (e.g., a Person having a list of friends), classes are better suited to managing these references without duplicating data.

Thus, classes are essential when:

• You’re using SwiftData or other persistence frameworks that need managed object contexts.
• Your data is shared across multiple parts of the app, and you want to observe and react to changes.
• You’re modeling complex relationships between objects.

When to Use Structs vs. Classes: A Recap

Final Thoughts

In modern SwiftUI development (2024 and beyond), structs are the default choice for most models due to their performance and value semantics. However, when working with frameworks like SwiftData—where persistence, shared state, and reference management are essential—classes become a necessity.

To summarize:

• Use structs for lightweight, simple, and self-contained models that don’t require shared state.
• Use classes when working with SwiftData or any scenario where reference semantics and persistence are required.

For more about Classes and Structs read this Article

Understanding when to use structs vs. classes will help you design more efficient and scalable SwiftUI applications. Happy coding!

The post Structs vs. Classes in SwiftUI: When to Use Each and why we use Classes in SwiftData appeared first on AppMakers.Dev.

1. What is Declarative Programming (SwiftUI)?

SwiftUI is Apple’s framework introduced in 2019 for developing user interfaces in a declarative way. In declarative UI, you describe what the UI should look like, not how to create it. You declare your user interface and its behavior in a way that is much closer to natural language, using SwiftUI’s body property.

Key Characteristics of SwiftUI:

• Less Code: SwiftUI requires fewer lines of code to achieve the same result as UIKit.
• Data-driven: The UI components are a function of the state. When the state changes, the UI updates automatically.
• Consistency Across Platforms: SwiftUI works across all Apple platforms, providing a unified development experience.
• Live Preview: With SwiftUI, you can see live previews of your UI as you code.

import SwiftUI

struct ContentView: View {
    @State private var isButtonPressed = false

    var body: some View {
        Button(action: {
            self.isButtonPressed.toggle()
        }) {
            Text(isButtonPressed ? "Pressed!" : "Press Me")
        }
    }
}

In this SwiftUI code, we describe a Button and its behavior. The UI automatically updates when isButtonPressed changes, without any need for explicit UI manipulation code.

2. What is Imperative Programming (UIKit)?

UIKit, the traditional framework used in iOS development, is imperative. This means you instruct the program how to perform operations to achieve the desired UI. You manually update the UI based on the state of the application, often leading to more boilerplate code.

Key Characteristics of UIKit:

• Detailed Control: UIKit gives you granular control over UI elements and their behaviors.
• Familiarity and Maturity: Being older, UIKit has a vast community, resources, and a proven track record.
• Manual Updates: Changes in the UI need to be manually handled, requiring more lines of code and effort.

import UIKit

class ViewController: UIViewController {
    private var isButtonPressed = false
    private let button = UIButton()

    override func viewDidLoad() {
        super.viewDidLoad()
        setupButton()
    }

    private func setupButton() {
        button.setTitle("Press Me", for: .normal)
        button.addTarget(self, action: #selector(buttonTapped), for: .touchUpInside)
        // additional code to layout the button
    }

    @objc private func buttonTapped() {
        isButtonPressed.toggle()
        updateButtonTitle()
    }

    private func updateButtonTitle() {
        button.setTitle(isButtonPressed ? "Pressed!" : "Press Me", for: .normal)
    }
}

In the UIKit example, we manually manage the state and update the UI (button title) based on the user interaction.

3. SwiftUI vs UIKit – Main Differences

Declarative vs. Imperative:

• SwiftUI: You declare the UI elements and their dependencies on data (datasource). The framework takes care of the rest.
• UIKit: You explicitly create and manage UI elements and their lifecycle.

State Management and UI Updates:

• SwiftUI: The view is a function of the state. Any changes in the state lead to a re-render of the UI.
• UIKit: You have to manually listen to changes and update the UI accordingly.

Code Conciseness and Readability:

• SwiftUI: Less and more readable code. Easier for beginners and reduces the chance of bugs.
• UIKit: More verbose, offering finer control but at the cost of more code.

4. How Views Update in SwiftUI and UIKit

SwiftUI:

In SwiftUI, the view automatically updates when the state changes. SwiftUI’s view is a struct, which is a value type, ensuring a single source of truth. When the underlying data changes, SwiftUI intelligently re-renders the view to reflect those changes, making the data flow seamless and straightforward.

UIKit:

In UIKit, updating the view is a manual process. When the data changes, you need to write additional code to update the UI elements. This approach gives you more control but requires a deeper understanding of the view lifecycle and state management.

Conclusion

In summary, SwiftUI’s declarative nature offers a modern, efficient, and streamlined approach to UI development in iOS, ideal for rapid development and reducing boilerplate code. UIKit, with its imperative approach, provides detailed control and is backed by years of community support and resources. Both have their place in iOS development, and the choice largely depends on the project requirements and developer preference.

The post SwiftUI vs UIKit – Declarative vs. Imperative Programming appeared first on AppMakers.Dev.

What is SwiftData?

SwiftData is a data management framework introduced by Apple, designed to integrate seamlessly with Swift and SwiftUI. It provides a simple yet powerful way to manage and persist data in iOS and macOS apps without needing extensive setup. By leveraging the @Model macro, developers can define Swift classes as persistent data models, allowing the framework to automatically handle database schemas, change tracking, and data synchronization. SwiftData also supports key features like iCloud syncing, in-memory storage for testing, and relationship management between models, making it an ideal tool for modern app development. Its deep integration with SwiftUI ensures that any changes to your data automatically trigger UI updates, simplifying the development process and enhancing the performance of data-driven apps.

Step 1: Setting Up Your SwiftData Model

First, let’s create a model representing something simple. In our case, we’ll model a Book. We’ll define properties such as the book’s title, author, and genre. You can add more attributes as needed.

1.1 Create the Model File

• Open Xcodea and. Create a new Swift file called Book.swift.
• Import SwiftData.
• Define your model class with the @Model macro. This macro ensures that your class is recognized by SwiftData for persistence.

import SwiftData

@Model
class Book {
    var title: String
    var author: String
    var genre: String?
    
    init(title: String, author: String, genre: String? = nil) {
        self.title = title
        self.author = author
        self.genre = genre
    }
}

Note: Optionals are important in SwiftData because non-optional properties must always have a value. If you’re planning future migrations, use optionals (?) for fields that could be nil.

Step 2: Setting Up the Main App and Model Container

Before we can persist and manipulate Book instances, we need to configure the model container in our main app file.

2.1 Set Up Model Container

1. In your main App file, import SwiftData.
2. Use the .modelContainer modifier to declare the models that should be persisted across app launches.

import SwiftUI
import SwiftData

@main
struct BookApp: App {
    var body: some Scene {
        WindowGroup {
            MainView().modelContainer(for: [Book.self])
        }
    }
}

This setup creates a default model container that stores data persistently. If you need to use a different storage method (e.g., in-memory), you can customize it, but for this example, we’ll stick with the default.

Step 3: Creating a View to Display and Modify Data

Now that we have our Book model and the model container set up, we can create a SwiftUI view to display and modify the data.

3.1 Fetching Data Using @Query

SwiftData simplifies fetching data with the @Query property wrapper, allowing us to query models and automatically update the UI when data changes.

import SwiftUI
import SwiftData

struct MainView: View {
    @Query(sort: \Book.title, order: .forward) private var books: [Book]
    @Environment(\.modelContext) private var context
    
    @State private var newBookTitle = ""
    @State private var newBookAuthor = ""
    @State private var newBookGenre = ""
    
    var body: some View {
        NavigationStack {
            VStack {
                // List of books
                List(books) { book in
                    HStack {
                        Text(book.title)
                        Spacer()
                        Text(book.author)
                    }
                }
                
                // Form to add a new book
                VStack {
                    TextField("Title", text: $newBookTitle)
                        .textFieldStyle(RoundedBorderTextFieldStyle())
                        .padding()
                    TextField("Author", text: $newBookAuthor)
                        .textFieldStyle(RoundedBorderTextFieldStyle())
                        .padding()
                    TextField("Genre", text: $newBookGenre)
                        .textFieldStyle(RoundedBorderTextFieldStyle())
                        .padding()
                    
                    Button("Add Book") {
                        addNewBook()
                    }
                    .padding()
                    .background(Color.blue)
                    .foregroundColor(.white)
                    .cornerRadius(8)
                }
            }
            .navigationTitle("Books")
        }
    }
    
    // Function to add a new book
    private func addNewBook() {
        let newBook = Book(title: newBookTitle, author: newBookAuthor, genre: newBookGenre.isEmpty ? nil : newBookGenre)
        context.insert(newBook)
        
        do {
            try context.save()
        } catch {
            print("Failed to save book: \(error.localizedDescription)")
        }
        
        // Reset form fields
        newBookTitle = ""
        newBookAuthor = ""
        newBookGenre = ""
    }
}

Here’s what’s happening:

• Fetching Data: The @Query property fetches all Book instances, sorted by title.
• Environment Model Context: The @Environment(\.modelContext) provides access to the current model context for saving or deleting data.
• Adding a New Book: The addNewBook function inserts a new Book into the context and saves the changes.

Step 4: Previewing and Working with In-Memory Storage

For previews and testing, we can use an in-memory container. This prevents saving the data permanently and resets it between preview runs.

#Preview {
    MainView().modelContainer(for: [Book.self], inMemory: true)
}

Using in-memory storage is particularly useful when testing or running previews, as it ensures that each run starts with a clean state.

Step 5: Deleting a Book

You can enable deletion of items in the list by adding a swipe-to-delete action. Add this to the List view:

List {
    ForEach(books) { book in
        HStack {
            Text(book.title)
            Spacer()
            Text(book.author)
        }
    }
    .onDelete(perform: deleteBook)
}

Then, define the deleteBook function:

private func deleteBook(at offsets: IndexSet) {
    for index in offsets {
        context.delete(books[index])
    }
    
    do {
        try context.save()
    } catch {
        print("Failed to delete book: \(error.localizedDescription)")
    }
}

This function removes the selected Book from the context and saves the change.

Conclusion

In this article, we’ve covered how to:

• Set up a simple model with SwiftData.
• Create a model container to persist data.
• Fetch and display data using @Query.
• Add, delete, and persist data within a SwiftUI view.

SwiftData is powerful yet straightforward, making data management in SwiftUI apps easier and more efficient. You can further extend this example by adding relationships, more complex attributes, or custom storage configurations. Happy coding!

The post SwiftData Tutorial – How to Implement SwiftData in SwiftUI App appeared first on AppMakers.Dev.