Whenever you consider creating a scrollable screen in SwiftUI, you might think of using a List. However, it’s not always the best choice. Lists are great for displaying uniform data. For anything else, a ScrollView with a lazy stack is almost always the best option. This week, we will learn how to build a custom scrollable container in SwiftUI with precise control of look and feel.

Talking Liquid Glass with Apple

I spent three days talking Liquid Glass with Apple in NYC. Here’s what you need to know.

Expanding Animations in SwiftUI Lists

Ever tried to add a simple expand/collapse animation to a SwiftUI List and watched in horror as your beautiful animation turned into a janky mess? You’re not alone. I faced this issue a couple of months ago and thanks to Donny Wals, I decided to publish my findings.

SwiftUI View Lifecycle: When onAppear Actually fires

onAppear has had genuinely unpredictable moments across SwiftUI’s lifetime — firing twice, firing in unexpected order, not firing when you’d swear it should. For an API that every app relies on, that’s a problem.

How to support dark mode in SwiftUI programmatically

Learn how to improve type safety when working with semantic colors.

Borrowing from Kotlin/Android to Architect Scalable iOS Apps in SwiftUI

After looking around, I discovered the Android world. I was surprised by what Google provides for developers compared to Apple. Android developers have clear guides and patterns, and most importantly, real-world examples that show how to structure production apps and not just toy projects.

Adjusting line height in SwiftUI on iOS 26

On iOS 26, we have a new SwiftUI modifier, lineHeight(_:), for adjusting the distance between the baselines of two subsequent lines of text. This modifier accepts a new AttributedString attribute, AttributedString.LineHeight, which can also be used separately for styling attributed strings.

Mastering Geometry in SwiftUI - GeometryReader, GeometryProxy & onGeometryChange

SwiftUI’s layout system is powerful but often misunderstood. Most of the time stacks and spacers are enough, but when you need things like scroll-based effects, collapsing headers, or custom layouts, you need to understand geometry. This article walks through how SwiftUI layout actually works and explores the tools that let you inspect it — including GeometryReader, GeometryProxy, coordinate spaces, and modern APIs like onGeometryChange.

SwiftUI Pro

An agent skill to help you write smarter, simpler, and more modern SwiftUI, including guidance on API usage, design, performance, and accessibility.

Agentic coding in Xcode

Apple has finally released Xcode 26.3, which now supports agentic coding. In this article, I’ll guide you through configuring Xcode 26.3 and utilizing the latest best practices when using agentic tools for building apps on Apple platforms.

Morphing Sheets Out of Buttons in SwiftUI

WWDC 2025 brought many advancements in the UI with the new Liquid Glass design. Among them, there’s a brand new feature, a transition in particular, that would be easy to overlook in that huge load of novelties. This new built-in transition comes to add a new way to present sheets, as it allows to morph a sheet out of the button that initiates its appearance, instead of sliding up from the bottom edge. In plain words, the button is transformed into a sheet and the opposite, creating a beautiful visual effect.

How to use SwiftUI Coordinators to communicate with UIKit

When building SwiftUI apps, we sometimes still need UIKit. Maybe we’re integrating an older code base or using system controllers that don’t yet have a native SwiftUI equivalent. In those cases, we can wrap UIKit views or view controllers using UIViewControllerRepresentable. But as soon as delegates or callbacks are involved, we need a way to communicate back to SwiftUI. That’s where coordinators come in.

Advanced NavigationStack Patterns in SwiftUI

If you’ve worked on any non-trivial SwiftUI app, you’ve felt it - navigation logic scattered across views, random NavigationLinks fighting each other, and deep linking bolted on as an afterthought. It works until it doesn’t, and then you’re hunting through ten files to figure out why tapping “Settings” opened the wrong screen.

Making SwiftUI Buttons with Equal Widths

It's really common to have two buttons, one above another, and to have those buttons be the same size. However, when I tried to do this by laying out Buttons in a VStack, they wrapped to the smallest width needed to fit the labels. That meant that every button was a different width.

Add an Open Recent Menu to a SwiftUI app

Why would you need to add an Open Recent menu? The most common reason is you created an app that doesn’t use the document architecture, and you want a way for your app’s users to access recent items.

Migrating to the Observation framework in SwiftUI

SwiftUI's current state-of-the-art approach to state observation is the Observation framework. It uses the macro system in Swift to transform Swift types into observable state.

