Sample Code Library

Simulate a bokeh effect by applying dilation.

Convert an RGB image to discrete luminance and chrominance channels, and apply color and contrast treatments.

Use a gamma function to apply a linear or exponential curve.

Convert an image to L*a*b* color space and apply hue adjustment.

Change the frequency response of an audio signal using a cascaded biquadratic filter.

Use the vImage library’s polynomial transform to apply tone curve adjustments to images.

Desaturate a range of colors in an image with a multidimensional lookup table.

Use the vImage convert-any-to-any functionality to perform real-time image processing of video frames streamed from your device’s camera.

Filter an image by convolving it with custom and high-speed kernels.

Find the main colors in an image by implementing k-means clustering using the Accelerate framework.

Perform compression or the appropriate kind of decompression to a file based on its path extension.

Reduce the storage size of an image using singular value decomposition (SVD).

Convert an RGB image to grayscale using matrix multiplication.

Create a displayable ARGB image using the luminance and chrominance information from your device’s camera.

Add biquadratic filter audio-effect processing to apps like Logic Pro X and GarageBand with the Accelerate framework.

Convert a chroma-key color to alpha values and trim transparent pixels using Accelerate.

Change the frequency response of an audio signal by manipulating frequency-domain data.

Share image data between vDSP and vImage to compute the sharpest image from a bracketed photo sequence.

Reduce or remove periodic artifacts from images.

Apply dithering to simulate colors that are unavailable in reduced bit depths.

Share image data between Core Video pixel buffers and vImage buffers to integrate vImage operations into a Core Image workflow.

Implement custom linear interpolation to prevent the ringing effects associated with scaling an image with the default Lanczos algorithm.

Rotate a cube through a series of keyframes using quaternion interpolation to transition between them.

Use Model I/O and vImage to composite a photograph over a computer-generated sky.

Use Accelerate’s discrete cosine transform to remove noise from a signal.

Select the optimal LAPACK routine to solve a system of linear equations.

Calculate the histogram of one image, and apply it to a second image.

Build a simple neural network and train it to recognize randomly generated numbers.

Render real-time video effects with the vImage Pixel Buffer.

Share image data between vDSP and vImage to visualize audio that a device microphone captures.

Improve navigation in your app by using keyboard shortcuts and accessibility containers.

Make improvements to your app’s interaction model to support assistive technologies such as VoiceOver.

Support advancements in SwiftUI accessibility to make your app accessible to everyone.

Make your app more accessible to users with disabilities by adding accessibility features.

Adjust your UI when a person chooses to dim flashing lights on their Apple device.

Display simple system translations and create custom translation experiences.

Design for large text sizes by modifying the user interface.

Simulate a conversation using speech synthesis.

Navigate to the end of a dark maze using VoiceOver as your guide.

Play a card-matching game using Switch Control.

Format, style, and localize your app’s text for use in multiple languages with string formatting, attributed strings, and automatic grammar agreement.

Support HTTP resumable upload protocol in SwiftNIO by translating resumable uploads to regular uploads.

Define and manage which of your app’s activities can be continued between devices.

Convert data into readable strings or Swift objects using formatters.

Create a user interface with searchable content in a table view.

Create a shared codebase to build a multiplatform app that offers widgets and an App Clip.

Provide a continuous user experience by capturing information from your app and displaying this information as proactive suggestions across the system.

Display content and provide services in an AR experience with App Clip Codes.

Store app preferences in iCloud and share them among instances of your app running on a user’s connected devices.

Encode and decode JSON data, regardless of its structure, using Swift’s JSON support.

Enable people to use your app’s features quickly through Siri, Spotlight, and Shortcuts.

Reveal your app’s shortcuts inside the Health app.

Add Intents extensions to your app to handle requests to book rides using Siri and Maps.

Customize your app’s behavior to reflect the device’s current Focus.

Add an Intent Extension to your app to handle money transfer requests with Siri.

Add an Intent Extension to your app that handles requests to control workouts with Siri.

Donate reservations and provide quick access to event details throughout the system.

Add assistant schemas to your app so Siri can complete requests, and integrate your app with Apple Intelligence, Spotlight, and other system experiences.

Control audio playback and handle requests to add media using SiriKit Media Intents.

Resolve, confirm, and handle intents without an extension.

Make it easy for people to use Siri with your app by providing shortcuts to your app’s actions.

Integrating App Intents to provide your appʼs actions to Siri and Shortcuts.

Implement Action Extensions to provide quick access to commonly used features of your app.

Adopt Touch Bar support by displaying interactive content and controls for your macOS apps.

Create table view cells that support Dynamic Type and use system spacing constraints to adjust the spacing surrounding text labels.

Write an app that creates, manages, edits, and saves text documents.

Bring compositional layouts to your app and simplify updating your user interface with diffable data sources.

Provide users quick access to your app’s features from a toolbar and corresponding Touch Bar.

Build a structured user interface that simplifies navigation in your app.

Group individual views in your app’s user interface into a scrollable stack view.

Share data between macOS apps during drag and drop by using an item provider.

