Koko

Jul 5, 2025

Architectural Deep Dive: The KotlinConf Application

The KotlinConf application is a useful showcase of Kotlin Multiplatform (KMP), demonstrating how KMP can deliver a comprehensive, cross-platform application from a largely shared codebase. This post covers the KotlinConf Application's architecture, capabilities, and the foundational libraries that enable core KMP functionality. The application uses KMP to share business logic and user interface components (via Compose Multiplatform) across Android, iOS, desktop, and web. Its backend is built with Ktor and Exposed, forming a Kotlin stack. Key capabilities include schedule management, real-time updates, and feedback mechanisms, all delivered with a consistent user experience across diverse platforms. This implementation highlights KMP's role in developer efficiency and cross-platform consistency.

Architectural Deep Dive: The KotlinConf Application

1. Introduction to the KotlinConf App

The KotlinConf application serves as the official digital companion for the annual KotlinConf event, developed by JetBrains. Its primary functional role is to provide attendees with a tool for navigating the conference, accessing schedules, and engaging with content. This includes functionalities such as viewing session details, filtering by tags, bookmarking favorites, and receiving timely notifications.

Beyond its immediate utility, the app holds important reference implementation for Kotlin Multiplatform (KMP). It is entirely written in Kotlin, showing how KMP facilitates code sharing across diverse platforms. The architectural decisions, modular structure, and library choices within the KotlinConf app are not arbitrary; they represent JetBrains' approach to applying KMP in a production application. This makes the KotlinConf app as a useful training resource and reference implementation for developers interested in KMP. By studying its codebase and architecture, developers can understand JetBrains' approaches, challenges, and solutions in a multiplatform context, and potentially adopt similar strategies in their own projects.

Critical Links

Follow Along

If you want to explore the code base and/or the working applications on your own machine, start by cloning the repository linked above into IntelliJ IDEA.

### Overview of Supported Platforms

The KotlinConf app is deployed across various target platforms. This platform coverage is due to efficient code-sharing capabilities provided by Kotlin Multiplatform, allowing a single codebase to target multiple environments. The platforms supported include:

  • Android: The application is accessible to Android users via Google Play.

  • iOS: For Apple device users, the app is available through the Apple App Store.

  • Desktop: The application can be run as a standalone desktop application, utilizing a specific Gradle run configuration, such as ./gradlew :shared:jvmRunHot.

  • Web: A web version of the application is deployed and accessible online through GitHub Pages.

This broad reach from a unified codebase shows KMP's advantages in reducing development overhead and increasing accessibility.

2. Overall Architectural: Kotlin Multiplatform (KMP)

Core Principles of KMP: Code Sharing Strategy

The design philosophy behind the KotlinConf app's architecture is rooted in Kotlin Multiplatform's core principle: maximizing code reuse across platforms while allowing platform-specific features when needed. The application uses KMP to share much of its codebase, encompassing core business logic, data models, and user interface components through Compose Multiplatform, targeting Android, iOS, desktop, and web.

This approach reduces development effort, improves consistency across platforms, and speeds up feature delivery. The KolinConf app even shares its User Interface or UI with Compose Multiplatform (CMP), rather than maintaining entirely separate native UIs. CMP for iOS is now stable, making it a smart choice for mobile teams looking to maximize developer productivity, minimize time to market, and overall improve mobile ROI.

Interoperability with Native UI Frameworks (Jetpack Compose on Android, SwiftUI/UIKit on iOS):

While the primary UI is shared, Compose Multiplatform offers interoperability capabilities with platform-specific UI frameworks. On Android, it integrates with Jetpack Compose, which is the native declarative UI toolkit. For iOS, Compose Multiplatform provides mechanisms to embed existing SwiftUI or UIKit components within a Compose Multiplatform UI, and conversely, Compose Multiplatform views can be embedded within native SwiftUI applications.10 This is facilitated through constructs like UIViewControllerRepresentable and UIHostingController, allowing a hybrid approach when necessary.10 This interoperability is important for scenarios requiring access to platform-specific UI elements (e.g., native Map views, Camera views, Web views) or for incrementally migrating existing native UIs to Compose Multiplatform.10

  1. Integration with the SwiftUI framework | Kotlin Multiplatform Documentation - JetBrains, accessed July 5, 2025, https://www.jetbrains.com/help/kotlin-multiplatform-dev/compose-swiftui-integration.html ↗(see bottom of page for complete list of referenced sources).