Advanced NavigationStack Patterns in SwiftUI

NavigationStack, introduced in iOS 16, revolutionized navigation in SwiftUI. While basic usage is straightforward, mastering its advanced patterns unlocks powerful capabilities for building complex, production-ready apps.

Swift Bits: Transition vs Transaction

Two concepts that frequently come up when building polished, animated interfaces are Transitions and Transactions. They sound similar (and they’re both related to motion and state changes) but they serve very different purposes.

SwiftUI Agent Skill: Build better views with AI

A SwiftUI Agent Skill that helps you build better views or refactor existing ones. It’s the reality we’re in today, and I honestly can’t live without it anymore myself. Several skills helped me improve the code quality produced by agents, and I’m happy to introduce you to a new open-source skill for SwiftUI.

The Secret to Buttery Smooth SwiftUI

Ever wondered why some SwiftUI views feel buttery smooth while others... don’t? I’ve been asking myself this question a lot lately.

Designing a Scalable App-Wide Theming System in SwiftUI

Theming is one of those features users notice instantly — and one of the easiest places to introduce inconsistency if it’s not designed carefully.

Introducing FabBar: The Liquid Glass Tab Bar I Wish Apple Made

FabBar is an open source SwiftUI library that recreates iOS 26's Liquid Glass tab bar with an integrated, tinted floating action button.

Migrating an iOS app from Paid up Front to Freemium

Paid up front apps can be a tough sell on the App Store. You might be getting plenty of views on your product page, but if those views aren't converting to downloads, something has to change.

Emptiness in SwiftUI

How “Empty” can be designed and accounted for using EmptyView, EmptyModifier, and ContentUnavailableView.

Monitoring app performance with MetricKit

Xcode Organizer provides access to essential performance metrics such as crashes, energy impact, hangs, launch time, memory consumption, and app terminations. However, it lacks sufficient information to resolve certain issues, particularly app terminations. To address this, Apple introduced the MetricKit framework, enabling us to collect comprehensive diagnostics and build a detailed performance dashboard.

Why Child @State Won't Update from Parent in SwiftUI

@State is designed to manage a view’s internal private state. Its initial value is only applied when the view establishes its Identity for the first time. To react to external data changes continuously, use @Binding or standard let properties instead.

Animating SF Symbols in SwiftUI

SF Symbols are a natural choice for icons in SwiftUI apps. The system provides a very large symbol catalog, and extensive customization options. Size, weight, rendering mode, and color can all be adjusted to match the surrounding UI, making symbols easy to integrate across an app.

From broken to testable SwiftUI navigation: The decoupled approach of MVVM with coordinators

SwiftUI provides several tools for managing navigation, and the introduction of NavigationStack and value-destination links improved programmatic navigation.

However, in larger applications, vanilla SwiftUI navigation can pose challenges for testability, maintainability, and modularity. Navigation logic is distributed across views, introducing coupling and making the navigation code hard to locate.

Reducing the Number of .sheet Modifiers in Your SwiftUI Views

When a SwiftUI view needs to present many different sheets, each sheet typically requires its own @State Boolean and .sheet modifier. This quickly clutters code and makes it hard to maintain.

Task Identity

When you write SwiftUI views, one of the big advantages over UIKit is that SwiftUI performs automatic dependency tracking. Whenever your model invalidates or one of your view’s properties change, your view is re-rendered.

Initializing @Observable classes within the SwiftUI hierarchy

I’ve noticed that many iOS developers, even those who have been working with SwiftUI for a while, still have questions about how @Observable classes work with SwiftUI views, how they should be initialized, and whether we need to store our observable models in @State. In this post, we’ll look at some examples of managing observable state in SwiftUI, explore the recommended approaches, and see what can go wrong if our observable classes are not stored correctly.

Document Preview Options in SwiftUI

Working with documents is a common requirement in many iOS apps. Whether you’re displaying a PDF, showing a Quick Look preview, or handing the file off to the system for deeper interactions, developers today have multiple options available. Each framework offers different capabilities, limitations, and levels of control.

Understanding the Transferable Protocol in Swift

Learn how to prepare your custom types to be sharable between applications and system features with the Transferable protocol.

Zooming With The Magnify Gesture in SwiftUI

