High-Performance Image Editing,
Right in Your Browser.
100% Free & Open Source — Start Creating Instantly, No sign-up required.
OpenGPEX is an open-source pixel editor with zero-lag 60FPS interactions, non-destructive layer editing, and a sandboxed plugin ecosystem. Run it anywhere, or connect to GPEX-Cloud for edge sync and GPU-powered AI tools.
Everything You Need for Pixel-Perfect Editing
A comprehensive toolset powered by Catmull-Rom spline smoothing, stamp-based brush engines, non-destructive masking, and DPR-aware text rasterization — all running at 60FPS in your browser.
Professional Brush Engine
Catmull-Rom 4-point spline smoothing with stamp-based rendering. Adjustable size, opacity, hardness. Pen pressure via PointerEvent API.
Inline Text Editing
Native contenteditable DOM with full IME support. Auto/fixed box modes, 8-direction resize handles, DPR-aware rasterization on commit.
Non-Destructive Eraser
Erases via bitmap masks — original layer data is never lost. Hold Cmd/Ctrl to restore erased regions. Full undo/redo support.
Advanced Layer System
Multi-type layers (image, paint, text) with composite cascade state machine. Non-destructive transforms, locking, and bitmap mask support.
Precision Clip & Crop
Pixel-perfect cropping with aspect ratio presets, free-form handles, and smart guides. Stored in Local Space, immune to viewport changes.
Real-Time Adjustments
Live brightness, contrast, saturation, hue, and temperature controls. CSS filter preview pipeline with Worker-based full-quality export.
Multi-Format Export
PNG, JPEG, WebP, and AVIF (via WASM). Layer compositing runs in Web Workers using OffscreenCanvas — zero UI thread blocking.
Viewport-Isolated Undo
JSON Patch-based incremental undo that never causes viewport jumping. Document state and navigation are fully decoupled.
Priority-Based Interactions
Unified gesture dispatcher with priority chains. Smart guides, snap-to-pixel, keyboard modifiers, and context-aware cursors.
Buttery Smooth. Designed for 60FPS.
No matter how complex your project gets — hundreds of layers, massive canvases, detailed brushwork — OpenGPEX stays silky smooth. Every interaction responds instantly, so your creative flow is never interrupted.
Zero-Lag Drawing
Your brush follows your hand with no delay — strokes appear the instant you draw them.
Fast-track volatile refs bypass React rendering. 60FPS GSAP ticker drives all visual updates.
Massive Canvas Support
Work on ultra-high-resolution artwork (8K+) without slowdown or memory crashes.
Tiled 512×512 rendering with Mipmap LOD. Only dirty tiles re-render per interaction.
Unlimited Undo History
Go back as many steps as you need. Your viewport stays exactly where you left it — no sudden jumps.
JSON Patch-based incremental undo. Document state and viewport navigation are physically isolated.
Pixel-Perfect Precision
Edges stay sharp, layers align exactly, and there are no gaps between elements — even during transforms.
Subpixel mask margins + counter-rotation matrix sync prevent light-gaps at any zoom level.
Heavy Lifting in Background
Export, blend, and composite layers without freezing your interface. Keep editing while it works.
Web Workers + OffscreenCanvas handle heavy pixel ops. Main UI thread stays fully responsive.
Crash-Proof Plugins
Third-party tools can't crash your editor. Your work is always safe, no matter what plugins you install.
PluginErrorBoundary sandbox with UID namespace isolation. Faults are locally contained.
A Plugin System Built for Absolute Extensibility
Every tool in OpenGPEX — from the brush engine to the layer panel — is a plugin. The metadata-driven IoC registry enables seamless extension without touching core code, with full runtime safety guarantees.
Metadata-Driven Registry
Plugins declare slots (SIDE_BAR, VIEWPORT_OVERLAY, OPTION_BAR), commands, and signals. The build compiler generates a global UID catalog automatically — zero manual wiring.
PluginErrorBoundary Sandbox
Third-party plugins render inside fault-tolerant error boundaries. A fatal crash in any plugin is isolated locally — the core canvas, undo stack, and project saving remain 100% intact.
UID Namespace Isolation
Every plugin, command, and signal gets a unique prefixed UID (author.category.plugin.cmd.name). Scoped context ensures plugins can only mutate their own authorized state blocks.
Physical Slot Positions
Discover and install community plugins. One-click install from the Hub, with sandboxed execution in the running editor.
Free and Open Source.
Self-Host, Fork, Embed — Your Rules.
OpenGPEX is licensed under GPL-3.0. The full source of the core editor, plugin system, brush engine, and rendering pipeline is open. Run it locally, deploy on your own infrastructure, build derivative works under the same open license, or contribute back to the community. Zero telemetry, zero vendor lock-in.
✔ 20+ core plugins loaded · 0 errors
Frequently Asked Questions
Common questions about OpenGPEX.
What is OpenGPEX?
OpenGPEX is an open-source, browser-based pixel editor featuring a tiled rendering pipeline, dual-track 60FPS architecture, non-destructive layer editing, and a fully extensible plugin system. You can self-host it for free, or use the official GPEX-Cloud service for edge sync, team collaboration, and GPU-powered AI tools.
How do I install and run OpenGPEX locally?
Clone the repository, run `pnpm install` and `pnpm dev`. The editor launches at localhost:3000 with all core plugins loaded. No external services or API keys are required — everything runs offline in your browser.
What image formats can I import and export?
Import supports PNG, JPEG, WebP, and common bitmap formats via drag-and-drop or file picker. Export supports PNG (lossless), JPEG (lossy), WebP (modern), and AVIF (next-gen via WebAssembly). All encoding runs in background Web Workers so the UI stays responsive.
Can I use OpenGPEX on mobile or tablet?
OpenGPEX uses the PointerEvent API which supports touch and stylus input. The viewport supports pinch-to-zoom and pan gestures. While the UI is optimized for desktop workflows, basic editing is functional on tablets with modern browsers.
How do I create a custom plugin?
Follow the 5-File Pattern: create a folder with index.tsx (plugin entry), protocols.ts (constants & IDs), commands.ts (business logic), hooks.ts (React bridges), and components.tsx (UI). Declare your target slot (SIDE_BAR, VIEWPORT_OVERLAY, etc.) and register commands/signals. The core auto-discovers your plugin at build time.
How does the plugin sandbox prevent crashes?
Every plugin renders inside a PluginErrorBoundary. If your plugin throws a fatal exception, only that plugin's UI is replaced with an error fallback — the core canvas, undo history, and project saving remain fully intact. Dynamic plugins also receive namespaced UIDs to prevent ID collisions.