Blog

"Swift Charts Beyond the Basics" is a new book by Natalia Panferova and Matthaus Woolard for developers who want to learn how to transform their app data into clear, beautiful, and interactive visualizations with the Swift Charts framework.

Keep SwiftUI layouts responsive across changing window sizes by deriving view dimensions directly from their containers for full-width views, horizontal card layouts and custom proportional sizing.

Adapt a SwiftUI interface to its available space using the onGeometryChange() modifier, while limiting state updates to the geometry changes that matter.

Build repeating and event-driven animations in SwiftUI with PhaseAnimator, using phase values and per-phase transitions to control each sequence.

Control which SwiftUI toolbar actions stay visible, move commands into overflow, pin an important item and configure navigation bar minimization with the new iOS 27 APIs.

Learn how alignment guides position views in SwiftUI, how to override a built-in guide, and how to define a custom alignment for views in nested containers.

Keep a complex Metal-rendered canvas responsive during pan, zoom and rotation gestures by reprojecting rendered states with CAMetalLayer.

Explore every SwiftUI blend mode through focused visuals and practical use cases, and learn how to control which views participate in each operation.

Learn how to build a non-modal, detent-based sheet API in SwiftUI that adapts from a bottom panel in portrait to an edge-aligned panel in landscape.

Learn how SwiftUI's similarly named geometryGroup(), compositingGroup() and drawingGroup() modifiers affect distinct stages of animation and rendering, and when each is appropriate.

"The SwiftUI Way" has been updated with expanded guidance on SwiftUI data flow, view updates, and performance, including changes introduced in Xcode 27.

Prevent unnecessary SwiftUI view updates by making custom types stored in @Observable properties conform to Equatable.

Learn why Xcode 27 shows a warning when an @Entry declaration creates a new class instance for every fallback access, how unstable environment defaults can cause unnecessary SwiftUI view updates, and how to make them stable.

Learn how closure-based bindings can affect SwiftUI view updates, and how labeled subscripts give the framework a more stable way to track changes.

iOS 27 gives AsyncImage more control over remote image loading with URLRequest support for custom headers, cache policies, and timeouts, plus the ability to provide a custom URLSession across a SwiftUI view hierarchy.

Reorder items within and between custom SwiftUI containers, and build selection-aware multi-item drag and drop interactions with the new APIs in iOS 27.

SwiftUI now includes CrossFadeNavigationTransition, a built-in cross-fade navigation transition, and AnyNavigationTransition, a type-erased wrapper that allows transitions to be selected dynamically at runtime.

iOS 27 extends support for swipe actions beyond List to any scroll container using the new swipeActionsContainer() modifier.

SwiftUI's @State changes from a property wrapper to a macro in Xcode 27, gaining lazy evaluation of the initial value and fixing unnecessary @Observable model initialization on view recreation.

Use the AttributedString API to build a reusable Text initializer that applies a distinct font to the unit component of a formatted measurement.

Review the full range of animation timing options available in SwiftUI, including easing curves, spring animations, the CustomAnimation protocol, and animation modifiers.

Build SwiftUI views that update periodically or continuously, without relying on explicit state changes, to create dynamic interfaces and visual effects.

Master programmatic scroll control in SwiftUI using defaultScrollAnchor(_:), scrollPosition(_:anchor:), and ScrollPosition to configure, drive, and read scroll position in your apps.

Customize the appearance of the macOS window toolbar in SwiftUI using scene and view modifiers to control its layout, title visibility, and background.

Configure a SwiftUI app to schedule and handle a background fetch task using the Background Tasks framework and the backgroundTask(_:action:) SwiftUI modifier.

Explore the different variants of the onChange() modifier in SwiftUI, including how to access old and new values, trigger the action on initial render, and run asynchronous code in the action closure.

Combine text with icons and style them using modifiers in SwiftUI by leveraging LocalizedStringKey interpolation.

"The SwiftUI Way" is a new book by Natalia Panferova that shows experienced SwiftUI developers how to align with the framework's internal expectations.

iOS 26 introduces the lineHeight(_:) modifier and AttributedString.LineHeight attribute for adjusting vertical spacing between lines of text in SwiftUI.