Zooming content in and out is a fundamental gesture that users of smartphones and tablets are well acquainted with. Also known as pinch to zoom, this gesture is available to attach to our SwiftUI views programmatically, letting users change the scale level of what they are interacting with, using a familiar move of the fingers.

ScrollView snapping in SwiftUI

By default, a ScrollView in SwiftUI uses the system’s standard deceleration rate and the scrolling velocity to determine where the scroll motion should stop. While this behavior works well in most situations, it doesn’t consider the dimensions of the scroll view or its content.

SwiftUI Architecture: Structure Views for Reusability and Clarity

As your SwiftUI projects grow, the need for a better SwiftUI architecture grows, as it’s easy for view bodies to become very long. You start with a simple screen, and before you realize it, your body includes dozens of nested VStacks, HStacks, and custom modifiers. At some point, scrolling through the body feels like reading a novel.

Optimize Your App’s Speed and Efficiency: Q&A

Learn depth of optimization from Apple Team.

Video

Optimize your app's speed and efficiency

Whether you’re optimizing an existing app or just starting out, you’ll learn how to improve your app’s responsiveness with SwiftUI, monitor performance when using foundation models, and explore ways to reduce your app’s battery usage.

Feature flags in Swift

Almost every project I work on has at least three build configurations: Debug, TestFlight, and App Store. These configurations differ not only in build settings but also in functionality. This week, we’ll learn how to implement feature flags in Swift, which allow us to toggle on and off specific functionalities under certain conditions.

Tunable, physics-driven motion primitives for SwiftUI

Kinetics brings the natural feel of real-world physics to your SwiftUI animations. Built on Swift 6 with strict concurrency compliance, it provides a modern, safe foundation for creating motion that responds to user input, respects boundaries, and feels alive.

When SwiftUI automatically applies the glass look and when it doesn’t

Since iOS 18, buttons, toolbars, and other controls can appear in Apple’s new glass button style. What’s interesting is that SwiftUI sometimes applies this effect automatically, depending on where a view is placed. In this article, we’ll look at when that happens, when it doesn’t.

Add a Close button to SwiftUI modals on iOS 26

In iOS 26, SwiftUI introduces a new close button role designed for buttons that dismiss informational views or modals, for example, sheets showing read-only content or contextual details.

Why a custom ViewModifier is often useless

You don’t always need to create a separate ViewModifier struct in SwiftUI. If your modifier just chains some view modifiers and does not depend on internal state or environment values, you can simplify by implementing it as a function on View instead.

Apple introduced the Observation framework a few years ago. The Observation framework became the main tool for building observable models, replacing the Combine framework. This week, we will talk about a new piece of the framework called Observations.

How to create a custom reusable toolbar in SwiftUI

When building navigation bars and toolbars in SwiftUI, we'll often want to keep the same look and functionality across multiple screens. Instead of copying and pasting the same toolbar code everywhere, we can abstract the toolbar into a reusable component.

Building a design system at Genius Scan

As an app’s code base grows and evolves, it can be really tricky to maintain consistency within its UI. It’s easy for things like margins and padding, or colors and fonts, to start diverging, as different developers might use different values within each individual UI component’s implementation. At the same time, UI code can also become increasingly complex, since new features might be designed and implemented completely from scratch, which often leads to a minimum amount of code reuse and duplicated engineering efforts.

Corner concentricity in SwiftUI on iOS 26

At WWDC 25, Apple talked a lot about corner concentricity in their new design system. The idea of concentric corners, rounded corners where the curved portions of the inner and outer shapes share the same center and create a visually consistent and nested appearance, was highlighted multiple times. They also showed how to create concentric shapes in SwiftUI in one of the WWDC sessions, but the API was missing from the early betas.

Perception 2.0: An updated back-port of Swift’s Observation framework

Today we are releasing a big update that brings many of the recent advancements in the Observation framework to Perception, and of course it is all back-ported to iOS 13+ and macOS 10.15+. Join us for a quick overview of what is new in Perception.

Glassifying custom SwiftUI views. Groups

Glassifying custom views can be very easy using the glassEffect view modifier. It is a one-shot view modifier that handles everything for you. But things can become quite complicated when you try to glassify a group of views. Today, we will talk about glassifying a group of views in SwiftUI.

Providing Multiple Accent Colors in SwiftUI Apps

