Favico

One logo goes in —
38 icons come out.

Favico turns one logo into the complete favicon set your site needs — every icon size, both manifests and a copy-paste HTML snippet. One command, ready to integrate. Less time exporting the same logo, more time finishing the site.

That’s 37 PNGs and one ICO in a single run. Feed it an SVG and every icon starts from a high-resolution render; a 1200×1200 raster fills the full set, and smaller sources still produce every size they can supply — no upscaling, with proportions preserved by default.

macOS Silicon DownloadSHA-256 checksum

Copyright © 2025-2026Igor Maric. All rights reserved.

Favico v0.96.5

One logo goes in — 38 icons come out. Browsers, iOS, Android, Windows and PWAs each want their own sizes, and hand-exporting them is a chore. Favico generates the whole set from one image — icons, manifests and an HTML snippet for your <head> — in a single local run.

Favico reads one source image and writes out the set your site needs: PNGs and ICO, Apple touch icons, Android icons, Windows tiles, the manifests, and an HTML snippet. Every icon is downscaled from your artwork, and sizes the source can't supply are skipped and listed in the run output — never silently upscaled.

Why Favico

Every platform wants favicons in its own sizes and shapes, and assembling that set by hand is tedious. Favico reads one image and generates the whole catalogue — each icon downscaled for crisp edges, maskable artwork kept inside the safe zone, and anything the source can't supply reported rather than faked. Predictable files with sensible names, ready to commit.

Who it’s for

  • Front‑end and full‑stack developers who just want their logo in the tab
  • Teams and agencies maintaining many sites with consistent branding
  • Platform engineers who need reproducible, committable assets in CI/CD
  • Anyone who has hand‑exported dozens of icon sizes

At a glance

  • The complete bundle from one source image — sizes the source can't supply are skipped and reported, never upscaled
  • PNG + ICO outputs; platform‑aware sizes across iOS/Android/Windows/Web
  • Vector or raster input: PNG, JPEG, GIF, WebP, BMP, TIFF, and static SVG rendered at the size the set needs
  • Centred crop by default, or letterbox with --mode fit; transparent padding with --padding
  • Platform background defaults, including white Apple backgrounds; set a global, Apple or maskable colour with --background, --apple-background, --maskable-background
  • site.webmanifest, browserconfig.xml, and favicon-integration.html included
  • Offline generation; only an explicit favico --check-updates contacts the release service

Key features

Point it at one image: Favico generates every size the source can supply, resamples each to suit the target, keeps maskable artwork inside the safe zone, and tells you exactly what it wrote.

  • Generates the full size set per platform, limited by source resolution
  • Accepts static SVG logos and renders them at the resolution the catalogue needs
  • Size-appropriate resampling: Lanczos3 for large icons, lighter filters for small ones
  • Dedicated maskable/PWA icons that stay inside the safe circle
  • Choose centre‑crop, letterbox (--mode fit) or stretch, with optional transparent padding

Supported platforms

Favico currently ships as a macOS (Apple Silicon) binary, downloaded directly from this page. Additional platforms may follow in future releases.

Note: Favico does not require design tools or Node.js. It's a standalone binary for your terminal.

Installation

Choose a manual install below, or skip to Homebrew if you already use it. You only need one installation method.

Downloads are unsigned and not notarised. A checksum detects corruption, not publisher identity. If macOS blocks the executable, review the warning in System Settings → Privacy & Security and approve it only if you trust the download. These installation commands do not remove quarantine.

Download, verify and extract

Download the ZIP archive and its matching SHA-256 checksum. Save both files in the same directory. In Terminal, change to that directory. Replace VERSION in the commands below with the downloaded version number; do not rename the downloaded files.

Verify the checksum, then extract into a new directory. The && prevents extraction if verification fails:

shasum -a 256 -c favico-macOS-AppleSilicon-VERSION.zip.sha256 &&
  unzip favico-macOS-AppleSilicon-VERSION.zip -d favico-VERSION

Continue only if the checksum reports OK and extraction succeeds. Enter the extracted directory, which contains the favico executable:

cd favico-VERSION

Now choose a single-user or system-wide install. Both use this verified executable.

Local install (single user)

Install in your own account without administrator access:

mkdir -p "$HOME/.local/bin"
cp ./favico "$HOME/.local/bin/"
chmod +x "$HOME/.local/bin/favico"
export PATH="$HOME/.local/bin:$PATH"

For future terminals, add the export PATH line to ~/.zshrc once if you use macOS's default Zsh shell. Other shells use their own startup file.

System-wide install (all users)

Alternatively, install in /usr/local/bin for all users. This requires administrator access; make sure /usr/local/bin is on your PATH.

sudo mkdir -p /usr/local/bin
sudo cp ./favico /usr/local/bin/
sudo chmod +x /usr/local/bin/favico

Homebrew (site formula)

If you already use Homebrew, this is an alternative to the manual steps above. The formula downloads the archive and checks its checksum for you; no separate Homebrew tap is required. Download the formula first:

curl --fail --show-error --location https://favico.odd.fyi/homebrew/favico.rb -o favico.rb

Open favico.rb in a text editor and inspect it before running:

brew install --formula ./favico.rb

Verify installation

After completing your chosen method, check that the installed command runs:

favico --version
favico --help

The version should match the release you downloaded. If the command is not found, check your PATH; if macOS blocks it, review the security warning described above.

Quick start

Generate the full set:

favico image.png

Output is written to image-favicons/ beside the source image. Use -o to choose another directory.

Generate from a vector logo into a project directory:

favico logo.svg -o www/public

Copy the generated files into your site's public asset directory if they are not already there, then copy the contents of favicon-integration.html into the page's <head>. By default, the HTML references assets at the site root. For a subdirectory or CDN, set --public-path when generating; -o alone only changes where files are written.

Regenerate an existing set

Inspect the destination first. Use --overwrite only when you intend to replace this run's targets:

favico image.png --overwrite

Other files are not deleted. Older assets not requested by this run are retained and reported; inspect them before deploying. Interrupted runs may leave completed files.

How it works

  • Input image: PNG, JPEG, GIF, WebP, BMP, TIFF, or static SVG. Raster images: min 16px, up to ~50MB.
  • Processing:
    • Mode: crop (default) with a centred anchor; wide targets crop to their own aspect ratio
    • --mode fit letterboxes the whole image; --mode stretch ignores the aspect ratio
    • --padding <PERCENT> insets the artwork by up to 40 percent per side
    • Maskable icons scale into the safe zone instead of cropping
    • Background: platform defaults, including white Apple backgrounds; set an opaque colour globally or per platform
    • --public-path sets the served asset URL without changing the output directory
    • --preview writes a local contact sheet with light/dark and mask simulations
    • --svg-output adds a normalised favicon.svg (SVG input only) with optional --svg-dark-brightness
    • SVG sources are rendered at the resolution the catalogue needs, so a small coordinate system is not a limit
  • Outputs: the full icon, manifest and integration set — see Generated files below. Sizes the source cannot supply without upscaling are skipped and listed in the run output; an existing site.webmanifest or browserconfig.xml is kept and reported unless --overwrite is set.

Generated files

  • Core icons: favicon.ico, favicon.png, favicon-16x16.png, favicon-32x32.png
  • Additional sizes: favicon-64x64.png, favicon-128x128.png, favicon-192x192.png, favicon-256x256.png, favicon-512x512.png, favicon-1024x1024.png
  • Apple touch icons (various sizes)
  • Android: android-chrome-192x192.png, android-chrome-512x512.png, plus -maskable variants
  • Windows tiles: mstile-*.png
  • Manifests: site.webmanifest, browserconfig.xml
  • Integration: favicon-integration.html (copy‑paste into <head>)
  • Optional: favicon.svg (--svg-output, from SVG input) and favicon-preview.html (--preview)
  • Includes social previews (Open Graph / Twitter)

Examples

Letterbox a wide logo rather than cropping it:

favico banner.png --mode fit

Write into the project's asset directory with extra breathing room:

favico logo.svg -o www/public --padding 12

Generate into a served subdirectory and inspect the results locally:

favico logo.svg -o www/public/assets/icons --public-path /assets/icons/ --preview

Open www/public/assets/icons/favicon-preview.html to inspect this run's icons. The contact sheet is a local preview, not the HTML integration snippet.

CLI reference

Source image

  • IMAGE Path to source image (PNG, JPEG, GIF, WebP, BMP, TIFF, SVG). Raster images: min 16px, max ~50MB.

Generation options

  • -o, --output-dir <DIR> Write into DIR instead of <name>-favicons beside the source. Relative explicit paths use the working directory.
  • --mode <crop|fit|stretch> How the source aspect ratio reconciles with each icon shape. Default: crop.
  • --padding <PERCENT> Padding per side, integer 0-40 percent. Selected/platform backgrounds fill the margins. Default: 0.
  • --public-path <PATH_OR_URL> Root-relative or HTTP(S) directory prefix for generated asset references.
  • --background '#RRGGBB' Global opaque icon background and HTML/XML theme/tile colour.
  • --apple-background '#RRGGBB' Apple touch icon background override.
  • --maskable-background '#RRGGBB' Maskable icon background override.
  • --preview Also write the local favicon-preview.html contact sheet.
  • --svg-output Also write favicon.svg from SVG/SVGZ input.
  • --svg-dark-brightness <FACTOR> Dark-theme SVG brightness, 0.1-4; requires --svg-output.
  • --overwrite Replace this run's targets without confirmation; do not delete other files.

Help, version and updates

  • -h, --help Print help. -V, --version Print version.
  • --check-updates Standalone read-only update check; no image or generation options, and nothing is installed.

CI

  • Use exit codes rather than parsing human summaries: 0 means completion (possibly with skips or retained files), 1 means a generation or update-check failure, and 2 means invalid usage or input.
  • Compare the generated file list with the files your site requires. A successful run can skip sizes the source cannot supply.
  • Human generation summaries go to stderr; help and version output go to stdout. Pipes and CI use plain output.

Limitations

  • The CLI generates a fixed catalogue, not a selectable size preset. Use a static SVG or a raster of at least 1200×1200 to supply the full default set; smaller rasters produce fewer sizes.
  • Static SVG is supported; scripts, animation and linked resources are not preserved in SVG export. Raster images are never vectorised.
  • SVG text depends on fonts installed on the machine. Convert text to outlines for consistent results across systems.
  • Background shapes and light/dark raster variants are library-only controls, not CLI options.

Troubleshooting

  • Command not found: check that your chosen installation directory is on PATH, then run favico --version again.
  • macOS blocks the executable: review System Settings → Privacy & Security. Only approve a download you trust; a matching checksum does not establish publisher identity.
  • Image file does not exist: check the path from your current directory. Absolute paths are useful in CI.
  • Artwork is cropped: cropping is the default. Use --mode fit to preserve the whole image, then inspect the output with --preview.
  • Sizes are skipped: the raster source is too small for those targets. Use a larger source or a suitable static SVG and generate into a new directory.
  • Icons do not appear on the site: check that the generated files are served at the URLs in favicon-integration.html. Use --public-path for a subdirectory or CDN, then regenerate the references.

Upgrade

Run favico --check-updates to check for a release; it does not install anything.

  • Manual install: download the new ZIP and checksum, then repeat download, verify and extract in a fresh directory. Repeat only the local or system-wide copy commands for your original installation method. This replaces the installed executable, not your generated icons.
  • Homebrew: download and inspect the current site formula again, then run brew reinstall --formula ./favico.rb.

Run favico --version afterwards to confirm the installed version.

Uninstall

Remove only the installation you chose. These commands remove Favico itself, not the icons it generated.

  • Local install: rm "$HOME/.local/bin/favico". Keep the PATH entry if other tools use that directory.
  • System-wide install: sudo rm /usr/local/bin/favico.
  • Homebrew: brew uninstall favico.

Safety & privacy

The Favico CLI does everything on your machine — no telemetry, no analytics, and nothing contacts the network unless you explicitly run --check-updates. It writes only to the chosen output directory and never modifies your source image. SVG input is rendered in-process: linked images, fonts and scripts are never fetched.

This website uses PostHog, shared with odd.fyi, for page views, clicks, performance measurements, error reports and session replay. Inputs are masked; public page text remains visible in recordings. Website analytics do not access the images you process with the CLI.

Support & docs

Copyright © 2025-2026 Igor Maric. All rights reserved.