3.2. Shared Business Logic and Data Layer

The core business logic and data access mechanisms of the KotlinConf app are shared across all client platforms within the shared module.1 This architectural decision ensures consistent behavior, data validation, and business rule enforcement across client platforms.

Architectural Patterns (e.g., Clean Architecture, MVVM/MVI) in KMP:

While the internal architecture of the KotlinConf app's shared logic is not explicitly detailed, common architectural patterns for KMP projects with shared logic include Clean Architecture and Model-View-ViewModel (MVVM) or Model-View-Intent (MVI).9 Clean Architecture advocates for a clear separation of concerns into distinct layers: Presentation, Domain (business logic), and Data. The Domain layer, containing core business rules and use cases, is typically platform-agnostic and resides within the commonMain source set of the shared module.9

Data Fetching Strategies and Flow Management:

Data fetching from external sources, primarily the backend APIs, is managed within the shared data layer. This typically involves using a multiplatform HTTP client like Ktor Client.5 Asynchronous operations and the management of reactive data streams are handled using Kotlin Coroutines and Flows.12 Coroutines simplify concurrent programming, while Flows provide a mechanism for observing changes over time.

Data loading patterns for UI-driven data involve wrapping suspend functions in flow { } builders to create cold flows. These flows can then be combined using operators like combine to merge data from multiple sources concurrently. The stateIn operator is important for converting these cold flows into hot flows, making them lifecycle-aware and suitable for UI consumption. The WhileSubscribed strategy within stateIn allows for efficient, lifecycle-aware data collection, pausing data source collection when no active subscribers are present and resuming when needed, often with a replayExpirationMillis for caching recent values.15 This approach helps manage stale data, optimize network calls, and ensure UI responsiveness. The discussion of data loading and caching strategies using Kotlin Flows 15 suggests that the KotlinConf app, as a real-world application, addresses common challenges like data freshness, network efficiency, and UI responsiveness. This indicates a focus on delivering a smooth and reliable user experience, even in offline or intermittent connectivity scenarios. Modern mobile and web applications require efficient data management to provide a fluid user experience, especially given varying network conditions and the need for up-to-date information. Stale data and excessive network requests are common performance bottlenecks.

The use of kotlinx.coroutines and Flow is fundamental to building a responsive and resilient data layer that can handle network operations, update UI efficiently, and potentially support offline modes. These patterns directly address the challenges of data consistency and performance in a multiplatform environment.

Client-side Data Persistence and Caching Mechanisms:

For local, structured data persistence on the client-side, SQLDelight is a commonly used library in KMP projects. It enables type-safe SQL database interactions directly from shared Kotlin code, suitable for storing data like conference schedules, speaker information, or user bookmarks.5 For Android-specific persistence, Jetpack libraries like Room + SQLite are also on-device data storage options within KMP shared modules.7

Caching strategies extend beyond structured (database) data to caching network responses (of non-database data). The Ktor client offers FileStorage for persistent caching on Android and JVM targets.17 For iOS, configuring caching with native APIs like NSURLSessionConfiguration is a recommended approach, using the system's built-in caching mechanisms.17 The "Single Source of Truth" (SSOT) pattern, which combines network data with a local database (e.g., Room or SQLDelight) to provide offline capability, ensure data consistency, and separate concerns between UI, network, and database, is an effective strategy for client-side data management.18 The approach to client-side persistence, using SQLDelight for shared database access and native caching mechanisms for network responses 17, balances cross-platform code sharing and platform-optimized features. This ensures data consistency while optimizing for native performance and system-level caching benefits.

