Prepare for takeoff 🛫

Adam Rush will be hosting your SwiftLeeds this year and hear some thoughts about what is in store for you this year and a glimpse into some of the amazing talks we have lined up.

Bringing back the love of Swift ❤️

TBC

Antoine van der Lee

Founder of SwiftLee & RocketSim

Swift for Game Development: The Wins, The Walls, The Gaps

iOS developer by day, game engine developer by night. Two worlds with little in common. I loved my engine project, but eventually wondered if Swift, my favourite language, could work for games. Few have tried, so I started exploring.

And there is a lot that should make Swift favourable for games. It has performance, modern syntax, value types, and an increasingly serious story outside Apple's walled garden. Games need exactly that. So why is no one actually doing this?

And so I tried it. What followed was an experiment into the depths of Swift most of us rarely touch. From memory layout control, C and C++ interop at large scale, runtime reflection (and its absence), to Swift on Windows, and the thin line between "Swift can technically do this" and "Swift can actually ship this". No deep experience with game engines is needed to follow along, but familiarity with Swift and C/C++ basics will help you get the most from this talk.

This talk is the result of that experiment. It's split into two parts.

First, we'll dive into Swift features that shape game performance: memory layout, UnsafePointer, ARC, C/C++ interop, and which language features help or hinder when venturing beyond managed code. We'll cover:

• Why memory layout and struct packing matter the moment you touch ECS architectures and raw memory
• What working with C interop actually feels like, where Swift/C++ interop promises more than it delivers, and one unconventional way to bind a C++ engine to Swift that bypasses it altogether.
• Why proper runtime reflection is the missing primitive for tools like scene editors and asset pipelines, and why Macros don't close the gap.
• What it's really like to use Swift on Windows in 2026.
• Where Swift's performance story genuinely holds up, and where the language's safety defaults fight you.

The second part is a live demo. We'll build a small physics sandbox on stage with Swift, Raylib, and Box2D – enough to see the pieces work together, and enough to see where the rough edges are. After the talk, all code samples, slides, and a link to the full project repository will be made available. This way, you'll be able to dive deeper, experiment on your own, and start building right away.

This is an honest look at Swift outside Apple’s ecosystem from someone who uses Swift daily and wanted to test its limits.

Marcel Kulina

Platform Lead iOS @ adesso SE · kulina.dev

Refreshment Break ☕️

CarPlay from Zero: Building Your First In Car Experience

We're iOS developers building Charge a Smile, an EV charging app that helps drivers across Germany find charging stations, compare prices, and plan routes. We've expanded the app beyond the phone to support Home Screen widgets, Lock Screen widgets, Live Activities, and most recently CarPlay.

Why CarPlay? Because our users are literally driving when they need to find a charger. The phone app wasn't enough.

Building CarPlay taught us more about UI design than any SwiftUI tutorial. When you only have 6 template types and your users can't look at the screen, you're forced to strip everything to its essentials. That constraint changed how we think about every surface our app lives on.

Topics we'd love to speak about:

CarPlay Development From entitlement approval to shipping. The architecture, the templates, the gotchas. Most iOS developers have never touched CarPlay, but it's more accessible than people think. We'd walk through building a real CarPlay experience using examples from Charge a Smile.

Multi-Surface App Design Your app now lives in 4+ places: phone, widget, Lock Screen, CarPlay. How do you share data across all of them? How do you design for glanceable vs. interactive vs. driving-safe contexts? We've built all of these and learned what works.

Designing Under Constraints CarPlay's limitations forced creative solutions. When you can't add features, you design better defaults. This is a broader talk about how constraints breed creativity with CarPlay as the case study.

Eyad Kelleh

Cursor Ambassador

Maurice Pfurr

Cursor Ambassador

Attendee Group Photo 📸

Lunch 🍕

Lunch will be provided by The Leeds Market (a short walk from the main conference venue).

You'll be given a voucher to redeem across many local Leeds food traders.

A full list is available here: https://markets.leeds.gov.uk/kirkgate-market-traders

Vapor 5 is actually here

Finally (finally!) Vapor 5 is here. This talk will cover the journey taken to releasing a new major version of a framework used by thousands of companies, both big and small and examine the improvements made in the 6 years since the last major release. We'll cover the newer Swift features that make it possible to write code that's a joy to use whilst maintaining its expressiveness and performance. And we'll dive in to some of the more advanced features that make it suitable for production systems. Of course, the talk wouldn't be complete without a live demo showing it in action!

