Debugging SwiftUI views can feel a little challenging due to its declarative nature. In this post, we’ll explore how to add print statements into your SwiftUI code to observe state changes, view updates, and data flow.

Why use print in SwiftUI?

SwiftUI’s declarative paradigm means you describe what your UI should look like, and the framework handles when to update it. This can make it easier to reason about but harder to debug lifecycle events and UI-related state changes. print statements give you:

  • A view of the views lifecycle
  • Insight into state changes
  • A quick way to trace logic in view modifiers and custom methods

Basic print usage

Place a print call inside lifecycle callbacks or action areas such as a Button action:

struct CounterView: View {
    @State private var count = 0

    var body: some View {
        VStack {
            Text("Count: \(count)")
                .padding()
            Button("Increment") {
                count += 1
                print("Button tapped. count is now \(count)")
            }
        }
        .onAppear {
            print("CounterView appeared with count = \(count)")
        }
    }
}

In this example, if you open the Debug console, you’ll see messages when the view appears or the button is tapped.

Printing inside the body

Sometimes SwiftUI’s view builders don’t accept bare expressions. If you place a print("…") call directly at the top level of your body (or anywhere else that expects a View), you’ll see:

'buildExpression' is unavailable: this expression does not conform to 'View'

To bypass this, prefix with let _:

struct DemoView: View {
    var body: some View {
        // the below print will work
        let _ = print("Body reevaluated")
        Text("Content")
    }
}

This executes every time the body reevaluates and can spam your logs so use with caution.

Printing computed properties and functions

For reusable logic, add prints inside functions or computed properties:

func formattedDate(_ date: Date) -> String {
    let formatter = DateFormatter()
    formatter.dateStyle = .medium
    let result = formatter.string(from: date)
    print("formattedDate called: \(result)")
    return result
}

Call this from your view, and each invocation logs its output.

Conditional printing with compilation flags

Most uses of prints are part of the development cycle. However, if you want to persist print statements then it is a good idea to disable prints in production builds using #if DEBUG:

#if DEBUG
print("Debug: user is \(user.name)")
#endif

This ensures no debug logs appear in Release builds.

Best practices

  • Keep prints concise and informative
  • Use custom prefixes (e.g., [ViewName]) for easier filtering
  • Remove or guard prints that log large data structures
  • Use debugPrint for richer, detailed output (e.g., debugPrint(appState) prints a structured dump of your appState data).

Alternatives to print

  • Xcode’s view debugger for inspecting view hierarchy

Debugging with print is simple yet powerful for understanding SwiftUI’s behavior. I hope these tips help you quickly trace state flows and view updates in your apps.