# fluentui-apple puts Fluent design system controls into UIKit and AppKit

> Microsoft's fluentui-apple repository is a Swift library of native Apple controls, built on UIKit for iOS and AppKit for macOS, aligned with the Fluent design system rather than with a web rendering of it. It is consumed through Swift Package Manager or CocoaPods, it needs a recent toolchain, and its release history, its localisation workflow and its separate asset licence are all part of the story.

**microsoft/fluentui-apple** — UIKit and AppKit controls for building native Microsoft experiences

- Repository: https://github.com/microsoft/fluentui-apple
- Website: https://www.microsoft.com/design/fluent/#/
- Stars: 978 · Forks: 181
- Language: Swift
- License: MIT
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/microsoft-fluentui-apple

## Native controls, not a rendered design system

Fluent UI Apple contains native UIKit and AppKit controls aligned with Microsoft's Fluent UI design system, and the word native is the whole design decision. A design system written for the web and rendered inside an application gives you pixel parity with the web product and none of the platform behaviour, and it usually gives you a slower app and a set of awkward edge cases around text input, focus and accessibility. This library takes the opposite route. The controls are UIKit on iOS and AppKit on macOS, so they behave the way the platform expects, and what the library contributes is the visual language of Fluent, the spacing, the corner treatment, the type ramp and the interaction patterns. The source tree is split accordingly, with a `Sources/FluentUI_iOS` and a `Sources/FluentUI_macOS`, and each has its own readme for the platform specific details, so the two are genuinely separate implementations that share a name rather than one implementation with a compatibility shim.

## The requirements decide whether you can use it at all

The requirements section is short and it filters the audience hard. You need iOS 17 or later, or macOS 14 or later, Xcode 26.0 or later, and Swift 5.9 or later. The iOS and macOS floors are ordinary for a modern Apple framework in 2026, and Swift 5.9 is not a new requirement either. The Xcode 26 requirement is the one that will stop a team, because it means the entire build environment has to be current, and a project that is still on an older Xcode cannot consume the library at all. The practical question for an engineer is therefore not whether the controls are good but whether your fleet of developer machines and your continuous integration images can move to that Xcode, and if they cannot, the answer is a hard no rather than a workaround. The documentation does not describe a lower deployment target mode or a compatibility shim, so treat the floor as the floor.

## Swift Package Manager or CocoaPods, and one module name

There are two supported ways to add the library, and the Swift Package Manager route is the one the documentation leads with. The dependency is declared in your project or in a `Package.swift` file:

```swift
dependencies: [
    .package(url: "https://github.com/microsoft/fluentui-apple.git", .upToNextMinor(from: "X.X.X")),
],
```

The CocoaPods route is a single line in the Podfile:

```ruby
pod 'MicrosoftFluentUI', '~> X.X.X'
```

Note that the two ecosystems use different names for the same thing, the GitHub repository is `fluentui-apple` while the pod is `MicrosoftFluentUI`, and the repository carries a `MicrosoftFluentUI.podspec` at the root to make that work. Both snippets use a version placeholder rather than a real number, which is the project's way of showing the shape of the declaration rather than a version to copy. Once the framework is in the project, the import is the same on both platforms, `import FluentUI` for Swift, and for Objective-C the generated header `#import <FluentUI/FluentUI-Swift.h>`, which is the standard bridge for a Swift framework used from Objective-C.

## The control catalogue lives in the platform readmes

The main README does not list the controls, and the reason it gives is that the information is platform specific. It points at the iOS readme in `Sources/FluentUI_iOS/README.md` and the macOS readme in `Sources/FluentUI_macOS/README.md` for more detail, which is the honest arrangement for a library whose two halves are separate implementations, since a control that exists on macOS and not on iOS, or that behaves differently on each, would make a shared list misleading. The repository also has a `Demos/` directory, which is where you would look to see the controls used together in a running application, and a `Docs/` directory, plus a `Tests/` directory and a `scripts/` folder. For an evaluation, the order that works is to read the platform readme for the platform you are shipping, then look at the demos, and only then read the source, because the source of a control that behaves differently on the two platforms is going to be a large file to wade through.

## Releases, changelog and the pipeline that publishes them

The project manages its releases with GitHub Releases, and the README says the changelog between every release lives on the releases page, with the complete list of additions, fixes and changes there rather than in a file in the repository. The recent versions are 0.37.0 from 2026-08-07, 0.36.0 from 2026-07-13 and 0.35.0 from 2025-10-26, so the spacing of releases has been uneven, and the version numbers being below one are worth noticing, since a zero major version is the project's way of saying the API may still move. The build and release machinery is visible in the badges. There is a GitHub Actions workflow for the build, one for localisation, which is a separate signal of how seriously the project treats its translations, and one specifically for publishing the CocoaPod. Alongside them is an Azure DevOps pipeline for the design side of the organisation, which suggests the design and the code are built and validated in different systems. The last push to the repository was on 2026-09-07, and the repository also carries a `SECURITY.md`, a `CODE_OF_CONDUCT.md` and a `.swiftlint.yml` configuration, so the linting rules are part of the repository rather than left to the host.

## MIT for the code, a separate agreement for the logos

The licence section is the one that needs two sentences read carefully. All files in the repository are subject to the MIT licence, and the LICENSE file at the root is the full text. Then there is a second rule, the usage of the logos and icons referenced in Fluent UI Apple is subject to the terms of the assets licence agreement, which is linked separately. That is a sensible split and a common one, because the code is meant to be reused while the brand assets are meant to be used only by people building something Microsoft branded. The practical consequence is that a team can adopt the controls, and their behaviour, without the Microsoft name, but if the intent is to ship something that looks like a Microsoft product, the assets agreement is a separate thing to sign. The `Demos/` and `Docs/` folders are where those assets will show up, so the licensing question surfaces as soon as you run the samples.

## Conclusion

fluentui-apple suits a team building a Microsoft branded application on Apple platforms who want native controls that follow the Fluent design system instead of a web view or a hand drawn approximation, and it suits a developer who wants an example of a design system shipped as a Swift package with a localisation pipeline. It is a poor fit if you need to support older operating systems, since the floor is iOS 17 and macOS 14 and the toolchain requirement of Xcode 26 is strict, and it is a poor fit if you need the Microsoft branding, since the logos and icons come under a separate assets agreement. Before you adopt it, check three things: the deployment targets of your app against the iOS 17 and macOS 14 floor, the changelog on the releases page, since the current one is 0.37.0 from 2026-08-07, and the assets licence, because the code is MIT while the icons that make it look Fluent are not.

## FAQ

### What is fluentui-apple?

It is a Swift library of native UIKit and AppKit controls aligned with Microsoft's Fluent UI design system, published by Microsoft. The iOS and macOS implementations are separate, with their own source directories and their own readmes under Sources/FluentUI_iOS and Sources/FluentUI_macOS.

### What are the requirements for using fluentui-apple?

iOS 17 or later, or macOS 14 or later, Xcode 26.0 or later, and Swift 5.9 or later. The Xcode requirement is the strict one, since the library cannot be built or consumed by a project on an older toolchain.

### How do I add fluentui-apple to a Swift project?

With Swift Package Manager, by adding `.package(url: "https://github.com/microsoft/fluentui-apple.git", .upToNextMinor(from: "X.X.X"))` to the dependencies in your project or Package.swift file. With CocoaPods, by adding `pod 'MicrosoftFluentUI', '~> X.X.X'` to the Podfile, and then importing the module with `import FluentUI`.

### Where can I find the list of controls in fluentui-apple?

The main README does not list them and points at the platform specific readmes instead, the iOS one at Sources/FluentUI_iOS/README.md and the macOS one at Sources/FluentUI_macOS/README.md. The repository also has a Demos directory showing the controls in use.

### Can I use the Fluent UI logos and icons in my app?

The code is MIT licensed, but the usage of the logos and icons referenced in Fluent UI Apple is subject to the terms of a separate assets licence agreement. So the controls can be reused under the MIT terms, while the brand assets come with their own conditions.

## Sources

- [License: MIT](https://github.com/microsoft/fluentui-apple/blob/main/LICENSE)
- [microsoft/fluentui-apple on GitHub](https://github.com/microsoft/fluentui-apple)
- [Project website](https://www.microsoft.com/design/fluent/#/)
- [README](https://github.com/microsoft/fluentui-apple/blob/main/README.md)
- [Releases](https://github.com/microsoft/fluentui-apple/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/microsoft-fluentui-apple