Apps are not monochrome, and one particular color with special meaning is the accent color that an app displays. We meet it mainly in primary actions, buttons, tabs, navigation bar elements, toolbars and other places, while it often works much like a visual signature. When trying to make our apps appealing to users, it seems suitable sometimes to provide various accent colors that users can choose from.

SwiftUI Search Enhancements in iOS and iPadOS 26

In iOS and iPadOS 26, the search experience has been updated with new placement behaviors and visual styling, and we also have new SwiftUI APIs to support the changes. In this post, we'll explore how we can take advantage of these enhancements to build search interfaces that feel modern and consistent with the system.

Creating amazing loading animations with SF Symbols.

In this post, we’ll take a look at how to use SF Symbols to easily create amazing loading animations.

SwiftUI: Scrollview tracking offset/items

Recently, I've been working on a feature which involved a small full screen banner implementation with scrollable content and pagination. Since the amount of items were fixed and were small - I picked the ScrollView with HStack in it. Had no issues with rendering them right away - that was even great since from UX will be no loaders.

Glassifying custom SwiftUI views

We already talked about glassifying tabs and toolbars in SwiftUI. This week, we will continue the topic of the new Liquid Glass design language and will talk about applying this concept to custom views.

Presenting Liquid Glass sheets in SwiftUI on iOS 26

iOS 26 introduces the new Liquid Glass design, which brings updates to the appearance and behavior of sheets in SwiftUI. In this post, we'll explore these changes and how we can adopt them in our apps.

Handling WebView navigation in SwiftUI

A key feature of web browsing is the ability to move backward and forward through your navigation history. In this post, we'll explore how to handle navigation in WebView and WebPage.

Supporting Reduced Motion accessibility setting in SwiftUI

Learn how to respect system settings for reduced motion to improve usability for motion-sensitive users.

Structuring Spacing for Scalable Mobile UIs

In growing teams and evolving codebases, maintaining visual consistency is a challenge, especially in mobile apps where layouts must adapt to different devices, screen sizes, and use cases. One of the easiest places for inconsistencies to creep in is spacing.

Glassifying tabs in SwiftUI

One of the most important changes presented during WWDC 25 was the new design language used across all Apple platforms called Liquid Glass. Tabs play a significant role in the new design and provide new ways of interacting with them.

Glassifying toolbars in SwiftUI

Liquid Glass is the new design language Apple using across all of its platforms. The look and feel of tabs was the major change that we covered last week. This week we will focus on another significant change related to toolbars.

Designing custom UI with Liquid Glass on iOS 26

Liquid Glass is iOS 26’s new design language. This means that a lot of apps will be adopting a new UI philosophy that might require some significant changes to how you’re designing your app’s UI.

Using WebKit to load web content in SwiftUI

Apple introduced WebView and WebPage to simplify web content handling in SwiftUI. Surprisingly, these new APIs are already available starting with iOS 18.4. Let's try to use them.

Attribute graph

It’s about the attribute graph, and I want to start off by saying I don’t know how this works, but I think we can make some educated guesses based on the information that’s out there and based on the dumps you can get. In my head, it kind of makes sense, and it really helps, I think, to understand how SwiftUI rendering works and how SwiftUI can be as efficient as it is.

What is new in SwiftUI after WWDC25

The 25th World Wide Developers Conference is here, and it’s the perfect time to explore the most significant changes and additions to the SwiftUI framework. Let’s delve into all the exciting new features Apple has prepared for us this year.

State of the Union: What I Took Away

This article is a quick post on what I took away from watching Apple’s Platforms State of the Union at WWDC25. The aim is to be neither overly objective nor overly subjective, but to cherry-pick the information that mattered most to me in a quick read.

Overlapping Views in SwiftUI with zIndex

SwiftUI lays out our views automatically based on the container they are in and the modifiers applied on them. Most of the time that’s enough, but when it comes to overlapping and the order in the Z-axis, then we have an additional tool at our disposal; the zIndex view modifier. Using it is pretty straightforward, so let’s get to know it next.

Exploring tab bars on iOS 26 with Liquid Glass

When your app has a tab bar and you recompile it using Xcode 26, you will automatically see that your tab bar has a new look and feel based on Liquid Glass. In this blog post, we’ll explore the new tab bar, and which new capabilities we’ve gained with the Liquid Glass redesign. I’ll also spend a little bit of time on providing some tips around how you can conditionally apply iOS 26 specific view modifiers to your tab bar using Dave DeLong’s “Backport” approach.