Tim Condon

Vapor Core Team

Delightful Text-Driven Experiences with SwiftUI's TextRenderer

Great apps sweat the small details, and text rendering is no exception. Since its introduction in iOS 17, I've enjoyed playing with SwiftUI's TextRenderer to create interactive text experiences that go beyond black-and-white pixels on screen. By combining animation, real-world user-generated text, and some SwiftUI know-how, TextRenderer can make your app truly sing.

In this talk, I'll share what I've learned shipping text-driven features in Particle News, from animated audio transcripts to progress-driven animations that can energize any SwiftUI app.

Eli Perkins

Engineer @ Particle News

Refreshment Break ☕️

Beyond Boilerplate: Building Production-Ready Swift Macros

Swift Macros introduced a powerful new metaprogramming capability to the Swift ecosystem, allowing developers to generate code at compile time and remove large amounts of boilerplate. While the initial examples are simple, building macros that are reliable, maintainable, and safe for production systems requires a deeper understanding of how Swift’s compiler and syntax tree work.

In this talk we explore how Swift Macros actually function under the hood and how they can be used to simplify real-world iOS architectures.

We will walk through the process of designing and implementing a macro that generates repetitive code commonly found in application layers such as networking models, dependency injection, and state management.

Along the way we will examine how macros interact with the SwiftSyntax tree, how compile-time transformations are applied, and what limitations developers should be aware of when using macros in production environments.

Rather than focusing on toy examples, the session demonstrates how macros can help reduce complexity in large codebases while maintaining type safety and compile-time guarantees.

By the end of the talk, attendees will understand when macros are the right tool, how to build them effectively, and how to integrate them safely into modern Swift projects.

Kevin Morales

Sr. Mobile Engineer

Who Let the App Intents Out? 🐾

Who says you need to open an app to use it? With App Intents, I logged my puppy’s walks 🐶 while keeping my iPhone in my pocket. This shows how apps can extend beyond the UI, letting Siri, Shortcuts, Spotlight, and widgets handle interactions hands-free.

User behavior is changing: people increasingly expect to talk to their devices or ask them to do things instead of navigating traditional screens. Modern apps should integrate seamlessly with the system, making everyday tasks effortless and enhancing the user experience. Developers will learn how to unlock system-level features without relying on traditional screens, making their apps smarter, more context-aware, and useful.

Major takeaways:

• Define and register AppIntents in Swift
• Expose actions to Siri, Shortcuts, Spotlight, and widgets
• Pass parameters with AppEnum and AppEntity
• Design background-driven experiences without touching the UI
• Apply practical examples immediately in your own apps

Claire Sivadier

iOS Developer

Getting physical: Using Swift for 3D printing

3D printing lets you turn ideas into real-world objects, whether it’s building cool gadgets or custom tools, fixing something at home, or creating art. But as developers traditional modelling tools often feel unfamiliar. What if you could design 3D models using Swift?

In this talk, we’ll explore how to use Swift alongside Cadova, an open-source library that brings a SwiftUI-like declarative approach to 3D modelling.

We'll start with a quick introduction to 3D printing: how it works, the typical modelling tools and workflows involved and the file formats being used. Then, we'll dive into Cadova and learn how to build simple shapes using its intuitive DSL. Stepping up, we'll look at combining shapes, creating reusable components and building more complex models based on some of my personal experiments, including an AI powered egg.

Finally, we'll look under the hood and see how Cadova uses Swift’s powerful result builders and how it compares to SceneKit and RealityKit.

This talk is aimed at a wide audience, only expecting basic Swift knowledge, no prior experience in 3D modelling or printing required. It's main goal is to show that Swift can be used for many different purposes beyond application development. It's also a great opportunity for more experienced developers to see result builders in action.

Eric Bariaux

Nelcea, Founder

Prepare for takeoff 🛫

Adam Rush will be hosting your SwiftLeeds this year and hear some thoughts about what is in store for you this year and a glimpse into some of the amazing talks we have lined up.

Building with iOS Screen Time APIs: The Talk I Wish I'd Had

