FigmaExport moves Figma styles into Xcode and Android Studio

Four kinds of export from one Figma file

FigmaExport is described as a command line utility to export colors, typography, icons and images from Figma to an Xcode or Android Studio project, and the four kinds map onto four different parts of a Figma file. Colour comes from Figma's colour style, typography from its text style, an icon is a Figma component containing a small black or colorized vector image, and an image is a component with a colorized image that has a light and a dark variant. That last distinction is the one that catches people. The tool is not reading a folder of exported PNGs, it is reading components in the document and interpreting their role, so the structure of the Figma file is part of the contract. The utility supports Dark Mode, SwiftUI and Jetpack Compose, and the features list adds high contrast colours for Xcode, UIKit, Objective-C and right to left support.

The gap it was built to close

The reasons for building it are given plainly in the README. Figma does not support exporting colours and images to Xcode or Android Studio, and manual export takes a long time. The second reason is the one that decides whether the tool earns its place. It is for easy sync of the component library with the code, which means the design system in Figma is treated as the source and the platform projects as generated output. That is a different workflow from a designer exporting a set of assets and a developer committing them by hand, because the assets stop being something a person copied. The practical consequence is that the Figma file becomes an input to the build, and a change to a colour in Figma is a change to the mobile project after the next export run, with the risk that follows from any generated source of truth.

Installing it as a package, a brew tap or a pod

The tool is written in Swift and distributed through the usual channels. The README carries a badge for Swift Package Manager compatibility and one for CocoaPods, and the installation section covers a manual route, a Homebrew route and a CocoaPods plus Fastlane route. The repository is a Swift package, with `Package.swift` and `Package.resolved` at the root, `Sources/` holding the implementation, `Tests/` the test suite, `FigmaExport.podspec` for CocoaPods, and `Scripts/` for the release automation, with a `Release/` directory for the built artefacts. The CI badge points at a `tests.yml` workflow, so the project runs its tests on every change. There is also a `CONFIG.md` at the root, which is where the configuration file format is described, and that file is the one to read before your first run, because the shape of the generated code depends on the options in it.

Colours become asset catalogues or generated code

Running the colours command exports the Figma light and dark palettes directly into the Xcode project, in the Assets.xcassets folder, and a Swift file is generated so the colours can be used from code. The default output is a thin accessor over the asset catalogue:

import UIKit
 
extension UIColor {
    static var backgroundSecondaryError: UIColor { return UIColor(named: #function)! }
    static var backgroundSecondarySuccess: UIColor { return UIColor(named: #function)! }
    static var backgroundVideo: UIColor { return UIColor(named: #function)! }
    ...
}

A SwiftUI equivalent is generated the same way, extending `Color` instead. The other path is to set `useColorAssets: False` in the configuration file, and then the tool writes literal colour values into the code instead of referencing asset catalogue entries, including a trait collection closure that returns a different value in dark mode, with an iOS 13 availability check and a fallback for older systems. The generated code differs in a second, more consequential way, because a hard coded value in a Swift file cannot be changed by a user in the system settings or overridden in an asset catalogue, and the high contrast variants that Xcode supports are a property of the asset catalogue route.

Icons and images are rendered assets with generated accessors

Icons are exported as PDF or SVG files with the Template Image render mode, which is what lets a single monochrome icon adapt to the tint a UIKit button applies to it, and a matching Swift file gives typed accessors for UIImage or, for SwiftUI, for Image, with names like an icon identifier and a size prefix. Images are exported as PNG files in the same way, again with a generated accessor. There is a convention for multiple idioms, where a name ending in an idiom such as `~ipad` is exported as its own variant. The generated accessors follow the same pattern in each case:

import UIKit
 
extension UIImage {
    static var ic16Notification: UIImage { return UIImage(named: #function)! }
    static var ic24ArrowRight: UIImage { return UIImage(named: #function)! }
    static var ic24Close: UIImage { return UIImage(named: #function)! }
    static var ic24Dots: UIImage { return UIImage(named: #function)! }
    ...
}

The force unwrap in `UIImage(named: #function)!` is worth noting. It is safe only if the asset is present in the bundle, which is true when the export ran against the project you are building, and it is a crash rather than a fallback if it is not.

Typography and the configuration file that drives everything

The typography command generates text style definitions for the platform, and the README explains the way it works in terms of the Figma file structure, with a section on design requirements for colours, icons, images and typography. The configuration file is the control surface, and the repository ships examples of it as `.webloc` files, one named for the dark variant and one for the light variant, so you can see the expected shape rather than guess it. The examples directory also holds complete projects, `AndroidComposeExample`, `AndroidExample`, `Example` and `ExampleSwiftUI`, which is the fastest way to see what a finished export looks like on each platform. The README also links a written article about automating the export of a UI kit from Figma into Xcode and Android Studio projects, which covers the workflow in more depth than the README itself does.

The Figma plan requirement is the constraint to plan around

One limitation is stated with unusual clarity for this kind of tool. Exporting icons and images works only for a Professional or Organisation Figma plan, because FigmaExport uses shareable team libraries. Colours and typography are not restricted in the same way, so a team on a cheaper plan can still automate its token export and only loses the component based assets. That is a decision about your Figma plan, not a limitation you can configure around, and it should be checked before anyone plans a pipeline around the tool. The licence is MIT, and the release history shows steady work: 0.38.2 in January 2025, 0.38.4 in February 2026 and 0.39.0 in July 2026, with the last push on 2026-10-10. The repository is not archived, and the Swift and CocoaPods distribution channels mean a team can pin a version rather than tracking a moving branch.

Editorial conclusion

Adopt FigmaExport when your designers work in Figma, your developers work in Xcode or Android Studio, and the colour and typography tokens are being copied by hand, since the tool writes asset catalogues and generated accessors in both platforms and supports Dark Mode. Do not adopt it if your Figma account is on a plan without shareable team libraries, because the README states that exporting icons and images works only with a Professional or Organisation plan. Verify first which Figma file structure your tokens live in, since the colour, icon, image and typography exports each read a different part of the file, and read the configuration file before your first run because the generated code shape changes depending on the asset options you set.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. RedMadRobot/figma-export on GitHub
5. Releases