iconflow

Enable at least one pack feature so the fonts and icon data are included.

[dependencies]
iconflow = { version = "2.1", features = ["all-packs"] }

See docs/quickstart.md for a fast end-to-end setup guide and API overview.

• fonts() returns the enabled font assets for registered packs.
• try_icon(pack, name, style, size) resolves an icon reference or returns IconError.
• resolve_all(pack, style, size) resolves every icon in a pack in list order (picker cold path).
• list(pack) returns the icon names for a pack.

Register every FontAsset in egui::FontDefinitions, then render IconRef.codepoint with FontFamily::Name(icon.family):

use eframe::egui::{self, FontData, FontDefinitions, FontFamily, FontId, RichText};
use iconflow::{fonts, try_icon, Pack, Size, Style};
use std::sync::Arc;

fn install_icon_fonts(ctx: &egui::Context) {
    let mut definitions = FontDefinitions::default();
    let fallback_fonts: Vec<String> = definitions.font_data.keys().cloned().collect();

    for font in fonts() {
        definitions.font_data.insert(
            font.family.to_string(),
            Arc::new(FontData::from_static(font.bytes)),
        );
        let family = definitions
            .families
            .entry(FontFamily::Name(font.family.into()))
            .or_default();
        family.insert(0, font.family.to_string());
        for fallback in &fallback_fonts {
            if fallback != font.family {
                family.push(fallback.clone());
            }
        }
    }

    ctx.set_fonts(definitions);
}

fn icon_label(ui: &mut egui::Ui) {
    let samples = [
        (Pack::Bootstrap, "alarm", Style::Regular, Size::Regular),
        (Pack::Bootstrap, "alarm", Style::Filled, Size::Regular),
        (Pack::Heroicons, "academic-cap", Style::Filled, Size::Regular),
    ];

    for (pack, name, style, size) in samples {
        let icon = try_icon(pack, name, style, size).expect("icon missing");
        let glyph = char::from_u32(icon.codepoint).unwrap_or('?');
        let font_id = FontId::new(32.0, FontFamily::Name(icon.family.into()));

        ui.label(RichText::new(glyph.to_string()).font(font_id));
    }
}

Runnable example: cargo run --example egui_demo --features all-packs

In iced 0.14, fonts are loaded asynchronously via Task. Load the bytes from fonts() and render a glyph with Font::with_name once loading completes.

use iced::{Task, font};
use iced::widget::text;
use iconflow::{fonts, try_icon, Pack, Size, Style};

#[derive(Debug, Clone)]
enum Message {
    FontLoaded(Result<(), font::Error>),
}

fn load_all_fonts() -> Task<Message> {
    Task::batch(fonts().iter().map(|font| {
        font::load(font.bytes).map(Message::FontLoaded)
    }))
}

fn icon_text() -> iced::widget::Text<'static> {
    let icon = try_icon(Pack::Bootstrap, "alarm", Style::Regular, Size::Regular)
        .expect("icon missing");
    let glyph = char::from_u32(icon.codepoint).unwrap_or('?');
    text(glyph.to_string())
        .size(48)
        .font(iced::font::Font::with_name(icon.family))
}

Runnable example: cargo run --example iced_demo --features all-packs

Example READMEs: examples/v2.0/egui_demo/README.md, examples/v2.0/iced_demo/README.md. Historical 1.0 demos (do not build on 2.x): docs/historical/v1.0/.

See docs/faq.md.

• cargo xtask gen regenerates src/generated/** from assets/maps/*.json.
• cargo xtask gen --check verifies generated output without writing files.

iconflow includes icon fonts from 14 open-source icon packs. All fonts are distributed under permissive licenses (MIT, Apache-2.0, or ISC).

Granularity is per pack: enabling a feature embeds that pack’s TTF(s). There is no per-icon subsetting yet — enable only the packs you need. Unused include_bytes! fonts can still be dropped by the linker if nothing calls fonts() / resolve paths that reference them; worst case is the full enabled set below.

Font MiB = sum of TTFs under assets/fonts/<pack>/ (measured on disk). Icon counts are generated ICON_NAMES lengths.

Total: 34 TTF files · ~15.0 MiB fonts on disk · 27 024 icon names across 14 packs (all-packs).

Some packs (notably Devicon and Lobe Icons) include glyphs that depict third-party brand marks. Upstream licenses cover the font/SVG artwork; they do not grant trademark rights to those brands. Using a logo glyph in a product UI may still require permission from the mark owner — treat brand icons as a separate compliance question from MIT/Apache/ISC.

iconflow is built on top of these excellent open-source icon libraries. We are grateful to all the contributors and maintainers of these projects:

• Bootstrap Icons by Bootstrap team
• Carbon Icons by IBM Carbon Design System
• Devicon by Devicon and contributors
• Feather Icons by Cole Bemis and contributors
• Fluent UI System Icons by Microsoft
• Heroicons by Tailwind Labs
• Iconoir by Luca Burgio and contributors
• Ionicons by Ionic team
• Lobe Icons by LobeHub
• Lucide by Lucide contributors
• Octicons by GitHub (Primer)
• Phosphor Icons by Phosphor Icons team
• Remix Icon by Remix Design
• Tabler Icons by codecalm and contributors

All icon fonts are converted from their original SVG sources and embedded as TTF files in this project. The fonts are included in the crate binary when corresponding feature flags are enabled.

This project is licensed under MIT License.

Third-party dependencies and fonts have their own licenses. See:

• THIRD_PARTY_LICENSES_CRATES.html for Rust crate licenses
• THIRD_PARTY_LICENSES_FONTS.md for font licenses