The International Swift Conference. For developers, designers and project managers at all levels of experience with Swift. #SwiftHeroes
Solo iOS workflow: go from idea to shipping, scaffold the project with tuist (tuist init), implement auth and storage, and connect a custom backend. Emphasizes practical tooling and choices that keep scope lean, reduce overhead, and help indie developers deliver and maintain apps efficiently.
JetBrains’ Swift Heroes 2025 talk explains what Kotlin Multiplatform is for iOS, debunks common myths, and outlines real benefits and how it differs from other approaches. It offers guidance on code sharing, integrating KMP into iOS projects, and practical trade-offs to help teams decide if/when to adopt it.
A tour from monolith to modular architecture in Swift, covering how modules are carved out, common circular dependency traps, and practical ways to break cycles. Demonstrates using SwiftSyntax to analyze/enforce boundaries and touches on the Swift–Clang toolchain route. Takeaway: structure modules, detect cycles, and automate refactors.
Overview of what to consider before migrating from XCTest to Swift Testing. Covers creating a simple test, recommended naming, the key improvements, core building blocks, and how traits influence tests. Highlights differences you’ll encounter and practical tips for structuring tests effectively in the new framework.
Talk warns how A/B testing and feature flags can bloat Swift codebases: branching logic increases complexity, dead paths linger, and experiment-induced damage accumulates. Covers cleanup strategies, guardrails, and data rigor for rollout decisions. Takeaway: treat experiments as temporary, plan refactors, and enforce removals to avoid tech debt.
A Swift Heroes 2025 talk reflecting on real-world failures—like the London Ambulance Service case—to show how software breaks in production. It distills lessons for iOS releases: validate assumptions, test in realistic conditions, monitor and triage incidents, and design for safe failure and learning.
Intro to Swift Heroes 2025, an international Swift conference welcoming developers, designers, and project managers across all experience levels. This video appears to promote or introduce the event rather than cover specific technical topics or APIs.
Conference talk introducing WebAssembly for Swift developers: what WASM is, why it matters, and how Swift can target it. Covers code sharing between iOS and web, basic toolchain/JS interop, and caveats like sandboxed APIs, threading, and performance limits. Takeaway: when and how to adopt WASM in Swift apps.
Swift Heroes 2024 talk on generating mocks with SwiftyMocky. Shows automating protocol-based mock creation, integrating with XCTest, and measuring coverage for faster, consistent unit tests. Highlights setup and usage for blazing-fast mock generation and more reliable, maintainable test suites.
Conference talk offering a deep dive into SwiftData. It explains what SwiftData is and how to start using it in apps, focusing on fundamentals, setup, and practical usage. Takeaway: understand SwiftData’s role in managing app data and how to begin adopting it in your architecture.
Swift Heroes 2024 talk on Trendyol’s iOS app revamp that achieved ~70% faster build times. It covers their modularization journey and practical Xcode build optimizations to speed builds and developer feedback. Takeaway: reorganize into modules and refine Xcode settings to significantly reduce build time.
Talk for iOS devs on using LLMs to generate SwiftUI views and business logic. Explains how GPT-style models work and demonstrates integrating LLM APIs into development workflows for code generation. Takeaway: accelerate UI/logic scaffolding with LLMs while keeping developer oversight.
Talk demystifies UI focus across Apple platforms and why it matters for great UX. It defines focus and focus effects, shows how to make views focusable, set default focus, guide directional movement (focus engine/guides), and avoid traps like loops or lost focus. Takeaway: predictable, polished focus on tvOS/iOS with SwiftUI and UIKit.
A Swift Heroes 2024 talk on building Swift command-line tools that users enjoy and contributors can extend. Covers motivation, organizing a Swift Package Manager project, argument parsing, clear help/errors, composable subcommands, testing, versioning and distribution, and contributor-friendly practices to keep the CLI maintainable.
Swift Heroes 2024 talk evaluating Objective‑C’s relevance in 2025. Reviews the language’s history, why it can still matter, and when to use it alongside Swift. Emphasizes tradeoffs and interoperability for maintaining legacy codebases, offering practical takeaways for iOS teams choosing a language strategy.
Swift Heroes 2024 talk on building a scalable CI/CD system for iOS. Covers pipeline architecture, Xcode-based builds, automated testing, parallelization and resource management, plus strategies to improve reliability and throughput. Takeaway: design CI that scales with team size and app complexity.
How to integrate legacy UIKit features and app extensions into a SwiftUI app. Techniques: UIViewController/UIViewRepresentable, UIHostingController bridges, Coordinators for delegates, bindings/environment for data flow. Covers extension lifecycle limits and performance pitfalls. Takeaway: safely reuse old code.
Conference talk on Swift macros as a modern code generation tool. Covers what macros are, freestanding vs attached variants, how they integrate with the compiler using SwiftSyntax/SwiftCompilerPlugin, practical use cases to remove boilerplate, safety/diagnostics, and caveats on build-time and testing for iOS devs.
Conference talk outlining inclusive design and the definition of accessibility for iOS apps. Focuses on why accessibility matters, core principles, common pitfalls, and practical techniques to make interfaces usable for all users, plus guidance on testing and integrating accessibility early. Takeaway: build it into design and development from day one.
Swift Heroes 2024 talk focused on avoiding developer burnout and cultivating a balanced life. Highlights recognizing burnout, setting boundaries, managing workload, prioritizing rest and recovery, and building sustainable habits. Non-technical guidance for iOS/Swift developers to maintain healthy productivity and long-term career wellbeing.
Replaces hand-written REST networking with Swift OpenAPI Generator: generate type-safe clients, models, and endpoints from an OpenAPI spec via a SwiftPM plugin, using URLSession and async/await. Cuts boilerplate and drift, improves self-documentation. Covers spec ownership, customization, and versioning considerations.
A Swift Heroes 2024 talk on building custom UITextView features with modern TextKit (TextKit 2). Explains the text pipeline and how to customize layout, rendering, attributes, editing, and selection to craft bespoke editors in UIKit. Notes differences from legacy TextKit and practical considerations. Takeaway: use TextKit 2 for flexible text UIs.
Talk explains replacing costly cloud AI calls with on‑device AI on iOS. Covers selecting models, converting/using Core ML for in‑app inference, and optimizing with techniques like quantization to reduce latency, memory use, and cost. Highlights privacy/offline benefits and trade‑offs (model size/accuracy). Takeaway: ship fast, private AI without API bills.
Swift Heroes 2024 talk on creating impactful developer presentations with Apple Keynote. Covers why slide design matters and offers practical tips on structuring content, visual clarity, and storytelling for technical talks. Focuses on presentation craft rather than code or iOS APIs.
Conference talk on using Swift for scripting and developer tooling: build CLI executables with Swift Package Manager, parse arguments, use Foundation for file I/O and process control, automate builds/CI, and integrate with iOS projects. Discusses pros/cons vs Bash/Python, distribution, and performance tips.
Swift Heroes 2024 roundtable on the realities of sustaining open‑source Swift/iOS projects: maintainer bandwidth, issue triage, code reviews, releases/versioning, documentation, and community health. Emphasizes clear governance, contribution guidelines, and respectful, test‑backed PRs as practical ways iOS developers can help.
Swift Heroes 2024 talk introducing the Typestate design pattern in Swift 5.9. It shows how to model workflow states as types to enforce valid transitions at compile time, with a practical example. Takeaway: leverage Swift’s type system to build safer APIs and eliminate invalid states.
Skyscanner explains how they de-couple a massive iOS codebase using Dependency Inversion: define abstractions (protocols), inject implementations, and enforce modular boundaries. The talk outlines the problem, gives an overview, and shows migration tactics that boost testability and scalability. Takeaway: apply DI/SOLID to reduce coupling in large apps.
Explains how to avoid “Big‑Head” SwiftUI components bloated with parameters. Covers refactoring strategies: compose smaller views, bundle related settings into configuration types, apply sensible defaults, and separate state from logic. Takeaway: design focused, reusable view APIs to improve maintainability and readability.
Talk on adopting a modular architecture using Swift Package Manager. It outlines splitting features into packages/targets, configuring products and dependencies, and handling visibility. Weighs initial migration effort against gains in build times, testability, and reuse. Notes pitfalls like cyclic dependencies, access control, and resource handling.
Swift Heroes talk on designing sustainable iOS apps by reducing energy use and carbon impact. Covers the role of mobile apps in greenhouse gases and practical ways to cut power/compute: minimize and batch network work, efficient rendering and images, smart background tasks, caching, and measurement-driven tuning. Takeaway: build fast, battery-friendly apps.
Conference talk introducing Swift development for visionOS and the new era of spatial computing. Outlines what visionOS enables, app and UX patterns, how Swift fits in, getting started, and high-level considerations for performance and user interaction. Takeaway: prepare apps for spatial experiences.
Conference talk on structuring complex navigation in SwiftUI while keeping apps testable and modular. Shows building a base skeleton, separating navigation from views via coordinator/router, using DI and protocols with MVVM, organizing features into modules, and writing unit tests for flows. Takeaway: decouple navigation to scale.
Conference overview from Swift Heroes 2024 outlining the main Swift topics of 2024, with a chaptered discussion on how to interact with them. Helps iOS developers identify current priorities and where to focus learning and adoption across the language and tooling.