Ready for a cross-platform adventure? This hands-on workshop brings Android and iOS developers together for a code-filled journey into Kotlin Multiplatform magic!

We'll pair you up—Android meets iOS—to build something awesome together. Think of it as a blind date where both parties speak different languages but leave holding hands. You'll learn to translate between platforms, discover shared foundations, and build bridges where walls once stood.

Through guided checkpoints and friendly competition, you'll craft a working app using Livesport APIs that you can take home as your multiplatform starter kit. Each checkpoint unlocks new challenges and teamwork opportunities, with our experts revealing pro solutions along the way.

Bring your Apple Silicon MacBook and mid-level platform skills—we'll provide the framework, fun, and prizes for winning teams! By workshop's end, you'll have new cross-platform friends, collaborative superpowers, and code that runs everywhere. No more platform tribalism—just beautiful, shared solutions!

Get ready to launch your creative coding rocket! This workshop opens the door to a world where Android Studio dances to your tune. You'll learn to juggle two plugin development approaches: lightning-fast prototyping with live-plugin and building standalone solutions robust enough to survive the zombie apocalypse.

We'll dive into the hacker's art of adding custom buttons to menus, creating dialogs that actually speak your language, and building tabs that make your workflow purr with satisfaction. From your first "Hello World" plugin to slick UIs with Android-specific tricks, you'll level up your dev superpowers.

Bring your laptop with IntelliJ IDEA CE installed, basic Kotlin knowledge, and your wildest ideas! All code samples are just a GitHub link away. By the end, you'll be wielding Android Studio like Thor's hammer – precisely customized to your developer needs.

Sick of writing the same business logic twice? Welcome to the Kotlin Multiplatform revolution—where code sharing isn't just a dream, it's your new reality!

This workshop cuts through the hype to show you exactly where KMP shines in real-world applications. We're not just theoretical enthusiasts—we've built our entire development workflow around a battle-tested KMP template that powers every new project we launch.

You'll discover the sweet spots where KMP delivers maximum value with minimum hassle, backed by actual metrics from our production experience. We'll share the real numbers that convinced us to go all-in on this approach, demonstrating exactly how it accelerates development across platforms.

The best part? You'll get hands-on with our proven KMP template, understanding why it forms the foundation of everything we build. By workshop's end, you'll have created your own fully functional cross-platform app and gained practical skills to immediately implement in your next project.

We’ll start where most visionOS Workshop stop, after the basic stuff was done, and we’ll look into some Math for mapping GPS coordinates on a globe. We’ll also look into the ability to zoom into a specific part of the world.

It all started with Hello World from Apple and then I thought it would be nice to not only put objects randomly on the globe but on actual Latitude and Longitude. That required more Math than I thought, but I survived it.

For years it’s felt as if iOS Developers have been working with someone else’s hand-me-down testing framework. Now we have the brand new SwiftTesting framework and it’s so much nicer to work with. Bring a Mac with the latest version of Xcode 16 and code along with this fast moving introduction to writing, organizing, and running unit tests in Swift with SwiftTesting. You’ll learn the @Test and @Suite macros to create and organize your tests. You’ll use #expect and #require and explore how Swift Tests are so much easier and more natural than XCTests.

As we rethink how we write code in light of Swift 6, don’t forget to think or rethink how we might test that code. This talk introduces the Swift Testing framework and shows you how to write simple powerful tests using the new @Test and @Suite macros using the #expect and #require macros.

In this workshop, you will create a Flutter application that uses Firebase as a backend for real-time data, A/B testing, and more.

We will show you how easy integrating the Firebase Firestore real-time database is.

Next, we will learn how to set up your app for A/B testing via Firebase Remote config and properly create UI components and their variants. In the end, we will have an application to distribute for testing over Firebase App Distribution.

