Generate Every App Icon Size From One Image: 4 Ways Compared

To generate every app icon size from one image, start with a square, opaque 1024 × 1024 px PNG and pick the route that covers your platforms: Xcode's single-size icon for Apple platforms, Android Studio's Image Asset Studio for Android, a short script, or a browser tool that returns a ZIP. In AI Icon Creator's test on 19 October 2026, repeated from 12 October with the same results, two scripts and two browser tools turned the same icon into 12 to 31 files and passed between 4 and 12 of our 13 checks for what iOS, Android and the web need. The biggest differences were the alpha channel on the iOS icon, Android adaptive icons and the web icons.

We ran the scripts and the browser tools. We read the documentation for Xcode and Android Studio instead of running them, because neither is installed on the Mac we tested on. We also built one of the browser tools, so every result below comes with the files it made and the script that checked them.

Which files does one image have to become?

One 1024 px image has to become a different set of files for each platform: a single file for iOS, a handful for the web, and a whole folder tree for Android. This table lists what a finished pack contains; our app icon sizes guide has every size with its safe zone.

The five per-density launcher icons are the older set, for Android 7.1 and lower; Android 8 and later use the adaptive icon. Android 13 and later can also tint an app's icon to match the wallpaper, when the user turns on themed icons and the adaptive icon includes a monochrome layer, so that is our fifth Android check.

How did we test the four ways?

We gave each route the same test icon in two versions and checked every file it made. The icon is a white bell on blue from the AI Icon Creator studio. One version is a square 1024 px PNG with no transparency. The other is the same icon pre-rounded, with transparent corners, which is how many design tools export it.

A script, icon-pack-check.py, answers 13 yes-or-no questions about each pack: three for iOS, five for Android and five for the web. They are the rows of the table further down, and they judge files by size and place, not by one tool's file names. We ran two scripts (sips, which is built into macOS, and Python with Pillow) and two browser tools (AI Icon Creator's app icon resizer and appicon.co's App Icon Resizer), all with default settings and one run per icon.

The checks are our own list of what an app team needs, and we built the resizer, so read its column with that in mind. We did not upload any of the icons to App Store Connect or Google Play, so a check that passes or fails here says what is in the files, not what a store would decide. You can download the checker and both scripts: icon-pack-check.py, make-icon-pack.py and make-icon-pack.sh.

Way 1: Xcode's single-size icon

Xcode can make every iOS icon size from one 1024 px image. Apple's documentation says iOS, iPadOS, tvOS and watchOS apps "can auto-generate all icon variations from a single 1024×1024 pixel image". In the asset catalog you choose Single Size from the platform's pop-up menu and add the image. macOS is not in Apple's sentence, and Xcode makes no Android or web icons.

Start from a square image. Apple's guidelines for app icons say icons are square and the system masks them to rounded corners, so you should provide square layers. Apple's current documentation does not say that the App Store icon must have no alpha channel, but developers have reported an upload error, ITMS-90717, for icons that carry one. The message they quote says the icon "can't be transparent nor contain an alpha channel", in a 2017 thread in the Apple Developer Forums. An opaque icon avoids the risk, so it is one of our checks.

Apple's page also points to Icon Composer for layered icons with dark and tinted looks. A file made there replaces the asset catalog, and our Icon Composer guide explains it. A flat 1024 px PNG in the asset catalog still works. We did not run Xcode for this test: this section is Apple's documentation, not our measurement.

Way 2: Android Studio's Image Asset Studio

Android Studio's Image Asset Studio builds the whole Android set from a foreground image and a background colour or image. In the Project window's Android view, right-click the res folder and choose New > Image Asset. You pick a foreground (an image, clip art or text), a background and, if you want themed icons, a monochrome layer. The tool previews the adaptive icon in circle, squircle, rounded-square and square masks, places the launcher icons in the res/mipmap-<density> folders and, in Google's words, "also creates a 512 x 512 pixel image" for the Google Play store. See Google's page on creating app icons with Image Asset Studio.

It makes Android icons only, so you need another route for iOS and the web. We did not run it for this test either.

Way 3: A script

A script gives you exact control and fits into a build, but it makes only the files you remember to ask for. We wrote two short ones, one for macOS and one that runs anywhere Python does, and ran each on both test icons.

sips, built into macOS

The sips command resizes images on any Mac with no install. This script makes the iOS, Android and web sizes from one PNG:

#!/bin/bash
# make-icon-pack.sh: the iOS, Android and web icon sizes from one square PNG, with sips (built into macOS)
# usage: ./make-icon-pack.sh icon.png [out-folder]
set -euo pipefail
src="${1:?usage: make-icon-pack.sh icon.png [out-folder]}"
out="${2:-icons}"