Receive and provide file promises to support dragged app files and pasteboard operations.

Share data between macOS apps during drag and drop by using an item provider.

Allow people to grant your app access to contact data by adding the Contact access button and Contact access picker to your app.

Choose and implement the appropriate Calendar access level in your app.

Persist data in your app intuitively with the Swift native persistence framework.

Ensure the academic integrity of your assessment app by using Automatic Assessment Configuration.

Create app extensions that block content, perform message and composing actions, and help message security.

Read and verify mobile driver’s license information without any additional hardware.

Give users a familiar experience when they manage HomeKit accessories.

Incorporate a custom PencilKit tool picker with a variety of system and custom tools into a drawing app.

Visualize an entire data collection efficiently by instantiating a single vectorized plot in Swift Charts.

Expand on the Messages sticker app template to create an app with a customized user interface.

Enable writing on a non-text-input view by adding interactions.

Fetch the assets your app requires before its first launch using an app extension and the Background Assets framework.

Add expressive, low-latency drawing to your app using PencilKit.

Edit, build, and add example order packages to Wallet.

Request and display weather data for destination airports in a flight-planning app.

Create a richer calling and messaging experience in your app by implementing communication notifications and Focus status updates.

Create, store, and present records for a variety of data types.

Bring attention to new features in your app by using tips.

Allow users to collaborate on the design of ice cream sundae stickers.

Add visible alert notifications to your app by using the UserNotifications framework.

Add background notifications to your app by using the UserNotifications framework.

Support adding an issued card to Apple Pay from directly within Apple Wallet using Wallet Extensions.

Walk through the process of setting up assignments and recording student progress.

Score users’ ability to match PencilKit drawings generated from text, by accessing the strokes and points inside PencilKit drawings.

Streamline your app’s API by moving georelated searches from inside your app to your server.

Find all the automation accessories in the primary home and control their state.

Organize data in two different stores and implement a link between them.

Add, fetch, complete, remove, and sort location-based reminders in your app.

Collect payments with iPhone and Apple Watch using Apple Pay.

Use scheduled background tasks for refreshing your app content and for performing maintenance.

Create and share private CloudKit data with other users by implementing the sharing UI.

Use Core Data and CloudKit to synchronize data between devices of an iCloud user and share data between different iCloud users.

Index app data so users can find it by using Spotlight search.

Share data between a user’s devices and other iCloud users.

Make remote files available in macOS and iOS, and synchronize their states by using file provider extensions.

Learn about the Service Management API with a GUI-less agent app.

Build complex and interactive charts using Swift Charts.

Use the CallKit framework to integrate native VoIP calling.

Use ARKit to generate environment probe textures from camera imagery and render reflective virtual objects.

Use room tracking in visionOS to provide custom interactions with physical spaces.

Track a person in the physical environment and visualize their motion by applying the same body movements to a virtual character.

Track the user’s face in an app that displays an AR experience with the rear camera.

Enable nearby devices to share an AR experience by using a peer-to-peer multiuser strategy.

Apply virtual fog to the physical environment.

Enable nearby devices to share an AR experience by using a host-guest multiuser strategy.

Use sound effects and environmental sound layers to create an engaging AR experience.

Annotate an AR experience with virtual sticky notes that you display onscreen over real and virtual objects.

React to known 2D images in the user’s environment, and use their positions to place AR content.

Present a visualization of the physical environment by placing points based a scene’s depth data.

Occlude your app’s virtual content where ARKit recognizes people in the camera feed by using matte generator.

Cover your app’s virtual content with people that ARKit perceives in the camera feed.

Place virtual content at tracked, real-world locations, and enable the user to interact with virtual content by using gestures.

Create anchors that track objects you recognize in the camera feed, using a custom optical-recognition algorithm.

Serialize a world-tracking session to resume it later on.

Record spatial features of real-world objects, then use the results to find those objects in the user’s environment and trigger AR content.

Update your local USD library to add interactive and augmented reality features.

Control an AR experience remotely by transferring sensor and user input over the network.

Create images from rectangular shapes found in the user’s environment, and augment their appearance.

Detect faces in a front-camera AR experience, overlay virtual content, and animate facial expressions in real-time.

Detect surfaces in the physical environment and visualize their shape and location in 3D space.

Track specific geographic areas of interest and render them in an AR experience.

Estimate the shape of the physical environment using a polygonal mesh.

Provide a more accessible experience by adding your app’s audio to a call.

Ensure your app is eligible to become the Now Playing app by adopting best practices for providing Now Playing info and registering for remote command center actions.

Display lesson content that’s synchronized to a learning video by matching the audio to a custom reference signature and associated metadata.

Create a plug-in and driver extension to support an audio device in macOS.

Use an audio source node and a custom render callback to generate audio signals.

Configure an iOS device’s built-in microphones to add stereo recording capabilities to your app.

Use a Core Audio tap to capture outgoing audio from a process or group of processes.

Detect and identify hundreds of sounds by using a trained classifier.

Use your custom voices to synthesize speech by building a speech synthesis provider.