Databases often have platform-optimized implementations, while network caching can also benefit from native system features. By using SQLDelight for core structured data (which benefits from being shared and type-safe across platforms) and then opting for platform-specific network caching solutions (like NSURLSessionConfiguration for iOS), the KotlinConf app demonstrates a nuanced approach. This strategy allows the shared logic to manage the primary data store, while each platform can leverage its most efficient and idiomatic caching mechanisms for network responses, optimizing performance and resource management within its native environment. This blend of shared and platform-specific solutions is a best practice in KMP applications. It shows that KMP is about intelligently choosing where to share for maximum benefit while still capitalizing on platform-specific advantages for optimal user experience.

4. Backend Application Architecture

4.1. Ktor Framework for Server-Side Development

The backend application of the KotlinConf app is powered by the Ktor server-side framework.1 This choice aligns with JetBrains' vision for a unified Kotlin ecosystem across the software stack. Ktor is a Kotlin-native framework designed for building asynchronous servers and clients. It is built using Kotlin Coroutines, offering a performant alternative to traditional JVM frameworks like Spring for certain use cases.19

Ktor's features suitable for a conference application backend include handling HTTP requests and responses, supporting WebSockets for real-time communication, facilitating database access, providing mechanisms for authentication and authorization, and offering a flexible plugin API for extensibility.19 Recent updates, particularly Ktor 3, have brought performance enhancements, including up to 3x faster I/O performance, improved configuration support, and new features such as server-sent events and WebAssembly support.4 These improvements solidify Ktor's position as a backend framework.

By using Kotlin across the entire stack (KMP for clients, Ktor for backend), the KotlinConf app provides a "Kotlin-first" full-stack development paradigm. This unified language approach can lead to benefits: developers can share knowledge, tools, and code (e.g., data models, validation logic) between client and server, reducing context switching and improving team efficiency. It also aligns with the broader goal of making Kotlin a versatile language for all development needs. This full-stack Kotlin strategy aims to provide a cohesive and productive development environment. It suggests that for teams already invested in Kotlin, leveraging Ktor for the backend offers a natural extension that can lead to faster development cycles, easier maintenance, and a more integrated development experience.

4.2. Exposed Database Library

For data persistence on the backend, the KotlinConf application uses the Exposed database library.1 Exposed is a Kotlin SQL framework developed by JetBrains, providing a type-safe Domain Specific Language (DSL) for interacting with SQL databases, and Object-Relational Mapping (ORM) capabilities.4 This allows developers to write database queries and schema definitions directly in Kotlin, benefiting from compile-time safety and Kotlin syntax.

The library has undergone enhancements, with recent updates including a rewritten core for improved performance and flexibility, expanded support for new SQL concepts, and better documentation. A new plugin provides IDE support, enhancing the developer experience for database interactions.4 The pairing of Ktor and Exposed provides a coherent Kotlin experience for server-side development, from routing and handling requests to interacting with the database, all within the JetBrains ecosystem. In backend development, choosing a web framework and a database access library are two critical decisions. These choices often come from different ecosystems or vendors. By selecting both Ktor and Exposed, JetBrains demonstrates a deliberate strategy to provide a complete, integrated Kotlin solution for backend development. This means developers can work within a consistent language and tooling paradigm for the entire server-side application, from handling incoming requests with Ktor to persisting data with Exposed. This integration can lead to smoother development, easier debugging, and a unified codebase. This cohesive backend stack strengthens Kotlin's position as a viable language for server-side applications. It reduces the need for developers to switch between different languages or paradigms, fostering a more productive development experience within the Kotlin ecosystem.

5. Core Libraries and Technologies Deep Dive

5.1. Kotlin Multiplatform Ecosystem Libraries