Android has provided Speech Recognition APIs and Voice Actions for several years. Then, the Google Assistant came in and allowed us to integrate with it using App Actions. Also, several third party solutions exist and can work not only for Android but also for iOS, the web and IoT devices. In the era of Cloud APIs, Gemini, LLMs, GenAI and privacy concerns, are voice interactions easier, more interesting and more useful for our users? Or is it the other way around? What new challenges are we facing and how can we solve them? Come to this talk to and we'll go together through the exciting path of voice interactions on Android!

This talk is about technical details on the 'Compose Hot Reload' implementation.

In a world of Jetpack Compose, Kotlin, Swift, and SwiftUI - we’re at the pinnacle of language and modern UI tooling that can even the playing field for iOS and android developers. Understand more about how the other platform isn’t so scary, how to effectively work across apps, and take your skills to the next level with cross platform development in this modern context.

The world of cross-platform development is rapidly evolving, with Kotlin Multiplatform and Compose Multiplatform leading the charge for creating shared codebases that work seamlessly across Android, iOS, and beyond. Let's dive into building modern and efficient multiplatform applications, with Koin as the go-to framework for effortless dependency injection.
We’ll cover best practices for integrating KMP, organizing shared and platform-specific code effectively and using Compose Multiplatform to deliver a consistent and engaging Multiplatform UI experience. Through a real-world case study, you'll see how we transformed Google's "Now in Android" demo app into a fully functional Multiplatform project powered by Koin. We'll discuss the challenges we encountered, as well as the "creative" solutions we implemented. and how to optimize performance while keeping code maintainable and scalable.
Are you ready to elevate your Kotlin cross-platform development skills?

TL;DR: This talk will showcase the development of a remote-controlled vehicle with an Android-powered device as its central unit.

Long Version:

Students and researchers around the world often struggle in the early stages of developing robotics and hardware projects. The reason? High cost and connection difficulties of all the sensors and effectors for Arduinos, Raspberry Pi’s, or whatever platform they choose. All of them have a solution right in their hands—or their pockets—with almost no additional costs.

By enabling an Android device to act as a part or center of an embedded system, you can unlock a vast variety of its capabilities—ones that would cost hundreds of dollars to purchase and dozens of hours to connect & set up. Some of them include:

• LTE, WiFi, Bluetooth
• Multiple cameras
• Accelerometer, gyroscope
• Biometric sensors
• Screen, speakers, microphone

Not to mention the higher level of services they offer through countless libraries ready to be used by developers.

Intents are the starting points for every Android application. The platform is very much built on Activities, potentially from different apps interacting with each other to complete some tasks. This open nature can be an avenue for exploitation.

You have to consider Intents for what they are: inputs. And inputs must be sanitized. With this mentality, you can protect against many attacks, but some can only be avoided with the right architecture and platform support. Google finally made strides in this area with Android 15’s safer Intents. At the same time, you need to understand the attack surface to defend your apps.

We will describe and demonstrate such issues:

• Privilege escalation via Intent redirection
• Denial-of-service via malformed Intents
• Leaking data via Intent parameter injection
• App impersonation via Task hijacking (StrandHogg)

At the end of the talk, you will have an understanding of mitigating and remediating many Intent-based Android vulnerabilities.

The talk is a walkthrough, taking the attendees through the process that their Kotlin code for Android apps follows: from class compilation, desugaring, packing, signing, distribution, downloads, installation, on-device recompilation (JIT/AOT) and optimization, and finally execution. I will showcase the different levels of abstraction that the process involves: from abstract JVM specification, to android-specific tooling for resource and kotlin+java bytecode handling, to how devices compile applications to native code, how ART executes and repeatedly profiles running apps, and how system updates affect this mode.
Additionally, to leave practical and tangible knowledge to attendees, we will analyze some kotlin features (which make it the great language we use to create apps), and dissect how they are actually compiled and implemented in the android ecosystem, to tie together the abstract system view with some useful takeaway examples.
But, most importantly, my goal is to to instill in attendees more awareness around their general developer workflow, with sharp technical knowledge and best practices.
The throughline is dividing the talk in initial exploration of the general ecosystem that android apps go through, how the devices actually represent and execute them, and then giving a bird's eye view of some key Kotlin language features, and analyzing their bytecode.