Implement a configurable audio input source as a driver extension that runs in user space in macOS and iPadOS.

Build a virtual audio device by creating a custom driver plug-in.

Add custom audio-effect processing to apps like Logic Pro X and GarageBand by creating Audio Unit (AU) plug-ins.

Enhance your app’s experience by incorporating haptic and sound feedback into key interactive moments.

Build an extension that streams media to a server app in iOS or macOS.

Convert audio formats to efficiently manage data and quality.

Track your outdoor runs with access to the Apple Music catalog, personal recommendations, and your own personal music library.

Convert 8-channel audio to 2-channel spatial audio by using a spatial mixer audio unit.

Configure your app to listen for motion-activity changes from headphones.

Add custom audio processing and MIDI instruments to your app by hosting Audio Unit (AU) plug-ins.

Add precision and improve musical control for your MIDI apps.

Configure your music app to work with CarPlay by displaying a custom UI.

Configure your navigation app to work with CarPlay by displaying your custom map and directions.

Configure your food-ordering app to work with CarPlay.

Add offline audio processing features to your app by enabling offline manual rendering mode.

Sample predesigned Apple Haptic Audio Pattern files, and learn how to play your own.

Play a custom haptic pattern whose strength depends on an object’s collision speed.

Construct an audio player to play your custom audio data, and optionally take advantage of the advanced features of AirPlay 2.

Add haptic feedback to supported game controllers by using Core Haptics.

Perform speech recognition on audio coming from the microphone of an iOS device.

Find a video of dance moves for a specific song by matching the audio to a custom catalog, and show a history of recognized songs.

Create a Bluetooth low energy central and peripheral device, and allow them to discover each other and exchange data.

Generate continuous and transient haptic patterns in response to user touch.

Discover and communicate with a Bluetooth Classic device by using the Core Bluetooth APIs.

Find an album in Apple Music that corresponds to a CD in a user’s collection, and present the information for the album.

Add voice-processing capabilities to your app by using audio engine.

Protect a keychain item with biometric authentication.

Allow users to sign in to a service without typing a password.

Provide a way for users of your app to set up an account and start using your services.

Supplement your own authentication scheme with biometric authentication, making it easy for users to access sensitive parts of your app.

Build a fluid sign-in experience for your tvOS apps using AuthenticationServices.

Identify machine readable codes or faces by using the camera.

Render a capture stream with rose-colored filtering and depth effects.

Simultaneously record the output from the front and back cameras into a single movie file by using a multi-camera capture session.

Use an audio source node and a custom render callback to generate audio signals.

Add the power of a photography studio and lighting rig to your app with the new Constant Color API.

Access the LiDAR camera on supporting devices to capture precise depth data.

Configure an iOS device’s built-in microphones to add stereo-recording capabilities to your app.

Create video content for visionOS by converting an existing 3D HEVC file to a multiview HEVC format, optionally adding spatial metadata to create a spatial video.

Add custom audio-effect processing to apps like Logic Pro X and GarageBand by creating Audio Unit (AU) plug-ins.

Resolve common problems when creating compositions, video compositions, and audio mixes.

Support high-dynamic-range (HDR) video content in your app by using the HDR editing and playback capabilities of AVFoundation.

Apply your own background to a live capture feed streamed from the front-facing TrueDepth camera.

Integrate AirPlay features and implement a dedicated external playback experience by preparing the routing system for long-form video playback.

Add offline audio processing features to your app by enabling offline manual rendering mode.

Construct an audio player to play your custom audio data, and optionally take advantage of the advanced features of AirPlay 2.

Go beyond simple ad insertion with point and fill occupancy HLS interstitials.

Render single images for the left eye and right eye from a multiview High Efficiency Video Coding format file by reading individual video frames.

Visualize depth data in 2D and 3D from the TrueDepth camera.

Enable high-quality photo and video capture by using an iPhone camera as an external capture device.

Create synchronized media experiences that enable users to watch and listen across devices.

Set up your app to support remote commands and events in a variety of scenarios by using the relevant approach.

Play HTTP Live Streams and persist streams on disk for offline playback using AVFoundation.

Play, write, and export HEVC video with an alpha channel to add overlay effects to your video processing.

Add voice-processing capabilities to your app by using audio engine.

Create an HTTP Live Streaming presentation by turning a movie file into a sequence of fragmented MPEG-4 files.

Crop and scale photos using the Vision framework and classify them with a Core ML model.

Use Create ML Components to analyze a series of video frames and count a person’s repetitive or periodic body movements.

Train a machine learning model by using Core ML to import and manage tabular data.

Identify body movements by sending a person’s pose data from a series of video frames to an action-classification model.

Locate people and the stance of their bodies by analyzing an image with a PoseNet model.

Locate relevant passages in a document by asking the Bidirectional Encoder Representations from Transformers (BERT) model a question.

Add a simple model to an app, pass input data to the model, and process the model’s predictions.

Modify an updatable Core ML model by running an update task with labeled data.

Detect dice position and values shown in a camera frame, and determine the end of a roll by leveraging a dice detection model.

Identify multiple objects in an image by using the DEtection TRansformer image-segmentation model.

Add auto layout constraints to your app to achieve localizable views.

Add alternate app icons to your app, and let people choose which icon to display.

Create Custom Modelers with the CLIPS language and learn how the embedded rules engine works.

This project demonstrates localization-friendly auto layout constraints. It uses `NSGridView` as a container view to achieve localized layouts.

Enable Touch Alternatives to provide keyboard, mouse, and trackpad equivalents to your iOS app when it runs on a Mac with Apple silicon.

Take advantage of the true native resolution of a Mac display when running your iPad app in full-screen mode on a Mac.

Build DocC documentation for a Swift package that contains a DocC Catalog.

Encourage competition in your games by adding leaderboards that have a duration and repeat.

Develop games where multiple players interact in real time.

Develop a spatial board game where multiple players interact with pieces on a table.

Develop games where multiple players take turns and can exchange data while waiting for their turn.

Present a mixed immersion style space to draw content in a person’s surroundings, and choose how upper limbs appear with respect to rendered content.

Support a physical controller or add a virtual controller to enhance how people interact with your game through haptics, lighting, and motion sensing.

Implement a custom document file format to manage user interactions with files on different cloud storage providers.

Create widgets to show your app’s content on the Home screen, with custom intents for user-customizable settings.

Highlight physical structures and display text that guides a user to scan the shape of their physical environment using a framework-provided view.

Demonstrates adding a watermark to a PDF page.

Offer Live Activities, controls, animate data updates, and add interactivity to widgets.

Animate a filtered image to a Metal view in a SwiftUI app using a Core Image Render Destination.

Export a 3D model that consists of multiple rooms captured in the same physical vicinity.

Demonstrates adding widgets—interactive form elements—to a PDF document.

Create visual effects in a scene by defining a rendering technique with custom symbols.

Enhance the look of an exported 3D model by substituting object bounding boxes with detailed 3D renditions.

Create spatial photos for visionOS by packaging a pair of left- and right-eye images as a stereo HEIC file with related spatial metadata.

Request authorization to query HealthKit for a user’s clinical records and display them in your app.

Query for and validate a verifiable clinical record.

Create your own workout app, quickly and easily, with HealthKit and SwiftUI.

Mirror a workout from a watchOS app to its companion iOS app, and perform bidirectional communication between them.

Inform people when they may have been exposed to COVID-19.

Create a health app that allows a clinical care team to send and receive mobility data.

Share and read heartbeat and quantity series data using series builders and queries.

Incorporate HealthKit State of Mind into your app and visualize the data in visionOS.

Simplify location delivery using asynchronous events in Swift.

Annotate a map with location-specific data using default and customized annotation views and callouts.

Enhance the readability of a map by replacing overlapping annotations with a clustering annotation view.

Use the Indoor Mapping Data Format (IMDF) to show an indoor map with custom overlays and points of interest.

Continually update a MapKit overlay displaying the path a user travels.

Use the Indoor Mapping Data Format (IMDF) to show an indoor map with custom overlays and points of interest in your browser.

Add regions of layered content to a map view.

Display a richly detailed map, and use Look Around to experience an interactive view of landmarks.

Leverage the spatial awareness of ARKit and Apple Ultra Wideband Chips in your app to guide users to a nearby device.

Enable devices to access relative positioning information.

Interact with a nearby Apple Watch by measuring its distance to a paired iPhone.

Establish a connection with a nearby accessory to receive periodic measurements of its distance from the user.

Provide automatic search completions for a partial search query, search the map for relevant locations nearby, and retrieve details for selected points of interest.

Define boundaries and act on user location updates.

Display a map that is relevant to the user by filtering points of interest and search results, and constraining the visible region.

Configure a device to act as a beacon and to detect surrounding beacons.

Ask for location access using a customizable location button.

Generate ray-traced images with motion blur using GPU-based parallel processing.

Implement ray-traced rendering using GPU-based parallel processing.

Pace rendering with minimal input latency while providing essential information to the operating system for power-efficient rendering, thermal mitigation, and the scheduling of sustainable workloads.

Run your own graph functions on the GPU by building the function programmatically.

Choose and render meshes with several levels of detail using object and mesh shaders.

Support dynamic scenes and denoising by extending your ray tracer with Metal Performance Shaders.

Reduce render workloads while increasing image detail with MetalFX.

Determine which pixels are visible in a scene by using a depth texture.

Invoke Metal’s frame capture from your app, then save the resulting GPU trace to a file or view it in Xcode.

Explicitly enumerate a ray’s intersections with acceleration structures by creating an intersection query object.

Build a 3D application that integrates with Hydra and USD.

Implement a lightweight view for Metal rendering that’s customized to your app’s needs.

Compile a library of shaders and write it to a file as a dynamically linked library.

Load image data into a texture and apply it to a quadrangle.

Draw a scene without rendering hidden geometry by checking whether each object in the scene is visible.

Implement a custom operation in PyTorch that uses Metal kernels to improve performance.

Implement a custom operation that uses Metal kernels to accelerate neural-network training performance.

Render into an offscreen texture by creating a custom render pass.

Define custom shader behavior at runtime by creating functions from existing ones and preferentially linking to others in a dynamic library.

Use a compute pass to encode an argument buffer and access its arguments in a subsequent render pass.

Reduce CPU overhead and simplify your command execution by reusing commands.

Maximize CPU to GPU parallelization by generating render commands on the GPU.

Filter an image with MPSGraph fast Fourier transforms using the convolutional theorem.

Use events to synchronize access to resources allocated on a heap.

Use fences to synchronize access to resources allocated on a heap.

Draw overlapping, transparent surfaces in any order by using tile shaders and image blocks.

Use Metal’s MSAA to enhance the rendering of edges with custom resolve options and immediate and tile-based resolve paths.

Stream texture and buffer data directly from disk into Metal resources using fast resource loading.

Create argument buffers to organize related resources.

Replace your app’s deprecated OpenGL code with Metal.

Draw with Metal and OpenGL in the same view using an interoperable texture.

Use advanced Metal features such as indirect command buffers, sparse textures, and variable rate rasterization to implement complex rendering techniques.

Use Metal to find GPUs and perform calculations on them.

Perform parallel calculations on structured data by placing the data in textures.

Implement a post-processing pipeline using the latest features on Apple GPUs.

Access texture data from the CPU by copying it to a buffer.

Implement ray traced rendering using GPU-based parallel processing.

Avoid expensive lighting calculations by implementing a deferred lighting renderer optimized for immediate mode and tile-based deferred renderer GPUs.

Avoid expensive lighting calculations by implementing a deferred lighting renderer optimized for immediate mode and tile-based deferred renderer GPUs.

Avoid expensive lighting calculations by implementing a deferred lighting renderer optimized for immediate mode and tile-based deferred renderer GPUs.

Implement a forward plus renderer using the latest features on Apple GPUs.

Implement realistic real-time lighting by dynamically generating reflection maps by encoding a ray-tracing compute pass.

Use layer selection to reduce the number of render passes needed to generate an environment map.

Use argument buffers to render terrain in real time with a GPU-driven pipeline.

Switch dynamically between multiple GPUs to efficiently execute a compute-intensive simulation.

Switch dynamically between multiple GPUs to efficiently render to a display.

Limit texture memory usage for large textures by loading or unloading image detail on the basis of MIP and tile region.

Configure alternative render paths in your Metal app to enable running your app in Simulator.

Avoid stalls between CPU and GPU work by using multiple instances of a resource.

Train a simple neural network digit classifier.

Use an MPS neural network graph to train a simple neural network digit classifier.

Render a simple 2D triangle.

Reduce CPU overhead by using arrays inside argument buffers and combining them with resource heaps.

Create pipelines for different levels of detail from a common shader source.

Create a MetalKit view and a render pass to draw the view’s contents.

Select media assets by using a Photos picker view that SwiftUI provides.

Help users organize their photos into albums and browse photo collections in a grid-based layout using PhotoKit.

Create a team-based guessing game for visionOS using Group Activities.

Stream desktop content like displays, apps, and windows by adopting screen capture in your app.

Follow subjects in real time using an iPhone that you mount on a DockKit accessory.

Augment the macOS Photos app with extensions that support project creation.

Invite your friends to draw on a shared canvas while on a FaceTime call.

Configure a compression session to encode video for live streaming.

Configure a compression session to optimize encoding for video-conferencing apps.

Configure a compression session to transcode video in offline workflows.

Embed a system-provided, half-height Photos picker into your app’s view.

Play and edit Cinematic mode video with an adjustable depth of field and focus points.

Share screen recordings, or broadcast live audio and video of your app, by adding ReplayKit to your macOS apps and games.

Improve the user experience of finding and selecting assets by using the Photos picker.

Create rendering effects by writing surface shaders and geometry modifiers.

Use systems and postprocessing effects to create a realistic underwater scene.

Reconstruct objects from user-selected input images by using photogrammetry.

Use attachments to place 2D content relative to 3D content in your visionOS app.

Build an interactive scene using an animation timeline.

Use collision groups and collision filters to control which objects collide.

Build efficient custom worlds for your app.

Create collision filters to control which objects collide.

Create AR games and experiences that interact with real-world objects on LiDAR-equipped iOS devices.

Combine RealityKit’s face detection with PencilKit to implement virtual face-painting.

Generate 3D objects from images using RealityKit Object Capture.

Build an immersive game using RealityKit audio, simulation, and rendering features.

Use low-level mesh and texture APIs to achieve fast updates to a person’s brush strokes by integrating RealityKit with ARKit and SwiftUI.

Secure a video player in an immersive scene with a docking region you can specify.

Create an interactive mesh with low-level mesh and low-level texture.

Implement a variety of postprocessing techniques to alter RealityKit rendering.

Display a scene from Reality Composer Pro in visionOS.

Bring an iOS or iPadOS game to visionOS and enhance it.

