# Android-Iconics in Maintenance Mode: What the Deprecation Notice Means for Your App

> Android-Iconics renders icon-font glyphs as drawables and still works, but the README declares the library deprecated in favour of Compose ImageVector icons. Here is how it loads fonts, how to wire it up, and who should migrate first.

**mikepenz/Android-Iconics** — Android-Iconics - Use any icon font, or vector (.svg) as drawable in your application.

- Repository: https://github.com/mikepenz/Android-Iconics
- Website: https://mikepenz.dev
- Stars: 5,273 · Forks: 613
- Language: Kotlin
- License: Apache-2.0
- Published: 2026-09-23 · Updated: 2026-09-23 · Language: en
- Canonical page: https://hysenlabs.com/projects/mikepenz-android-iconics

## The problem Android-Iconics solved, and the one it now creates

Before vector drawables were practical across Android versions, shipping an icon meant shipping bitmaps at every density: mdpi, hdpi, xhdpi and so on. Android-Iconics took the opposite route. You add one icon-font artifact, and the library renders any glyph from that font as a drawable at whatever size, color, contour, shadow or padding you ask for. The README lists those customizations as the headline feature, alongside the claim that it saves APK size by collapsing many raster assets into one font file.

That trade is the whole design, and it is also why the project is now deprecated. The README states the library loads an entire icon font into memory and renders glyphs through a Drawable. In a Compose app, vector icons are described as cheaper, tree-shakeable, previewable and typed at compile time. So the audience has narrowed to one group: teams maintaining Views-based Android apps that already pull icon fonts, or apps that need an icon set with no first-party Compose equivalent.

## How the typeface artifacts, IconicsDrawable and the string keys fit together

The architecture is split across four Gradle modules visible in the repository root: iconics-core, iconics-typeface-api, iconics-views and iconics-compose, plus one module per font family such as google-material-typeface, fontawesome-typeface-library and phosphor-typeface-library. iconics-core holds the drawing logic with no widgets, iconics-views adds the View subclasses (IconicsButton, IconicsImageView and similar), and each typeface module packages one font plus the enum of its glyph names.

At runtime you construct an IconicsDrawable from a Context and a glyph constant, then chain modifiers. The migration table in the README shows the shape of that API: IconicsDrawable(ctx, GoogleMaterial.Icon.gmd_favorite), then .size(IconicsSize.dp(24)) and .color(IconicsColor.colorInt(c)). The same table notes that icons could also be referenced by string keys such as "gmd-favorite", which is precisely the indirection the README says Compose removes by using typed ImageVector properties checked at compile time.

One detail that matters operationally: the README warns that the fonts use the jetpack startup library to register themselves automatically, and that if jetpack startup is disabled you must register the fonts manually. That is the failure mode people hit first, an icon that renders as a blank box because the typeface never registered.

## Installing Android-Iconics and rendering a first icon

The README gives the Gradle coordinates directly. You need the core library plus appcompat, and the version placeholder is written as latestAndroidIconicsRelease in the README's own snippet. The latest tagged release listed in the repository is v5.6.0, dated 2026-08-20.

```gradle
dependencies {
    implementation "com.mikepenz:iconics-core:${latestAndroidIconicsRelease}"
    implementation "androidx.appcompat:appcompat:${versions.appCompat}"
}
```

Adding the view widgets is a separate, optional dependency. If you only draw icons yourself, skip it.

```gradle
implementation "com.mikepenz:iconics-views:${latestAndroidIconicsRelease}"
```

Then pick the font artifacts you actually use. The README lists each one with a pinned version, and notes that fonts ending in -kotlin require at least v4.x of Android-Iconics, and that v5.1.x or newer requires the latest font versions. Two examples from that list:

```gradle
implementation 'com.mikepenz:google-material-typeface:4.0.0.3-kotlin@aar'
implementation 'com.mikepenz:fontawesome-typeface:5.9.0.3-kotlin@aar'
```

The @aar suffix is not decorative. The README adds a note for version-catalog users: the type cannot be declared in the catalog, so it has to be set on the implementation definition itself, as implementation(libs.material.typeface) { artifact { type = "aar" } }. Expect the first blank-icon bug to come from that suffix or from jetpack startup being disabled.

## Where Android-Iconics is the wrong choice

The README is unusually direct: the library is deprecated, it will receive critical and security fixes, but no new features and no new icon fonts. If your project needs an icon added to FontAwesome or Simple Icons next quarter, this library cannot supply it, and no amount of configuration changes that.

Memory is the second constraint. Loading an entire icon font to draw one glyph is a poor fit for a Compose UI where the same glyph could be a small vector with no font file in the APK at all. The README frames this as the platform having solved the problem better rather than as a bug, but the cost is real in any app that ships several typeface artifacts.

The third case is RTL. Auto mirroring for RTL is listed as opt-in, so an app that assumes mirrored icons by default will ship unmirrored ones until someone enables it. None of these are reasons to rip the library out of a working Views app today; they are reasons not to introduce it into a new one.

## Compose ImageVector as the replacement, and what the migration actually costs

The recommended alternative in the README is ImageVector with androidx.compose.material.icons, and the difference is structural rather than cosmetic. Android-Iconics resolves a glyph by name at runtime against a loaded font; ImageVector is a typed property resolved at compile time, so a renamed or removed icon becomes a build error instead of a blank drawable.

The README's before-and-after pair makes the API change concrete:

```kotlin
// before
Image(GoogleMaterial.Icon.gmd_favorite, colorFilter = ColorFilter.tint(MaterialTheme.colors.primary))

// after
Icon(Icons.Filled.Favorite, contentDescription = null, tint = MaterialTheme.colorScheme.primary)
```

Size and color move out of the drawable and into the Compose call site: .size(IconicsSize.dp(24)) becomes Modifier.size(24.dp), and .color(IconicsColor.colorInt(c)) becomes the tint parameter. The dependency swap is from the *-typeface-library artifacts to androidx.compose.material:material-icons-extended.

The honest gap is coverage. The README states that icon sets without a first-party Compose equivalent, naming FontAwesome, Simple Icons and Phosphor, rely on community ImageVector ports. Those ports are not maintained by this project, so a migration plan that assumes a drop-in replacement for every glyph is a plan with an unverified dependency in it. For a fully custom set, the README suggests converting SVG sources with Android Studio's Vector Asset import instead of shipping a font. Teams still on Views get a shorter path: VectorDrawable plus app:tint is described as covering most of what IconicsImageView and friends provided.

## Maintenance status, release cadence and the Apache-2.0 licence

The repository is not archived, and the last push was on 2026-08-20, the same day v5.6.0 was tagged. The release history shows the cadence clearly: v5.5.0-b01 in May 2024, v5.5.0 in November 2025, v5.6.0 in August 2026. Roughly one release a year, which matches the README's statement that only critical and security fixes are planned. Upgrade cost is therefore low but also finite: you can pin a version and expect it to keep working, and you should not expect a fix for anything that is not a crash or a security issue.

The licence is Apache-2.0, which permits commercial and closed-source use and requires that you keep the licence and notice files. That is the standard reading of the text, not legal advice; if you vendor or modify the typeface modules, check your own notice obligations with whoever handles compliance. One thing the README does not document is a rollback path for the font artifacts, so pinning exact versions in your build is the practical safeguard.

## Conclusion

Adopt Android-Iconics only if you are maintaining an existing Views-based app that already depends on it and cannot move to Compose yet; the README explicitly says existing integrations do not need to move urgently because nothing is being shut off. Do not start a new Compose-only project on it, because the same README points new code at ImageVector and androidx.compose.material.icons and warns that no new icon fonts will be added. Before touching anything, verify three things against your own build: whether jetpack startup is enabled in your app, since the README warns fonts self-register through it and must be registered manually when it is disabled; whether any icon you depend on has a first-party or community ImageVector port, since FontAwesome, Simple Icons and Phosphor only have community ports according to the migration table; and whether the typeface artifact you use is a -kotlin build, because the README's font list is entirely -kotlin and the Compose migration examples are written in Kotlin.

## FAQ

### Is Android-Iconics deprecated?

Yes. The README states the library is in maintenance mode and deprecated: it still works and will receive critical and security fixes, but no new features and no new icon fonts will be added. It also says existing integrations do not need to move urgently because nothing is being shut off.

### How do I install Android-Iconics?

Add com.mikepenz:iconics-core plus androidx.appcompat:appcompat to your Gradle dependencies, then add one or more typeface artifacts such as com.mikepenz:google-material-typeface:4.0.0.3-kotlin@aar. The iconics-views dependency is optional and only needed for the View widgets.

### Why is my Android-Iconics icon showing as a blank box?

The README warns that the fonts use the jetpack startup library to register themselves automatically, and that if jetpack startup is disabled the fonts must be registered manually. A missing @aar suffix on a typeface artifact is the other common cause, since the README notes the type cannot be set through a version catalog entry.

### What should I use instead of Android-Iconics in Compose?

The README points to ImageVector with androidx.compose.material.icons, replacing the typeface artifacts with androidx.compose.material:material-icons-extended. It notes that FontAwesome, Simple Icons and Phosphor only have community ImageVector ports, and that a custom set can be converted from SVG with Android Studio's Vector Asset import.

### What licence does Android-Iconics use?

The repository is licensed under Apache-2.0, which allows commercial and closed-source use with the usual requirement to retain licence and notice files. This is a description of the licence, not legal advice.

## Sources

- [License: Apache-2.0](https://github.com/mikepenz/Android-Iconics/blob/develop/LICENSE)
- [mikepenz/Android-Iconics on GitHub](https://github.com/mikepenz/Android-Iconics)
- [Project website](https://mikepenz.dev)
- [README](https://github.com/mikepenz/Android-Iconics/blob/develop/README.md)
- [Releases](https://github.com/mikepenz/Android-Iconics/releases)

---

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