Compose Multiplatform is a game-changer for sharing UI implementation across Android, iOS, desktop, and web, but things can still get tricky when it comes to previewing those UIs.
Jetpack Compose's tooling in Android Studio is truly powerful, but what about multiplatform Composables? Can we quickly test and visualize our UIs for multiple platforms without constantly switching tools? Are previews really important now that Compose Hot Reload is emerging?
In this talk, we’ll dig into the challenges we can face when working with Compose Multiplatform Previews, from platform quirks to tooling features and shortcomings. I’ll share some practical workarounds to help you stay productive, plus tips for structuring your code to make previewing across platforms smoother. We’ll also take a look at where the tooling is headed and what we can all hope for in the future.
Expect examples and tips you can start using right away. Whether you’re just getting started or you’ve been using Compose Multiplatform for a while, this talk will give you the confidence to work more effectively with Compose Multiplatform Previews.

Kotlin Multiplatform (KMP) is usually discussed from the Android developers' perspective, but what about the iOS developers' perspective?

While Android developers are often interested in the technical challenges of adopting and using KMP, iOS developers ask different questions:

• How can we maintain productivity when part of our codebase is in Kotlin?
• How do we effectively contribute to the shared Kotlin codebase?
• What impact will KMP have on the quality of our iOS app?

We will answer these questions and more by exploring topics like:

• The key differences between Kotlin and Swift
• Which IDE to choose: Xcode, IDEA, or Android Studio
• Debugging Kotlin Multiplatform code
• Build toolchain differences: Xcode vs. Gradle
• Best practices for calling Kotlin from Swift

Inspired by "Kotlin/Native for Android Developers," this talk flips the focus to iOS developers exploring KMP, while still offering insights for Android and KMP devs.

Learn everything you need to know about Passkeys, why we need them, what they are and how to implement them in your apps

In this session, we’ll explore practical tips and best practices for working with ScrollView. You’ll learn how ListView manages position, scrolling, and pre-rendering, and discover how to take full control. We’ll also walk through real-world challenges and show you how to effectively solve them in your apps.

Build your own apps, they said. It will be fun, they said! Which it definitely is, but at times also frustrating and makes you question why you got into this in the first place. Over the past year, I’ve built and published three indie apps, and in this talk, I’m going to share the challenges, tips, and solutions I gathered on this journey.
We’ll discuss why building an app is just the first step, what it takes to publish it to stores in 2025, and how to avoid getting it suspended. I’ll cover how to leverage AI and integrate a secure backend—even without a backend team—and much more. By the end of this talk, you’ll have a roadmap and a toolset to finally release your own app in 2025.

Flutter developers typically build UIs using widgets as basic building blocks. But sometimes the declarative nature of widgets can become limiting for more complex designs. Shaders can fill this gap by offering complete control over every single pixel on the screen. At the same time, shaders can be intimidating to work with due to their low-level programming language, math-heavy code, and challenging debugging environment.
This talk demystifies fragment shaders by demonstrating how they can enhance widget-based UIs and seamlessly integrate with the Flutter platform. Through simple examples and combinations of formulas, we'll explore how to create stunning visual effects.
Aimed at mobile developers curious about pixel rendering and low-level graphics, this presentation will reveal the secrets behind crafting captivating, high-performance UIs that go beyond traditional widget capabilities.

In today's fast-paced development landscape, selecting the right cross-platform framework is key to building successful applications. With options like Uno Platform, Flutter, MAUI, React Native, and others, how do you decide which one fits your project's needs? This session will explore the strengths and weaknesses of popular frameworks, considering factors such as performance, ecosystem, and development experience. Whether you're targeting mobile, web, or desktop, we'll help you navigate the pros and cons to make an informed decision for your next cross-platform project.