Implement a full scanning workflow for capturing objects on iOS devices.

Update your local USD library to add interactive and augmented reality features.

Add a range of visual effects to a RealityKit view by attaching a particle emitter component to an entity.

Create realistic, connected motion using physics joints.

Create entities that behave and react like physical objects in a RealityKit view.

Capture high-quality images with depth and gravity data to use with RealityKit Object Capture.

Move an entity between a volumetric window and an immersive space using coordinate space transformations.

Build a RealityKit component to support standard visionOS gestures on any entity.

Create a chess game using RealityKit and assets created using Object Capture.

An AR experience that randomly selects a programming framework and maps it onto the user’s face.

Identify a customer’s entitlement to your service, offers, and messaging by analyzing a validated receipt and the state of their subscription.

Generate a signature using your private key and lightweight cryptography libraries.

Offer In-App Purchases and manage entitlements using signed transactions and status information.

Fetch, display, purchase, validate, and finish transactions in your app.

Allow users to purchase media in the App Store from within your app.

Implement best practices for prompting users to review your app in the App Store.

Validate your ad impressions and test your postbacks by creating unit tests using the StoreKit Test framework.

Create a data entry form for collecting and changing data managed by SwiftData.

Use a variety of C++ APIs in Swift – and vice-versa – across multiple targets and frameworks in an Xcode project.

Create relationships for static and dynamic data stored in your app.

Explore different ways to use SwiftData to delete persistent data.

Manage data store presentation using predicates and dynamic queries.

Create and update a persistent store to cache read-only network data.

Use C++ APIs in Swift – and Swift APIs in C++ – in a single framework target, and consume the framework’s APIs in a separate app target.

Use distributed actors to take your Swift concurrency and actor-based apps beyond a single process.

Use this code to follow along with a guide to migrating your code to take advantage of the full concurrency protection that the Swift 6 language mode provides.

Improve your app’s performance by refactoring your code to take advantage of asynchronous functions in Swift.

Make your apps stand out by adding background materials, vibrancy, custom graphics, and animations.

Enable drag-and-drop interactions in lists, tables and custom views.

Compose rich views by reacting to state changes and customize your app’s scene presentation and behavior on iPadOS and macOS.

Use navigation links, stacks, destinations, and paths to provide a streamlined experience for all platforms, as well as behaviors such as deep linking and state restoration.

Code along with the WWDC presenter to transform an app with SwiftData.

Create engaging SwiftUI Mac apps by incorporating side bars, tables, toolbars, and several other popular user interface elements.

Create a custom view with data-driven transitions and animations in SwiftUI.

Arrange views in your app’s interface using layout tools that SwiftUI provides.

Build sophisticated animations that you control using phase and keyframe animators.

Make your app accessible to everyone by applying accessibility modifiers to your SwiftUI views.

Build standard content lockups and rows of content shelves for your tvOS app.

Access individual subviews to compose flexible container views.

Add scroll effects, rich color treatments, custom transitions, and advanced effects using shaders and a text renderer.

Configure how your app’s windows look and function in macOS to provide an engaging and more coherent experience.

Keep your app content front and center while providing quick access to navigation using the tab bar.

Create custom focusable views with key-press handlers that accelerate keyboard input and support movement, and control focus programmatically.

Create a single codebase and app target for Mac, iPad, and iPhone.

Create a shared codebase to build a multiplatform app that offers widgets and an App Clip.

Consume data in the background, and lower memory use by batching imports and preventing duplicate records.

Create connections between your app’s data model and views.

Update your existing app to leverage the benefits of Observation in Swift.

Show changes to data in your app’s user interface by using observable objects.

Provide app continuity for users by preserving their current activities.

Discover, select, and set up a specific Bluetooth accessory without requesting permission to use Bluetooth.

Use networking frameworks to create a custom protocol for playing a game across iOS, iPadOS, watchOS, and tvOS devices.

Read NFC tags with NDEF messages in your app.

Set up and load a driver that logs output to the Console app.

Use reports to understand how DNS and protocol handshakes impact connection establishment.

Send and receive different kinds of data securely by validating inputs and asynchronously by storing and using a callback.

Find and connect to a modem attached to a serial port using IOKit.

Perform compression for all files and decompression for files with supported extension types.

Associate an iOS device with an accessory’s network to deliver network configuration information.

Create an Ethernet driver that interfaces with the system’s network protocol stack.

Improve the security of your macOS app by limiting the ways its components can run.

Implement a configurable virtual MIDI driver as a driver extension that runs in user space in macOS and iPadOS.

Save data to tags, and interact with them using native tag protocols.

Encrypt a single file and save the result to the file system, then decrypt and recreate the original file from the archive file using Apple Encrypted Archive.

Encrypt the contents of a string and save the result to the file system, then decrypt and recreate the string from the archive file using Apple Encrypted Archive.

Compress and encrypt the contents of an entire directory or decompress and decrypt an archived directory using Apple Encrypted Archive.

Use the Network Extension framework to allow or deny network connections.

Process keyboard-related data from a human interface device and dispatch events to the system.

Process stylus-related input from a human interface device and dispatch events to the system.

Build a simple `netcat` tool that establishes network connections and transfers data.

Receive notifications and authorization requests for sensitive operations by creating an Endpoint Security client for your app.

Use CryptoKit to carry out operations like hashing, key generation, and encryption.

Provide voice and text communication on a local network isolated from Apple Push Notification service by adopting Local Push Connectivity.

Install and run GUI Linux in a virtual machine using the Virtualization framework.

Run a Linux operating system on your Mac using the Virtualization framework.

Install and run macOS in a virtual machine using the Virtualization framework.

Convert between strongly typed cryptographic keys and native keychain types.

Add advanced multitasking capabilities to your video apps by using Picture in Picture playback in tvOS.

Create full-fledged TVML documents by using data binding and queries on simplified TVML files.

Highlight content from your Apple TV application by building a full screen Top Shelf extension.

Display and navigate between TVML documents on Apple TV by retrieving and parsing information from a remote server.

Build an interface that plays multiple videos simultaneously and handles transitions to different experience types gracefully.

Display content with a collection view that maximizes the tvOS experience.

Specify scrollable and fixed regions in a product page.

Display content options with document view controllers and fetch and populate content with TVMLKit JS.

Adapt the content of your app for the current viewer by using an entitlement and simplifying sign-in flows.

Play media items in a client-server app using the built-in media player for TVMLKit JS.

Play media full screen, embedded inline, or in a floating Picture in Picture (PiP) window using a player view controller.

Update onscreen information by adding event listeners to your Apple TV app.

Capture high-quality photos, video, and audio in your Apple TV app by connecting an iPhone or iPad as a continuity device.

Store separate data for each user with the new Runs as Current User capability.

Add interactive overlays, parental controls, and livestream channel flipping using a player view controller.

Expose commonly used functionality with static or dynamic 3D Touch Home Screen quick actions.

Provide quick access to useful actions by adding context menus to your iOS app.

Enhance interactions with your app by handling raw keyboard events, writing custom keyboard shortcuts, and working with gesture recognizers.

Provide quick access to useful actions by adding menus and keyboard shortcuts to your Mac app built with Mac Catalyst.

Respond dynamically to keyboard movement by using the tracking features of the keyboard layout guide.

Demonstrates how to enable drag and drop for a `UIImageView` instance.

Demonstrates how to enable and implement drag and drop for a table view.

Enhance user feedback for your iPadOS app with a hover preview for Apple Pencil input.

Adopt Dark Mode in your iOS app by using dynamic colors and visual effects.

Add menus to your user interface, with built-in button support and bar-button items, and create custom menu experiences.

Store and fetch images asynchronously to make your app more responsive.

Implement a custom document file format to manage user interactions with files on different cloud storage providers.

Use a document browser to provide access to the user’s text files.

Improve your iPadOS app with Mac Catalyst by supporting native controls, multiple windows, sharing, printing, menus and keyboard shortcuts.

Improve the performance of lists and collections in your app with prefetching and image preparation.

Provide visual feedback to the user about the state of a cell and the transition between states.

Create table view cells that support Dynamic Type and use system spacing constraints to adjust the spacing surrounding text labels.

Discover how to create a layered and customized sheet experience in UIKit.

Manage user interactions and present custom information when taking pictures by adding an overlay view to your image picker.

Customize a view layout by changing the size of cells in the flow or implementing a mosaic style.

Create custom titles, prompts, and buttons in your app’s navigation bar.

Share data between iPad apps during a drag and drop operation using an item provider.

Listen for and respond to a user’s preference changes in your Mac app built with Mac Catalyst using Combine.

Ensure a positive user experience when presenting a view controller as a sheet.

Create a user interface with searchable content in a table view.

Lay out text in a custom-shaped container and apply glyph substitutions.

Provide a great user experience with pointing devices, by incorporating pointer content effects and shape customizations.

Add exclusion paths, text attachments, and text lists to your text, and render it with text views.

Capture Apple Pencil and touch input in views.

Bring compositional layouts to your app and simplify updating your user interface with diffable data sources.

Accelerate actions in your app by providing shortcuts to preview content in detail view controllers.

Support touch interactions in your iPad app by adding pointer interactions to your views.

Capture touches as a series of strokes and render them efficiently on a drawing canvas.

Navigate between user interface elements using a keyboard and focusable UI elements in iPad apps and apps built with Mac Catalyst.

Load data for collection view cells before they display.

Provide continuity for the user by preserving current activities.

Provide app continuity for users by preserving their current activities.

Accelerate user selection of multiple items using the multiselect gesture on table and collection views.

Explain the purpose of interface elements by showing a tooltip when a person positions the pointer over the element.

Enhance your iPad app by adding desktop-class features and document support.

Enrich your app’s user experience by supporting standard and custom gesture interaction.

​ Load, display, edit, and save HDR images using SwiftUI and Core Image. ​

Support side-by-side instances of your app’s interface and create new windows.

Manage documents across multiple devices to create a seamless editing and collaboration experience.

Customize your app’s user interface with views and controls.

Streamline the display and update of data in a collection view using a diffable data source that contains identifiers.

Create a search interface with a table view of suggested searches.

Learn how to incorporate SwiftUI views into a UIKit app.

Interact with text by managing text selection and inserting custom text elements.

Construct a composite image from images that capture the same scene.

Calculate face-capture quality and visualize facial features for a collection of images using the Vision framework.

Generate a feature print to compute distance between images.

Generate image masks for people automatically by using semantic person-segmentation.

Segment the foreground subjects of an image and composite them to a new background with visual effects.

Detect and classify human activity in real time using computer vision and machine learning.

Analyze and label images using a Vision classification request.

Draw the skeleton of an animal by using Vision’s capability to detect animal body poses.

Create a virtual drawing app by using Vision’s capability to detect hand poses.

Render skeletons of 3D body pose points in a scene overlaying the input image.

Identify the trajectory of a thrown object by using Vision.

Locate and demarcate rectangles, faces, barcodes, and text in images using the Vision framework.

Analyze and filter phone numbers from text in live capture by using Vision.

Identify the most visually pleasing frames in a video by using the image-aesthetics scores request.

Quantify and visualize where people are likely to look in an image.

Perform text recognition on a photo using the Vision framework’s text-recognition request.

Apply Vision algorithms to identify objects in real-time video.

Use the Vision framework to isolate and apply colors to people in an image.

Compare face-capture quality in a set of images by using Vision.

Detect, recognize, and structure text on a business card or receipt using Vision and VisionKit.

Apply Vision algorithms to track objects or rectangles throughout a video.

Detect and track faces from the selfie cam feed in real time.

Train a flower classifier using Create ML in Swift Playgrounds, and apply the resulting model to real-time image classification using Vision.

Add camera-based features to enterprise apps.

Create text that expands out of a window using stacked SwiftUI text views.

Add a layer of mesh to objects in the real world, using scene reconstruction in ARKit.

Add a deeper level of immersion to media playback in your app with RealityKit and Reality Composer Pro.

Use room tracking in visionOS to provide custom interactions with physical spaces.

Draw two-dimensional shapes in your visionOS app with SwiftUI shapes or with your custom shapes.

Display a horizontal row of three-dimensional shapes in your visionOS app, using predefined mesh and white material.

Display 3D content with a volumetric window that people can move.

Implement a painting canvas entity, and update its mesh to represent a stroke.

Enhance your visionOS app by adding an immersive space using RealityKit.

Display an interactive car model using gestures in a reality view.

Display and manage multiple SwiftUI windows in your visionOS app.

Implement a portal window that displays a 3D environment and simulates entering a portal by using RealityKit.

Create an entity that tracks and follows head movement in an immersive scene.

Build a stereoscopic image by applying textures to the left and right eye in a shader graph material.

Create styled text in a window using SwiftUI.

Show video from devices connected with the Developer Strap in your visionOS app.

Create a more immersive experience by adding video reflections in a custom environment.

Display a 3D model that generates procedural textures in a reality view.

Update the adjustable parameters of a 3D model in visionOS.

Create an immersive experience by making your app’s content respond to the local shape of the world.

Create engaging, hands-free experiences based on barcodes in a person’s surroundings.

Use object tracking in visionOS to attach digital content to real objects to create engaging experiences.

Increase the realism of an immersive experience by adding entities with invisible materials real-world objects.

Detect horizontal surfaces like tables and floors, as well as vertical planes like walls and doors.

Query and react to changes in the position and rotation of Apple Vision Pro.

Create and adjust spatial audio in visionOS with RealityKit.

Use hand-tracking anchors to display a visual representation of hand transforms in visionOS.

Retrieve the position and orientation of anchors your app stores in ARKit.

Create a watch app to manage and share a task list and visualize the status with a chart.

Learn how to make your watchOS app more accessible.

Create complications that batch-load a timeline of future entries and run periodic background sessions to update the timeline.

Create, preview, and sync workouts for use in the Workout app on Apple Watch.

Use common SwiftUI elements and watch-specific features in a comprehensive sample app.

Implement complications in a watch app to display essential information on a watch face.

Keep your complications up-to-date by reading values from a Bluetooth peripheral while your app is running in the background.

Present multiple complications for a single complication family using descriptors.

Transfer data between a watchOS app and its companion iOS app.

Integrate SwiftUI elements and watch-specific features, and build widgets for the Smart Stack.

Provide quick access to useful actions by adding context menus to your iOS app.

Block web content with your web extension using the declarative net request API.

Improve your web extension in Safari with a non-persistent background page and new tab-override customization.

Learn how to make custom Safari Web Inspector extensions.

Create a web browser app and associated extensions.

Customize and enhance web pages by building a Safari web extension.

Communicate between your Safari web extension and its containing app.

Learn about enhancements to Safari Web Extensions.

Build a Safari Extension that displays metadata using Open Graph.

Implement a simple iPad web browser that can view either the desktop or mobile version of a website.