Skip to main content
CF

Portfolio Piece - SwiftUI, HealthKit, Charts, Foundation Models - iOS 26

14h 45m 6s
English
Paid

Portfolio Piece - SwiftUI, HealthKit, Charts, Foundation Models - iOS 26 is a 70-lesson 14 hours 45 minutes self-paced course by Sean Allen. In this course, you build a clear and useful iOS app .

Course facts

Lessons
70
Duration
14 hours 45 minutes
Level
All levels
Language
English
Updated
Instructor
Sean Allen
Price
Premium

In this course, you build a clear and useful iOS app. You use tools from the Apple ecosystem and learn how each part fits in a real project. This app becomes a strong piece in your portfolio.

Build the App with SwiftUI

You create the full interface with SwiftUI. You learn how views work and how data moves through the app. You also work with the new Liquid Glass UI style in iOS 26.

Work with Health Data

You connect the app to HealthKit. You read and write steps, heart rate, and other data. You learn how to request user permission and handle common issues.

Show Data with Charts

You build clear charts with Swift Charts. You add basic animation and make the charts respond to user input.

Use On‑Device AI

You work with Foundation Models that run on the device. You learn how to send prompts, read responses, and use this feature in safe and simple ways.

Write Clean and Safe Code

You set up Git and GitHub to track your work. You add error handling for common app tasks. You write unit tests to check your logic.

Improve Accessibility

You make the app easier to use. You add labels, hints, and layout changes that help more people use your app.

Document with DocC

You add clear notes to your code. You build DocC pages that help others understand your project.

Learn Modern Swift

You use Swift 6 Concurrency to run tasks in a safe way. You also try Swift Testing to write small and focused tests.

Course Updates

You get updates for iOS 27 and later versions. This helps you keep your project fresh and useful.

Who teaches Portfolio Piece - SwiftUI, HealthKit, Charts, Foundation Models - iOS 26? Sean Allen

Sean Allen thumbnail

Sean Allen is a US iOS developer and educator behind the Sean Allen YouTube channel — one of the larger independent iOS / Swift channels online, focused on practical SwiftUI development and the iOS-engineer career track.

His CourseFlix listing carries Dub Dub Grub — An Intermediate SwiftUI Course with MapKit and CloudKit. Material is paid and aimed at iOS developers building real SwiftUI apps that integrate Apple's MapKit and CloudKit frameworks.

What lessons are included in Portfolio Piece - SwiftUI, HealthKit, Charts, Foundation Models - iOS 26?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 70 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: How You Benefit From This Course. Watch Before Buying
All Course Lessons (70)
#Lesson TitleDurationAccess
1
How You Benefit From This Course. Watch Before Buying Demo
02:57
2
Who Is This Course Designed For? Watch Before Buying
01:13
3
How the iOS 26 Update Works. Watch Before Buying
02:04
4
1-on-1 Coaching & Help
01:56
5
App Demonstration & Overview
04:05
6
Portfolio Strategy - Deep vs. Shallow Projects
04:31
7
What is Source Control & How We'll Use It (GitHub)
05:20
8
Setup GitHub Repository & Create Xcode Project
08:58
9
My Thoughts on Architecture & What We Use
05:21
10
Main > Dev > Feature Branching
03:27
11
Dashboard UI
12:53
12
Navigation Setup
13:12
13
Data List View UI - Date & Number Formatting Intro
17:13
14
Our First Pull Request & My Biggest Piece of Advice
12:28
15
Permission Priming UI
10:23
16
Enable HealthKit & Request Access to User's Health Data
16:56
17
@AppStorage & Presenting Permission Priming
10:10
18
Write Mock Data to iOS Simulator's Health App
15:01
19
Fetch HealthKit Data
15:15
20
Pull Request Review & Submit
05:22
21
Step Bar Chart Basic UI
13:32
22
Step Bar Chart Customizations
14:58
23
Step Bar Chart Interactivity & Animations
16:01
24
Quick Chart Refactor & Project Organization
10:49
25
Average Steps Per Weekday Calculation
17:54
26
Step Pie Chart UI
13:17
27
Step Pie Chart Interactivity & Animations
15:14
28
Pull Request - Step Charts
05:56
29
Weight Line Chart - Basic UI
14:06
30
Weight Line Chart - Y-Axis Scale & Customizations
15:01
31
Weight Line Chart Interactivity
11:11
32
Average Weight Change Calculation
16:39
33
Weight Bar Chart UI & Challenge
15:01
34
Pull Request with a Fix - Weight Charts
08:33
35
Write Step & Weight Data to HealthKit
15:57
36
Error Handling - Part 1 - Throw, Do, Try, Catch, Custom Error
19:49
37
Error Handling - Part 2 - Catch at The Call Site
17:47
38
Dynamic Error Alerts - Deep Link to Settings
17:44
39
Play Haptics When Dragging on Charts
11:23
40
Empty States - ContentUnavailableView
12:23
41
Text Input Validation
09:13
42
Pull Request - Error Handling, Haptics, Empty States and Input Validation
10:25
43
Refactor - Chart Container - @ViewBuilder
21:11
44
Refactor - Chart Annotation View & Misc
22:27
45
Refactor - Chart Pull Request, Discussion, Squash Commits
22:38
46
Refactor - Improve fetches, async let, DateInterval
25:24
47
Optimization - Misc code improvements
23:38
48
Project File Organization
04:13
49
A Lesson in Refactoring - Prep for Accessibility
14:26
50
Basic Accessibility - An Introduction & VoiceOver
10:47
51
Basic Accessibility - VoiceOver - The Code
24:48
52
Documenting Code with DocC & Code Comments
14:21
53
Quick App Icon - Bakery
03:34
54
Giant 1.0.0 PR, Versioning, Release, & Source Control Parting Advice
13:40
55
What Makes a Great GitHub README
09:48
56
A Taste of Swift 6 Concurrency
20:06
57
A Taste of Swift Testing
25:09
58
iOS 18 Update - Pull Request and Release
05:53
59
Initial Run & What We'll Update
15:41
60
Liquid Glass UI - Availability Checks & Backward Compatibility
10:24
61
Liquid Glass UI - Gradient Background & Chart UI
16:26
62
Liquid Glass UI - Toolbars & Sheets
15:53
63
Swift 6.2 Concurrency - @MainActor Default
06:17
64
Foundation Models Intro & What We'll Build
07:42
65
Foundation Models - Setup & Availability Check
15:42
66
Foundation Models - AI Coach Logic - Working With the LLM
25:26
67
Foundation Models - Streaming Response UI
20:09
68
Icon Composer - New App Icon
09:33
69
Final Pull Request & ReadME Update
05:12
70
Where to go from here?
03:00
Unlock unlimited learning

Get instant access to all 69 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

What courses are similar to Portfolio Piece - SwiftUI, HealthKit, Charts, Foundation Models - iOS 26?

  • Kotlin Coroutines and Concurrency  thumbnailNew

    Kotlin Coroutines and Concurrency

    By: Dave Leeds
    In-depth Understanding of Coroutines in Kotlin. Learn how to apply asynchronous programming in practice. Step-by-step training with examples by Dave Leeds.
    10h 8m5/5

Frequently asked questions

What prerequisites are needed for this course?
Prospective students should have a basic understanding of Swift and iOS development. Familiarity with Xcode and GitHub is recommended since the course involves setting up repositories and creating Xcode projects. Prior experience with SwiftUI and HealthKit, while beneficial, is not required as the course covers these topics extensively.
What will I build by the end of the course?
By the end of the course, you will have built a fully functional iOS app that integrates HealthKit to read and write health data, such as steps and heart rate. The app will feature a user interface created with SwiftUI, including charts made with Swift Charts, and it will utilize on-device AI with Foundation Models to enhance user interaction.
Who is the target audience for this course?
The course is designed for intermediate iOS developers who wish to enhance their skills in building comprehensive applications using modern tools and frameworks. It is particularly suitable for those interested in integrating health data and AI into their apps and for developers looking to improve their portfolio with a robust project.
How does this course compare to other iOS development courses?
This course provides a focused approach on integrating HealthKit, SwiftUI, and on-device AI, which sets it apart from more general iOS development courses. It offers specific insights into using the new Liquid Glass UI style in iOS 26, as well as the opportunity to work with Swift 6 Concurrency and Testing, providing a modern and comprehensive learning experience.
What specific tools and platforms are covered in the course?
The course covers SwiftUI for building user interfaces, HealthKit for managing health data, Swift Charts for data visualization, and Foundation Models for implementing on-device AI. It also includes lessons on using Git and GitHub for source control, Swift 6 Concurrency for safe task execution, and DocC for documenting code effectively.
What topics are not covered in this course?
The course does not cover beginner-level Swift or iOS development fundamentals, as it assumes a foundational knowledge in these areas. It also does not delve into server-side Swift or cross-platform mobile development frameworks, focusing solely on iOS-specific tools and techniques.
What is the expected time commitment for completing the course?
The course consists of 70 lessons, each designed to provide detailed insights and practical exercises. While the exact time to complete will depend on the student's pace, a commitment of several weeks is expected for those engaging with the material in-depth, especially when implementing and testing the app features taught in the course.