At SKY, we are responsible for mobile applications as part of a platform that runs several streaming services. Millions of customers use it daily. It is a huge scale project, which is an interesting challenge. Addressing complexity to keep development simple is key. Complexity comes from the need to build multiple app variants from a single codebase. Each streaming service has its own design, app store entry, production/dev environments, and release/debug variants. When you want to select one exact variant of our Android app, you get to an N-dimensional problem, resulting in about 250 options. And it grows exponentially if a new dimension is added, such as territory. This is unsustainable. I will tell you how we dealt with it using our own Android plugin for Android Studio to make the life of Android developers easier and development quicker, with less risk of a wrong variant being selected by mistake. We will show you how to create such a plugin in Android Studio from the perspective of an Android developer – spoiler: Kotlin is everywhere.

In this talk, you’ll learn three practical techniques we’ve implemented at Futured to make Kotlin Multiplatform (KMP) development more efficient. First, we’ll look at how using local Swift Packages significantly improved build times and iteration speed for iOS developers. Next, we’ll cover how we handle date formatting in shared code using Moko Resources to ensure consistency and proper localization. Finally, we’ll explain how we work with third-party SDKs through platform bindings—enabling integration with native functionality while maintaining a clear separation between shared and platform-specific code.

The talk focuses - as the name suggests - to strategy to migrate the project from Swift 5 compilation mode to Swift 6. We will discuss several issues anyone will encounter to have project that compiles under Swift 6 mode, such as issues with Combine and Async publishers, DispatchQueue.main precondition queue checks, working with older APIs that predate the concurrency, as well as a debate whether it is all worth it. I will also mention the transition of not only the project itself but also a story of external dependencies, some of which written by me, and how did the migration in the libraries took place.

In a world where security and privacy are critical, Mutual TLS (mTLS) ensures that only trusted devices can communicate with each other. In this talk, we’ll break down mTLS fundamentals and explore how we’ve implemented a robust certificate architecture at Harbor to secure baby monitor connections. We’ll dive into the technical details of integrating mTLS with URLSession delegates, the challenges of managing certificates in the Keychain, and the hurdles of enforcing mTLS across the entire stack—including AVPlayer and third-party libraries that don’t support custom networking. Join us for a deep dive into real-world lessons from securing IoT applications with mTLS.

Code reviews in pull requests have long been the backbone of software quality, but let’s be honest—they can be slow, inconsistent, and sometimes frustrating. AI is stepping in to change the game, but is it truly solving the problem ✅ or just introducing new ones 🤔 ? This talk is a 50% deep dive into the why of AI-assisted code reviews and 50% live demo—so attendees leave not just with ideas but with actionable implementation strategies. We’ll explore real-world tools, how to build your own AI-powered reviewer, and key insights from my team’s experience integrating AI into our workflow. Expect storytelling, real-world challenges, and hands-on demos that will reshape how you think about code reviews forever. 🚀 This session is a must for any developer who cares about code quality and wants to rethink the future of pull request reviews.

In this talk, we will explore what accessibility truly means and why it is essential for creating inclusive digital experiences. We’ll cover how to ensure your applications are usable by everyone, including people with disabilities. You’ll learn best practices and practical tips for building accessible mobile apps, with a focus on real - world examples in Flutter. We will also explore tools and techniques to test and improve accessibility, making development easier and more effective. Whether you’re new to accessibility or looking to refine your skills, this talk will equip you with the knowledge to create apps that truly reach everyone.

AI is here to stay—so how can it make you a better developer? In this session, we’ll explore the current state of AI coding tools, share practical tips, and discuss how to work together with AI and integrate it into your development process.