Stretchy header in SwiftUI with visualEffect()

It’s a common design pattern in modern iOS apps to have a large image at the top of a scroll view, extending all the way into the top safe area. When the user pulls down to overscroll, instead of revealing empty space above the image, the image expands, growing in size and creating a dynamic visual effect.

Books

Escape from Tutorial Hell

This book aims to fill in that gap and take you from a person who knows the basics of Swift and SwiftUI to a developer with an app that's designed, built, shipped, and ready to be maintained.

The evolution of native engineering at Tripadvisor: Part 1

In December 2024, we made the pivotal decision to migrate to The Composable Architecture (TCA), developed by Point-Free. This wasn’t just a technical refactoring — it represented a fundamental shift in how we approach iOS development, particularly for complex applications with sophisticated navigation requirements.

SwiftUI in 2025: Forget MVVM

It’s 2025, and I’m still getting asked the same question: “Where are your ViewModels?” Every time I share this opinion or code from my open-source projects like my BlueSky client, IcySky, or even the Medium iOS app, developers are surprised to see clean, simple views without a single ViewModel in sight.

Tips and tricks for when using SwiftUI’s ViewBuilder

SwiftUI’s ViewBuilder type is a key part of the library’s overall API design, in that it’s what enables multiple view expressions to be declared within a given scope (such as a body property implementation, or a closure passed to containers such as HStack or VStack) without requiring any manual grouping or wrapping at each call site.

Understanding toolbars in SwiftUI

Learn how to add toolbar items in SwiftUI views across various placements like navigation bars, bottom bars and more.

Enable scrolling based on content size in SwiftUI

When designing interfaces in SwiftUI, it’s often a good idea to wrap our app’s content in a scroll view, even if the content usually fits on screen. This helps ensure that users who enable larger text sizes in accessibility settings can still access all the content without layout issues, clipped views and truncated text. However, doing this introduces an unintended side effect. By default, ScrollView adds a bouncy scrolling behavior, even when the content fits entirely within the available space. This can make the interface feel oddly springy when no scrolling is actually needed.

Mesh gradients in SwiftUI

A mesh gradient is a technique for rendering smooth, multi-directional color transitions across a surface using a structured network of control points. Unlike linear or radial gradients, which interpolate color along fixed axes, a mesh gradient defines colors at specific positions within a two-dimensional grid. These positions act as anchors, and the rendering engine computes smooth interpolations between them across the surface.

Demystifying SwiftUI’s .ignoredByLayout() — How to Apply Geometry Effects Without Breaking Your Layout

Among SwiftUI’s many APIs, .ignoredByLayout() is something of an “understated member.” Information is scarce, usage scenarios are uncommon, and its very name tends to raise questions.

Ever heard of .contextMenu()?

Vincent Pradeilles demonstrates how to implement a simple emoji reaction feature in a SwiftUI chat interface using the built-in .contextMenu() modifier. This approach allows developers to add contextual menus that appear upon a long press on a chat bubble, offering various emoji reactions.

XCUITest: How to Write UI Tests for SwiftUI Apps

If you’ve ever shipped a bug where a button did nothing, a sheet didn’t show, or the wrong item appeared on screen—this post is for you.

Videos

Elevate Your SwiftUI Lists with iOS 18’s New Container Features

I’ll walk you through two practical examples: enhancing a basic list with stylized sections and creating a dynamic, filterable to-do list using ContainerValue to elevate a selected section to the top.

What's new in Swift 6.2?

Raw identifiers, backtraces, task naming, and more.

SwiftUI View Model Ownership

When we cover SwiftUI’s state system in our workshops, we often get asked: How can I set up my view model in a view? There’s a bit more to this question, so let’s try to spell out the requirements.

Choosing between LazyVStack, List, and VStack in SwiftUI

SwiftUI offers several approaches to building lists of content. You can use a VStack if your list consists of a bunch of elements that should be placed on top of each other. Or you can use a LazyVStack if your list is really long. And in other cases, a List might make more sense.

Formatting data inside SwiftUI Text views

I’ve just started a new "Nil Coalescing" YouTube channel, and in the first video I take a closer look at how we can use FormatStyle and Text.DateStyle directly inside SwiftUI Text views to format values inline using string interpolation. This approach allows us to display arrays of strings, measurements, dates and other types of data in a clean, declarative way without writing additional formatting code.