The KotlinConf app extensively utilizes libraries from the broader Kotlin Multiplatform ecosystem, which are designed to function seamlessly across all target platforms.

  • kotlinx.coroutines (Asynchronous Programming): This library is fundamental for managing concurrent and asynchronous operations across all platforms.5 It provides a way to write non-blocking code, important for responsive UIs and efficient backend processing, by offering structured concurrency and simplifying complex asynchronous tasks.

  • kotlinx.serialization (Data Serialization): Essential for efficient and type-safe serialization and deserialization of data, particularly for network communication (e.g., JSON, Protobuf).5 It integrates with Ktor for handling data exchange between client and backend.

  • kotlinx.datetime (Date and Time Handling): A multiplatform library that provides a consistent and robust API for working with dates and times across all Kotlin targets, simplifying date-time calculations and formatting.5

  • Dependency Injection (e.g., Koin, Kodein-DI): While not explicitly confirmed as used in the KotlinConf app's build.gradle.kts (due to inaccessibility), Koin is a widely adopted and lightweight dependency injection framework in the KMP ecosystem.5

    Kodein-DI is also mentioned in a KMP MVVM example, indicating its use in similar architectures.12 These frameworks are important for managing dependencies and improving testability in complex applications.

  • Local Storage (SQLDelight, Multiplatform Settings, Room/SQLite):

    • SQLDelight: A multiplatform SQLite database library that enables type-safe database interactions directly from shared Kotlin code.5 This is likely used for structured data persistence (e.g., conference schedules, user preferences) on the client-side, providing a consistent database layer across platforms.

    • Multiplatform Settings: Provides a common API for simple key-value storage across various platforms.5 It is often used for storing user preferences, feature flags, or small, non-structured data.

    • Room and SQLite: For the Android target, Room (a Jetpack persistence library built on SQLite) and direct SQLite are viable options that can be integrated with KMP shared modules, especially when leveraging Android-specific features or existing Android codebases.7

The pervasive use of kotlinx libraries (coroutines, serialization, datetime) and other multiplatform-first libraries like SQLDelight signifies a mature and comprehensive ecosystem built around Kotlin Multiplatform. This allows developers to write significant portions of their application logic and data handling once, minimizing platform-specific code and ensuring consistency. The core promise of KMP is code sharing. To fully realize this, developers need libraries that are themselves multiplatform, meaning they can run on JVM, Native, and JS/Wasm targets without requiring platform-specific wrappers for common functionalities. The reliance on these multiplatform-first libraries indicates that JetBrains is not just providing the KMP framework but also building out an ecosystem of essential tools that function across all targets. These libraries address fundamental cross-cutting concerns (asynchronicity, data format, date handling, persistence) in a unified manner. This significantly reduces the amount of platform-specific code that needs to be written, directly contributing to the efficiency and consistency benefits of KMP. The availability and maturity of these comprehensive multiplatform libraries are critical enablers for widespread KMP adoption. They empower developers to build complex applications with high levels of code reuse, making KMP a more attractive and practical choice for cross-platform development compared to alternatives that might require more platform-specific code or less integrated tooling.

5.2. Networking and API Communication

Effective and efficient client-server communication is vital for a dynamic application like KotlinConf.

  • Ktor Client for HTTP requests: This is the primary library for handling HTTP requests from the client application to the backend.5 As a multiplatform HTTP client, Ktor Client integrates with kotlinx.serialization for data exchange, enabling efficient and type-safe communication over the network.

  • GraphQL integration: While the KotlinConf app's direct use of GraphQL is not explicitly stated, a closely related "Confetti" app (also a Kotlin Multiplatform conference app) utilizes a graphql-kotlin backend and leverages the Apollo library for GraphQL queries on its KMM clients.30 Given JetBrains' involvement in both projects and the growing popularity of GraphQL for complex data fetching, it is a strong possibility that the KotlinConf app also incorporates GraphQL for its API communication. The likely adoption of Ktor Client and potentially GraphQL (via Apollo) for networking highlights a modern, efficient approach to client-server communication in the Kotlin ecosystem. Ktor Client's multiplatform nature aligns with KMP, while GraphQL offers efficient data fetching, reducing over-fetching common in traditional REST APIs. The KotlinConf app has a client and backend.1 Ktor Client is a multiplatform networking library often used in KMP.5 A similar JetBrains-related conference app ("Confetti") uses GraphQL with Apollo.30 Modern applications prioritize efficient data transfer and API design. REST is common, but GraphQL offers advantages for complex data graphs, allowing clients to request exactly what they need. It is highly probable that the KotlinConf app uses Ktor Client for its network communication due to its multiplatform compatibility and integration with the Kotlin ecosystem. The use of GraphQL, as seen in a parallel JetBrains-backed conference app, would be a logical and efficient choice for managing the rich, interconnected data (sessions, speakers, tracks, etc.) typical of a conference application. GraphQL's ability to fetch specific data points in a single request can significantly optimize network payload and client-side processing, aligning with the goal of a high-performance cross-platform app. This demonstrates that KMP projects are not limited to basic networking but can integrate cutting-edge API technologies like GraphQL to build performant, scalable, and data-efficient applications, further enhancing their capabilities in complex domains.