resize() { mkdir -p "$(dirname "$3")"; sips -z "$1" "$1" "$2" --out "$3" >/dev/null; }

resize 1024 "$src" "$out/ios/AppIcon.appiconset/AppIcon.png"
cat > "$out/ios/AppIcon.appiconset/Contents.json" <<'JSON'
{
  "images": [{ "filename": "AppIcon.png", "idiom": "universal", "platform": "ios", "size": "1024x1024" }],
  "info": { "author": "xcode", "version": 1 }
}
JSON
for d in mdpi:48 hdpi:72 xhdpi:96 xxhdpi:144 xxxhdpi:192; do
  resize "${d#*:}" "$src" "$out/android/res/mipmap-${d%%:*}/ic_launcher.png"
done
resize 512 "$src" "$out/android/ic_launcher-playstore.png"
resize 180 "$src" "$out/web/apple-touch-icon.png"
resize 192 "$src" "$out/web/icon-192.png"
resize 512 "$src" "$out/web/icon-512.png"
sips -z 48 48 -s format ico "$src" --out "$out/web/favicon.ico" >/dev/null

It made 12 files and passed 7 of the 13 checks on the square icon and 6 on the pre-rounded one. sips keeps transparency, so the pre-rounded icon's 1024 px file still had an alpha channel and transparent corners. Its favicon.ico held one 48 px image instead of 16, 32 and 48 px.

Python with Pillow

The Pillow library can lay transparency onto a colour, so the 1024 px icon has no alpha channel, and it can write a favicon.ico with three sizes. This version runs on macOS, Windows and Linux after pip install pillow:

# make-icon-pack.py: the iOS, Android and web icon sizes from one square PNG (pip install pillow)
# usage: python3 make-icon-pack.py icon.png [out-folder]
import json, sys
from pathlib import Path
from PIL import Image

LAUNCHER = {'mdpi': 48, 'hdpi': 72, 'xhdpi': 96, 'xxhdpi': 144, 'xxxhdpi': 192}

