Graphite

Graphite is an open source, community-driven 2D content creation suite that reimagines what a graphics editor can be. Where traditional tools like Illustrator or Photoshop silo vector and raster work into separate applications, Graphite merges them into a unified, nondestructive editing environment powered by a live node graph. Every brush stroke, boolean operation, and color adjustment is a composable, reversible node—so you can rethink your creative decisions at any point without degrading quality or losing work.

At its technical core, Graphite is built in Rust and compiled to WebAssembly, delivering near-native performance directly in the browser with no installation required. An experimental desktop app (Windows, macOS, Linux) is in release-candidate stage, using the same WASM runtime wrapped in a native window. GPU-accelerated rendering via WebGPU and the wgpu library enables complex procedural effects and raster compositing at interactive speeds even on large canvases.

The editor’s architecture is intentionally open-ended. The node graph is not just a visual scripting layer—it is the document format. Every design decision is serialized as a graph of typed, composable nodes, making files trivially inspectable, diffable, and scriptable. Nodes cover vector path manipulation, image color grading, procedural pattern generation, physics-based effects, text layout, and real-time animation. New capabilities can be added by composing existing nodes or by implementing a new node in Rust with a declarative macro.

Graphite is fully funded by community donations and volunteer contributors. There are no subscription tiers, no cloud lock-in, and no feature paywalls. The project is in alpha and is actively developed with an ambitious roadmap covering digital painting, desktop publishing, VFX compositing, and an AI-assisted creative workflow layer.

What You Get

• Node-based nondestructive editing - Every transformation, filter, and drawing operation is a live node in a graph, so any parameter can be tweaked after the fact without redoing work or losing fidelity.
• Unified vector and raster pipeline - Work with scalable vector paths and pixel-level raster imagery in the same document, composited and rendered together through the same node graph without format conversion.
• Procedural pattern and generative art tools - Build infinitely scalable designs—polka dots, fractals, Voronoi patterns, noise textures—by wiring together math and generation nodes rather than drawing each element by hand.
• Real-time animation playback - Drive node parameters with time-based or frame-based animation curves to create motion graphics and interactive effects directly inside the editor.
• GPU-accelerated rendering via WebGPU - Complex raster effects, shader-based filters, and large canvas operations are offloaded to the GPU using the wgpu library and WGSL shaders for interactive frame rates.
• Browser-native with optional desktop app - Run Graphite instantly at editor.graphite.art with no installation, or download the native desktop build for Windows, macOS, or Linux once it reaches stable release.
• Open file format based on the node graph - Documents are serialized JSON node graphs that are human-readable, version-control-friendly, and scriptable without proprietary tooling.

Common Use Cases

• Designing scalable brand identities - A graphic designer builds logo systems with procedural symmetry and parametric color palettes, then exports clean SVG at any size without rasterization artifacts.
• Generating algorithmic art for print or exhibition - An artist wires together noise, fractal, and color-mapping nodes to produce Mandelbrot-filled compositions exported as high-resolution PNGs or infinitely scalable SVGs.
• Prototyping animated motion graphics - A motion designer uses the animation timeline and node-driven parameter curves to produce looping transitions and data-driven visual effects without leaving the editor.
• Creating procedural textures for game or web assets - A developer builds tileable, parametrically adjustable texture sheets using noise and repeat nodes, then exports them directly for use in game engines or CSS backgrounds.
• Educational exploration of visual programming - A teacher or learner uses Graphite’s transparent node graph to explore how graphic operations compose, making it ideal for understanding image processing concepts visually.

Under The Hood

Architecture Graphite is organized as a Cargo workspace of tightly scoped crates that enforce strict domain boundaries: an editor crate handles all user-facing message dispatch via a centralized Dispatcher using typed, discriminant-driven message queues; a graph-craft crate owns the document node model and compilation from a higher-level NodeNetwork to a flattened ProtoNetwork; and an interpreted-executor crate handles runtime evaluation of the compiled graph. The node graph is both the runtime representation and the document format, serialized as JSON with stable hashed node IDs, making documents inherently diffable and versionable. Rendering is fully decoupled through a wgpu-executor crate that abstracts GPU operations behind trait interfaces, so the raster and vector pipelines can evolve independently. The frontend Svelte application communicates with the WASM core through a typed bidirectional channel, with all mutable state owned exclusively by Rust—the JavaScript layer is purely a rendering and input surface.

Tech Stack The editor core is written in Rust 1.88 using the 2024 edition, compiled to WebAssembly via wasm-bindgen for browser deployment and wrapped in a Chromium Embedded Framework shell for native desktop use on Windows, macOS, and Linux. GPU rendering uses wgpu 29 with WGSL shaders and SPIR-V compilation support, targeting both WebGPU in browsers and native GPU APIs on desktop. The vector pipeline leans on the Linebender ecosystem—kurbo for bezier math, vello for GPU-accelerated path rendering, resvg/usvg for SVG parsing and rasterization, and parley/skrifa for text shaping. The Svelte 5 frontend uses Vite 8 and TypeScript, communicating with the Rust backend through wasm-bindgen-generated TypeScript bindings. New node types are declared with a #[node_macro] procedural macro that auto-generates UI registration, serialization, and type metadata from an annotated Rust function.

Code Quality The codebase has a solid test foundation: unit and integration tests exist across the editor message handlers, graph-craft document model, interpreted-executor, and node implementations including math, vector, and brush nodes. Error handling follows Rust idioms with typed Result propagation using thiserror and anyhow; panics are limited to genuinely unrecoverable invariant violations. Type safety is enforced aggressively—tagged values, domain-specific wrapper types, and disciplined enum hierarchies prevent mixing of incompatible coordinate or color representations. The CI pipeline enforces rustfmt formatting, cargo-deny for license compliance and dependency auditing, and runs the full test suite on pull requests. Code quality is strong in the core layers; the sheer breadth of the node library means some newer node implementations are thinner on inline documentation, which tempers an otherwise excellent baseline.

What Makes It Unique Graphite’s defining architectural novelty is treating the node graph as the document model rather than as an optional scripting layer bolted onto a conventional layer stack. This means documents are deterministic, reproducible pipelines: given the same node graph and inputs, the output is always identical, which enables features like procedural animation, algorithmic art at infinite resolution, and lossless round-tripping through serialization. The #[node_macro] system lets contributors add new capabilities in a single annotated Rust function with zero boilerplate for UI wiring or type registration, lowering the barrier to extending the editor significantly. Running the full editing engine in WebAssembly without a server component is also unusual for a graphics application of this ambition—there is no account required, no data uploaded, and no vendor dependency for the core creative workflow.

Self-Hosting

Graphite is licensed under the Apache License 2.0, one of the most permissive open source licenses available. You can use it commercially, modify the source code, distribute it, and sublicense your modifications without triggering copyleft obligations on your own work. The license requires attribution and preservation of the Apache 2.0 notice in distributed copies, but imposes no restrictions on proprietary use of the editor or on works created with it. There are no contributor license agreement surprises: contributors agree to license their code under Apache 2.0 when submitting patches.

Self-hosting Graphite means serving the compiled WebAssembly and JavaScript frontend—there is no backend server, no database, and no persistent network service required. The entire application runs in the browser or as a native desktop executable. You can host the web build on any static file server or CDN. The native desktop app bundles the same runtime using the Chromium Embedded Framework (CEF), which means deployment is a matter of distributing a self-contained binary. There are no moving parts to manage at runtime: no container orchestration, no managed database, no auth service. If you build from source you will need the full Rust and Node.js toolchain, which adds meaningful setup complexity, but the compiled artifacts are fully standalone.

Because Graphite is a single-user local application with no cloud synchronization layer, there is no hosted SaaS tier to compare against. What you get from self-hosting is identical to the official hosted version at editor.graphite.art. The trade-off is that you take on responsibility for staying current with upstream releases—the project moves quickly and file format migrations may be required between versions. There is no commercial support contract, SLA, or managed upgrade path. The community Discord and GitHub issues are the primary support channels, and response quality depends entirely on volunteer availability.