5.3. Build System and Tooling

The build system and associated tooling are components of any software project, impacting developer productivity and project maintainability.

  • Gradle Kotlin DSL for project configuration: The KotlinConf app utilizes build.gradle.kts files for its build configuration, indicating the adoption of Gradle with the Kotlin DSL.32 This choice offers advantages over the traditional Groovy DSL, including improved readability, code completion, and navigation within IDEs like IntelliJ IDEA and Android Studio.32

  • Mention of K2 Compiler and Amper's role in the ecosystem:

    • The K2 compiler represents an advancement in the Kotlin ecosystem. It is now the default compiler in IntelliJ IDEA 2025.1, bringing build speed improvements (e.g., up to 40% faster builds for large monorepos) and a foundation for future compiler plugin APIs.4 While the KotlinConf app itself might be built with an earlier compiler version, it directly benefits from the ecosystem-wide performance boosts and tooling advancements enabled by K2.

    • Amper is JetBrains' experimental build tool, designed for Kotlin and JVM projects. It aims to simplify build configurations, offering a streamlined experience than Gradle while providing IDE support and built-in capabilities for multiplatform and backend projects.4 Amper represents the future direction of Kotlin build tooling, promising greater ease of use and efficiency.

The adoption of Kotlin DSL for Gradle and the ongoing development of tools like K2 and Amper signify JetBrains' approach to the Kotlin developer experience. They are not just developing the language and frameworks but are investing in tooling to ensure productivity and performance for Kotlin developers across the software development lifecycle. A programming ecosystem relies on a language, frameworks, and efficient tooling (IDEs, build systems, compilers). JetBrains' investment in improving the entire Kotlin development toolchain, from the build script language (Kotlin DSL) to the compiler (K2) and future build systems (Amper), shows a commitment to developer productivity and performance. The KotlinConf app, as a flagship project, benefits directly from these advancements and serves as a real-world example of how these tools contribute to a smoother and faster development process. This integrated approach ensures the Kotlin development experience is optimized. This comprehensive focus on tooling is important for the long-term success and adoption of Kotlin. By continuously enhancing the development environment, JetBrains reduces friction for developers, making Kotlin a more attractive and efficient choice for building complex, multiplatform applications, and fostering a developer community.

6. Key Capabilities and User Experience

Detailed breakdown of features

The official KotlinConf app is designed to provide a comprehensive experience for conference attendees, offering a set of functionalities.2

  • Schedule Access: Users are granted full access to the conference schedule, allowing them to browse all available sessions, including details like session titles, speakers, times, and descriptions.2

  • Session Management and Personalization:

    • Search Sessions: A search functionality enables users to quickly find specific talks or topics of interest.

    • Filter by Tags: Sessions can be filtered by various tags (e.g., tracks, topics, levels), allowing attendees to narrow down the schedule according to their preferences.

    • Bookmark Favorites: Users can easily mark sessions as favorites, creating a personalized schedule view and ensuring quick access to their preferred talks.

    • Notifications: The app provides timely notifications, alerting users before their bookmarked sessions are about to begin, helping them manage their time effectively and avoid missing talks.2

  • Engagement and Feedback:

    • Vote for Sessions: Attendees can participate by voting for sessions, providing feedback on presentations.

    • Share Feedback: Detailed feedback mechanisms are available, allowing users to provide input on sessions and overall conference experience.2

  • Real-time Updates: A feature for live events, the app receives and displays real-time updates directly from the organizers. This ensures that attendees are always informed about any last-minute changes, schedule adjustments, or important announcements during the event.2

Cross-platform consistency and native experience