Can You use PreferenceKeys for Testing SwiftUI Views

One afternoon I was experimenting with EnvironmentKeys—trying to drive navigation and coordinate between screens without resorting to imperative hacks. SwiftUI’s environment feels like a top‑down broadcast: you inject a value at the root, and child views pick it up. But what if you want the opposite? What if a child view could whisper something back up the tree?

Free mobile payments SDK by Square

Square’s new Mobile Payments SDK is free, and easy to embed—perfect for adding seamless in-app payments!

Reading

SwiftUI ForEach Explained with Code Examples

If you’re building dynamic lists or repeating UI components in SwiftUI, there’s a high chance you’re already using the SwiftUI ForEach view element. It’s a powerful, yet sometimes misunderstood, view element in SwiftUI.

Loving SwiftUI, missing UIKit.

At this point, I am primarily working in SwiftUI. At work right now, we are doing macOS and iOS, and we’re not using AppKit or UIKit at all. Where I’m at right now in my thinking is that while I do like SwiftUI, I kind of miss the old way of doing things.

How to persist navigation state in SwiftUI

Learn how to save and restore NavigationPath to maintain user context across app launches.

Why Your SwiftUI App Is Slower Than You Think

Ever wondered why your SwiftUI views feel sluggish, even though you’ve followed every “best practice”? Yeah, I’ve been there too — pulling my hair out at Frontier Airlines as a seemingly simple list lagged like it was running on an iPhone. Turns out, SwiftUI’s magic isn’t always free; unnecessary view invalidation and subtle diffing issues can absolutely murder your app’s performance.

The Underground Wrapper Scene

10 SwiftUI Property Wrappers and Values You Probably Don’t Know… But Should.

Video

iOS Conf SG 2025

The Grand Gathering of Apple Developers in Asia.

Free mobile payments SDK by Square

Square’s new Mobile Payments SDK is free, and easy to embed—perfect for adding seamless in-app payments!

Reading

Introducing Swift Testing. Scoping.

Apple recently released Swift 6.1, with most of the changes being cosmetic. However, I particularly like the scoping feature introduced in the Swift Testing framework. This week, we’ll delve into the new test scoping feature and explore how to effectively utilize it in Swift.

Using Instruments to profile a SwiftUI app

A key skill for every app developer is being able to profile your app's performance. Your app might look great on the surface, but if it doesn’t perform well, it’s going to feel off—sometimes subtly, sometimes very noticeably. Beautiful animations, slick interactions, and large data sets all fall flat if the app feels sluggish or unresponsive.

What is @MainActor In Swift?

Today I want to explain a simple topic: the use of @MainActor when you're using Swift. I came across this macro while programming async with SwiftUI, so I want to share my findings with you. Let's start with a scenario so we can understand the problem that this macro solves.

SwiftUI Colors – Exploring Overlooked Features

Working with colors is one of the most common tasks for any developer in SwiftUI. However, we almost always stick to the basics; we apply the necessary colors and sometimes we also change their opacity. So, in this post we'll see some not so well-known Color features; levels, gradients, mixing and shadows.

Is There A Better AsyncButton?

Can We Tap Into Button's Full Async Potential... Or Are We Pressing Luck?

Free mobile payments SDK by Square

Square’s new Mobile Payments SDK is free, and easy to embed—perfect for adding seamless in-app payments!

Reading

WWDC25 wishes

The World Wide Developers Conference, the largest event in the Apple development world, is just around the corner. Today, I’m excited to share my wishes for the upcoming WWDC 25, which is expected to be unveiled in two months.

Showing What's New Screens using @AppStorage

In this post, Jordan demonstrates how to create new screens in a SwiftUI app using the AppStorage property wrapper.

Plurals with SwiftUI

SwiftUI introduced new ways of working with plurals in code.

Text concatenation vs Text interpolation in SwiftUI

SwiftUI allows us to combine multiple Text views into a single view using the plus (+) operator. This enables us to apply different styles to individual parts of the text.

A Guide to the SwiftUI @Environment

The @Environment property wrapper in SwiftUI gives access to shared values across your app. Apple provides a wide range of values that are built-in to every app. These cover accessibility, layout, colours, and more. The system automatically updates the built-in environment values so that your app knows more about the environment it is running in.