Precisely scope animations to specific animatable attributes by using the animation(_:body:) API introduced in iOS 17.

Extend Swift’s string interpolation to define custom behavior, such as value formatting, directly inside string literals.

Add symbol effect animations and transitions to symbol images in SwiftUI to handle icon state changes without custom drawing or animation logic.

Learn the recommended ways to initialize and store @Observable classes in SwiftUI views, and see what can go wrong when observable state is managed incorrectly.

UIKit now has native support for Swift Observation, automatically tracking reads of @Observable properties in update methods, making it easier to share data between UIKit and integrated SwiftUI components.

Explore SwiftUI APIs for customizing scroll behavior, including paging and view-aligned snapping, and learn what to watch out for to avoid unexpected results.

"SwiftUI Fundamentals" by Natalia Panferova has been updated for iOS 26 with refreshed visuals and examples reflecting the new Liquid Glass design.

Starting with iOS 26, SwiftUI shows both title and icon in swipe action buttons by default, but the previous icon-only appearance can be restored using the labelStyle() modifier.

Take a closer look at my new app Breve, exploring the technical insights around Liquid Glass design, iOS 26 SwiftUI APIs, and system integrations.

Configure the NavigationStack and Form background in SwiftUI so partial height sheets keep the translucent Liquid Glass appearance on iOS 26.

Make your views and controls fit perfectly within their containers using new SwiftUI APIs in iOS 26 such as the ConcentricRectangle shape and the containerShape() view modifier.

Use a shared Core Spotlight search index to make content discoverable in system Spotlight and support internal search within the app.

Take advantage of the updated search placement and behavior in iOS 26, and implement toolbar and tab bar search patterns that adapt across devices and integrate with the new Liquid Glass design.

Learn how to leverage the new glass appearance for partial sheets in iOS 26, and set up morphing transitions for sheets presented from toolbar buttons using SwiftUI APIs.

Step through the essential setup for AlarmKit timers in iOS 26, from requesting authorization and scheduling a countdown to presenting the Live Activity and an in-app list of active timers.

Starting with Swift 6.2 and iOS 26, EnumeratedSequence conforms to RandomAccessCollection, allowing enumerated() to be used directly in ForEach and List views.

Build a stretchy image header in SwiftUI using the visualEffect() modifier, scaling the image on pull-down without tracking scroll offset or modifying its frame.

The new backgroundExtensionEffect() modifier in iOS 26 lets us extend and blur visual content beyond a view’s bounds, creating continuous backgrounds behind elements like sidebars, inspectors, and overlay controls.

Explore ways to create and customize mesh gradients in SwiftUI, including color adjustments, finer control with Bezier points, and color position animations to add variety and emphasis to your design.

Format interpolated values like arrays of strings, measurements, and dates directly inside SwiftUI Text views using FormatStyle, and display dynamic dates using Text.DateStyle.

Add a custom font to your Mac app by embedding it in the app bundle and making sure it loads correctly for use in your UI.

Design a custom About window for your SwiftUI macOS app with a personalized layout, detailed app information, and a styled background that fits your app’s look and feel.

SwiftUI offers several methods to change the color of text, including foregroundStyle() and tint() modifiers, AttributedString attributes, and the textRenderer() API for advanced styling.

"Swift Gems" by Natalia Panferova has been updated with tips from Swift 6, along with new techniques based on earlier Swift versions, covering optionals, noncopyable types, async programming, and more.

Combining multiple SwiftUI Text views into a single text with the + operator to apply different styles can cause localization issues, making text interpolation the preferred technique for accurate translations.

Dive into how static and dynamic dispatch work in Swift, how they affect performance, and how to control method resolution to write faster, more efficient code.

Make SF Symbols and custom images adapt to different font sizes while maintaining layout balance, keeping key icons clear, and providing more space for higher-priority content when needed.

Learn how to define custom environment values in SwiftUI, eliminate boilerplate with the @Entry macro in Xcode 16, and pass data through the view hierarchy efficiently.

Set a custom background, like an image or a translucent material, for SwiftUI sheets, popovers, and full-screen covers, and explicitly control the presentation color scheme.

Implement a high-performance lazy scrolling list in SwiftUI by efficiently reusing views for smooth scrolling with large datasets.

"SwiftUI Fundamentals" is a new book by Natalia Panferova that explores SwiftUI’s core principles and APIs in depth. It will help you build a solid foundation for using SwiftUI effectively in your projects.

Learn how to build a macOS menu bar app in SwiftUI using MenuBarExtra, customize its icon, hide it from the Dock, and add essential features like a quit option.

Build reusable, type-safe components for extracting and validating UUID values using Swift's RegexBuilder framework.

Extend your app’s functionality to the entire macOS system by implementing services that users can access from the context menu or the Services menu in other apps.

Register your macOS app as a login item using SMAppService.

Learn how to add Codable conformance to Swift enums, including automatic synthesis, customizations, and fully manual implementations for complex cases.

Apply a translucent background to macOS windows using SwiftUI APIs, and adjust the toolbar background and title visibility to customize the window's appearance.

Explore noncopyable types in Swift and learn how they enforce stricter ownership rules to avoid unintended errors and resource conflicts.

Learn how to use matchedGeometryEffect() in SwiftUI to animate a capsule background that highlights the selected option in a custom segmented control.

With iOS 18, we can now use SwiftUI animations to animate UIKit views, making it easier to bring SwiftUI’s expressive and flexible animations into UIKit projects.

Learn how to resolve the issue of using lazy variables in @Observable classes by annotating them with @ObservationIgnored.

"Integrating SwiftUI into UIKit Apps" by Natalia Panferova has been updated, featuring the latest tools like Observable, the Preview macro, and a new section on animating UIKit views with SwiftUI animations in iOS 18.

Font modifiers in SwiftUI let us style text directly at the font level, offering precise control over typography in our apps.

Explore different ways to work with the SwiftUI environment, including reading and setting values, creating custom environment keys, and using it to pass down actions and observable classes.

Discover how to use the @Observable macro in SwiftUI and its advantages over ObservableObject, such as more efficient view updates and simplified code management.

This post explains how to use recursive enums in Swift, including the indirect keyword, to effectively model and manage complex, hierarchical data structures.

A simple method for rendering quadratic Bézier curves on the GPU in Metal without pre-processing geometry.

Efficiently count the number of elements in a sequence that satisfy the given condition with the new count(where:) method introduced in Swift 6.

Learn how to adjust size, color, rendering modes, variable values, and design variants of SF Symbols in SwiftUI apps.

Discover Strolly, our new free app that generates unique daily walking routes, providing variety and adventure while keeping user privacy in mind.

Using the overlay() modifier in SwiftUI, we can elegantly wrap text within another view, ensuring the text is positioned and sized relative to the primary content.

SwiftUI custom scenes enable the creation of modular, maintainable code, allowing for precise management of complex user interfaces and behavior across different platforms.

Leverage the new magic replace symbol effect in iOS 18 for smooth transitions of slashes and badges in SF Symbols.

Discover how to leverage SwiftUI's versatile scene types, like WindowGroup, DocumentGroup, Settings, Window, and MenuBarExtra, to create efficient and dynamic macOS applications.

Use convertFromSnakeCase in JSONDecoder to automatically map JSON snake case keys to Swift camel case properties, simplifying model definitions and ensuring naming consistency.

I recently gave a talk at Code Camp Wellington on how starting a technical blog can transform your career development. Since it wasn't recorded, I've summarized my insights in this post to inspire others to share their technical knowledge online.

Swift's tuples are a convenient way to group multiple values, and their true utility shines with the language's built-in ability to compare tuples.

"Swift Gems" is a new book by Natalia Panferova for seasoned Swift developers. It offers over 100 tips and techniques to improve code efficiency and robustness, ideal for those looking to advance their Swift expertise.

By taking advantage of provisional authorization for notifications, we can provide a gentle introduction to our app's notifications without upfront permission from the user.

Guide users through resolving issues and make your Swift applications more intuitive and supportive by defining user-friendly descriptions and recovery suggestions for custom errors.

Explore the practical applications and distinctions of self, Self, and Self.self in Swift, clarifying their roles in instance referencing, protocol conformance, and metatype access.

Discover how string comparison methods from Foundation outperform basic case conversion, ensuring precise, efficient, and culturally aware comparisons in our applications.

Define custom logic for matching different types of data in switch cases by overloading the Swift pattern matching operator (~=).

Property observers like willSet and didSet aren't triggered during initialization in Swift, but if we need to execute logic from property observers at this stage, we can use some workarounds.

Learn how to wrap withObservationTracking() into an AsyncStream to iterate over changes with an async for loop.

Monitor changes to specific properties of an observable class using withObservationTracking() function from Observation framework in iOS 17.

Use the new instance properties of the ShapeStyle in iOS 17 to access hierarchical system background styles, such as secondary and tertiary background.

Take advantage of the improvements in the debug console in Xcode and learn how to filter logs by type, category or message, show and hide similar items and view log metadata.

This post will walk you through all the necessary setup so that you can enable remote push notification functionality in your iOS project.

Add icons to buttons in actionable push notifications using the UNNotificationActionIcon class to make notifications more intuitive and visually appealing.

Xcode 15 automatically generates static properties on ColorResource and ImageResource types for colors and images that we store in asset catalog. This lets us access them in SwiftUI, UIKit or AppKit code without using string literals.

Let's look into the new inspector() presentation API in iOS 17, iPadOS 17 and macOS 14 and see how to customise its width on iPad and Mac, and how to change the sheet style it defaults to on iPhone.

Discover the power of precise pattern matching with Swift enums as we look into using the where clause in switch statements and for-in loops, and adding extra conditions in while loops and if-case statements for more expressive code.

Explore how to replace the position() modifier with a custom AnchoredPosition layout to improve flexibility in aligning views relative to an anchor point, and adjust the alignment dynamically based on available space.

Build an interactive bar chart in Swift Charts that displays detailed annotations when the user is hovering over bar marks.

Enable modified actions, such as command + click or shift + click, in a SwiftUI lifecycle application on iPad using GCKeyboard from the Game Controller framework.

Register when the pointer enters and exists view's bounds and get the mouse cursor location with onContinuousHover() modifier.

Find out how text modifiers are different from view modifiers in SwiftUI and how we can use them in our code to style portions of text.

Create a chart with the Swift Charts framework to show UV index throughout the day inspired by the iOS Weather app that dims the area up to the current time.

Use the accessibilityShowButtonShapes environment value to change the appearance of custom buttons and links embedded in Text views to make them more accessible.

Add a gradient to a bar chart that stretches from top to bottom of the plot area rather than filling each individual mark.

Generate xcloc files that can be sent to translators directly from SwiftUI code and import translations back to create Localizable.strings files.

Programmatically dismiss presentations and pop views from the navigation stack in both pure SwiftUI and hybrid UIKit/SwiftUI apps with the help of the dismiss action.

Let users rename items from the navigation title in the toolbar using the new navigationTitle() modifier that takes a binding.

Make all parts of your app readable for users with low vision using the large content viewer APIs.

We can customize how the user navigates through focusable views in our macOS apps with the help of the new focusSection() modifier.

Build a bar chart using data with values of type Measurement<UnitDuration> that doesn't conform to Plottable by default.

Let users configure the visible items in the center area of the toolbar on iPadOS 16 to suit their personal workflows.

Learn how to use the new openWindow action in SwiftUI to programmatically present new windows in macOS 13.

Take advantage of the new URL APIs in iOS 16, which let us obtain paths to system directories more easily without the need to use FileManager methods.

Read and set the color scheme in SwiftUI by accessing the environment value, applying preferences for presentations, and customizing specific views or toolbars.

Visualise data distributions by building a histogram and a 2D density plot with the new Swift Charts framework.

Starting from iOS 16 and macOS 13 we have a SwiftUI API to request App Store reviews. We can read requestReview property from the environment and call it as a function at the appropriate time.

In Swift 5.7 that comes with Xcode 14 we can check if two values of type Any are equal, because we can cast values to any Equatable and use any Equatable as a parameter type.

Find and replace feature is automatically supported by SwiftUI TextEditor, but we also have some APIs to customize its behavior, such as disable replace or present the find UI programmatically.

New ViewThatFits API introduced at WWDC 2022 lets us create more flexible layouts in constrained space. It can even help us detect if text is truncated and adapt our views accordingly.

Build a custom ridge chart with the new Swift Charts framework to show the distribution of a numeric variable for several groups.

SwiftUI’s resizable sheet APIs let us present half sheets, define custom detents, and control sheet behavior across different device configurations.

Use the new NavigationSplitView API with a column visibility parameter to programmatically control the visibility of the sidebar in multicolumn navigation in SwiftUI.

Explore the capabilities of the Swift Charts framework introduced at WWDC 2022 while making a stream graph with custom colour gradient and text labels.

Let's try out the new SwiftUI navigation APIs introduced in beta 1 for iOS 16 and macOS 13: NavigationStack, NavigationSplitView and ways to set up programmatic navigation.

Find out about different ways we can provide feedback about new APIs to Apple engineers, ask questions during WWDC and get help from Apple experts and wider developer community.

Take a closer look at AttributedString type and different attribute scopes it can contain. Explore how Apple system frameworks interpret available attributes and how to create your own.

Add custom encoding and decoding logic for SwiftUI Color that is not Codable by default to be able to save it to disk or remote database.

Look into how to insert images, formatted data, attributed strings etc. inside SwiftUI Text views by leveraging the power of string interpolation in LocalizedStringKey.

Present multiple sheets at the same time one on top of the other like, for example, in Apple Calendar app when adding a new calendar.

Set a keypath to your model properties as FocusState value to avoid declaring custom enums to programmatically set focus and respond to focus changes.

Build sidebar navigation for your macOS app with the help of selection binding in List view and use SceneStroage for state restoration.

Learn how to rapidly evaluate a polynomial function of variable size on the GPU without needing to write C++ Metal shaders.

Explore how to get around the Swift language limitation of not being able to define static mutable properties in generic types and protocol extensions.

Make use of the focused scene value API to pass data from the focused scene to the commands section of the app.

Build a system for conforming polymorphic types to Codable protocol, that can be reused in multiple situations.

Customize encoding and decoding logic for individual fields of codable types in Swift by defining codable property wrappers.

Avoid the conflict between the drag gesture and editing of text fields inside list rows and make focusing on text fields easier.

Change the style of navigation view in document based apps, by hiding the default view and adding our own.

Make an editable list of items in SwiftUI that automatically adds an empty text field for users to easily add new entries.

Add custom information and copyright to your app's About window on macOS when using the SwiftUI app lifecycle.

Integrate with UndoManager in SwiftUI by building a reusable UndoProvider view that can be used with any binding.

Add RawRepresentable conformance to a custom type that represents a setting or a view state in SwiftUI to be able to save it in AppStorage or SceneStorage.

Remove the default TextEditor background on iOS and add a placeholder that is not currently supported in TextEditor out of the box.

Let users preview various file formats such as Images, Live Photos, PDFs etc. in your SwiftUI app using QuickLook framework.

Explore how to add support for local network privacy if, for example, your app uses URLSession to access local servers.

Programmatically scroll SwiftUI ScrollView to a newly added item by combining ScrollViewReader and onChange() view modifier.

Implement state restoration in an example tab-based app that stores records of different types of trips.

Build an example social network with Django Channels Rest Framework that lets you subscribe to a hashtag in realtime.

In this article we will look into how to create a custom hover effect in SwiftUI and how to abstract this logic into a reusable view modifier.

View and manage files created by your app on the simulator, browse the Documents folder or Core Data SQLite Database.

Programmatically scroll SwiftUI List to a particular item, using the fact that its internal implementation is based on UITableView.

Publish database changes to subscribed WebSocket clients using Django Channels Rest Framework.

Explore the features of Django Channels REST Framework for building WebSocket API consumers with Django.

Add keyboard shortcuts to a SwiftUI iOS/iPadOS app to improve user experience when using your app with an attached hardware keyboard.

If you need to release an app built with an older version of Xcode, but want to test the app on the beta iOS simulators, you can follow the steps described in this article to transfer your build to the beta simulator.

Build a WebSocket server in Node.js using the ws library and test it with a WebSocket client app.

Make a scrollable view in SwiftUI scroll the active text field into visible range when the keyboard appears on screen in iOS 13.

Buttons inside a List row can cause the entire row to become tappable and trigger multiple buttons at once, but applying a specific button style ensures each button works independently.