Compose Fluent: Fluent Design components for Compose Multiplatform

The library says experimental in its own status section

Compose Fluent is described as a Fluent Design UI library for Compose Multiplatform, and the current status section puts the caveat first: the library is experimental and any API would be changed in the future without any notification.

The next line is the one that tells you what to expect from the source. The README notes that there are lots of hard-coding and workarounds in the source code, which the maintainers plan to eliminate in the future. That is an honest description of a port in progress, and it changes how you read the component list: an item marked as done means a component exists and renders, not that its behaviour is finished or that its API is settled.

The project is written in Kotlin, licensed under the Apache License 2.0, and the last push was on 2026-10-11. The release history is short: v0.1.0 on 2025-08-10, then v0.0.1-dev.8 from 2024-05-31 and v0.0.1-dev7 from 2024-02-22. So the first stable-looking version came more than a year after the last listed development build, and the gap between the version people use and the version being developed is wide.

The library is published to Maven Central under the group io.github.compose-fluent, with the main artifact called fluent and a separate extended icons artifact. The homepage hosts documentation, and there is a Telegram channel linked from the badges.

The repository layout shows more than a single module. There is fluent/ for the components, fluent-icons-core/, fluent-icons-extended/ and a fluent-icons-generator/, a gallery/ module with a gallery-processor/, a build-plugin/ and a source-generated/ directory paired with a source-generated-processor/, which is how the icon set is turned into Kotlin code.

Seven targets, from desktop JVM to the browser

The supported target table is the reason this is a multiplatform project rather than an Android one.

The desktop target covers Linux, macOS and Windows. The Apple targets are listed separately as iosX64, iosArm64 and iosSimulatorArm64, with the first two covering iPhone and iPad and the third covering the iOS Simulator. Then there is androidTarget for Android devices, and two web entries, wasmJs and js, both described as web browsers.

Splitting the Apple targets the way it does is the detail worth noticing. A library that supports both a device build and a simulator build for Apple silicon has to compile for both, and an application that wants to test on a simulator and ship on a device needs both variants present. A library that only claims iosArm64 would leave the simulator path broken, and a project that silently fails to link on the simulator is a frustrating hour to lose.

Having both wasmJs and js is the other interesting part. Those are two distinct Kotlin web targets with different compilation models, and supporting both means the composables in this library are constrained to the common subset rather than using anything platform specific in a composable body.

The list of libraries the project is built on explains how the targets are covered. JetBrains compose-multiplatform provides the framework itself, Kotlin kotlinx-datetime provides a unified clock API, and the acrylic and mica effects come from the haze project by chrisbanes, which the credits describe as offering essential implementations for those effects. That last dependency is doing real work, since the Windows background materials are the most platform-specific part of the Fluent look and the hardest thing to reproduce on a web canvas.

The design source is the Windows UI Kit Figma file, credited under CC BY 4.0, and the project describes it as having provided design mockups for the controls.

Adding the dependency and rendering the first screen

The quick start is two coordinates. The main artifact and the extended icon set, which is a separate artifact so that applications only pull the extra icons they use:

implementation("io.github.compose-fluent:fluent:v0.1.0")
implementation("io.github.compose-fluent:fluent-icons-extended:v0.1.0") // If you want to use full fluent icons.

Snapshot builds are published automatically from the dev branch, and to use them you add the Sonatype snapshot repository to your build file:

repositories {
    mavenCentral()
    // Add Sonatype snapshots repository
    maven("https://central.sonatype.com/repository/maven-snapshots/")
}

And the snapshot dependency takes the -SNAPSHOT suffix:

implementation("io.github.compose-fluent:fluent:0.1.0-SNAPSHOT")

The example then shows the shape of the API, and it is the same shape as any Compose application, which is the point of the library:

import io.github.composefluent.component.*

@Composable
fun App() {
  FluentTheme {
    Mica(Modifier.fillMaxSize()) {
      Column(Modifier.padding(24.dp)) {
        Button(onClick = {}) {
          Text("Hello Fluent Design")
        }
      }
    }
  }
}

Three things are visible in that snippet. FluentTheme() is the context and entry point of the application, described as just like MaterialTheme. The components live in a component package. And the background is a composable, Mica, which fills the available space and draws the material behind the content.

A gallery module is referenced for more detail, which in a library structured this way is the equivalent of a component showcase, and the repository carries a gallery-processor directory that presumably drives it.

