Library / SDK
iconify/iconify avatar
iconify/iconify

Iconify: one icon syntax across 200+ sets, with icon data loaded at runtime

Universal icon framework. One syntax for FontAwesome, Material Design Icons, DashIcons, Feather Icons, EmojiOne, Noto Emoji and many other open source icon sets (over 200 icon sets and ~300k icons). SVG framework, React, Vue and Svelte components!

6,409 stars209 forksTypeScriptMIT

At a glance

What is it?
Iconify is an MIT-licensed icon framework whose components render icons by name and fetch the SVG data from the Iconify API on demand, rather than bundling every icon. This article covers how that data flow works, where the web component and the React wrapper live, and where the API dependency becomes a real constraint.
Who is it for?
Adopt Iconify if you want one naming syntax across many open source icon sets and you accept that icon data arrives from the Iconify API at render time, which suits admin panels, editors and user-customisable interfaces where the icon list is not known ahead of time.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 1 day ago.
What is it written in?
Mainly TypeScript, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 21, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • iconify/iconify6,409 ★ · +78
Star history
Repository2026-09-232026-11-21
iconify/iconify6.3k6.4k

78 Stars in the last 59 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The problem Iconify solves is icon naming, not icon drawing

Most projects that use more than one icon set end up with two problems. The first is naming: FontAwesome, Material Design Icons, DashIcons, Feather Icons, EmojiOne and Noto Emoji each ship their own package, their own import path and their own component API, so switching sets means editing call sites. The second is bundle size: importing an icon package usually pulls in the whole set or requires per-icon imports that are easy to get wrong. Iconify's answer is a single naming syntax that addresses any of the sets it indexes. The README states the framework ships with 200+ icon sets and more than 250,000 icons, and the repository description puts the figure at roughly 300k icons across over 200 sets. That is the pitch: one component, one name format, any set.

The audience is front-end and design-tool users who need breadth. If you are building an application where users pick their own icons, or an editor where the icon list is decided at runtime, a fixed import list is the wrong shape. Iconify is aimed at that case, and the README says so directly: the API is useful "if you don't know what icons user will need, while offering thousands of icons to choose from." That sentence is also the honest boundary of the project, because it explains why the API exists at all.

Icon data is fetched by name, not bundled at build time

The mechanism is the part worth understanding before you install anything. Iconify icon components do not contain icon data. The README is explicit: "Unlike other icon components, Iconify icon components do not include icon data. Instead, icon data is loaded on demand from Iconify API." A component receives a name, resolves it against the API, and renders the returned SVG. During development you do not enumerate the icons you might use, and the component only loads the ones that actually render.

The API itself is described as hosted on publicly available servers spread out geographically, with redundancies in place. Two packages in this repository exist specifically to manage that redundancy. The `api-redundancy` package handles timeouts and rotates hosts so a request falls back if the main host is unreachable; the README marks it as due to be deprecated in favour of the `fetch` package, which is described as a fetch wrapper with built-in redundancy for using multiple hosts. `core` is likewise marked for replacement by `component-utils`. If you are reading the source to understand failure behaviour, read `fetch` and `component-utils`, not the older pair.

There is a second component family in the repository. The CSS components in `components-css` render SVG through CSS, which the README says Safari does not support, so those components check for feature support rather than browser identity and fall back to the API only for browsers that need it. The README labels this family as in development. Treat it as a different trade-off from the main components: less runtime fetching for most visitors, more moving parts.

Installing Iconify and rendering your first icon in HTML

The repository is a pnpm workspace, so the top-level `package.json` is for building the monorepo, not for consuming it. Its scripts run recursively across the `packages`, `iconify-icon`, `components`, `components-css` and `plugins` directories, and `packageManager` pins `[email protected]`. If you want to build the components from source rather than install published packages, the root scripts are the entry point:

json
"scripts": {
	"clean": "rm -rf node_modules */*/node_modules */*/lib */*/dist",
	"fmt": "pnpm recursive --workspace-concurrency=1 --filter \"./(packages|iconify-icon|components|components-css|plugins)/**\" run fmt",
	"lint": "pnpm recursive --workspace-concurrency=1 --filter \"./(packages|iconify-icon|components|components-css|plugins)/**\" run lint",
	"build": "pnpm recursive --workspace-concurrency=1 --filter \"./(packages|iconify-icon|components|components-css|plugins)/**\" run build",
	"test": "pnpm recursive --workspace-concurrency=1 --filter \"./(packages|iconify-icon|components|components-css|plugins)/**\" run test"
}

That is the exact block from the repository's `package.json`. The `build` script runs `pnpm recursive --workspace-concurrency=1` over those directories, so builds are serialised rather than parallel. Expect that to be slower than a typical monorepo build, and do not be surprised when a failure in one package stops the rest.

For actual use, the README points at the web component in `iconify-icon/icon/`, described as usable "Everywhere". Check the package directory for the published name before running anything. The README says the components render icons by name and load the data from the Iconify API.

What you should see is an SVG rendered in place of the tag. The data for that name is not in your bundle; it is requested from the Iconify API when the element renders.

Using Iconify in React, and the Nuxt custom element config

React is listed as working with the web component, but with small differences. The web component works with React, but with differences such as `class` instead of `className`, and the wrapper fixes that and provides types. The package is `iconify-icon/react`. Confirm the export name in that directory before writing code against it.

Vue 2 and Vue 3 are listed as confirmed to work with the web component without a custom wrapper, with one exception: Nuxt needs configuration. Without it, the README says Nuxt 3 shows warnings in dev mode because it does not recognise the custom element. The README prints the fix as a `nuxt.config.ts` file:

ts
export default defineNuxtConfig({
	vue: {
		compilerOptions: {
			isCustomElement: (tag) => tag === 'iconify-icon',
		},
	},
});

The README notes this change is not needed when using Vue with `@vitejs/plugin-vue`. Svelte, Lit and Ember are listed as working with web components without custom wrappers. The repository also carries demos under `iconify-icon-demo/` for React, Next.js, Svelte with Vite, Vue 3, Nuxt 3 and SolidJS; the README states that each is started with `npm run dev`. Those demos are the fastest way to see the intended integration for your framework, and they are in-tree, so you can read them without leaving the repository.

The API dependency is the limitation, and the README does not hide it

The README states the constraint plainly: Iconify icon components "do not work without API." That is not a footnote. Every icon rendered by the main components is a network request to a third-party host, and the redundancy packages exist because that host can be slow or unreachable. If you are building something that must render identically offline, behind an air-gapped network, or inside a native app with no browser fetch, the primary component family is the wrong tool.

The README points elsewhere for data: the `iconify/icon-sets` repository holds the icon data, and `iconify/tools` holds the parsing and generation tools. Those repositories are named as places to look, not as a documented drop-in replacement for the API in a browser component. If your requirement is "no runtime third-party requests", treat that as an open question to resolve before committing, not as a supported configuration.

There is a second, quieter cost. Because icons are resolved by name at render time, a typo in an icon name is not a compile error. It is a request that returns nothing. Any codebase using Iconify at scale needs its own check that the names it references exist.

How Iconify differs from importing an icon package directly

The obvious alternative is to import icons from the source packages themselves: pull SVG files or components from the icon set's own package for your framework, and let your bundler include exactly what you import. The difference is not quality, it is where the data lives and when it is resolved. Direct imports put icon data in your bundle at build time. Nothing is fetched at runtime, nothing depends on an external host, and a missing icon fails at build time. The cost is that every icon you might ever show has to be imported somewhere, and switching icon sets means changing imports and component APIs.

Iconify inverts that. The data stays out of your bundle and is resolved by name at runtime, which is what makes "over 200 icon sets" usable in one project without shipping all of them. The price is the API dependency and the loss of build-time checking. Neither approach is strictly better; they fail in opposite directions. If your icon set is fixed and small, direct imports are simpler and have no runtime dependency. If your icon set is large, user-selected, or spans multiple libraries, Iconify's model is the one that scales without a bundle blow-up.

Iconify also spans a second surface the direct-import route does not: the README lists plug-ins for Figma, Sketch and Adobe XD, and an Icon Finder for adding icon search to applications. Those live outside this repository, but they are part of the same naming model.

Maintenance, licence and what a version bump costs you

The repository is not archived, and the last push was on 2026-11-02. The top-level `package.json` shows a modern toolchain: `typescript` ^6.0.3, `vite` ^8.3.4, `vitest` ^5.0.5, `oxlint` ^1.89.0 and `tsdown` ^0.23.1, with `pnpm` as the package manager. There is a `renovate.json` at the root, which indicates dependency updates are automated. The repository has no published GitHub releases, so there is no version history to reason about here.

The licence is MIT, declared in `package.json` and present as `license.txt` at the repository root. MIT is permissive: it allows commercial and closed-source use with attribution and without a copyleft obligation on your own code. That applies to the code in this repository. It does not automatically settle the licence of the icon artwork, which comes from the individual icon sets indexed by the framework; if you are shipping icons in a product, check the terms of the specific sets you render. This is not legal advice.

Upgrade cost has a specific shape here. Because icons are addressed by name and fetched at runtime, the icon sets behind those names can change without any change to your dependencies. A set can add icons, rename them or drop them, and your code will not know until a name stops resolving. The parts you pin are the components and the utility packages. The parts you do not pin are the names themselves.

Editorial conclusion

Adopt Iconify if you want one naming syntax across many open source icon sets and you accept that icon data arrives from the Iconify API at render time, which suits admin panels, editors and user-customisable interfaces where the icon list is not known ahead of time. Do not adopt it as your only icon path if your product must render correctly with no network access to that API, or if you need a documented offline or self-hosted data path, because the README describes the API as the source of icon data. Verify first that the wrapper package you intend to use actually exists for your framework: the README confirms React and SolidJS wrappers and lists Svelte, Lit, Ember and Vue as working with the web component without one.

Frequently asked questions

What does Iconify do?

It is a unified icon framework: one syntax for FontAwesome, Material Design Icons, DashIcons, Feather Icons, EmojiOne, Noto Emoji and many other sets, with components for HTML, React and other front-end frameworks. The components render icons by name and load the icon data on demand from the Iconify API rather than bundling it.

Is Iconify free to use?

The repository is MIT licensed, declared in package.json and included as license.txt at the root, which permits commercial and closed-source use with attribution. Check the licences of the individual icon sets separately for the sets you render.

How do I use Iconify in HTML?

The README points to the iconify-icon web component, which it describes as usable everywhere, and says the components render icons by name. The SVG data for that name is requested from the Iconify API when the element renders.

How do I use Iconify in React?

The README says React works with the web component but with differences such as class instead of className, and that the wrapper at iconify-icon/react fixes this and provides types. Confirm the export name in that package directory before writing code against it.

How do I install Iconify?

The repository is a pnpm workspace, so the root package.json exposes clean, fmt, lint, build and test scripts that run recursively across the packages, iconify-icon, components, components-css and plugins directories. For consuming the components in an application, use the published package for your framework.

How do I install Iconify in React?

The README lists a React wrapper in the iconify-icon directory, which fixes the differences between the web component and React conventions and provides types. Check that package directory for the published name and exports.

Official sources

  1. iconify/iconify on GitHub
  2. Issues
  3. License: MIT
  4. Project website
  5. README
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/iconify-iconify.svg)](https://hysenlabs.com/projects/iconify-iconify)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/iconify-iconify.svg)](https://hysenlabs.com/projects/iconify-iconify)

Was this useful?