A design goal of the KotlinConf app's design is to deliver a consistent user experience across all its supported platforms (Android, iOS, desktop, and web), while maintaining a native-like feel on each.1 The utilization of Compose Multiplatform plays a role in achieving this balance. Its stability on iOS, with features such as native scrolling behavior, iOS-native text selection, drag-and-drop, variable font support, and natural gestures, ensures the shared UI provides a quality, production-ready experience that closely mimics native applications.4 The feature set of the KotlinConf app, delivered through a shared UI (Compose Multiplatform), shows an investment in development efficiency without compromising user experience. The ability to deliver "native-like" experiences on diverse platforms with a single codebase is an achievement, validating Compose Multiplatform's maturity for production applications. Cross-platform UI frameworks have often faced criticism for failing to deliver native-feeling experiences or for being limited in complex UI scenarios. By implementing a feature-rich application like KotlinConf with a shared UI, JetBrains is showing that Compose Multiplatform has overcome many of these limitations. The fact that a critical, public-facing application uses this approach implies the framework is capable of delivering a consistent brand experience and a quality, performant user experience that feels natural on each platform. This is a testament to the framework's maturity and its ability to meet the demands of real-world applications. This successful implementation positions Compose Multiplatform as a solution for developers and organizations seeking to build complex applications efficiently across multiple platforms without sacrificing the quality or responsiveness typically associated with native development. It validates the "write once, run anywhere" promise for UI in the Kotlin ecosystem.

7. Conclusion and Future Outlook

Summary of Architectural Strengths

The KotlinConf app stands as an example of the capabilities of Kotlin Multiplatform. Its architecture demonstrates how to achieve code sharing for core business logic and user interface components across Android, iOS, desktop, and web platforms. The modular structure, including distinct shared, androidApp, iosApp, backend, data, ui-components, and ui-components-gallery modules, shows best practices in software engineering. This modularity supports maintainability, scalability, and separation of concerns, important for managing complex, multi-target applications. The choice of a full-stack Kotlin approach, using Ktor and Exposed for the backend alongside Compose Multiplatform for the client UI, highlights a cohesive and productive development ecosystem. This unified language stack simplifies tooling, promotes knowledge transfer, and streamlines the development lifecycle. The implementation of data handling, caching strategies, and persistence mechanisms ensures a performant, responsive, and resilient user experience, even in challenging network conditions.

Implications for Cross-Platform Development

The KotlinConf app serves as a real-world case study for organizations considering Kotlin Multiplatform. It illustrates how a single, shared codebase can reduce development time and cost, while delivering quality, consistent, and native-like experiences across platforms. Its successful deployment and continuous evolution demonstrate that KMP is no longer an experimental technology. Instead, it has matured into a production-ready solution capable of powering complex applications across various operating systems and form factors.

Future Trends in Kotlin and KMP

The KotlinConf app, as a flagship project from JetBrains, is positioned to embrace and showcase advancements within the Kotlin ecosystem. Its future evolution will likely reflect broader trends in Kotlin and KMP development. The KotlinConf app, as a JetBrains product, is positioned to adopt and showcase these advancements. Its evolution will likely reflect the broader trends in the Kotlin ecosystem, making it a learning resource for future KMP development. Technology companies often use their own products as testbeds and demonstrations for their innovations. This provides validation and shows practical applications. Given this relationship, it is likely that as K2 matures, Amper evolves, and new KMP features or AI-powered tools (like Koog, Mellum, Junie) become stable, the KotlinConf app will be among the first to integrate and demonstrate these technologies. It serves as an example of how these advancements translate into practical application development. This creates a feedback loop and a learning opportunity for the Kotlin community. The KotlinConf app's ongoing development and updates will not only reflect the state of the art in KMP but also provide concrete, production-grade examples of how to leverage the newest features and tools, thereby accelerating the adoption and best practices within the Kotlin development landscape. It transforms the app into an educational platform for the future of Kotlin development.

Ongoing advancements such as the K2 compiler, which promises build speed improvements and a foundation for advanced tooling, and Amper, JetBrains' experimental build tool aiming for simplified configuration, will enhance developer productivity and application performance.4 The continued stability and ongoing feature parity efforts for Compose Multiplatform on web and Kotlin/Wasm targets will expand KMP's reach into new domains, making it a more versatile choice for cross-platform development.4 Collaborations, such as the partnership between JetBrains and the Spring team to strengthen Kotlin for backend development, coupled with official Language Server Protocol (LSP) support for VS Code, indicate a broader push for Kotlin's adoption beyond its traditional strongholds in mobile and server-side JVM applications.4

Works cited

  1. JetBrains/kotlinconf-app: The official KotlinConf application - GitHub, accessed July 5, 2025, https://github.com/JetBrains/kotlinconf-app ↗

  2. KotlinConf on the App Store, accessed July 5, 2025, https://apps.apple.com/am/app/kotlinconf/id1299196584 ↗

  3. KotlinConf on the App Store, accessed July 5, 2025, https://apps.apple.com/us/app/kotlinconf/id1299196584 ↗

  4. KotlinConf 2025 Unpacked: AI-Powered Kotlin, Multiplatform Momentum, and What's Next for Devs | by Yodgorbek Komilov - Medium, accessed July 5, 2025, https://medium.com/@YodgorbekKomilo/kotlinconf-2025-unpacked-ai-powered-kotlin-multiplatform-momentum-and-whats-next-for-devs-854f6131782a ↗

  5. Kotlin Multiplatform samples - JetBrains, accessed July 5, 2025, https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-samples.html ↗

  6. KotlinConf 2025 Unpacked: Upcoming Language Features, AI-Powered Development, and Kotlin Multiplatform Upgrades - The JetBrains Blog, accessed July 5, 2025, https://blog.jetbrains.com/kotlin/2025/05/kotlinconf-2025-language-features-ai-powered-development-and-kotlin-multiplatform/ ↗

  7. Announcing Kotlin Multiplatform Shared Module Template - Android Developers Blog, accessed July 5, 2025, https://android-developers.googleblog.com/2025/05/kotlin-multiplatform-shared-module-templates.html ↗

  8. Kotlin Multiplatform | Kotlin Documentation, accessed July 5, 2025, https://kotlinlang.org/docs/multiplatform.html ↗

  9. Kotlin Multiplatform Architecture Best Practices for Mobile Apps - Carrion.dev ↗, accessed July 5, 2025, https://carrion.dev/en/posts/kmp-architecture/ ↗

  10. Integration with the SwiftUI framework | Kotlin Multiplatform Documentation - JetBrains, accessed July 5, 2025, https://www.jetbrains.com/help/kotlin-multiplatform-dev/compose-swiftui-integration.html ↗

  11. How can I use swiftUI in my compose in compose multiplatform kotlinlang #compose-ios, accessed July 5, 2025, https://slack-chats.kotlinlang.org/t/16245829/how-can-i-use-swiftui-in-my-compose-in-compose-multiplatform ↗

  12. Kotlin Multiplatform — MVVM & Clean Architecture | by Javier Arroyo | ProAndroidDev, accessed July 5, 2025, https://proandroiddev.com/kotlin-multiplatform-mvvm-clean-architecture-f20b99f90b95 ↗

  13. What is difference between mvvm with clean architecture and mvvm without clean architecture in Android? - Stack Overflow, accessed July 5, 2025, https://stackoverflow.com/questions/58484680/what-is-difference-between-mvvm-with-clean-architecture-and-mvvm-without-clean-a ↗

  14. KotlinConf 2025. Day two recap - Medium, accessed July 5, 2025, https://medium.com/@sporentusjourney/kotlinconf-2025-day-two-recap-bd6e97d7a145 ↗

  15. How to load data in Kotlin with Coroutines: MVVM | MVI | ProAndroidDev, accessed July 5, 2025, https://proandroiddev.com/the-final-article-on-loading-data-in-kotlin-apps-898f9add9c6f ↗

  16. Kotlin and SQLite: Building Local Database Apps for Android | by REIT monero - Medium, accessed July 5, 2025, https://medium.com/@juricavoda/kotlin-and-sqlite-building-local-database-apps-for-android-e1a54f48dc6b ↗

  17. For persistent caching on ktor client we got FileStorage f kotlinlang #ktor - Kotlin Slack, accessed July 5, 2025, https://slack-chats.kotlinlang.org/t/27079033/for-persistent-caching-on-ktor-client-we-got-filestorage-for ↗

  18. Caching Strategies in Android: Room + Network with Single Source of Truth Pattern - Reddit, accessed July 5, 2025, https://www.reddit.com/r/Kotlin/comments/1ldjiso/caching_strategies_in_android_room_network_with/ ↗

  19. KotlinConf 2023: Unveiling the Power and Potential of Kotlin | Senacor Blog, accessed July 5, 2025, https://senacor.blog/kotlinconf-2023-unveiling-the-power-and-potential-of-kotlin/ ↗

  20. Kodee's Kotlin Roundup: A Carefully Curated June Edition - The JetBrains Blog, accessed July 5, 2025, https://blog.jetbrains.com/kotlin/2025/07/kodees-kotlin-roundup-june-edition/ ↗

  21. How are you all handling database persistence? : r/Kotlin - Reddit, accessed July 5, 2025, https://www.reddit.com/r/Kotlin/comments/11z3hil/how_are_you_all_handling_database_persistence/ ↗

  22. accessed December 31, 1969, https://github.com/JetBrains/kotlinconf-app?tab=readme-ov-file ↗

  23. accessed December 31, 1969, https://github.com/JetBrains/kotlinconf-app/blob/main/backend/build.gradle.kts ↗

  24. accessed December 31, 1969, https://github.com/JetBrains/kotlinconf-app/blob/main/androidApp/build.gradle.kts ↗

  25. accessed December 31, 1969, https://github.com/JetBrains/kotlinconf-app/blob/main/iosApp/build.gradle.kts ↗

  26. Workshops | KotlinConf 2023, April 12–14, Amsterdam, accessed July 5, 2025, https://kotlinconf.com/2023/workshops/ ↗

  27. Add dependencies to your project | Kotlin Multiplatform Documentation - JetBrains, accessed July 5, 2025, https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-dependencies.html ↗

  28. Talks | KotlinConf 2023, April 12–14, Amsterdam, accessed July 5, 2025, https://kotlinconf.com/2023/talks/ ↗

  29. KotlinConf'23 - YouTube, accessed July 5, 2025, https://www.youtube.com/playlist?list=PLlFc5cFwUnmwcJ7ZXyMmS70A9QFyUu1HI ↗

  30. Confetti: building a Kotlin Multiplatform conference app in 40min | KotlinConf 2023, April 12–14, Amsterdam, accessed July 5, 2025, https://kotlinconf.com/2023/talks/368995/ ↗

  31. Building a Full-Stack Kotlin Conference App in 40 Minutes - Confetti from Android Makers, accessed July 5, 2025, https://www.classcentral.com/course/youtube-confetti-building-a-kotlin-conference-app-in-40min-john-o-reilly-martin-bonnin-348478 ↗

  32. Migrate your build configuration from Groovy to Kotlin | Android Studio, accessed July 5, 2025, https://developer.android.com/build/migrate-to-kotlin-dsl ↗

  33. kotlinconf-app/build.gradle.kts at main · JetBrains/kotlinconf-app ..., accessed July 5, 2025, https://github.com/JetBrains/kotlinconf-app/blob/main/build.gradle.kts ↗

Matt Dyor2
by Matt Dyor2
More Posts
Build Native Apps Fast with Koko

Build Native Apps Fast with Koko ↗

If you are a startup looking to build a native Android and iOS application, you should consider using Kotlin Multiplatform or KMP. And if you want to use KMP, you should consider using Koko - the libraries, tools, and guidance that startups need to move fast.

Published May 25, 2025

Step 1: Get Your AI Running

Step 1: Get Your AI Running ↗

There are a number of options for leveraging AI to build your KMP apps. For Koko, we are going to focus on Junie. Let's get started!

Published May 26, 2025

Getting Started building Android and iOS apps with Kotlin Multiplatform

Getting Started building Android and iOS apps with Kotlin Multiplatform ↗

Let's install the key tools needed to begin Android Studio development with Kotlin Multiplatform. This guide is designed to help developers leverage Koko's startup framework to streamline their development process.

Published Jun 29, 2025

Page generated at: 2025-07-12T12:32:29.650Z
Koko
Kokopart of the gokoko.dev network