Schedule

We have implemented an AI assistant in the Drinkit mobile application as a new interface for a complex menu: the user says "I want something refreshing", and the application selects a drink and customization.

The talk includes an analysis of the code and architecture: Firebase AI Logic, function calling + agent loop, how not to go bankrupt, and an alternative via Koog (if Firebase is unavailable).

We dive into the "complexity of the debug" of SwiftUI using the example of incorrect operation of the GeometryReader and LazyVStack bundle. We analyze how AttributeGraph participates in calculating the size and updating frames, and form a practical approach to diagnosing and solving such problems.

Let's talk about an alternative view of the implementation of the SDUI platform and what prerequisites led to this particular solution design.

I'll show you how to start using AI tools, in particular Claude Code, in your project.

I'll show you exactly what tools Claude Code provides, tell you how they can be useful to you in your daily work and how to start using them, share potential problems that may arise when working with AI and how to deal with them.

What has changed, how to work with it, and what are the prospects for using Swift at Android.

A bridge builder doesn't weld seams — he designs. The code is an artifact of a software engineer's work, not the work itself, and for the first time, AI agents allow you to work exactly like an engineer: analyze a task, design a solution, and delegate construction.

This talk demonstrates why using Metal does not always lead to performance improvements. Using an image-processing example, we’ll explore when the GPU truly wins and how to measure it correctly.

We will explain and show how the compilation and execution of application code in Android work under the hood and how baseline profiles are related to this.

We will dive into the Codable internals, find bottlenecks, design a solution, and commit it to Swift itself!

Using Compose Multiplatform, we will write a small internal corporate task tracker application for several users with different roles. Finally, it will be possible to run not only on Android and iOS, but also on the Aurora OS.

We will encounter performance issues in a SwiftUI project, learn how to analyze symptoms using Xcode Instruments, and fix these bottlenecks by revisiting the theory.

How to make Swift great and close the children's gestalt? We will discuss ways to optimize code, work with multiplatform, UI and bindings with C++ code.

Shared animations are increasingly becoming not just a decoration, but a required part of the design.

I'll share how we at Drinkit implemented unusual Shared Transitions with blur in Compose and why there's no reason to be afraid of this instrument.

The talk is about the work of isolates and the garbage collector in Dart VM, the connection of isolates with OS threads and restrictions on their number.

A 700,000-line mono project—why is it cool and how to live with it?

Let's explore how thermal state affects the user experience of iOS apps: from the metrics of playable sessions to the smoothness and responsiveness of the app, including approaches to data collection and aggregation, as well as analysis of heating effects based on real-world Okko scenarios.

Why HashMap isn't the best choice for Android, and how the Swiss Table architecture in ScatterMap addresses memory and performance issues through open addressing, metadata grouping, and SIMD emulation on the JVM.

2025 has divided the industry into two camps—those who have learned to live with AI, and those who are waiting for the dust to settle. Today we will analyze not hype, but what really works in production. Which rakes with AI integrations should we stay away from, and what awaits us in 2026.

CMP is a growing framework for cross-platform development, adapted by the Open Mobile Platform team for the Aurora OS. We will examine the approach to adapting CMP, how it differs from Flutter, and the tools available for development on the Aurora OS.

How to transform an AI agent from a local tool into a personal autonomous developer assistant.

I'll tell you how to bring an agent to the server, set up isolation and security, and organize the process so that it performs tasks independently and in parallel, without competing for resources and without being tied to your working time.

How to legally run an alternative App Store in EU/Japan: from DMA and Apple's docs to MarketplaceKit and real-world cases from Onside.

Let's talk how to add releaseless business logic to the Server Driven UI using Kotlin Multiplatform.

PWA as Plan B: a story of how we lost the App Store but kept our users. Technical pitfalls, architectural decisions, and unexpected perks of a forced migration to the web.

A session in the format of a level-by-level game will show how algorithmic interviews work and what skills need to be upgraded in order to pass each stage of the selection process.

Is it possible to use Rust in mobile app development?

How we use OpenCode and its HTTP API to orchestrate LLM agents that automatically review merge requests and post comments to GitLab.

We’ll look at how to investigate any macOS application using the native LLDB debugger and a few supporting tools. Through practical examples, we’ll analyze system applications, uncover non-obvious behavior, and carefully tweak it via code injection.

We suffered from 20 minutes of IDE Sync and seven minutes of pure Android debug build on a KMP project with a million lines of code. We didn't find any available boxed solutions on how to reliably measure build optimizations, so we made our own Frankenstein out of open source and self-made stuff.

I'll show you how to turn vague design requirements into optimization tasks with a measurable quality function, explicit constraints, and a predictable solution search algorithm.

In the talk, we will analyze how we implemented mobile pipeline failure point monitoring at Tutu, learned how to automatically classify the causes of crashes using AI, and divided responsibility into Dev, Core, and External levels. I will show you how the introduction of pipeline stability SLAs and nightly reports from LLM help not only resolve incidents faster, but also plan infrastructure development for the coming quarters.

Let's look at what smoothness is in a mobile app and what metrics to measure it with (and why FPS alone is often not enough). Let's see a case study: how measurements found a bottleneck in the product scenario and improved the metrics.

The hidden risks of implicit actions when building Android applications and the implementation of the shift left approach for early error detection through automated checks.

How to solve the problem of different development speed in a large mobile application.

AI agents accelerate mobile development, but one "toxic" piece of generated code can reset the entire Time-to-Market. The talk shows how to integrate legal control directly into the CI/CD pipeline, so that lawyers can help roll out faster rather than slow down releases.