App icon sizes for iOS and Android in 2026

The first time I shipped an Android app, the icon looked fine in Android Studio's preview and arrived on a Pixel with its corners chopped off. The launcher had cropped the mark into a circle and eaten the part I cared about. The export was technically correct. The design wasn't.

That is the trap with app icons. The size tables are easy. Knowing what the platform actually does to your art at runtime is the part people miss.

What to export first

Start with a 1024x1024 square master and test it at 40x40 and 24x24 before exporting the full set. For iOS, that usually means one no-alpha 1024x1024 PNG for App Store Connect. Android needs adaptive icon layers, a monochrome layer for themed icons, and a 512x512 Play Store icon with alpha. PWAs need 192x192 and 512x512 manifest icons plus a maskable version.

Export order

1. Design the icon as a 1024x1024 square at vector resolution.
2. Test legibility at 40x40 and 24x24 before exporting anything.
3. For iOS, export one 1024x1024 PNG with no alpha. Drop it into the Xcode asset catalog and let Xcode generate the rest, or use a tool like Bakery or Icon Set Creator if you want manual control.
4. For Android, use vector layers where practical. If you need bitmap layers, export foreground, background, and monochrome assets at 432x432 for xxxhdpi, then generate the lower density buckets. Export a separate 512x512 Play Store icon.
5. For the web app manifest, export 192, 512, and a 512 maskable PNG with the mark inside the central circle whose radius is 40 percent of the image width. Add a 180 apple-touch-icon for iOS Safari.
6. Test the maskable icon in Chrome DevTools' Application tab, which previews the circle and squircle masks.
7. Install the app on at least one real device per platform before shipping. Simulators lie about icon rendering more often than they should.

Start with one good master

Before any export, you need one square master file at 1024 by 1024 pixels or larger. Vector is better. PNG is fine if you keep it sharp.

Start by checking the file itself. Keep the canvas square. Do not bake in rounded corners, because the platforms apply their own masks. Use a full-bleed background instead of transparent margins; the OS already adds visual padding. Keep important detail near the middle, away from the corners. On Android adaptive icons, the visible area can be a circle, a squircle, a teardrop, or a rounded square depending on the launcher.

If the master breaks any of those, every export will inherit the problem.

If your logo is a thin wordmark, do not shrink the whole wordmark into the icon. Build a separate app icon mark from the strongest letter, symbol, or shape in the identity. The home screen already shows the app name below the icon.

iOS app icons

Modern Xcode handles most of this for you. Ship a single 1024x1024 PNG and the asset catalog will generate the rest. You still need to know what the platform expects, though, especially if you build outside Xcode or want pixel control.

Most teams only need the 1024 App Store icon unless they manage exports manually. If you do need manual exports, these are the usual iOS sizes:

The small sizes are the ones to worry about. Notification at 20 pixels is brutal. If your mark has detail you cannot read at 20 by 20, the detail does not exist as far as the user is concerned.

For App Store Connect, the 1024x1024 must be a flat PNG with no alpha channel and no transparency. Apple rejects icons with alpha. Flatten the background.

Rounded corners are applied by iOS at runtime. Do not pre-round.

Android app icons

Android adaptive icons are two layers: a foreground and a background, both 108 by 108 dp. The launcher applies its own mask to the result, so the safe zone in the middle is only 66 dp across. The outer 18 dp on each side is reserved for parallax and masking.

If you build the adaptive layers as vectors, you avoid most bitmap export churn. If you use bitmap layers, the 108 dp canvas maps to these pixel sizes:

The 66 dp safe zone is where your visible logo lives. Anything inside it will be shown regardless of which mask the launcher applies; anything outside it may be cropped.

For example, a coffee app might use the cup mark as the foreground layer and a solid brand color as the background layer. The cup stays inside the 66 dp safe zone; the color fills the whole 108 dp canvas.

For the Play Store listing, you also need a 512 by 512 PNG icon. Google Play requires a 32-bit PNG with alpha, under 1024KB. This store-listing icon does not replace your launcher icon.

Add a monochrome layer if you want the icon to work cleanly with Android themed icons. Newer Android versions may attempt automatic theming when no monochrome layer exists, but that is a fallback, not brand-controlled output.

If your app's minSdkVersion is below 26, keep legacy launcher icons at the sizes above. If it is 26 or higher, adaptive icons cover launcher support.

The background layer is often where people go wrong. It can be a solid color, a gradient, or a simple shape, but it must cover the full 108 dp canvas. The launcher uses it for parallax effects, so it shifts behind the foreground when the user tilts the device.

If your background layer is transparent or smaller than 108 dp, the icon will look broken on some launchers and the OS may fall back to an ugly default.

The foreground layer should also be 108 dp with the actual mark centered inside the 66 dp safe zone, with the rest transparent.

Notification and small icons (Android)

Android also needs a notification icon and a small status bar icon. Vector drawables are usually preferable. If you use bitmap notification icons, export single-color transparent PNGs in these density buckets:

The system tints them. Design as a flat silhouette with no gradients and no color.

PWA icons and the web app manifest

For broad progressive web app install support, include two PNG icons declared in the manifest: 192 by 192 and 512 by 512. Chrome's installability checks expect those sizes. iOS Safari uses the apple-touch-icon link tag, which expects a 180 by 180 PNG.

Optional PWA sizes:

The manifest entry looks like this:

{
  "icons": [
    {
      "src": "/icons/icon-192.png",
      "sizes": "192x192",
      "type": "image/png"
    },
    {
      "src": "/icons/icon-512.png",
      "sizes": "512x512",
      "type": "image/png"
    },
    {
      "src": "/icons/icon-512-maskable.png",
      "sizes": "512x512",
      "type": "image/png",
      "purpose": "maskable"
    }
  ]
}

The maskable variant is the PWA equivalent of an Android adaptive icon. The platform may crop the icon into a circle, a squircle, or a rounded square. Keep important content inside the central circle with a radius equal to 40 percent of the image width. The outer 10 percent edge may be cropped on some platforms, so fill it with the background color or pattern.

On Android/Chromium, a transparent or non-maskable icon can appear on a white background with the art shrunk into the middle of a rounded tile. It looks like a packaging mistake, even when the source icon is sharp.

Other platform assets

If your app ships to iPadOS, the asset catalog handles the iPad-specific sizes above. If you also ship to macOS, do not reuse the iOS full-bleed icon without checking it against Apple's macOS icon template or Icon Composer guidance. macOS icons use a different visual shape and usually need more breathing room.

For a manual macOS .iconset or asset catalog, expect the pixel files to include 16, 32, 64, 128, 256, 512, and 1024 px. Those map from 16x16 through 512x512 at 1x and 2x scales.

For Windows, the old live tile system is mostly gone in Windows 11, but packaged Windows apps still need Microsoft Store and app-list assets. Microsoft currently says Windows 11 does not use tile assets, while the 100 percent Medium tile asset is still required for Store publishing. Treat Windows icons as a separate packaging checklist if you ship through the Microsoft Store.

For iOS splash screens, modern Xcode handles it with the launch storyboard. You no longer need pre-rendered splash PNGs per device.

For PWAs, Chrome derives the splash screen from manifest metadata, including the icon, app name, background or theme colors, and display settings. Set theme_color explicitly. If you do not, you get a flash of white.

Where icons usually break

Most app icon problems are not sizing problems. They are design problems that the small sizes expose.

• Detail that disappears at 40 pixels. If you cannot read the mark at 40 by 40, redesign before you export. A letterform or simple symbol usually survives better than a full logo.
• Thin outlines. They alias into mush at small sizes. Use solid shapes or thicken the stroke before making the export set.
• Text inside the icon. The app's name is shown next to the icon on the home screen. You do not need it inside.
• Transparent corners or padding. Both platforms add their own. Pre-padding doubles it.
• Pre-rounded corners on iOS. The OS rounds them again. Your icon ends up with a smaller, lumpier curve.
• Forgotten maskable variant on PWAs. The non-maskable version gets shrunk and centered on a white square on Android.
• Notification icons designed in color. The system flattens them. Design as a silhouette from the start.

Brandize can turn one logo direction into the 1024 master, Android layers, and a maskable PWA icon.