Skip to content
GlyphPact
Menu

GlyphPact v1.1.0

Compile SVG icon packs for Flutter without moving codepoints

Your icon codepoints should never move. Compile a directory of SVG files into a validated OpenType font, a committed codepoint lock, and const Flutter IconData. Existing icons keep their codepoints when the pack changes.

uv tool install glyphpact

Installs the latest stable release from PyPI, currently v1.1.0. Already installed? Run uv tool upgrade glyphpact. Release notes.

Convert an SVG folderHow the lock worksRead the source
  • Python 3.10+
  • Runs locally
  • MIT licensed
  • No Node toolchain
The glyph for arrows/back.svg on its em square, bound to codepoint U+E000 A left-pointing arrow drawn as a filled outline inside a measured em square, with registration marks at the corners and control points on the outline's vertices. A plate below the square reads U+E000 and marks the assignment as locked.arrows/back.svgU+E000LOCKED

What it produces

A universal core with a Flutter binding on top

Worth being precise about, because it decides whether GlyphPact fits your project. Two of the three outputs are framework-neutral. The third is Dart-specific, and there is no generated binding for any other platform.

Universal artifacts

Usable from any language

  • A validated OpenType/CFF font, reopened and checked after build against cmap, bounds, metrics, checksums, and required tables
  • iconfont.lock.json, a documented JSON registry mapping every source file to its permanent codepoint
  • A deterministic machine-readable build report
Flutter binding

Dart-specific, and only Dart

  • A const IconData provider class, annotated@staticIconProvider
  • Dart-shaped flags: --class-name,--font-package
  • No generated CSS, WOFF2, React, Android, or JavaScript output

So can you use it outside Flutter? The font and the lock file, yes. The high-level binding, no. A non-Flutter project reads codepoints from the lock file and writes its own integration layer. Turning the font into a web icon set means converting it and authoring the CSS yourself, because GlyphPact does neither.

The problem

Three ways generated icon fonts go wrong quietly

None of these fail loudly at build time. That is what makes them expensive: each one ships.

DriftCodepoints shift

Add an icon whose filename sorts early and every later assignment moves up one. The font is still internally consistent, so nothing errors. Your existing AppIcons.back constant now points at whatever landed on that codepoint instead, and renders a different picture.

SilenceFidelity loss goes unreported

An icon font glyph holds monochrome coverage, not RGB and not partial alpha. A generator without a stated policy can flatten a half-transparent fill or ignore a blur, and simply not mention it. You find out from a design review, not from the build.

StalenessCommitted output stops matching its sources

Someone edits an SVG and forgets to regenerate, or regenerates and forgets to commit. The generated font and Dart file are now a snapshot of an older pack, and no test in the repository can tell.

The answer

The lock file is the codepoint ABI

GlyphPact writes iconfont.lock.json into the output tree and reads it back on every later build. An assignment already recorded there is reused verbatim. Only genuinely new sources draw new codepoints.

iconfont.lock.jsongit diff, after adding four icons
--- a/lib/generated/app_icons/iconfont.lock.json+++ b/lib/generated/app_icons/iconfont.lock.json@@ -9,6 +9,30 @@   "unitsPerEm": 1000,   "glyphs": [     {+      "source": "actions/add.svg",+      "name": "actionsAdd",+      "codepoint": "0xE002",+      "sourceSha256": "a169819fd451...",+      "matchTextDirection": false,+      "geometrySha256": "2025c5f8dff2..."+    },+    {+      "source": "arrows/arrow_down.svg",+      "name": "arrowsArrowDown",+      "codepoint": "0xE004",+      "sourceSha256": "b6e87581e2f2...",+      "matchTextDirection": false,+      "geometrySha256": "48a927141186..."+    },+    {       "source": "arrows/back.svg",       "name": "back",       "codepoint": "0xE000",       "sourceSha256": "38121f4ed8a1...",       "matchTextDirection": true,     },     {       "source": "status/verified.svg",       "name": "verified",       "codepoint": "0xE001",     },+    {+      "source": "status/warning.svg",+      "name": "statusWarning",+      "codepoint": "0xE005",+    }   ],   "retired": []
+ addedunchanged assignment
A real diff after adding four icons to a two-icon pack. actions/add.svg now sorts before everything else, yet it took 0xE002 rather than 0xE000, and arrows/back.svg kept the 0xE000 it already had. Every line in this diff is an addition: not one existing assignment was modified.

What the lock guarantees

  • Adding or reordering source files never changes existing codepoints.
  • Removing an icon leaves a tombstone in retired rather than freeing its codepoint for reuse.
  • Restoring a removed icon reactivates its original slot.
  • A unique content-preserving rename keeps both its codepoint and its generated Dart name.
  • Identical inputs, config, lock, and compiler version produce byte-identical artifacts, across any worker count.

Tombstones are permanent on purpose. Deleteactions/archive.svg and its codepoint0xE003 moves toretired, leaving a gap in the active sequence. Recycling it would be the exact bug the lock exists to prevent: a codepoint that already shipped, pointing at a new picture.

Why codepoints move in the first place, in detail

The workflow

Three commands, all of them local

  1. Install the compiler

    A single Python command-line tool. There is no website step, no project file to keep in a browser, and no server that receives your artwork.

    uv tool install glyphpact

  2. Compile the pack

    Sources are discovered recursively and compiled with bounded worker processes. GlyphPact owns the output directory and refuses to overwrite a non-empty directory that lacks its ownership marker.

    bash
    glyphpact assets/icons \
  --output lib/generated/app_icons \
  --name AppIcons

  3. Commit the output, then let CI defend it

    Commit the font, the lock, the report, the attribution file, and the generated Dart. Then have CI rebuild a candidate set and compare, without rewriting anything. Exit code3 means the committed artifacts are stale.

    bashexit 3 = stale
    glyphpact --config icon_font.json --check
    Exit codes
    CodeMeaning
    0Build or check succeeded
    1Unexpected internal failure
    2Config, input, policy, geometry, or font contract failed
    3--check found stale committed output

Generated output

Everything it writes, and who owns it

The whole output is plain files you can read, diff, and review. Nothing is hidden in a cache or a binary project format.

lib/generated/app_icons/
fonts/AppIcons.otfframework-neutral Validated OpenType/CFF font. Framework-neutral.
iconfont.lock.jsonframework-neutral Codepoint registry and provenance. Schema version 1. Commit this.
app_icons.dartFlutter only const Flutter IconData provider and optional name-keyed catalog. Dart-specific.
layer_fonts/layer_*.otfframework-neutral Optional solid-alpha paint-order layers, for icons that opt in.
iconfont.report.jsonbuild metadata Deterministic build report and stable code-generation input. Schema version 3.
ATTRIBUTION.mdbuild metadata Declared artwork authorship, licences, and unattributed count.
.glyphpact.jsonbuild metadata Ownership marker. GlyphPact refuses to overwrite a directory without it.
../.app_icons.glyphpact.lockPublication coordination file. A sibling of the output directory, not part of the owned tree. Leave it in place and ignore it in version control.

Fidelity policy

Unsupported SVG is classified, not guessed

A normal icon-font glyph stores monochrome alpha coverage, and Flutter supplies the colour at runtime. So source RGB is irrelevant, but surviving partial transparency and features like filters genuinely have nowhere to go. GlyphPact decides that with two independent policies rather than a heuristic.

Both axes default to error. Each axis is independent, so the four combinations are all reachable.
--unrepresentable error--unrepresentable skip
--lossy errorLossless onlydefaultAnything that would be approximated or omitted fails the build instead. This is the default.Omissions allowedSources outside the profile are dropped and reported. Anything that would be approximated still fails.
--lossy convertDocumented approximations allowedDeterministic approximations are emitted and reported. Sources with no faithful conversion still fail.Approximations and omissions allowedBoth are permitted, and every one is reported as a typed issue.

The same three icons, under both policies

back.svg is a plain filled path. ghost.svgcarries an opacity=".5" that survives to the final coverage.blurred.svg applies an feGaussianBlur, which a monochrome outline cannot represent at all.

exit 2Default: strict

glyphpact icons -o out -n AppIcons
[SVG_ATTRIBUTE_UNREPRESENTABLE] blurred.svg: Attribute 'filter' has no supported static monochrome conversion.
[SVG_ELEMENT_UNREPRESENTABLE] blurred.svg: <filter> has no supported static monochrome outline conversion.
[SVG_PARTIAL_ALPHA_APPROXIMATED] ghost.svg: Surviving fractional alpha was flattened to opaque coverage.

Nothing is published. The previous valid output is left untouched.

exit 0Explicitly permissive

... --lossy convert --unrepresentable skip
Built 2 of 3 discovered icon(s): 1 lossless, 1 approximated, 1 skipped.
[SVG_ATTRIBUTE_UNREPRESENTABLE] blurred.svg: Attribute 'filter' has no supported static monochrome conversion. (unrepresentable, skipped)
[SVG_PARTIAL_ALPHA_APPROXIMATED] ghost.svg: Surviving fractional alpha was flattened to opaque coverage. (lossy, converted)

Every deviation is a typed record in the JSON result and the report, with a code, a classification, an action, and the feature responsible.

--unrepresentable skip is not an error-suppression switch. These stay fatal under every policy: scripts and event handlers, external references, malformed or non-finite values, unknown semantics, exhausted work limits, compiler or font-contract failures. And if every source would be skipped, the build fails and publishes nothing rather than shipping an empty font. A failed build never replaces the last valid output.

The complete versioned SVG profile documents every classification.

Flutter

The generated Dart is ordinary, const, and reviewable

Register the font

Asset paths are relative to pubspec.yaml. This step is yours: GlyphPact writes the font, it does not edit your pubspec.

pubspec.yaml
flutter:
  fonts:
    - family: AppIcons
      fonts:
        - asset: lib/generated/app_icons/fonts/AppIcons.otf

Use the constants

Generated IconData carries no label, so supply a localized semanticLabel, or exclude decorative icons from semantics.

dart
import 'package:my_app/generated/app_icons/app_icons.dart';

Icon(
  AppIcons.back,
  semanticLabel: 'Back',
)

What the generator actually emits

lib/generated/app_icons/app_icons.dart
// GENERATED CODE - DO NOT MODIFY BY HAND.
// Generated by GlyphPact 1.1.0.

import 'package:flutter/widgets.dart' as flutter;

@flutter.staticIconProvider
abstract final class AppIcons {
  static const String _fontFamily = 'AppIcons';
  static const String? _fontPackage = null;

  /// Source: arrows/back.svg
  /// License: MIT
  static const flutter.IconData back = flutter.IconData(
    0xE000,
    fontFamily: _fontFamily,
    fontPackage: _fontPackage,
    matchTextDirection: true,
  );
}

Font packages, layered icons, tree shaking, and CI for Flutter projects

Agent workflows

Use GlyphPact from the coding agent you already run

Claude Code and Codex can install the full plugin. Antigravity, Cursor, JetBrains, VS Code, Zed, Windsurf, Gemini CLI, and other local stdio clients can run the MCP server directly from PyPI.

read onlyaudit_icon_pack

Audit a file or directory once, then page a stable local snapshot of the findings instead of recompiling.

writesbuild_icon_font

Build the output declared by a checked-in config.

writescheck_icon_font

Check committed output for staleness without rewriting generated artifacts.

read onlyread_icon_report

Page through large machine-readable reports.

Claude Code
claude plugin marketplace add omar-hanafy/glyphpact
claude plugin install glyphpact@glyphpact
Codex
codex plugin marketplace add omar-hanafy/glyphpact
codex plugin add glyphpact@glyphpact

Plugin and manual MCP installation, prompts, tools, and safety boundaries

Built for repeated updates

Built for icon packs that keep changing

Convert an SVG folder to Flutter icons

Discover nested files, audit the pack, and generate the font, Dart provider, lock, and report locally.

Add icon batches without changing IconData

Move from 3 icons to 5, 10, and 100 while every existing assignment remains fixed.

Investigate SVGs that render incorrectly

See a reproducible FlutterIcon.com comparison with the exact SVG sources and generated fonts.

Alternatives

Where GlyphPact fits, and where it does not

GlyphPact is narrow on purpose. It has no icon browser, no bundled icon packs, and no web output. If you want a web icon font with a stylesheet today, three of the tools below already do that and it does not.

Capabilities relevant to a repository-driven icon pipeline.
GlyphPactLocal CLI compilerIcoMoonOffline-first browser appFlutterIcon.comHosted Fontello forkicon_font_generatorDart CLIFantasticonNode CLI
Existing codepoints survive a pack changeIf an assignment moves, shipped application code renders the wrong glyph.Supported: Committed lock file`iconfont.lock.json` is generated into the output tree and read on every later build. Removed icons leave a tombstone in `retired` instead of freeing the codepoint.Conditional: Project file plus matching-name replacementThe current app stores its project in `icomoon.json`. Its Replace by Matching Names workflow can update matching glyphs without changing their metadata. Stability depends on retaining the project and using that workflow correctly.Conditional: If you re-import config.jsonInherits the Fontello session model, where the downloaded `config.json` records each glyph code and can be imported again. Stability depends on retaining and re-importing that file.Not documented: No documented mechanismNeither the pub.dev page nor the README documents a lock file or persistence mechanism. Published examples show codepoints running sequentially from `0xe000` in glyph order.Manual: Hand-pinned in configA `codepoints` map in the config assigns fixed values, so stability is achievable. The map is maintained by hand rather than generated and updated by the tool.
CI can prove committed output is currentGenerated artifacts drift from sources silently unless something fails the build.Supported: `--check` exits 3 when staleRebuilds a candidate artifact set and compares it without rewriting the owned output tree. Verified: exit 0 on current output, exit 3 after a source edit.Not documented: No documented repository staleness checkCurrent first-party documentation describes an offline-first browser app, project files, and exports. It does not document a command that compares committed output with sources and fails CI when they differ.Not supported: No first-party staleness checkThe third-party `fontello-cli` can install a config against a host, but neither it nor the site offers a check that fails on stale committed output.Not supported: Not offeredThe CLI generates output. No check or verify mode is documented.Not supported: Not offeredNo check or verify mode is documented.
Runs entirely on your machineUnreleased or licensed artwork often cannot leave the building.Supported: Local CLI, no network stepA Python command-line compiler. No website step, no project service, no server that receives artwork.Supported: Offline-first PWAThe current app is documented as an offline-first progressive web app. Imported files and generated assets are processed locally unless the user opts into account-backed project storage.Not supported: Hosted service sessionA hosted web application in the Fontello lineage, where the font configuration is posted to the service and held in a server-side session.Supported: Local CLIRuns locally. Described as written fully in Dart with no external dependency.Supported: Local CLIRuns locally on Node.
Byte-identical rebuildsNon-reproducible artifacts turn every rebuild into an unreviewable diff.Supported: Same bytes across worker countsSame inputs, config, lock, and compiler version produce byte-identical artifacts. Verified: identical SHA-256 across default, 1, and 4 worker processes.Not documented: Not documentedNot documented: Not documentedNot documented: Not documentedNot documented: Not documented
Explicit policy for SVG a font cannot holdAn icon font stores monochrome coverage. Something has to decide what happens to a blur or a half-transparent fill.Supported: Two policy axes, both strict by default`lossy` and `unrepresentable` each default to `error`. Approximations and omissions require explicit opt-in and are reported as typed, coded issues.Not documented: Import support, no typed build policyThe current app documents broader import support, including strokes and even-odd geometry without manual conversion. It does not publish GlyphPact-style lossless, lossy, and unrepresentable build outcomes with coded report entries.Not documented: No published policyNot documented: No published policyExposes `--[no-]normalize` and `--[no-]ignore-shapes` flags, but documents no classification of unsupported input.Not documented: No published policy
Generates a Flutter IconData APIHand-written IconData constants are the place codepoint drift actually bites.Supported: Const provider plus optional catalogEmits a tree-shakeable `@staticIconProvider` class, optional same-file name-keyed enumeration, `fontPackage` handling, and layered-icon widgets.Supported: Dart class for FlutterThe current IcoMoon app exports a Dart class for Flutter.Supported: Dart icon classPurpose-built for Flutter: exports a font plus a Dart icon class.Supported: Dart icon classGenerates an OTF font and a Flutter-compatible class.Not supported: Web asset types onlyGenerates CSS, SCSS, SASS, HTML, JSON, and TypeScript. No Dart or Flutter output.
Web assets: WOFF2 and CSSThe honest place GlyphPact is behind. If you need a web icon font today, these tools already do it.Not supported: OpenType/CFF onlyEmits a `.otf` font and the lock registry. No WOFF, no WOFF2, no generated CSS. Web use means converting the font and writing the CSS yourself.Supported: Fonts plus CSSDocumented export targets include a web font pack and further asset types.Supported: Web font packFontello lineage produces web font formats alongside the Flutter output.Not supported: OTF onlySupported: WOFF2, WOFF, TTF, EOT, SVG, CSSDocumented font formats are EOT, WOFF2, WOFF, TTF, and SVG, with CSS, SCSS, SASS, HTML, JSON, and TS asset types.
Generates an attribution recordThird-party icon licences usually require attribution, and audits ask for it.Supported: `ATTRIBUTION.md` per buildCarries declared author, licence, and source URL per glyph, and counts emitted icons with no declared provenance. It does not verify ownership.Not documented: Not documentedConditional: Bundled-pack licencesShips licence information for the open-source packs it bundles. Not an attribution file generated from your own artwork metadata.Not supported: Not offeredNot supported: Not offered
Required runtimeA toolchain you do not already run is a toolchain you have to maintain.Supported: Python 3.10+Dart 3+ only to consume the generated provider.Supported: A browserSupported: A browserOptional third-party CLI needs Node.Supported: DartSupported: Node 16+
Coding-agent integrationIcon work is increasingly delegated, and an agent needs typed results rather than screenshots.Supported: Local stdio MCP serverClaude Code and Codex can install the full plugin. Other stdio MCP clients can configure the published server directly. It exposes four tools plus the config, report, and inner CLI-result schemas.Not supported: Not offeredNot supported: Not offeredNot supported: Not offeredNot supported: Not offered
Verified on 2026-07-27.Checked against current first-party documentation and, for GlyphPact, against observed output. Sources:GlyphPact README, SVG profile; IcoMoon IcoMoon docs, Flutter and Dart update; FlutterIcon.com FlutterIcon, polyicon source, Fontello API; icon_font_generator pub.dev page, Source; Fantasticon README.Behaviour changes. If a cell has gone out of date, it is worth reporting.

FAQ

Common questions

Why do icon-font codepoints change when icons are added?

A generator that derives codepoints from the current source list can shift assignments when the list changes. Insert an icon whose name sorts early, rename a file, or start a new browser import without restoring the previous project, and every icon after that point can move.

The font itself is then internally consistent, so nothing fails at build time. The breakage appears in application code that still refers to the old value: a constant for a back arrow keeps pointing at U+E001 while U+E001 now contains a different glyph. The icon renders, it is simply the wrong picture.

How does GlyphPact keep existing codepoints stable?

GlyphPact writes a lock file, iconfont.lock.json, into the generated output directory and reads it back on every later build. Each entry records the source path, the Dart name, the assigned codepoint, and content hashes. An assignment already in the lock is reused as-is; only genuinely new sources draw new codepoints from the end of the allocated range.

Removing an icon does not free its codepoint. The entry moves to a "retired" list in the same file, leaving a permanent tombstone so the value is never handed to a different picture. Restoring the source later reactivates the original slot, and a unique content-preserving rename keeps both its codepoint and its generated Dart name.

How the lock file works

Should iconfont.lock.json be committed to Git?

Yes. The lock file is the codepoint ABI for the generated font, and it only protects existing assignments if the next build can read the same file the previous build wrote. Committing it alongside the generated font, Dart provider, report, and attribution file is the intended workflow.

If the lock is deleted or lost, the next build has no record of prior assignments and will allocate codepoints from scratch, which can reassign icons even when no source file changed.

How can CI detect stale generated icon output?

Run the same GlyphPact build with the --check flag: glyphpact --config icon_font.json --check. It rebuilds a candidate artifact set from the current sources and compares it against the committed output without rewriting the owned output directory.

Exit code 0 means the committed artifacts are current, and exit code 3 means they are stale, which fails the job. Adding --json produces a stable machine-readable result at schema version 2 so a workflow can inspect glyph counts, the active policy, and typed issues rather than treating every successful run as equivalent.

CI setup for Flutter projects

Does GlyphPact work offline?

Yes. GlyphPact is a command-line compiler that runs locally. Compiling a pack involves no network access: there is no website step, no project service, and no server that receives your artwork. Installation itself needs the network once, to fetch the package.

Does GlyphPact upload my SVG files anywhere?

No. Source SVGs are read from disk and all compilation happens in the local process. Nothing is transmitted, so unreleased or licence-restricted artwork never leaves the machine or the build runner.

Can I use the generated font outside Flutter?

Partly, and the boundary is worth stating precisely. The compiled OpenType/CFF font, the lock registry, and iconfont.report.json are framework-neutral. Report schema v3 records every emitted glyph name and codepoint plus the font family, file, hashes, layered metadata, and remaining allocation capacity, so it is the stable lower-level input for another language's generator.

The generated high-level binding is Dart-specific: it contains const Flutter IconData values and, when enabled, a name-keyed catalog companion. GlyphPact does not generate a ready-made web, React, Android, or JavaScript binding.

A non-Flutter project can consume the font and generate its own integration from the report. That custom output must live outside GlyphPact's owned output directory and needs its own drift check.

Does GlyphPact generate CSS or WOFF2?

No. GlyphPact emits an OpenType/CFF .otf font, the lock registry, a machine-readable report, an attribution file, and a Dart provider. It does not produce WOFF, WOFF2, or any stylesheet, and it has no browser integration.

Using the font on the web is possible but manual: convert the .otf to WOFF2 with a separate tool and write the @font-face rule and class names yourself. Active glyph names and codepoints can be read from iconfont.report.json. If a turnkey web icon-font pipeline is what you need, a web-first generator is the better fit today.

What happens when an SVG contains features an icon font cannot represent?

The source is classified rather than silently approximated. An icon-font glyph stores monochrome alpha coverage, so features like a Gaussian blur filter or surviving fractional transparency have no faithful representation in it.

GlyphPact sorts each source into one of three outcomes. Lossless sources are normalized and emitted automatically. Deterministically approximable sources are emitted only when the lossy policy is set to convert, and are reported as a typed lossy issue. Sources with no faithful conversion are omitted only when the unrepresentable policy is set to skip, and are reported as a typed unrepresentable issue.

Both policies default to error, so by default an affected build fails and prints the diagnostic code, the file, and the feature instead of shipping a wrong-looking icon. Malformed, unsafe, or unknown input, and exhausted resource limits, always fail regardless of policy.

The versioned SVG profile

Is GlyphPact an IcoMoon alternative?

Yes, when the requirement is a repository-managed Flutter icon pipeline. Both tools import SVG folders, run locally or offline, and can generate Flutter output.

IcoMoon is stronger for visual editing, bundled libraries, and broad output formats. Its current app exports a Dart class for Flutter, imports files and folders, and can replace glyphs by matching names while retaining their metadata.

GlyphPact is different at the build boundary. It provides a first-party local compiler, a committed codepoint lock with permanent tombstones, typed SVG audit results, byte-identical rebuilds, and a --check command that fails CI when generated output is stale.

Full IcoMoon comparison

Can GlyphPact convert a folder of SVGs to Flutter IconData?

Yes. Point the GlyphPact CLI at an SVG directory and choose an output directory and class name. One build emits an OpenType/CFF icon font, a const Flutter IconData provider, iconfont.lock.json, iconfont.report.json, and ATTRIBUTION.md.

The generated output is meant to be committed. Later builds reuse the lock so adding another SVG batch does not renumber existing IconData constants.

Bulk SVG workflow

Can Flutter code enumerate every generated icon by name?

Yes. Set catalog to true in the checked-in GlyphPact config. The existing generated Dart file then includes a separate AppIconsCatalog companion whose static const byName map contains every emitted IconData in ascending codepoint order. Packs with partial-alpha icons also receive layeredByName for their lossless layered descriptors.

The config switch alone does not enlarge a release. If the catalog is unreachable, Flutter removes it and subsets the font from the individual provider constants the app uses. Reachable byName retains every base glyph, while reachable layeredByName retains those icons' fallbacks and layer-font glyphs. A catalog referenced only from tests has no release cost.

For another collection shape, order, variable name, or language, use report schema v3 as a build-time input. Report codepoints are 0x... strings, and codepointsRemaining plus rangeUtilization expose the current allocation headroom. Generated Dart should reference the reported provider constants rather than constructing IconData dynamically, and custom generated files must stay outside GlyphPact's owned output directory.

Flutter integration details

Which coding agents can use the GlyphPact MCP server?

Any client that can start a local stdio MCP server can use GlyphPact. The documented setups cover Claude Code, Codex, Antigravity, Cursor, JetBrains AI Assistant, VS Code, Zed, Windsurf, and Gemini CLI. Clients use different JSON keys, TOML sections, and config locations, but each one launches the same published glyphpact-mcp process.

The server has four tools: audit an SVG file or directory and page a stable local findings snapshot, build the output declared by a config, check generated output for staleness without rewriting the artifact set, and page a published report. It also exposes the config, report, and inner CLI-result JSON Schemas as MCP resources.

MCP installation and tool reference

Keep reading

Read next

Stable codepointsAdd new SVGs to a Flutter icon font without renumbering existing IconData. See how a committed lock handles growth from 3 icons to 5, 10, and 100.FlutterWire a generated OpenType icon font into Flutter with pubspec.yaml, const IconData, semantics, packages, tree shaking, and CI staleness checks.vs IcoMoonCompare IcoMoon and GlyphPact for Flutter icon fonts: visual editing and broad exports versus a local compiler, committed codepoint lock, and CI checks.vs FlutterIconA FlutterIcon.com alternative for local SVG compilation, stable codepoints, CI checks, and reproducible Flutter IconData without repeated browser exports.