On paper, FamilyControls, DeviceActivity, and ManagedSettings give you everything you need to build focus apps, parental controls, and digital wellbeing tools. In practice, you spend the first two weeks wondering why nothing works, why your extension can't see your app's data, and why a token you can't even read is the only handle you get on the app a user just selected. I've been building on these APIs in production, and this talk is the honest version of what I've learned.

We'll get into the architectural choices Apple quietly forces on you, the privacy boundaries that aren't documented, and the workarounds you’ll need to ship real features within those constraints. You'll leave with a real sense of what these APIs can and can't do, how to scope a Screen Time feature without burning a sprint discovering Apple won't let you do it. If you're thinking about Screen Time, or already deep in it, this is the talk I wish I'd had.

Nikki Eke

Mobile Engineer, Rive Ambassador.

Why Does Our Swift Code Work? Understanding Swift Through Platforms, Runtime, and the Compiler

Swift often looks simple on the your writing code, but every line depends on layers most app developers rarely see: the platform, the runtime, and the compiler. Have you ever wondered why a new Swift API can only be used on a newer OS? Why the same language can run on Apple platforms, Linux, and Windows? Why a small change can suddenly make compilation slower? Or why swiftc sometimes produces a mysterious stack trace?

These are not just compiler trivia. They are opportunities to understand how Swift really works. In this talk, we will explore Swift through the hidden layers beneath our everyday code and bugs: how Swift is distributed across different platforms, how the Swift runtime supports and constrains our apps, and how the compiler optimizes our code.

The goal is NOT to turn every Swift developer into a compiler engineer. Instead, this talk will give you a practical mental model for debugging strange issues, improving build performance, and making better architectural decisions. You will learn clearer understanding of why Swift behaves the way it does, and how deeper knowledge of the language infrastructure can help solve real-world problems in professional Swift development.

Yuki Aki

Software Engineer at Yappli

Refreshment Break ☕️

From Code to Outcomes: Building with User Impact in Mind

Modern software engineering is no longer just about writing good code. It is about making good decisions.

In this talk, I explore how developers shape product outcomes through the technical and strategic decisions they make every day: from architecture choices and experimentation approaches to defining success metrics and validating ideas before investing heavily in them.

Drawing on over a decade of experience across companies including Bloomberg, BBC, and fast-paced start-ups, I share real-world examples of technically excellent features that ultimately failed to deliver meaningful user impact, and suggest what teams could have done differently.

The session will cover:

• how teams fall into “feature factory” mode
• why discovery should involve engineers from the start
• how scrappy experimentation can reduce wasted effort
• why measurement and analytics must be first-class citizens
• and how both indie developers and large product teams can build with outcomes, not just output, in mind

For newer developers, the talk offers a broader perspective on how engineering work connects to real user value and product thinking.

For more experienced engineers, it challenges traditional delivery-focused mindsets and explores how modern developers can play a more active role in shaping what gets built, not just implementing it.

This is a talk about moving beyond writing code… and towards creating impact.

Natalija Marcinska

Product Leader at the BBC Mobile

Lunch 🍕

Lunch will be provided by The Leeds Market (a short walk from the main conference venue).

You'll be given a voucher to redeem across many local Leeds food traders.

A full list is available here: https://markets.leeds.gov.uk/kirkgate-market-traders

CloudKit Public Database as a Backend

CloudKit is best known for syncing user data across Apple devices, but it can do more than that. In addition to the private database, CloudKit also offers public and shared databases. The public database can be used as a lightweight backend for apps that need developer-managed, shared data users can access. In this talk, I’ll show how my app uses CloudKit Public Database as a backend and cover the benefits, constraints, and practical limitations that come with it.

Danijela Vrzan

Indie iOS Developer

Swift Meets Kotlin: Lessons in Building Cross-Platform Architecture

We shipped a complex production app on both Apple and Android platforms by combining Kotlin Multiplatform (KMP) for shared logic with SwiftUI on iOS and Jetpack Compose on Android, and Compose Multiplatform for sharing UI - all powered by a strongly type-driven design that spans the entire stack.

In this talk we merge our complete real-world journey and show exactly how we made Swift and Kotlin not just coexist, but thrive together in a large, modular, multi-feature-team codebase.

You’ll discover:

• How we organized the “marriage” between KMP and Swift in a fully modularized project so every feature team owns its domain while safely sharing business logic and types.

• Our type-driven UI state management system that delivers compile-time guarantees and almost zero boilerplate across SwiftUI and Compose.

