Convert GBR to ICNS

Drag and drop files here or click to select.
Max file size 100mb.
Uploading progress:

GBR vs ICNS Format Comparison

Aspect GBR (Source Format) ICNS (Target Format)
Format Overview
GBR
GIMP Brush Format

A specialized image format created by the GIMP project (GNU Image Manipulation Program) for storing custom brush tip patterns. GBR files contain a single raster image used as a stamp pattern when painting in GIMP. The format supports both grayscale brushes (version 1) and full RGBA color brushes (version 2), allowing artists to create detailed, reusable brush shapes with transparency information.

Lossless Standard
ICNS
Apple Icon Image Format

Apple's native icon format for macOS applications, supporting multiple resolutions in a single container file. ICNS files store icon variants from 16x16 to 1024x1024 pixels, allowing macOS to select the appropriate size for Finder display, Dock, Spotlight, and other system contexts. Modern ICNS files embed PNG-compressed images for each resolution, supporting full RGBA transparency with 32-bit color depth.

Standard Lossless
Technical Specifications
Color Depth: 8-bit grayscale or 8-bit RGBA
Compression: Uncompressed raw pixel data
Transparency: Full alpha channel (version 2)
Animation: Not supported
Extensions: .gbr
Color Depth: 32-bit RGBA (8-bit per channel)
Compression: PNG or JPEG 2000 (per icon size)
Transparency: Full alpha channel per resolution
Animation: Not supported
Extensions: .icns
Image Features
  • Transparency: Full alpha in version 2 RGBA brushes
  • Animation: Not supported
  • Metadata: Brush name and spacing stored in header
  • Color Modes: Grayscale (v1) and RGBA (v2)
  • HDR: Not supported (8-bit only)
  • Multi-resolution: Single resolution per file
  • Transparency: Full 8-bit alpha for each icon size
  • Multi-resolution: 16x16 to 1024x1024 in one file
  • Retina Support: @2x variants for HiDPI displays
  • Container: Multiple images in a single file
  • System Integration: Native macOS Finder/Dock display
  • Adaptive: OS selects best size automatically
Processing & Tools

GBR files are natively handled by GIMP:

# GBR brush structure
# Header: size(4) + version(4) + width(4)
#   + height(4) + bpp(4) + name(null-term)
# Data: raw pixel data (grayscale or RGBA)

# GIMP brushes directory
# ~/.config/GIMP/2.10/brushes/

ICNS creation for macOS applications:

# macOS iconutil command
iconutil -c icns icon.iconset

# Python with Pillow
from PIL import Image
img = Image.open("input.png")
img.save("output.icns")

# Create iconset with multiple sizes
# icon_16x16.png, icon_32x32.png, etc.
Advantages
  • Native GIMP brush format with full editor integration
  • Supports transparency for precise brush shapes
  • Simple binary format easy to parse programmatically
  • Lossless storage preserves exact brush detail
  • Embedded brush metadata (name, spacing)
  • Lightweight files for small brush patterns
  • Native macOS icon format recognized by Finder
  • Multi-resolution container for all display contexts
  • Retina/HiDPI display support
  • Full alpha transparency for macOS icon rendering
  • Pillow native read/write support
  • Required format for macOS application bundles
Disadvantages
  • Only usable within GIMP ecosystem
  • No compression results in larger files for big brushes
  • Not viewable in web browsers or standard image viewers
  • Limited to 8-bit color depth
  • No standard metadata beyond brush name and spacing
  • macOS-specific format not used on other platforms
  • Not viewable in web browsers
  • Limited support on Windows and Linux
  • Fixed icon sizes required by macOS conventions
  • Single source image may not look ideal at all sizes
Common Uses
  • Custom brush tips in GIMP
  • Artistic texture stamps for digital painting
  • Repeating pattern brushes for illustration
  • Sharing brush collections among GIMP users
  • Specialized brush shapes for photo retouching
  • macOS application icons (.app bundles)
  • Finder folder and file type icons
  • macOS Dock display icons
  • Spotlight and Launchpad icons
  • Custom file type associations on macOS
Best For
  • GIMP digital painting and illustration workflows
  • Creating reusable brush libraries
  • Storing small pattern stamps with transparency
  • Artists working within the GIMP ecosystem
  • macOS application development
  • Custom folder and file icons on macOS
  • macOS system integration for apps
  • Apple platform icon design
Version History
Introduced: 1995 (GIMP 0.54)
Current Version: Version 2 (RGBA support)
Status: Stable, maintained by GIMP project
Evolution: v1 (grayscale) → v2 (RGBA color)
Introduced: 2001 (Mac OS X)
Current Version: ICNS with 1024px Retina support
Status: Active, required for macOS apps
Evolution: Classic Mac icons → ICNS (2001) → Retina ICNS (2012)
Software Support
Image Editors: GIMP (native), limited third-party support
Web Browsers: Not supported
OS Preview: Not natively supported
Mobile: Not supported
CLI Tools: GIMP Script-Fu, Python with custom parser
Image Editors: Xcode, Icon Composer, GIMP, Photoshop (plugin)
Web Browsers: Not supported
OS Preview: macOS (native), limited elsewhere
Development: Xcode, iconutil, sips
CLI Tools: Pillow, iconutil, libicns, ImageMagick

Why Convert GBR to ICNS?

Converting GBR to ICNS allows digital artists to transform their GIMP brush designs into macOS application icons. This is valuable for macOS developers and designers who create distinctive brush-based artwork that they want to use as application icons, custom folder icons, or file type associations on Apple's operating system. The ICNS format ensures the icon displays correctly across all macOS system contexts.

Artistic brush patterns can create visually striking icons that stand out from typical flat or gradient icons. A unique brush texture or painted style translates well to application icons when properly sized and formatted. The ICNS container stores multiple resolutions, so the brush artwork can be displayed sharply at sizes ranging from 16x16 to 1024x1024 pixels.

For independent macOS developers and designers, this conversion streamlines the icon creation process. Instead of working with complex icon editors, you can design your icon as a GIMP brush — leveraging GIMP's painting tools and brush engine — then convert the result directly to ICNS format ready for inclusion in an application bundle.

The conversion handles the scaling to standard macOS icon sizes and packages them into the multi-resolution ICNS container. The alpha channel from RGBA brushes is preserved, allowing the icon to have transparent areas that integrate naturally with the macOS desktop background, Dock, and Finder display contexts.

Key Benefits of Converting GBR to ICNS:

  • macOS Native: ICNS is the required icon format for macOS application bundles
  • Multi-Resolution: Single file contains all needed icon sizes
  • Retina Ready: HiDPI support for sharp display on Retina screens
  • Alpha Transparency: Brush transparency preserved for seamless desktop integration
  • Finder Display: Icons appear correctly in Finder, Dock, and Spotlight
  • Unique Design: Brush-based artwork creates distinctive application icons
  • Direct Workflow: From GIMP brush design to macOS icon in one step

Practical Examples

Example 1: Custom Application Icon for Indie macOS App

Scenario: An independent developer designs a painterly application icon as a GIMP brush for their macOS art application.

Source: paint_palette_icon.gbr (512x512px, RGBA, 1 MB)
Conversion: GBR → ICNS (multi-resolution)
Result: paint_palette_icon.icns (~200 KB with all sizes)

macOS development workflow:
✓ ICNS includes 16, 32, 128, 256, 512, 1024px sizes
✓ @2x Retina variants generated automatically
✓ Place directly in .app bundle Resources folder
✓ Finder shows the icon at all zoom levels
✓ Dock displays the brush-based design sharply

Example 2: Custom Folder Icons for macOS

Scenario: A designer creates custom painted folder icons using GIMP brushes to organize their macOS desktop with visual categories.

Source: art_folder.gbr (256x256px, RGBA, 262 KB)
Conversion: GBR → ICNS
Result: art_folder.icns (~60 KB)

macOS customization:
✓ Apply custom icon via Get Info → paste icon
✓ Brush-painted folder design visible in Finder
✓ Alpha transparency blends with desktop background
✓ Different brush designs for different folder categories
✓ Professional, artistic desktop organization

Example 3: File Type Icons for Custom Application

Scenario: A macOS application developer creates custom file type icons using GIMP brushes for documents created by their application.

Source: document_icon.gbr (512x512px, RGBA, 1 MB)
Conversion: GBR → ICNS
Result: document_icon.icns (~180 KB)

File type association:
✓ ICNS registered in app's Info.plist for file type
✓ Finder shows custom icon for associated documents
✓ Quick Look preview uses the icon for thumbnails
✓ Brush artwork makes documents visually recognizable
✓ Consistent branding across all app-created files

Frequently Asked Questions (FAQ)

Q: What icon sizes are included in the ICNS file?

A: ICNS files typically include standard macOS sizes: 16x16, 32x32, 128x128, 256x256, 512x512, and optionally 1024x1024 pixels. Each size may also have a @2x Retina variant (e.g., 32x32@2x = 64x64 pixels). The conversion generates appropriate sizes from the source brush data.

Q: Will the brush transparency work as icon transparency?

A: Yes, ICNS fully supports alpha transparency. The RGBA alpha channel from version 2 GBR brushes is preserved, allowing the icon to have transparent areas that blend with the macOS desktop background and other UI elements. This is how macOS icons achieve their rounded shapes and shadow effects.

Q: Can I use ICNS files on Windows or Linux?

A: ICNS is a macOS-specific format. Windows uses ICO format and Linux typically uses PNG for icons. While some cross-platform tools (like Pillow and ImageMagick) can read ICNS files, they are not usable as system icons outside macOS. Convert to ICO for Windows or PNG for cross-platform use.

Q: What is the ideal brush size for ICNS conversion?

A: For best results, use a brush of at least 512x512 pixels (or 1024x1024 for Retina). The conversion scales down for smaller icon sizes. If the source brush is smaller than the target icon size, the result may appear blurry. Larger source sizes produce sharper icons at all display resolutions.

Q: How do I apply the ICNS icon to my macOS app?

A: Place the ICNS file in your application bundle's Contents/Resources directory and reference it in your Info.plist file using the CFBundleIconFile key (without the .icns extension). Xcode can also accept ICNS files directly in the app icon asset catalog.

Q: Can grayscale GBR brushes produce good icons?

A: Grayscale brushes can produce distinctive monochrome icons, but they may look dull compared to colorful app icons. The grayscale values are converted to RGB (equal values in R, G, B channels), producing a gray-toned icon. This can work well for utility applications or minimalist design aesthetics.

Q: What happens if the brush is not square?

A: macOS icons must be square. If the GBR brush is rectangular, the image will be scaled or cropped to fit a square aspect ratio. For best results, create your brush design in a square canvas before exporting as GBR and converting to ICNS.

Q: How large are ICNS files typically?

A: ICNS file size depends on the icon complexity and the number of included sizes. A typical ICNS with all standard sizes ranges from 100 KB to 500 KB. The images are PNG-compressed within the container, so detailed artwork produces larger files than simple flat designs.