Have you heard about accessibility? Does your app implement it yet? Do you know what it even is, why it's important and how it works? How exactly would you change your development process to craft accessible experiences in the future? And what happens if you don't, both to your users and to your product itself? Come learn what it's all about and why it matters, even to your future self, directly from a person who wears the hats of an end user with a disability, accessibility specialist and developer simultaneously. Most exciting thing: If implemented properly, accessibility helps and improves the experience for everyone, including the devs as it results in cleaner and more elegant code. Wanting to really get into it is even in your own best interest, it's not just a legal requirement or the right thing to do. I'll be talking and providing practical live demos from my phone. The audience will learn how a screen reader works and how a blind user perceives the app with it, what its limitations are and what needs to be considered in all stages of the process in order to develop an accessible app. There will be room for questions at the end of the talk.

Discover how A/B testing fuels mobile app growth, essential for success in the fast-paced tech world. Learn the key processes and skills needed for an effective team and explore experimental approaches that yield measurable results. Through case studies, gain actionable insights you can immediately apply to enhance your apps. Focus on practical methods for implementing and evaluating A/B tests, while uncovering team collaboration strategies that drive innovation and product growth.

Sharing experience of actively using AI during development for last 2 years. Featuring instruments, use cases and hacks I use daily.

In this exclusive session, we'll delve into the hidden realities of mobile leadership, exploring the challenges and insights that make it a journey not suited for everyone. Join us as we uncover the secrets to successful tech leadership in the dynamic world of mobile development. Are you up for the challenge?

Join my talk at mDevCamp to learn how App Clip extensions can solve user attribution issues on iOS. Discover how to ensure your app continues the intended flow from social media campaigns, accurately track conversions, and reward your sales team. Don't miss this opportunity!

Bringing your mobile app to Wear OS? It sounds simple until you realize that logins, navigation, and UI need to be adapted to an entirely new form factor. We'll explore what it takes to extend an existing mobile app to Wear OS—whether to build a standalone app or integrate it into your current project. We'll tackle authentication, navigation, adapting to a tiny screen, and handling Wear OS constraints on memory and performance. We'll also cover how to reuse business logic while adapting the UI with Compose for Wear OS, along with key considerations for CI/CD and distribution on wearables. Expect real-world insights, unexpected challenges, and lessons that can save you time when bringing your app to Wear OS.

Much in the same way that Coroutines revolutionized reactive architecture, Compose challenges us to rethink how we design applications. While traditionally seen as a UI toolkit, Compose — and specifically Compose Multiplatform — can play a much larger role in our applications. By leveraging its declarative and state-driven nature, we can build, model, and manage application state in a way that is consistent, scalable, and platform-agnostic.

Talk is about performance issues you might do in a Compose app, I'll show how to find the issues, how to use the performance tools and what can you do to fix the problems.

Our product Gitrix is an IT system that enhances the IT security of our customers by simplifying digital certificate management and enabling multifactor authentication for computers and workstations. In this talk, I'll focus on how we built a mobile app to add a second factor to the login process by enabling TOTP and push notification-based verification. This solution required (among other things) encrypting and decrypting data on both ends using private and public keys generated in Secure Enclave, as well as signing data with this technology. We'll start with a brief overview of securing data during transit, followed by a deep dive into implementing these cryptographic operations on iOS (sneak peek: Secure Enclave is available not just on iPhones).

App Clips provide a lightweight, instant way for users to experience an app without installing it—but designing a great App Clip goes beyond just meeting Apple's guidelines. In this talk, I will share real-world lessons from building a high-performance, NFC-powered App Clip. You'll learn how to optimize for speed and size, implement deep linking, persist data across sessions, and smoothly transition users to the full app. Through practical insights and technical deep dives, this session will help you create an App Clip experience that delights users and drives engagement.

Join our keynote to discover 5 years of real-world mobile app testing insights: see how vulnerabilities evolved, master correct methodologies, and pick the perfect partner. Key takeaways: Evolving Threats, Testing Done Right, Partnership Essentials!