Compose Multiplatform on iOS by: Sebastian Aigner and Nikita Lipsky

foreign [Music] are we ready to start yeah there we go it seems there's a lot of people here so uh maybe like a slightly squeeze inside if you have a couple of empty seats beside you because I can still see a couple of people trickling in thank you so much for showing up and such a wonderfully huge crowd all right great cool well I was instructed that we're going to get thrown off after exactly 45 minutes so we're gonna start uh hi everyone and Welcome to our session on compose multi-platform on iOS my name is Sebastian I'm one of the kotlin and compose multi-platform developer Advocates at jetbrains you may have seen me before maybe on our YouTube channel maybe on Twitter I don't know somewhere like that and I'm joined today by my wonderful co-speaker Nikita hello everyone my name is Nikita lipsky I joined compose multi-platform last summer because I liked so much the whole concept of composable functions I believe it's something new not only in UI programming but in programming in general and before that I used to be a jvm developer so I'm quite fresh and composed so please don't ask me how to do and compose this or how to do and compose that all right with that out of the way um we can get started and we can just get right into the thick of it after our formalities compose multi-platform is common to iOS that enables one of the very cool synergies which is being able to write a user phase once and then share it between different platforms so we're going to take you on a little bit of a journey today that's going to of course include com include compose multi-platform on iOS we're going to see a bunch of live demos a look at the architecture and how that whole implementation actually works and how you can get started writing your own shared user interfaces today first let's do a super brief recap on the classic kotlin multi-platform case we're just looking at the mobile case here because that one's probably the most popular but this of course easily generalizes he was always to share the code that's supposed to behave the same on multiple platforms but not give up access to platform-specific apis and capabilities but there's kind of one part uh Missing here and that's a solution for when you don't want to build and maintain native user interfaces for your Target platform separately because maybe you don't have enough people or maybe you don't have the time or maybe because you just really really want to get your app out there out of the door and in the hands of as many people as soon as possible that's exactly the thing that composed multi-platform enables it allows you to implement your user interface once and then use it for all the platforms that you target scenario that you're seeing here that's IOS and Android but you can absolutely throw desktop and web in the mix as well because it is worth pointing out once again that compose multi-platform is actually the jetbrains initiative to enable cross-platform UI across various parts of the ecosystem so in late 2021 we already stabilized the desktop Target for compose multi-platform which provides you a really delightful way to build user interfaces for Windows Mac and Linux that will be a wonderful talk in and of itself but it's not going to be us who's gonna give it instead we're gonna leave that to Victor crop who's going to have his talk you can desktop 2 tomorrow at 1pm um and if you want to kind of get Hands-On there's also a lab tomorrow at 2PM where you can write some compost for desktop code yourself within the context of Victor's talk you're also going to hear a little bit about the story of one of the composed multi-platform apps you may have used yourself which is of course jetbrain's toolbox another big Target that we saw today is compose multi-platform on the web once again that could fall easily its own talk but it's not this one so if you want to learn more about that and you're physically here in the room like a lot of you are then I would suggest stopping by the booth after this talk I hear there's a couple of very enthusiastic people with very cool demos I am one of those people so you can also come up to me I also have that demo on my laptop anyway today we are going to spend our time uh talking about this new and shiny iOS Target now all of compose multi-platform uh that we build at jetbrains Builds on top of Jetpack compose from Google as we've seen in the keynote today that's already a very well established UI framework that's built on 100 kotlin and when Nikita is going to talk about the architecture of compose multi-platform we'll see how closely we actually are related but for you as developers the gist is that whether you're an experienced composed developer or you are one of those hundreds of thousands of developers that are learning jetpack compose you are in luck because except for a few minor differences the apis and compose multi-platform and Jetpack compose they are the same that means any knowledge that you already have on how to build user interfaces that translates very directly as we'll see in just a bit in other words if you've built a modern a modern Android user interface that means that you can use those exact same skills to write interfaces for iOS and Beyond as well so real multiplier to leverage your skills on a whole new level the best part about all this hyping up that I've been doing is that you don't actually have to wait uh to get your hands on this kind of Technology we are releasing compost for IOS as Alpha today within the context of compose multi-platform 1.4 I cannot tell you how excited I am about this I saw someone trying to clap so let's do that so a little behind the scenes look I had the pleasure of working with a couple of the pre-release artifacts for the few the last few months and it has been absolutely Agony not being able to tell other people about this it's really really exciting and I think you are going to get just as much excitement out of it as I did so we have a lot to talk about we need to figure out where composed for is currently is what it means that it is Alpha and where we're going with it we'll do that in just a second but first I think it's time we remember this moment and make a memory and I mean that quite literally I have a little app here called my memories which I'm just going to pull up here on the screen which is running on my iPhone and this is of course built in compose multi-platform that's a great picture up there already so just like a regular um just like a regular demo app we have everything you need right you have stock photos we have cute cats um and we have you know high resolution images of architecture but this actually also contains a couple of real memories that I made like that one time when I was in a software engineering class and I solved an exercise really really quickly so the professor handed out um this little donut to me and I'll treasure that forever you can actually see that if we look into this there's a little description attached to this as well but of course the picture that I want to take a look at a little bit closer is the cat so this is actually the cat of a good friend of mine if you do read this description you'll figure out that she's very very fond of soups which is why if we actually look at the map of where we've located her um she's at one of the very nice soup restaurants in the middle of Munich and you can see that it's very Central because it's right next to the main church that we have in my neck so you can kind of see that one right here sweet but of course those were all memories in the past they were all good memories and I feel like being here today is just as good so I would love to make a little bit of a memory with all of you we're going to take a bit of a picture um I know there's a couple of people here with the orange lanyard so please provide the uh the sponsored censorship and just do that maybe because you might be otherwise you might be in the background of this and of course I'm not alone here so I actually want to have uh Nikita make the same kind of memory for us using his Android phone yes application but on Android so start with my mice and then we'll do yours let's see here you can wave or something else like that look at that wonderful and we'll do that one more time [Music] excellent look at that wonderful now those are some great images all right we can we can take a closer look you know if we're if we're just let's share it yeah you know maybe we do some sensors I don't know yeah let's you know let's just uh let's share that one and maybe we can collect a couple of retweets uh by the end of the by the end of the session not that we encourage you to pull out your phones right now or anything well let's just tweet this one wonderful and it's out great thank you so much for being part of that [Applause] okay now I'm not sure if you could tell but this was actually just a a kind of a mock scenario I wasn't actually just trying to take a picture of all of you I was trying to show you all the things that compose multi-platform could already do so that's actually kind of dissect this all of this a little bit because I was very much involved in the implementation of this app together with folks from the compose multi-platform team and just to share my own experience it was almost frightening how quick I was able to be productive with this because I said that kind of the apis are the same but that was a very abstract statement so let's actually look at this app and see what we have here on the screen this image right there that's an image component like that's an image composable from from compose the same one that you know from Android I don't mean it's a re-implementation or it's kind of the same it's literally the Android X compose Foundation image it's the same one this grid down here that's just a lazy vertical grid so it uses the exact same kind of apis you use the same kind of item syntax all of that it's just the same we went a little bit Fancy with the button we could have of course just used a regular button but you know how it is you just use a box with a modifier of size 50 uh circle shaped clip and you know you add a little bit of clickability and then it works just as well we could use the build in one but we wanted to be a bit fancy and we also wanted to show you that all the modifiers that you're used to from Android potentially those are all in there as well and they behave just the same now this topic actually stretches to most of the UI topics that you've seen the animations and fading that all uses the same dsls as on Android the little Parallax effect that we had when you scrolled up and the cat would scroll a little bit slower that's also just built on top of the regular apis as are the Transitions and so on so the main takeaway from this is just you're building on the same building blocks as all the established jetpack compose apps so it's really really quick to get started first we also saw a bunch of stuff that wasn't just composed right because just like any other fully featured app we want to make use of what the platform has to offer we showed you two of these examples we had the map kit map which also had this nice little 3D animation in there and of course we fed that using the core location like sensor data so that it's actually the the real GPS and you saw the camera view which actually uses AV Foundation which is another Apple specific API and still we managed to put things like compose buttons on top of that Nikita is going to tell a little bit more about how that actually works from an architecture perspective but for these kind of platform specific widgets that are kind of complex it is one of our goals to provide smooth interoperability um yeah so that's the composable button very good um talking about this being one of our goals it's probably a good segue to manage some expectations and let you know that not everything is finished yet remember this was all very flashy but we have only just reached Alpha it starts from very very simple things right there's stuff like scroll physics that might feel not exactly as they are on the underlying system or the way that gestures behave it extends further to stuff like navigation principles and Transitions and other complex interactions like text selection or input management dialogues and pop-ups but you already saw that we can do things like pop up the share sheet and just kind of integrate with other apps quite easily so that's kind of cool and of course we also want to provide solid accessibility Integrations we want to respect user choices we want to make sure that text to voice works properly with your apps that zoom in contrast settings that those all work as as you would expect them to granted this is a lot of points but we really do want to put in proper thoughts so that your shared user interfaces feel great regardless of the platform that you use them on one more topic that is of course also currently still work in progress and that's really important is providing absolutely smooth performance even on high refresh rate displays so 60 or 120 frames per second on the higher end devices Nikita is going to tell a little bit about what's going on in that regard in just a little bit okay expectations managed wonderful we can kind of conclude our thread on what we saw in the demo under the hood here we of course had a bunch of things that were just built on top of regular kotlin multi-platform this isn't actually composed multi-platform specific stuff like concurrency networking persistence and business logic but it's worth pointing out once more that this is indeed a kotlin multi-platform project this is really good on the one hand because it means that you get native binaries on iOS through kotlin native but it also means that you can't just flip a magic switch and expect your Android app that you already have to just magically work on iOS you still have to turn it into a multi-platform app luckily for that use case the same kind of approaches apply that have always applied in in kotlin multi-platform apps so things like expect an actual and of course as we already saw in the keynote for a little bit a lot of libraries that might be Android specific already have multi-platform counterparts that you can use that help you in your migration towards providing an implementation for multiple platforms we already saw a huge part of this catalog already during the keynote uh Svetlana showed that one and yeah there's really a lot of multi-platform libraries that cover most common use cases in your app we want to take this opportunity to once again shout out Google for pushing their jetpack libraries to multi-platform as well so beyond compose that will make it even easier to bring Android applications to other platforms what's especially cool is that there's also a bunch of libraries out there that are actually already working on compose multi-platforms specifically like compo like specific composables or navigation libraries and now that composed for iOS is available in Alpha I'm sure that those Trailblazers won't take very long to support that Target as well okay but how did we actually make composed multi-platform how does all this work under the hood those are questions that I cannot answer but thankfully I have someone who can a real professional so you take it away Nikita so uh Charles please explain what is compose multi-platform so we have kotlin multi-platform and we have compose that is written in kotlin oops compose multi-platform dude by the way Sebastian do you see an apple in this sculpture I very much do yes but it's not the right Apple is this apple is much better let me choose the Apple and swallow it so let's now talk oh so all of it so now let's now talk what is how we've made compose multi-platform compose password project started just between jetpack compose official announcement and its first public release so we started early is a part of the of Android packs with of libraries that lives on GitHub as a repository called Android X jetpack compose is fully written in kotlin and to make a kotlin library a Scotland multi-platform library you have to Define kotlin multi-platform sources for the targets you're going to support so we just Falls this way and to make the story short on if we go now to Android X GitHub repository and navigate to compose UI sources the most low level part of composite we may find that it defines Scotland multi-platform sources so official Japan pose is kotlin multi-platform right now and yes Google mostly reads their quote as common kotlin is not that amazing it allows us to reuse Google works for other targets that we are working on thank you Google you know that writing a quote in the comments are said imposes certain restrictions on what you can use and what you can't so our regards to Google that they do it actually we collaborate with Google in compose multi-platform development and we regularly port and we do our development in a repository called compose multi-platform core and where we maintain maintain additional budgets supported by composed multi-platform and the regular report our changes in common code back to Android X Repository talking about additional targets if we navigate to compose UI sources of compose multi-platform core we may note not only Android and these top targets but we can also know Source sets for web and iOS targets that are called GS Main and UI kit main respectively by the way among the sources you may also note ski commands are set it is actually a common source set for all for all our targets except Android containing most of the code of our port but what is Kiko so let's now talk about compose multi-platform architecture and to understand how compose multi-platform and Jetpack compose relay we first need to understand the architecture of the park compose itself so the most low level part of composer deals with layout drawing input is compose UI that defines basic blocks for UI Construction compose Foundation is based on compose UI and provides basic layouts like column box lazy column gestures text Etc compose animation is on top of compose UI and Foundation and on top of three Design Systems with common widgets are provided like material or material 3. to write compose applications you need compose compiler because the whole concept of composable functions is actually an extension to kotlin language that needs compiler support and the whole compose system is managed by compose runtime so it was about jetpack compose itself about the architecture about the different parts and on Android compose is managed by Android of course and probably you know that Android uses Kia Graphics engine for all rendering stuff by the way Chrome also uses skier and we decided to use gear as well for other targets for compose multi-platform is written in C plus and so we wrapped it with Scotland bindings and named its Kiko so now you know what is Kiko main this is where compose multi-platform comes into play most of the quote of our Port is in skiko Mains are set but of course there is some code for individual targets as well but most of the quote of composed multi-platform is just shared with jetpack compose except some parts that are 200 specific like Resource Management that we will talk later and if we talk about iOS port the whole system is managed by kotlin native compiler and runtime compose is exported to an iOS application in the form of UI view controller for instance so it can be consumed by UI kit or Swift UI in any place let me show how to do that so first you define your UI staff in common main sources then you export your UI in iOS Mains are shared in the form of UI view controller using compose UI view controller wrapping function the function just gives compose a canvas and compose draws all your UI on that canvas using skier easy and the returns UI view controller back to the iOS world finally you just use exported function in your Swift sources you may use compose as individual screens or as a whole applications uh like any memories that we've shown but you can also embed composing to your UI your Swift UI screens like in the chat app on the right where uh top and bottom uh bars and text input are Swift UI elements while chat view itself is written in compose that allows you to gradually adopt compose multi-platform in your existing projects Scotland interrupt works great here however it can work opposite way as well you can wrap UI kit widgets as composable functions using UI key to view composable function and use it within compose use here we will wrap MK map view iOS map native map view widget and note that it's just pure kotlin code that references MK map view directly so you don't need to write any Swift or objective c code for this then you may use rep native mapping memories view or and you can also wrap other complex widgets like camera or webview but please don't ever use this approach you know that mixing different UI Frameworks on the same screen always has issues so please don't embed Swift you want to compose composing to Swift UI recursively on the same screen but we believe that this approach should work for complex widgets like camera where we use that we aren't going to re-implement but you may ask okay it's clear but what about performance that is Kim perform well so if we talk about the performance of UI applications we actually talk if we can fit into 60 frames per seconds or even 120 FPS for modern devices and it means that we have only 16 milliseconds or even 8 milliseconds to do all rendering stuff within a frame and if something heavier appears in the middle of our rendering process if we do something heavy in the main UI thread just for 16 milliseconds we immediately lose the frame and the users will notice it and will percept it as a leg and now recall that compose forward yes is managed by kotlin native please note that kotlin native is not just compiler it not only compiles your sources into native code but it also provides a managed runtime and that runtime has garbage collector by the way if you appear to try kotlin native two years ago and faced with the problems that it's hard to write multi-credit code is it it's not the case anymore now multitrade in cement is the same for all kotlin Targets so you don't need to use freeze message for shared mutable State anymore but it resulted that a garbage collector had to be re-implemented and it is not reference counting anymore but classical Mark and slipper sweep face is concurrent but marked face is not only performed in GC pose so GC pose linearly depends on the number of Life objects so for now gcpos is exactly that have a thing that can appear in the middle of your rendering process causing your app losing frames and unfortunately yes we are observe 16 milliseconds gcposition users applications now but the native team is team hurricane current GC and we believe that we can achieve two milliseconds the suppose that should be enough for your applications to lose frames so if you try compose multi-platform for is and see that the performance is not good enough please don't throw it away immediately but first make sure that you compiled your application in a release mode it is very important and then you may try to disable garbage collector to estimate the fugitive performance if you disable it your application won't crash immediately without of memory but you can compare if the performance is smoother or not uh if it is not performant enough anyway please share us your use cases because we are regulating the performance right now we believe it's very important for the projects to be successful we are closely with Scotland native team to improve performance so please provide us your feedback and here's my underhood part comes to end and I give the flow to Sebastian all right wonderful so now that we even understand how things are working internally I think it's time for us to get into compost for Iris and do a little bit of a live coding demo those are always fun you know keeps the heart healthy keeps the heart rate up so I love doing those a little side note here um of course if you are working on an IOS app and you want to build and run that on a simulator or on a physical device you need to have a macro you need to run on Mac OS that's not a limitation from us that's a limitation from Apple very unfortunately but how do we kind of get started with all of this well the answer is of course found on the home page of compose multi-platform um you can we'll put a very big short link on this in uh on the slides in just a little bit now here you can explore a bunch of wonderful texts that we've worked a long time that tries to Define what exactly compose multi-platform is but most importantly it also provides you a direct entry point to our templates so in this case what I clicked on was the iOS Target which sends us to our multi-platform IOS and Android template which allows you to build applications for exactly those two mobile targets I do not trust uh the Wi-Fi that we have here in the venue so I have taken the liberty of already importing and starting up this project and we can just do a little bit of exploration of course first we need to make sure that our setup is properly download so the correct way to do that is to run kdoctor which is our tool for diagnosing your development environment it checks things like your operating system that you have the correct versions of Java Android studio xcode and cocoapod setup and also provides a bunch of other convenience functions in regards to signing and so on that might be useful if you're running on on physical devices I also made sure that in my Android Studio I have actually installed the latest version of the kotlin multi-platform mobile plugin because that is the part that enables us to run our application on emulators or physical devices using the Run configurations so before I do anything else let me just start these compilations so that they can kind of just run in the background while we go and explore for a little bit if you first open the project you're going to see something quite similar to this because Android Studio has Android in the name you're going to see the Android view first and we're just going to switch that one to project because while we're doing multi-platform development here and if you've ever done multi-platform development before this is a structure that might already be quite familiar to you spoilers [Music] so you have your Android app here you have your IOS app here and you have a shared module and then inside the shared module you once again have three parts you have your actual common code that's shared between all platforms and then you also have your Android Main and iOS main parts where you can if you're using the expect actual mechanism you can write some kotlin definitions in there that are specific to a um to a Target before we actually dive into the code we can also take a brief detour into the build file where we can see that a couple of the claims that I made before are in fact true this is a kotlin multi-platform project it also Builds on top of the compose multi-platform Gradle plugin which provides a bunch of convenience things like for example defining the common dependencies on runtime foundation and material using this wonderful little syntax that makes sure that the artifacts you pull into your project are always compatible with each other if I just press Ctrl space here to invoke the autocomplete we see that I put my cursor just off by one space and we can see that the run you can see all the things that are available here for you to import right that is of course something that is best explored at your own teacher so where does the actual application then live well as you can see that's just in our very very shared module between all the platforms and here you can see that this is just classic compose code um if you've done jetpack compose before this should be mostly self-explanatory we use remember to manage some State together with the mutable State off we have a button that defines an on click Handler and a bunch of text the only thing that might be new to you if you're not a multi-platform developer yet is this get platform name function which is actually defined as an expect actual function so it has different implementations based on the platform that you target for example if I go into the iOS version of this we will see that it returns indeed iOS versus the Android one would probably just return Android okay so we have probably a mental model of what this app looks like now and we can validate this by indeed running it and we'll see that on Android we get Hello World which changes into hello Android on a click and if we go into our iOS simulator we get Hello World which changes into hello iOS sweet a little boring so I suggest we make it maybe a little bit more interesting because we saw right I made all these claims well animation apis work the same and you should be able to get started pretty quickly so if you've done compose you can probably follow along with me as I add an image component that is inside an animated visibility component and then we'll do a bunch of layout around it and we'll make it so that it animates in and out as I click okay classic approach um we want to have some kind of state that remembers whether we want to show the image or not it's just a Boolean variable we're just going to go into this on click Handler and invert that one every time we click the button wonderful then we need a little bit of layout Primitives because we don't want everything rendering on top of each other so let's stuff our button and whatever else we create into a column and while we are at it we might actually also want to add a couple of modifiers so we want to make sure that this one is the maximum size and I don't know let's see here since these are the same apis I can just invoke my uh my little hints here and see well it seems that probably the horizontal alignment would be nice to have something like centering everything horizontally just to make it a little more aesthetically pleasing okay um so we're still currently just rendering a button so let's make sure we also render an image and this is one of the parts where what Nikita said is also going to come into play because usually if you were just developing on Android you would use the R class uh here right to access your resources the images that you have but we want to be we want to make it possible for you to manage resources in your common modules as well so in this case I have a a vector XML in here that is shared between all the platforms so what compose multi-platform actually does is it provides you with Alternatives with implementations that allow you to do exactly this kind of cross-platform resource management in this case there will be a painter resource and then we'll just type the name of that one in here and of course we need to also provide a Content description which will keep now for the time being we can actually navigate into painter resource to see that this is indeed defined as a common function so that one is just available from composed multi-platform specifically it's not much animation going on here yet so let's just use one of the very basic animation apis animated visibility we can just give that one a um we'll just give that one a Boolean and then we'll kick off the kick off the running of these two apps again and we'll see that this indeed hopefully behaves um the way that we want to so we can already see that the Android version has already finished and indeed first good sign everything is centered so at least the layout seems fine and then when we click on this we get the correct resource and it kind of loads and it pops in and out very very satisfying great so moving back to the Android the iOS simulator we can see that we get the exact same user interface and as I press this also animates in and out wonderful okay so but there's a there's a couple of questions here right um which is okay so we have all of this but what does it look like from a tooling perspective can we debug can we profile and for all of that I'm going to hand over to Nikita again and he's going to demo a little bit about that okay so uh please first let me show that the bucket just works so we just set uh my breakpoint we are now yes and so start the debugger and the buyer stops at the break point it and we see the strike of current threat we can also examine other threats but let us find a hello world string within the debugger um I'm currently on top of the stack we see some composed magic because we are now in the remember function so let us find an appropriate frame where greeting text is declared and here it is please note that bike reward actually Maps a local variable to some field of an object and debugger shows uh uh just that object and we should find our hello world text in the fields of that object Andy here it is so it just works but they can actually we can actually profile our application as well using just standard uh profiler that comes with xcode called instruments so let us start profile our application and then nothing happens on the screen so we don't see any CPU consuming right except except some suspicious Peaks that should happen okay let us check what are they and we see that it is just GC pose but let's make something happening on the screen and we see that CPU starts consuming and let us check what our inside personally I don't like how instruments shows profiles but fortunately there is an amazing app called speed scope app that can import instruments profiles and show them as a flame graph and let us check what are inside and here we see that we do some drawing yes we do some drawing it's we do it where compose layer scale layer and we finally we do composting render and let us check out what are hot methods and we see again here GC we see some memory location we see in GC again and they see again and synchronization synchronization memory location core routines and BC composes well here right compose also works so we can evaluate performance using just standard instruments that comes with xcode so thank you for your attention [Applause] wonderful so um I think there's still uh one question that might be on everyone's mind at least a little bit and that's the question of what does it look like right because so far we've shown you very consistent user interfaces through the power of just the drawing on a canvas but of course these look very much like Android the reason for that is because well we are building on top of Jetpack compose and out of the box what you're getting there are material and material three components the good thing is that these are quite customizable which is nice so you can kind of style them you can imbue them with your own brand and you can kind of already make them a little bit yours but I also want to say that you can we we don't really have a a conclusive answer just yet about what the future should look like with compost multi-platform it's always one of those like key decisions that that multi-platform or cross-platform user interface libraries and Frameworks have to make and this is a decision we don't want to make without first having consulted with the community and understanding what it is that you need the most personally I hope for a future where we can all just agree on one delightful looking interface paradigm I I think everyone will be best served with something like this and I think everyone can actually tell what's a button and you know what's uh what's the text field and all those kind of things but for real please do join this conversation with us it's important for us to really make sure that you get an excellent experience on cross-platform and we want to work together with all of you and understand what it is that you need to make sure that everything looks and behaves the way that you expect it to okay that was a joke by the way disclaimer okay from here on out it's essentially just your turn uh if you are an app developer go and experiment with compose multi-platform see how it can benefit uh you when you're sharing user interfaces in your apps I do want to remind you once more that this is an alpha release so there are things in here that aren't gonna work but you also saw that there's a lot of things that are working just fine and we'd really love for you to play with it and help us evolve it into something that's a joy for everyone to use and develop with but since it is an Alpha maybe don't use it in your production apps yet unless you're one of those Daredevils like touch lab when they build the conference app for droidcon New York City while composed for iOS wasn't even released but they still built it on top of it I mean do what you want I'm not your dad I also was approached about five minutes before we started our talk from one of our folks at the kotlin team that apparently here at this conference there's a couple of folks from a logistics app that already use compose for iOS to support their share of drivers that are using iOS which again impressive speed I don't know if they implemented that since the keynote or since when but apparently they did that so that's uh that's quite exciting all right yeah you can get started by going to jb.gg compose um where you can find everything it's just a couple of clicks to also get to the issue tracker to get an idea of where we currently are um what's not working and of course that is one of the places where you can leave feedback for how you envision the future of compose multi-platform to be we also want to be in a clear dialogue with all of you that you can be in uh using the compose iOS channel on our kotlin Lang slack where a lot of the developers from the team are hanging out directly answering questions and so on for your own exploration we've prepared a number of examples that you can explore in the example subdirectory on the compose multi-platform GitHub project this includes the demo that you've seen today it includes what Nikita has shown for Swift UI interop but it also shows just a couple of more basic apps like a to-do list application or something like a code viewer for example if you've been following following the whole kotlin multi-platform story for longer you might be familiar with the production samples that we've built these now also have branches for compose implementations for the user interface so you can see kind of what the differences are and you can compare and if you want to stop by the talk of two of my colleagues on the kotlin X libraries where you can learn about a lot of cool things you'll also see a compose multi-platform application there as one of their big demo projects so isn't this exciting compose multi-platform on iOS is now an alpha and it allows you to write uis using the apis that you've already seen in Jetpack compose you can still interoperate with the underlying platform and you still get the same kind of powerful abstractions everything to work perfectly just yet but do explore it then please give it a try we want you to get involved and we want you to go and build awesome things so please give a compose for iOS a shot and let's stay in touch thank you so much thank you thank you

Channel: Kotlin by JetBrains

Views: 28,638

Keywords: Compose Multiplatform, Compose, Kotlin, Kotlin Programming Language, Kotlin Multiplatform Mobile, Kotlin Android, Kotlin for server-side, Kotlin/JS, Programming language, Programming, Android development, Kotlin Multiplatform, Compose for iOS, Compose multiplatform, compose multiplatform, jetpack compose, android ui, cross platform, compose ios kotlin, compose ios app

Id: FWVi4aV36d8

Length: 44min 50sec (2690 seconds)

Published: Thu May 04 2023