• “Apple’s Way” — a clean, bidirectional SwiftUI - Compose communication pattern that feels completely native on both platforms while keeping the UIs perfectly synchronized.

Whether you’re a Swift engineer exploring KMP, a Kotlin developer who wants a truly native iOS experience, or a tech lead scaling mobile teams, you’ll walk away with battle-tested patterns, concrete architecture decisions, and measurable results you can apply immediately.

Just the real choices, the mistakes we made, the wins we celebrated, and the dramatic impact on velocity, code quality, and team happiness.

Yeskendir Salgara

Staff iOS Engineer at Trackman

Refreshment Break ☕️

Manipulating Pixels with Metal Shaders

Metal shaders are one of those topics that often get overlooked by iOS developers. They can feel intimidating, with unfamiliar parameters and math that seems it doesn’t belong to an app. But once things click, it opens up a whole new way of thinking about what you can build visually on Apple platforms.

This talk starts by explaining real scenarios where shaders outshine standard animations, and why pixel-level control sometimes gives you things SwiftUI simply can't. From there, we’ll build up the foundations: why working at the pixel level matters, what Metal is and how to read and write your first shader without getting lost. We'll walk through real examples, what the code is doing, why it produces the result it does, and how to bring it into a SwiftUI view so it lives in an actual app.

Attendees will walk away with a clear mental model of how Metal shaders work, enough practical knowledge to start experimenting, and a sense of where to go next. Whether they're brand new to shaders or already familiar with them, attendees will leave with something useful, a solid foundation or a new angle on concepts they already know. In any case, I would like to transmit the spark to start seeing your apps as a canvas on which you can create beautiful worlds.

Letizia Granata

Lab Assistant Coding at imaginary institute

Peer-to-Peer Sync: Building Offline-First Apps That Talk to Each Other

In a world obsessed with cloud connectivity, what if your app could sync data directly with nearby devices, without hitting the cloud? This session introduces peer-to-peer (P2P) sync patterns for iOS that enable apps to share data over LAN, Peer-to-Peer Wi-Fi, or Bluetooth.

We’ll walk through building resilient, offline-first apps where data flows between devices securely and automatically using Apple’s native frameworks. This is perfect for field deployments, disaster zones, or privacy-focused use cases.

Whether you’re building a logistics tool, health records app, or a real-time multiplayer experience, this talk will show you how to build iOS apps that sync serverlessly!

Pulkit Midha

Senior Mobile Developer at Couchbase

Using OpenTelemetry in Swift Apps

OpenTelemetry is an open standard for tracing what happens inside your code by capturing nested behaviours, errors and metrics. Server developers use it to get production-grade observability across their stack, and with first-party Swift support you can have that in your iOS and macOS apps as well.

We'll learn how to integrate tracing into any Swift application, and I'll show a few examples of how my workplace uses it in production. Then we'll go over using OpenTelemetry for error and exception tracking. We'll have a look at how to use it to find performance bottlenecks: wouldn't it be nice to find out quickly that a graphical hitch is actually a Core Data issue? And finally we'll even go into tracking general user behaviour: where are the points that your users are stumbling and leaving?

By the end, you'll have the tools to know where your application crashes, where it's slow, and where it disappoints your users, all taken from real data generated on actual devices.

Daniel Jilg

Makes apps & analytics, rides bikes, loves space

A Proper' Yorkshire Roast 🍮

What's going on here then?

Building an Audience for Your Apps

The crowded App Store and opaque search algorithms make it hard for indie apps to get traction, even if you have a great app.

This talk explains how even a small, well-nurtured audience can help apps launch, grow, and survive without the guesswork.

The talk will include:

• Examples of how an audience can future-proof your app as the App Store changes
• My experiences building audiences for apps for 15+ years
• Specific, easy examples that developers can build into their apps today
• A deep dive into building an email audience: — Practical ways to invite sign-ups inside your apps without breaking Apple’s guidelines, and keep users happy — Some common misconceptions about GDPR and how to be a good email citizen — Some fun examples of unexpected outcomes from using email to engage with users (celebrity interactions and incredible opportunities we’ve had)

Joe Allen

Teleprompter Pro

Final Approach 🛬

We've covered a lot of ground this week. Before we disembark, a few final thoughts on what made this year's flight memorable — and where we go from here.