The component list is a status board, and the unchecked boxes are the roadmap

The component list in the README is formatted as a checklist, and reading it as a status board is more useful than reading it as a feature list, because the unchecked entries tell you where the project is heading.

The Layers section separates materials from the two composables that apply them. Under materials, the app layer variants are the ones implemented: App Layer Mica, App Layer Mica Alt, App Layer Acrylic Default, App Layer Acrylic Base, Accent Acrylic Default, Accent Acrylic Base and Thin Acrylic. The window layer Mica and window layer Acrylic are not. And under both Mica and Layer there is a distinction between the simple implementation, which is done, and the real one, which is not. Card is done.

That simple versus real split is the single most useful signal in the document. It says the library can currently draw a flat approximation of the Windows background material, and that the version which actually samples what is behind the window is still to come.

The basic components list is long and mostly complete. The button family is the fullest part, with the plain Button, Accent, Subtle, Dropdown, Hyperlink, Repeat, Toggle, Split and Toggle Split variants. Then Radio Button, Toggle Switch, Check Box, Combo Box, Progress Bar, Progress Ring, Slider, Text Field and Text. The Color Picker, Rating Control, Pill Button, Segmented Button, Lite Filter, List Item, Grid View Item, Flip View and Pips Pager are also present. The one gap in that group is the TriState Check Box.

The compound components show the same pattern. Calendar View, Date Time Picker, Tooltip, Info Bar, Badge, Menu Bar, MenuFlyout, Expander, Command Bar, Command Bar Flyout and Auto Suggest Box are done. Navigation is not done as a whole, though Side Nav, Top Nav, Navigation View, Breadcrumb Bar, Tab View and Selector Bar are, and only Pivot is missing inside it. File Picker is unchecked.

Under Dialogs, the Fluent Dialog, Content Dialog and a simple Flyout are done. Under Animations there are preset constants for durations and easing functions. Under Theme, light and dark themes are done while a custom accent colour is not, and under Accessibility, accessibility semantics is not implemented, which is the gap most worth knowing about before shipping a control library to end users.

The icon pipeline is a build-time concern, and Microsoft owns the artwork

The licensing arrangement here has two halves and they are not the same.

The code is under the Apache License 2.0. The icon assets, in the io.github.composefluent.icons package, are a separate matter: the README states that the copyright of the icon assets belongs to Microsoft. The icons themselves come from the microsoft/fluentui-system-icons repository under the MIT License, and a svg-to-compose project by DevSrSouza is credited with facilitating the conversion of SVG icons to Compose icons, which is how the implementation of the Fluent icons was done.

So the artwork is Microsoft's, it is published under a permissive licence by Microsoft, and the library redistributes a converted form of it inside an Apache licensed package. The icons are split across three modules, a core set, an extended set and a generator, and the extended set is a separate Maven artifact precisely so that an application does not pull the full icon set when it is not needed.

The generator module and the paired source-generated and source-generated-processor directories are the build-time half of this. Generating the icon code rather than committing it by hand keeps the repository diffable and lets the upstream icon set be refreshed on a schedule.

The Windows UI Kit Figma file is the design side, credited under CC BY 4.0, and it is what the component implementations were drawn from. Combined with the haze dependency for the acrylic and mica effects, the picture is of a library that takes Microsoft's design assets and design language and reimplements them for Compose Multiplatform, with Microsoft's artwork on Microsoft's terms and the implementation under Apache 2.0.

Editorial conclusion

Compose Fluent is worth evaluating if you are building a Compose Multiplatform application and want the Fluent look without hand-porting each control, because the layer components and the breadth of the button and dialog set are the parts that would otherwise consume weeks. It is the wrong tool if you need a stable API today, since the project states it is experimental and that any API may change without notification, and it is the wrong tool if you need accessibility semantics, because that item is still unchecked in the component list. Before you depend on it, verify three things yourself: that the target you ship to is in the supported list, since the wasmJs and js targets are web browsers and the iOS entries cover device and simulator builds separately, that the version you resolve matches what your code expects, since the last stable release is v0.1.0 and the development line has been on dev builds since, and that you are comfortable with the Microsoft copyright over the icon assets, which is separate from the Apache 2.0 licence covering the code.

Frequently asked questions

Official sources

1. compose-fluent/compose-fluent-ui on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases