Convert GBR to QOI

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

GBR vs QOI Format Comparison

Aspect GBR (Source Format) QOI (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
QOI
QOI (Quite OK Image)

A modern lossless image format designed by Dominic Szablewski in 2021, prioritizing simplicity and speed over maximum compression ratio. QOI achieves compression comparable to PNG while encoding 20-50x faster and decoding 3-4x faster. The entire specification fits on a single page, making it ideal for game engines, embedded systems, and real-time applications where encoding speed matters more than file size.

Modern 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: 8-bit RGBA or RGB (24/32-bit)
Compression: Lossless (run-length + index + delta)
Transparency: Full alpha channel (RGBA mode)
Animation: Not supported
Extensions: .qoi
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 channel
  • Speed: 20-50x faster encoding than PNG
  • Simplicity: Entire spec fits on one page
  • Lossless: Perfect pixel reproduction
  • Streaming: Can encode/decode in streaming fashion
  • Deterministic: Same input always produces same output
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/

QOI (Quite OK Image) creation and processing:

# Convert to QOI with Python
from PIL import Image
img = Image.open("input.png")
img.save("output.qoi")

# QOI reference encoder (C)
# qoiconv input.png output.qoi

# Pillow 12+ supports QOI natively
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
  • Extremely fast encoding (20-50x faster than PNG)
  • Lossless compression with no quality loss
  • Full alpha transparency support
  • Minimal code footprint — trivial to implement
  • Compression ratio comparable to unoptimized PNG
  • Pillow 12+ native read/write support
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
  • Less compression than optimized PNG (larger files)
  • Very new format with limited ecosystem support
  • Not supported in any web browser
  • No metadata or ICC profile support
  • Limited to 8-bit per channel
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
  • Game engine texture loading (fast decode)
  • Real-time screenshot capture (fast encode)
  • Embedded systems with limited CPU
  • Image processing pipeline intermediate format
  • Rapid prototyping and development
Best For
  • GIMP digital painting and illustration workflows
  • Creating reusable brush libraries
  • Storing small pattern stamps with transparency
  • Artists working within the GIMP ecosystem
  • Real-time applications needing fast lossless encoding
  • Game engines prioritizing load speed over file size
  • Embedded systems with limited processing power
  • Development and testing requiring quick image I/O
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: 2021 (Dominic Szablewski)
Current Version: QOI 1.0 specification
Status: Stable, growing adoption
Evolution: QOI 1.0 (2021, final specification)
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: GIMP (plugin), limited editor support
Web Browsers: Not supported
OS Preview: Not natively supported
CLI Tools: Pillow 12+, qoiconv, libqoi, ImageMagick 7+

Why Convert GBR to QOI?

Converting GBR to QOI transforms GIMP brush patterns into the Quite OK Image format, which prioritizes encoding and decoding speed above all else. QOI can encode images 20-50x faster than PNG while achieving comparable compression ratios, making it ideal for real-time applications that need to save brush previews instantaneously.

For game developers using brush patterns as runtime textures, QOI provides significantly faster loading times than PNG. The simple decoder runs with minimal CPU overhead, which matters for games and applications that load many texture assets during scene transitions or level loading.

QOI supports full RGBA transparency, meaning the brush alpha channel is preserved. The format's compression is particularly effective for images with large areas of uniform or similar colors, which is characteristic of many brush patterns — solid areas compress well while detailed edges are stored faithfully.

The trade-off is that QOI has very limited ecosystem support compared to PNG. It is not viewable in web browsers, and few image viewers support it natively. QOI is best used as an internal format within applications and pipelines where speed matters more than universal compatibility.

Key Benefits of Converting GBR to QOI:

  • Extreme Speed: 20-50x faster encoding than PNG
  • Fast Decoding: 3-4x faster decode for quick loading
  • Alpha Support: Full RGBA transparency preservation
  • Lossless: Perfect pixel reproduction guaranteed
  • Simple Spec: Entire format fits on one page
  • Pillow Native: Pillow 12+ supports QOI read/write
  • Deterministic: Same input always produces identical output

Practical Examples

Example 1: Converting Brush Art for Sharing

Scenario: A digital artist converts their custom GIMP brush patterns to QOI format for sharing with collaborators who do not use GIMP.

Source: custom_texture.gbr (256x256px, RGBA, 262 KB)
Conversion: GBR → QOI
Result: custom_texture.qoi (256x256px)

Benefits:
✓ Brush pattern viewable in standard image viewers
✓ Format compatible with target workflow requirements
✓ Original brush detail preserved in conversion
✓ Collaborators can preview without installing GIMP
✓ Ready for integration into project assets

Example 2: Batch Processing Brush Collections

Scenario: An artist converts an entire collection of GIMP brushes to QOI for cataloging and preview purposes in their asset management system.

Source: 50 GBR brushes (various sizes, 5 MB total)
Conversion: GBR → QOI (batch processing)
Result: 50 QOI files for preview catalog

Asset management benefits:
✓ Visual catalog of all available brushes
✓ Quick preview without opening GIMP
✓ Searchable by visual appearance
✓ Organized brush library with thumbnails
✓ Easy sharing of brush previews with team

Example 3: Integrating Brush Patterns in Design Projects

Scenario: A designer uses GIMP brush patterns as texture elements in a design project, converting them to QOI for compatibility with their preferred design tools.

Source: grunge_overlay.gbr (512x512px, RGBA, 1 MB)
Conversion: GBR → QOI
Result: grunge_overlay.qoi (512x512px)

Design workflow:
✓ Converted file imports into design application
✓ Brush texture used as overlay or pattern element
✓ Alpha channel preserves transparency for compositing
✓ Multiple brush textures combined for complex effects
✓ Seamless integration with existing design assets

Frequently Asked Questions (FAQ)

Q: What is a GBR file?

A: A GBR file is a GIMP Brush format used by the GNU Image Manipulation Program to store custom brush tip patterns. It contains a single raster image used as a stamp when painting. Version 1 supports grayscale brushes, while version 2 supports full RGBA color with transparency. GBR files include brush name and spacing metadata.

Q: Will the brush quality be preserved in QOI?

A: The conversion preserves the visual quality of the brush pattern within the capabilities of the QOI format. The original pixel data from the GBR file is converted to QOI representation. Any format-specific limitations (color depth, transparency support) of QOI may affect the output.

Q: Can I convert the QOI file back to GBR?

A: Not directly. QOI is a general image format without brush-specific metadata (name, spacing). You can import a QOI image into GIMP and export it as a GBR brush, manually setting the brush properties. Always keep original GBR files if you need them as GIMP brushes.

Q: Does the conversion handle both GBR v1 and v2?

A: Yes, both GBR version 1 (grayscale) and version 2 (RGBA color) brushes are supported. Grayscale brushes are converted to the appropriate color representation in the QOI output, and RGBA brushes preserve their color and transparency information where the target format supports it.

Q: What is the recommended brush size for conversion?

A: GBR brushes of any size can be converted. Common brush sizes range from 32x32 to 1024x1024 pixels. Larger brushes produce higher-quality output with more detail. Very small brushes (under 32x32) may not show much detail in the converted format, especially if the target format applies compression.

Q: How long does the conversion take?

A: GBR to QOI conversion is typically very fast, completing in 1-3 seconds for most brush sizes. The speed depends on the brush dimensions and the complexity of the target format's encoding. Larger brushes (512x512 and above) may take slightly longer.

Q: Can I convert multiple GBR files at once?

A: Yes, you can upload multiple GBR files simultaneously and each will be converted to QOI individually. This is useful for converting entire brush collections at once, creating preview images for all your brushes in a single batch operation.

Q: What happens to the brush metadata during conversion?

A: GBR-specific metadata (brush name, spacing) is not carried over to the QOI output, as it is brush-specific data that general image formats do not store. The pixel data and applicable color/transparency information are fully preserved in the conversion.