def opaque(im):
    """App stores want no transparency: lay it on the icon's top-edge colour (white if that is clear)."""
    if im.mode == 'RGB':
        return im
    rgba = im.convert('RGBA')
    top = rgba.getpixel((rgba.width // 2, 2))
    base = Image.new('RGBA', rgba.size, top if top[3] == 255 else (255, 255, 255, 255))
    return Image.alpha_composite(base, rgba).convert('RGB')

def save(im, path, px):
    path.parent.mkdir(parents=True, exist_ok=True)
    im.resize((px, px), Image.LANCZOS).save(path, optimize=True)

src, out = sys.argv[1], Path(sys.argv[2] if len(sys.argv) > 2 else 'icons')
im = Image.open(src)
if im.width != im.height:
    sys.exit('use a square image')
master = opaque(im)

ios = out / 'ios' / 'AppIcon.appiconset'
save(master, ios / 'AppIcon.png', 1024)
(ios / 'Contents.json').write_text(json.dumps({
    'images': [{'filename': 'AppIcon.png', 'idiom': 'universal', 'platform': 'ios', 'size': '1024x1024'}],
    'info': {'author': 'xcode', 'version': 1},
}, indent=2))

for density, px in LAUNCHER.items():
    save(master, out / 'android' / 'res' / f'mipmap-{density}' / 'ic_launcher.png', px)
save(master, out / 'android' / 'ic_launcher-playstore.png', 512)

web = out / 'web'
save(master, web / 'apple-touch-icon.png', 180)
save(master, web / 'icon-192.png', 192)
save(master, web / 'icon-512.png', 512)
master.save(web / 'favicon.ico', sizes=[(16, 16), (32, 32), (48, 48)])

It also made 12 files and passed 8 of the 13 checks on both icons. It does not make round or adaptive Android icons, a monochrome layer, a maskable icon or a web manifest, because we did not write them.

Way 4: A browser tool

A browser tool does the same job without code and returns the files as a ZIP. We ran two with default settings.

AI Icon Creator's app icon resizer made 31 files from one upload. The iOS folder had a 1024 px icon with no alpha channel and its Contents.json. The Android folder had square and round launcher icons for five densities, adaptive icon layers from 108 to 432 px with their XML and background colour, and a 512 px Google Play icon. The web folder had favicon.ico with three sizes, a 180 px Apple touch icon, 192 and 512 px icons, a maskable icon, a manifest and the HTML for the page's <head>. It passed 12 of the 13 checks on both icons. The one miss was the monochrome layer, which the tool adds when you tick Add an Android themed icon layer: with that ticked, the pack had 36 files and passed all 13. The tool says it resizes the image in your browser and never uploads it, and the network log agreed: after we chose the 1 MB test image, the page loaded a few of its own script files and sent two analytics posts of about 2 KB each, nothing large enough to hold the image.

appicon.co's App Icon Resizer also made 31 files, aimed at iOS and Android. It wrote an asset catalog with 19 PNG sizes from 20 to 1024 px, an AppIcon.icon file for Xcode's Icon Composer, five Android launcher icons, a 1024 px adaptive foreground image, a 1024 px appstore.png and a 512 px Play Store icon. It made no web icons, no round icons and no adaptive icon XML or background. It passed 4 of the 13 checks. Its 1024 px iOS icons were RGBA files, which means they carry an alpha channel, even though every pixel in them was opaque.

What did the 13 checks show?

On the square test icon, the browser tool from AI Icon Creator passed 12 checks, the Pillow script 8, the sips script 7 and appicon.co's resizer 4. Where a route fell short mattered more than its total, because appicon.co does not claim to make web icons and a script makes only what you write.

Five things stood out.

• The alpha channel is the quietest miss. A PNG saved as RGBA has an alpha channel even when every pixel is opaque, and appicon.co's 1024 px files were like that. sips also kept the transparent corners of the pre-rounded icon. You can check any file on a Mac with sips -g hasAlpha icon.png, which prints hasAlpha: yes or hasAlpha: no.
• The routes did not agree on a pre-rounded icon. sips left the corners transparent, the Pillow script filled them with the icon's own colour, and both browser tools filled them with white. Since the system rounds the icon itself, give every route a square.
• An adaptive icon is not a resized PNG. It needs a foreground layer, a background and an XML file that joins them. Only the resizer wrote all three. In its pack the foreground is the whole icon scaled into the central 72 dp, over a background colour taken from the icon's edge, which leaves no seam on a flat blue like ours. Our guide to Android adaptive icons covers the safe zone.
• A favicon.ico is best with several sizes. The MDN documentation notes that ICO files can store multiple sizes in one file. sips wrote a single 48 px image, while Pillow and the resizer wrote 16, 32 and 48 px. A free PNG to ICO converter builds a multi-size file too.
• Few routes make the rest of the web set. Only the resizer wrote a maskable icon and a manifest; our PWA icon guide explains what they are for.

Which way should you use?

The right route depends on which platforms you ship, and most apps ship more than one.

• An iOS app only: use Xcode's single-size icon with a square, opaque 1024 px PNG, and check it with sips -g hasAlpha.
• An Android app only: use Image Asset Studio and give it a separate foreground and background, so the adaptive icon survives every mask.
• iOS, Android and the web from one file: use a browser tool that returns all three, such as the free app icon resizer, or run the Pillow script and add what it lacks.
• A build pipeline: keep a script in your repository so every release makes the same files, and run icon-pack-check.py on its output.
• Whichever you pick: start from a square 1024 px master with the subject centred, and look at the result at small sizes, as in our study of what survives at 29 pt.

If you do not have an icon yet, describe one and compare styles:

Frequently asked questions

Can I generate all app icon sizes from a single 1024 × 1024 image?

Yes. For iOS, Apple's documentation says Xcode can generate every icon variation for iOS, iPadOS, tvOS and watchOS from one 1024 × 1024 px image. For Android and the web you need a tool or script that also writes the launcher, adaptive and web icons: in our test, a browser resizer made 31 files from one upload.

What size should the source image be for app icons?

The source image should be a square PNG of at least 1024 × 1024 px, because 1024 px is the biggest icon iOS needs and Android and the web need smaller ones. A smaller source works, but the biggest icons look soft. Keep the artwork full-bleed and square, since iOS and Android apply their own masks.

Why does my app icon "contain an alpha channel"?

Your PNG is saved with an alpha channel, which is the transparency data in RGBA files, and developers have reported App Store upload errors for 1024 px icons that carry one. Re-export the icon without transparency, or flatten it onto a colour. On a Mac, sips -g hasAlpha icon.png tells you whether a file has one.

Should I round the corners of my app icon before resizing it?

No. Give every tool a square icon with no rounded corners, because iOS and Android round it themselves. In our test the four routes handled transparent corners in three different ways: transparent, filled with the icon's colour, and filled with white by both browser tools.

Can I make the Android adaptive icon from a single flat image?

You can make a basic one: put the whole icon on the foreground layer, scaled into the middle of the 108 dp canvas, and use its edge colour as the background. That is what the AI Icon Creator resizer did with our test icon, scaling it into the central 72 dp, and it leaves no seam on a flat background. Android's own guide asks you to keep a logo inside the inner 66 dp safe zone, so a full square icon can lose its corners under a round mask. For a detailed icon, draw a separate foreground and background in Image Asset Studio.

Try it with your own idea and check every size afterwards: