Fact-checked by Grok 2 weeks ago

GrafX2

GrafX2 is a free and open-source graphics editor designed for creating and game graphics using a 256-color palette, drawing inspiration from classic painting programs such as and Brilliance. It provides a range of specialized tools for precise, mouse-driven drawing, including brushes, flood fills, and effects tailored to modes, making it particularly suitable for retro-style artwork and low-color environments. Originally developed by Sunset Design—comprising Gilles Dorme and Karl Maritaud—between 1996 and 2001, GrafX2 was revived and expanded by the GrafX2 Project Team, including Adrien Destugues, Yohan Rizoud, and Thierry Bernard, starting in 2007. The software is licensed under the GNU General Public License (GPL), allowing users to freely distribute, modify, and contribute to its . Primarily developed on , , and Windows, it is portable across multiple platforms, supporting features like configurable brushes ( or multi-colored), spline tools, and input for enhanced precision in drawing tasks. As of October 2025, the latest version is 2.9.3250, continuing to evolve as a community-maintained tool for pixel artists seeking an authentic, Amiga-inspired workflow without truecolor editing capabilities.

Overview

Description

GrafX2 is a , open-source bitmap paint program specialized in 256-color indexed . It draws inspiration from classic software such as and Brilliance, focusing on pixel-level precision to facilitate detailed, hand-crafted visuals. The program's core purpose is to enable mouse-driven creation of intricate graphics, particularly in retro-style , setting it apart from general-purpose editors like by prioritizing specialized tools for low-color, high-detail work. It supports primary use cases including game graphics, art, and low-resolution illustrations, where exact control over individual pixels is essential. GrafX2 is available across multiple platforms, making it accessible for artists working in diverse environments. Its development history traces back to 1996, evolving from early bitmap editing roots.

Platforms and licensing

GrafX2 is released under the GNU General Public License version 2.0 only (GPL-2.0-only), classifying it as that permits users to freely run, study, modify, and redistribute the program while requiring derivative works to adhere to the same terms. The source code is openly available on the project's , facilitating community-driven development and compilation for custom environments. The program is implemented in and relies on the (SDL) library for graphics, input, and audio handling, which underpins its extensive cross-platform portability without necessitating platform-specific rewrites. This architecture supports operation on resource-constrained hardware, as the software is optimized for 256-color indexed graphics modes that demand minimal processing power and memory, typically running efficiently on systems from the era onward. GrafX2 is compatible with a variety of operating systems, including , (via third-party builds), Atari MiNT, , , , macOS, Windows, and others through compilation such as /FreeMiNT and . These platforms encompass both modern desktops and legacy systems, reflecting the library's role in enabling builds for diverse architectures ranging from x86 to PowerPC and . Downloads for precompiled binaries are provided via the official website for primary platforms like Windows, macOS, and , while and additional builds are accessible directly from . On macOS, it is also installable through third-party package managers such as Homebrew (brew install --cask grafx) and (port install grafx2), enhancing accessibility for users on that system.

Development

Origins and early versions

GrafX2 was created in 1996 by the French development team Sunset Design, consisting of Guillaume Dorme and Karl Maritaud, as a graphics editor for systems. The program made its debut at the Wired '96 demoparty in on November 1, 1996, with the first public release labeled as beta 90%. This initial version focused on efficient creation in constrained environments, supporting formats like , LBM, and without relying on contemporary graphical libraries, emphasizing direct hardware access typical of applications. During its early years from 1996 to 2001, GrafX2 gained significant traction within the community, where it became a staple tool for producing 256-color graphics under hardware limitations of the era. Its design catered specifically to low-color palettes, enabling artists to craft detailed bitmap images for demos and intros on platforms with 8-bit or VGA constraints, such as 320x200 resolutions. Key updates included the addition of multi-undo functionality in 1996, mask and smear drawing modes by 1997, and support for larger canvases in 1998, culminating in the final Sunset Design release, version 2.0 beta 96.5%, in December 1999. In 2001, following the cessation of active development due to waning interest in DOS-based tools, Sunset Design released the source code under the GNU General Public License version 2.0, preserving the program's legacy for potential future enhancements. This open-sourcing marked the end of the original era, during which GrafX2 had established itself as an essential utility for creators working in 256-color bitmap editing. Inspired briefly by graphics editors like , it adapted those influences to the PC demoscene's needs without incorporating advanced features beyond basic raster manipulation.

Modern ports and updates

In 2004, the developed a Windows port of GrafX2, releasing it at demoparty to extend the original application's reach to . The project saw a significant revival in 2007 when Adrien Destugues (known as PulkoMandy) initiated an SDL-based cross-platform port, recovering the original source code and enabling support for , , and other platforms beyond Windows. This effort expanded GrafX2's accessibility while preserving its retro focus, initially gaining traction within communities for multi-platform compatibility. Since 2007, the Grafx2 Project Team—comprising Adrien Destugues, Yves Rizoud, and Thomas Bernard—has maintained and advanced the software through 2025, with contributions tracked in the project's repository since around 2017. The development transitioned to the 2.x version series starting with the port, introducing iterative improvements in stability and features, including full import and export support in the modern versions to facilitate workflows without losing fidelity; the latest stable release, version 2.9.3250, was built on October 12, 2025, with nightly builds available for ongoing testing. Key updates in recent versions have emphasized practical enhancements for artists. Bug fixes have focused on retro compatibility, such as resolving issues with legacy file formats like and to prevent crashes on older hardware emulations. Enhancements for low-resolution art include optimized drawing tools and palette handling compatible with systems like the Commodore 64 and Atari ST, ensuring precise pixel-level control in constrained environments.

User interface

Core layout

GrafX2's core layout centers on a central main editing area that displays the active , allowing users to work with images in a dedicated space optimized for pixel-level precision. This area supports split views, featuring a normal resolution pane alongside a zoomed preview to facilitate detailed without losing sight of the overall composition; the views can be synced for scrolling when their dimensions align. At the bottom of the interface lies the palette display, presented as a 256-color indexed grid that enables quick selection of colors for drawing. Users left-click to set the foreground color and right-click for the background color, with these selectors visible adjacent to the grid to streamline the workflow in the indexed color system. The tool palette occupies the side of the window, featuring icons for essential brushes, shapes, and other drawing instruments, which users can access directly for efficient tool switching. A spare page toggle, activated via the TAB key or an icon, allows seamless alternation between the primary canvas and a secondary one, enhancing productivity for iterative work. Overhead, the menu and icon bars integrate core functions such as loading and saving files, adjusting , and quitting the application, all positioned for intuitive access within the single-window environment. This compact arrangement reflects GrafX2's design philosophy, drawing inspiration from 1990s paint programs like and Brilliance to prioritize mouse- and keyboard-driven operations in a retro, space-efficient interface.

Navigation and customization

GrafX2 provides intuitive keyboard navigation for efficient workflow, with cursor keys used to scroll the image when it exceeds the window boundaries. The TAB key swaps between the main canvas and the spare page, allowing quick access to a secondary buffer for storing image elements. Shortcuts for undo and redo are assigned to 'U' and Shift+'U' respectively, enabling rapid reversal of actions, while the 'M' key activates the magnifier for zooming, and '+' and '-' keys adjust the zoom level when magnified. Mouse interactions in GrafX2 follow a consistent : left-clicking on the applies the foreground color, while right-clicking applies the background color, which serves as the transparent index in brush tools to avoid overwriting existing pixels. This setup facilitates precise color placement without additional menu selections. Customization options allow users to personalize the interface extensively; keyboard shortcuts are remappable through the contextual help system accessed via F1, supporting up to two key combinations per function including modifiers like Shift, , and mouse wheel events. Theme adjustments are possible by editing skin files in the program's directory, limited to four colors for the , with changes reloadable without restarting. Interface scaling supports high-DPI displays via the and includes fixed GUI scaling factors for better visibility on various resolutions. Help systems enhance with on-screen tooltips that appear on hover over elements and one-line contextual descriptions triggered by F1, which also permits direct editing. Documentation is accessible through the program's menus, linking to the official for in-depth guidance. features include support for alternative input devices such as graphics tablets, though without pressure sensitivity, allowing use for precise cursor control. Brush sizes are configurable on-the-fly with '.' to increase and ',' to decrease, or DEL for a single-pixel brush, accommodating varied input methods and user preferences.

Features

Color and palette management

GrafX2 operates exclusively in mode, supporting up to 256 colors per image where each pixel references an index in the palette rather than direct RGB values, allowing efficient storage and manipulation for . Changing a color in the palette globally updates all pixels using that index throughout the image, enabling consistent recoloring without individual pixel edits. The palette editor provides tools for precise color adjustment, including sliders for hue, , and in both RGB and HSL modes, as well as options to edit groups of colors or generate ranges for gradients. Users can import and export palettes in standard formats such as .pal and , facilitating reuse across projects or compatibility with other software. Additionally, colors can be reordered within the palette without affecting the underlying image data, and automated palette generation aids in merging images from different sources. For color application, GrafX2 uses a foreground (FG) and background (BG) selection system, where the left applies the FG color and the right applies the BG color, with the latter also serving as a in certain brushes. These selections are made by clicking the corresponding palette entries, and any palette modifications propagate instantly to all affected pixels. When importing 24-bit images like JPEGs, GrafX2 converts them to the 256-color palette using the median-cut algorithm, which optimizes color reduction while preserving visual fidelity through dithering. A "clear palette" option determines whether unused slots beyond the imported image's color count are reset to black or retained from the previous palette. To support retro authenticity, GrafX2 includes special low-color modes that constrain the palette to emulate hardware limitations, such as a scale of 64 for VGA, a scale of 3 for 27 colors on , or a scale of 16 for 4096 combinations on the ( mode emulation). These modes adjust RGB precision with blockier sliders to preview and enforce color restrictions, defaulting to a 64-color menu palette that can be customized in rows and columns for better usability with limited sets.

Drawing and editing tools

GrafX2 provides a suite of brush tools for creating on the , including freehand drawing for precise pixel placement and an for softer, textured applications. Monochrome shape tools enable the construction of geometric forms such as lines, rectangles, circles, and curves using splines for smooth paths. Users can create custom color brushes by capturing groups of pixels via rectangular or freehand grab tools, allowing these brushes to be applied with background to preserve details during stamping. Editing functions facilitate modifications through for coloring enclosed areas, copy and paste operations in both mode for small elements and picture mode for larger sections, and selection tools like the magic wand for isolating color-based regions. Precision aids enhance accuracy, with snapping to align elements to a configurable for tile-based work. Layer allows users to raise or lower layers in the stack, merge them into others, and hide them temporarily for focused editing. The program features a multi-level undo system, enabling iterative revisions by reverting multiple actions without .

Effects and advanced functions

GrafX2 provides a range of basic effects designed for post- modifications to enhance , including , blending, , and smearing, which allow users to achieve more organic appearances in indexed-color images. operates through a quick-shade mode that applies custom gradients for effects, while blending supports additive and subtractive modes to mix colors within the 256-color palette limitations. uses a customizable matrix to soften edges, and smearing enables a drawing mode that distorts pixels for fluid, painterly results. These effects are applied via a dedicated Effects screen, where users select options like , , or modes to darken or lighten selected areas without altering the original palette structure. Advanced filters in GrafX2 extend these capabilities for specialized enhancements, such as explicit darken/lighten operations on sections and color to simulate by rotating palette entries. Darken and lighten functions modify brightness in targeted regions, preserving color integrity for retro-style graphics, while color animates static images by reordering shades, with cycles savable in and formats for seamless playback. Tilemap editing facilitates game through a mode that assembles and copies tiles into mockups, supporting patterned layouts for efficient level . These filters integrate with the program's indexed system, ensuring modifications remain within palette constraints to maintain compatibility with legacy hardware. Animation support in GrafX2 focuses on frame management for simple sequences, allowing users to create and edit multiple frames without relying on full layers, and merge them for output. Frames are handled in a timeline-like , where color cycling can overlay dynamic effects across sequences, enabling low-overhead animations suitable for assets or . This system supports loading and saving animated directly, with previews available in a split-view that displays zoomed edits alongside the actual-size result for accurate assessment. Utility functions complement these effects with practical tools like text rendering using or fonts, which can be applied to canvases for labeling or stylistic elements in . Low-resolution art helpers include pixel merging and software scaling options, such as 2x2 or 3x3 pixel expansions via command-line flags, aiding creation for 8-bit or 16-bit emulations like modes. All utilities operate through the Effects screen for non-destructive previews, with split-view integration ensuring real-time feedback during application. Lua scripting further enhances integration by automating effect chains, such as batch shading or cycling, for complex workflows.

File formats

Supported import formats

GrafX2 supports a variety of import formats, enabling users to load images from both modern and retro sources into its 256-color indexed palette environment. For modern formats, it handles PNG files with paletted images (2 to 256 colors) directly, converting greyscale PNGs to a 256-level greyscale palette while ignoring alpha channels and transparency. GIF files in Compuserve GIF 89a format are loaded with support for a single 256-color palette, transparency, and animation frames (introduced in version 2.4), including preservation of color cycling data. JPEG images, along with truecolor PNG and TGA files, are imported via the SDL_image library, undergoing 24-bit to indexed color conversion using the median-cut algorithm to generate a custom 256-color palette; this process is platform-dependent and lacks preview capabilities. Retro bitmap formats are a core strength, with full support for compressed and uncompressed files from classic drawing tools. PI1 and PC1 files from Degas Elite (Atari ST) are loaded completely, including RLE compression in PC1 variants and palette extraction for the embedded 16- or 52-color palettes, which GrafX2 extends to 256 colors if needed. NEO files from Neochrome (Atari ST) are imported fully, preserving the original 16-color palette and resolution modes (low, medium, high). IFF/ILBM files from Amiga systems, including Deluxe Paint variants like LBM and PBM (Deluxe Paint 2E/3.5 for MS-DOS and Amiga), support bitplane images, EHB modes, HAM via SHAM chunks, and additional elements such as TNY (Tiny Stuff thumbnails), color cycling (CRNG), and palette changes (PCHG); palette extraction occurs from CMAP or CLUT chunks. Other retro formats include PCX (Z-Soft, full support), BMP (most Microsoft Paint variants), IMG (Bivas), SCx (ColoRix VGA Paint), CEL/KCF (K.O.S.), and ICO (OS/2 and Windows icons/cursors, selecting the largest 8-bit image). Compressed files like PC1 and PKM (GrafX2's original RLE format, without layers or animation) are decompressed on import, with error handling for incompatible or corrupted data to prevent crashes. Platform-specific formats extend compatibility to vintage hardware. For Atari ST/TT, imports include PI1/PC1 (Degas), NEO (Neochrome), and higher-resolution PI4 (TT low-res, 320x480, 256 colors) and PI5 (TT medium-res, 640x480, 16 colors or monochrome). Apple II GS files such as APF (Apple Preferred Format), HGR, and DHGR are supported for loading, with palette adaptation to the program's 256-color limit. Thomson MO/TO formats (MAP and BIN) from systems like MO5/MO6/TO8 are imported, handling raw pixel data and embedded 4-bit RGB palettes with 16 indexes. Amstrad CPC/CPC+ pictures, MSX MODE2 (256x192), and raw PAL files (768-byte RGB or JASC palettes) are also loaded, often with automatic palette extraction and conversion to fit GrafX2's indexed model. TIFF files are supported via SDL_image for basic import. All imports focus exclusively on raster bitmap data up to 256 colors, with no support for or layers from external files; post-import, images are optimized for GrafX2's palette management, and incompatible elements (e.g., in non-GIF formats) are discarded or approximated during conversion.

Supported export formats

GrafX2 supports a variety of export formats tailored for , ranging from modern lossless options to legacy formats for retro compatibility and sharing. Among modern outputs, provides with full 256-color palette support and a single transparent color, though it lacks alpha channel . enables animated exports with non-looping frame sequences, preserving one 256-color palette, , and color cycling for effects like fire or water animations. offers high-quality, uncompressed saving for archival purposes, supporting up to 256 colors per image. Legacy formats include the deprecated custom PKM, which saves static images without layers or animation support and is no longer recommended for new work. BMP exports 256-color bitmaps suitable for broad compatibility, while IFF (including variants) ensures compatibility with 2–256 colors and color cycling, excluding EHB modes. Specialized exports cater to retro platforms: Neochrome (.NEO) for Atari ST, preserving palette and resolution; and PI1 for Degas-style images, popular in demoscene communities for 320x200 sharing. Other options like , , PC1, CEL, KCF, and SC? provide additional compatibility for older and tools. Export options include palette embedding in most formats to maintain fidelity, dithering for reducing colors in true-color outputs, and animation frame export specifically to . Palette files can be saved as JASC .PAL for external use. Recommendations emphasize using or over the outdated for better compatibility and features in web and retro applications.

References

  1. [1]
    GrafX2 - The ultimate 256-color painting program
    GrafX2 is a bitmap paint program inspired by the Amiga programs Deluxe Paint and Brilliance. Specialized in 256-color drawing.DownloadsFundamentals2010sAbout GrafX2Customization
  2. [2]
    http://grafx2.chez.com/index.php?article2/fundamentals
  3. [3]
    GrafX2 version 2.9.3250 - GitLab
    Oct 12, 2025 · GrafX2 version 2.9.3250. build date : Sun, 12 Oct 2025 10:16:25 + ... Source repository : https://gitlab.com/GrafX2/grafX2; Bug tracker ...<|control11|><|separator|>
  4. [4]
    Frequently Asked Questions - GrafX2
    Note that the source code of Grafx2 is freely available under the GPL license, so anybody is free to start such project on his own. Or pick a piece of code ...
  5. [5]
    About GrafX2 - GrafX2
    ### Summary of GrafX2
  6. [6]
    GrafX2 - Free Software Directory
    Dec 29, 2023 · A pixel-art focused tool inspired by Deluxe Paint. Originally running on MS-DOS as a bitmap editor authored by the team at Sunset Design, has ...
  7. [7]
    Version history - GrafX2
    GrafX2 has a long history, with the first versions being published in 1996. The development by the original team (Sunset Design) continued until late 1999.
  8. [8]
    grafX2 - GitLab
    Feb 24, 2017 · The ultimate 256 color painting program. Read more. GrafX2 pixelart pixel art + 2 more. C sdl · 3,251 Commits · 7 Branches · 9 Tags.
  9. [9]
    Develop/Compiling – GrafX2
    Jul 29, 2025 · SDL library v1.2; SDL_image library; libpng; FreeType library (optional); SDL_ttf library (optional); liblua5.1 (optional). Note that some ...
  10. [10]
    Documentation - GrafX2
    GrafX2 has a long history, with the first versions being published in 1996. The development by the original team (Sunset Design) continued until late 1999, ...
  11. [11]
    GrafX2
    FreeBSD, ​FreshPorts (ext). OpenBSD, ​http://openports.se/graphics/grafx2. Caanoo gaming console, ​Openhandhelds (ext).Missing: operating | Show results with:operating
  12. [12]
    doc · master · GrafX2 / grafX2 - GitLab
    gpl-2.0.txt ... === LICENSE === GrafX2 is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License ...
  13. [13]
    Downloads - GrafX2
    GrafX2 is available on many other platforms, most of which the main developers don't own. So, the binaries are provided by other people. Android · AppImage ...Missing: licensing | Show results with:licensing<|control11|><|separator|>
  14. [14]
    History - GrafX2
    New algorithm for reducing true color images to 256 colors. Support OS/2 and Windows CE BMP files. Support CGA and 3-plane PCX files.
  15. [15]
    GraFX 2 Beta 96.5% by Sunset Design - Pouet.net
    demotool. release date : december 1999. related : ported to: GraFX 2 (win32); ported to: Grafx2 ...
  16. [16]
    GraFX 2 (win32) by Eclipse - Demozoo
    GraFX 2 (win32). by Eclipse. Released January 2004 at State of the Art 2004 · Windows. No screenshot yet! Add one. Downloads.Missing: port | Show results with:port
  17. [17]
    DETAILED SETTINGS - GrafX2
    Possible values range from 1 to 256. Maximize preview Maximize the preview of the pictures so that it is as big as possible. If you're not in the same ...
  18. [18]
    Fundamentals - GrafX2
    Grafx2 is made for drawing with a system called indexed colors. This means that your image defines a palette of colors, 256 at most.Missing: Genode | Show results with:Genode
  19. [19]
    Helpers - GrafX2
    Keyboard shortcuts · Scroll picture : cursor arrows · Magnifier : M · Zoom in/out when magnified : + and - · Grab brush : B · Choose single-pixel brush : DEL · Color ...Missing: navigation | Show results with:navigation
  20. [20]
    HELP - GrafX2 - GitLab
    HELP. Contextual help is available by pressing the F1 key You can do it while hovering a menu icon, or while a window is open. When a keyboard shortcut is ...Missing: navigation customization options
  21. [21]
    Customization - GrafX2
    Documentation. Frequently Asked Questions · Getting Started · Fundamentals · Helpers · Customization · Low resolution art · Low colors · Layers.Customization · Settings · Bookmark Directories
  22. [22]
    Is Grafx2 compatible with drawing tablets? - Google Groups
    Hi, yes! I'm using it under WinME with a Wacom 18X12 Tablet with pen and digitizer, but GrafX2 is not pressuresensitive.Missing: devices | Show results with:devices
  23. [23]
    Features - GrafX2
    Features · Image editing in indexed colors (with palette), up to 256 colors · Classical tools : lines, circles, text, multiple undo/redo, built-in brushes, ...Missing: Pulsation | Show results with:Pulsation
  24. [24]
    Palette.wiki - Archive - Google Code
    * Default: Restores the predifined GrafX2 palette. * Gray: Transforms the current selection into its gray-scaled equivalent. * Negative: Transforms the current ...
  25. [25]
    Low colors - GrafX2
    By default, Grafx2 allows you to set RGB values of palette with 256 levels of precision, but if you are drawing graphics for older technologies (or inspired by ...Missing: management | Show results with:management
  26. [26]
    2010s - GrafX2
    GrafX2 2.6 added size options, keyboard shortcuts, generic drawing mode, better C64 support, and Thomson MO/TO picture loading. 2.5 added drawing ellipses/ ...Missing: Genode | Show results with:Genode
  27. [27]
    Grafx2 - Dash Cheat Sheets - Kapeli
    Grafx2 cheat sheet for Dash - Pixel art editing shortcuts and commands for the bitmap paint program. Download Dash for macOS to access this and other cheat ...
  28. [28]
    GrafX2 - Pricing, Features, and Details in 2025 - SoftwareSuggest
    GrafX2 is a bitmap graphics editor inspired by Amigas Deluxe Paint. It excels in pixel art creation, offering a wide range of tools and effects.
  29. [29]
    GrafX2 Help
    HAND-DRAWING Freehand draw. / Toggle. SPLINES Splines / Toggle. LINES Lines / Toggle. SPRAY Spray / Menu. FLOODFILL Floodfill / Replace col. POLYGONS POLYFORMS ...Missing: tools | Show results with:tools
  30. [30]
    UserGuide/FileFormats – GrafX2
    Feb 1, 2018 · Saving is always with 256-color palette. Palette transparency is supported, up to 1 color can be fully transparent. Saving is always in 8 ...
  31. [31]
    UserGuide/Develop/FileFormats/IFF – GrafX2
    ### Summary of Supported IFF Formats for Import in GrafX2
  32. [32]
    Test, Load and Save functions - GrafX2 - GitLab
    Modules. Amstrad CPC/CPC+ picture formats. Support for Amstrad CPC/CPC+ picture formats. Bitmap and icon files .BMP/.ICO/.CUR files from OS/2 or Windows.Missing: import | Show results with:import
  33. [33]
    2020s - GrafX2
    C64 file formats: show packer format and file size when loading; CPC file formats: load CPC+ ConvImgCPC files and some other executable formats. When loading ...Missing: list | Show results with:list
  34. [34]
    GIF format - GrafX2
    The GIF format uses LZW compression and stores indexed color pictures up to 256 colors. It has the ability to store several pictures in the same file : GrafX2 ...Missing: export | Show results with:export