Graphite features

The current alpha version of Graphite is a tool for vector art and graphic design. It also supports a limited, experimental raster editing toolset. All this is built around a central node graph that stores layer data and provides a basic—but continually improving—procedural design and nondestructive editing workflow which is a unique feature among vector editing software.

Stay tuned for major performance uplifts, a multiplatform native desktop app, and a full suite of raster editing tools being developed throughout 2024.

Layers & nodes: hybrid editing

Graphite combines the best ideas from multiple categories of digital content creation software to redefine the workflows of 2D graphics editing. It is influenced by the core editing experience of traditional layer-based raster and vector apps, the nondestructive approaches of VFX compositing programs used by film studios, and the boundless creative possibilities of procedural production tools daily-driven by the 3D industry.

Classic layer-based image editing is easy to understand, with collapsable folders that help artists stay organized. A variety of interactive viewport tools make it easy to manipulate the layers by drawing directly onto the canvas. On the other hand, node-based editing is like artist-friendly programming. It works by describing manipulations as steps in a flowchart, which is vastly more powerful but comes with added complexity.

The hybrid workflow of Graphite offers a classic tool-centric, layer-based editing experience built around a procedural, node-based compositor. Users can ignore the node graph, use it exclusively, or switch back and forth with the press of a button while creating content. Interacting with the canvas using tools will manipulate the nodes behind the scenes. And the layer panel and node graph provide two equivalent, interchangeable views of the same document structure.

Raster & vector: sharp at all sizes

Digital 2D art commonly takes two forms. Raster artwork is made out of pixels which means it can look like anything imaginable, but it becomes blurry or pixelated when upscaling to a higher resolution. Vector artwork is made out of curved shapes which is perfect for some art styles but limiting to others. The magic of vector is that its mathematically-described curves can be enlarged to any size and remain crisp.

Other apps usually focus on just raster or vector, forcing artists to buy and learn both products. Mixing art styles requires shuttling content back and forth between programs. And since picking a raster document resolution is a one-time deal, artists often choose to start really big, resulting in sluggish editing performance and multi-gigabyte documents.

Graphite reinvents raster rendering so it stays sharp at any scale. Artwork is treated as data, not pixels, and is always redrawn at the current viewing resolution. Zoom the viewport and export images at any size— the document's paint brushes, masks, filters, and effects will all be rendered at the current native resolution.

Marrying vector and raster under one roof enables both art forms to complement each other in a cohesive content creation workflow. (Scalable raster compositing is still in-development.)

Powered by Graphene

Graphene is the node graph engine that powers Graphite's compositor and procedural graphics pipeline. It's a visual scripting environment built upon the high-performance Rust programming language. Its runtime is designed to distribute rendering across CPU cores, GPUs, and network/cloud machines while optimizing for interactive frame rates.

Written in Rust

Always on the bleeding edge and built to last— Graphite is written on a robust foundation with Rust, a modern programming language optimized for creating fast, reliable, future-proof software. Even the GPU compute shaders are written in Rust, enabling reuse of CPU code implementations for nodes.

Roadmap

— Pre-Alpha —

Editor systems; basic vector art tools

— Alpha 1 —

Better tools; node graph prototyping

— Alpha 2 —

Fully node graph-driven documents

— Alpha 3 —

Stackable adjustment layers
Boolean operations for shapes
Editable nested node subgraphs
Procedurally alterable vector data
New vector 2D renderer (with Vello)
Imaginate (Stable Diffusion node/tool)
GPU-accelerated raster rendering
Imported RAW photo processing
Interactive graph auto-layout
Adaptive resolution system
Graph data attribute spreadsheets
Timeline with animation channels
Native desktop app (with Tauri)
Local file browser for saving/loading
Fully-supported brush tool
Select mode (marquee masking)
Stable document format

— Alpha 4 —

AI nodes and tools (e.g. magic wand)
Local fonts access
Command palette and context menus
Outliner panel (node graph tree view)
Variable color swatches
Mesh vector format
Shape builder tool
Guide mode (construction geometry)
CAD-like constraint relationships
Hosted compile/render server
Code editor for custom nodes

— Beta —

Document history management
Internationalization and accessibility
Frozen-in-time graph references
Liquify and non-affine rendering
Reconfigurable workspace panels
Automation and batch processing
HDR and WCG color handling
CMYK and other color spaces
Asset libraries and marketplace
Portable, embeddable render engine
Predictive graph rendering/caching

— 1.0 Release —

Procedural styling of paint brushes
Constraint models for UI layouts
Advanced typography and typesetting
PDF export
Finer-grain control over SVG export
Distributed graph rendering
Cloud document storage
Multiplayer collaborative editing
Offline edit resolution with CRDTs
Native UI rewrite (no HTML frontend)
SVG animation authorship
Live video compositing
Pen and touch-only interaction
iPad app
…and that's all just the beginning…