Graphite/website/content/features.md

+++ title = "Graphite features"

[extra] css = ["features.css"] +++

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 compositing

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 not fully implemented yet

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 may 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 native resolution.

Marrying vector and raster under one roof enables both art forms to complement each other in a cohesive content creation workflow.

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

Procedurally alterable vector data

Imaginate (Stable Diffusion node/tool)

Native desktop app (with Tauri)

Custom subgraph nodes

Boolean operations for shapes

WebGPU accelerated rendering

Adaptive resolution raster rendering

Interactive graph auto-layout

Imported RAW photo processing

AI nodes and tools (e.g. magic wand)

New vector 2D renderer (with Vello)

Fully-supported brush tool

Timeline with animation channels

Graph data attribute spreadsheet

Local file browser for saving/loading

Local fonts access

Stable document format

— Alpha 4 —

Select mode (marquee masking)

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

Node manager 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…