Graphite is a free, open-source 2D graphics engine designed for artists and designers who need a unified, nondestructive workflow for vector editing, raster manipulation, motion graphics, and procedural generation. Built with Rust and powered by WebAssembly and WebGPU, it eliminates the need to switch between multiple apps by integrating graphic design, digital painting, VFX compositing, and desktop publishing into a single tool. Unlike traditional editors, Graphite’s core is a node graph system that enables parametric, scalable, and reversible creative workflows.
The project is community-driven and platform-agnostic, offering a web-based alpha version with native desktop apps (Windows, Mac, Linux) in release candidate stage. It runs entirely on the user’s hardware with no server dependency, prioritizing performance, privacy, and open standards. Its architecture leverages modern web technologies to deliver native-like speed across platforms while maintaining a unified codebase.
What You Get
- Node-based procedural editing - Create graphics using visual node graphs where every operation is nondestructive and parametrically adjustable—change a shape’s properties globally by tweaking a single node.
- Vector and raster editing in one tool - Combine scalable vector paths with pixel-based image manipulation without switching applications or losing quality.
- Procedural generation for patterns - Generate infinitely scalable designs like polka dots, fractals, and noise-filled shapes using node-based algorithms instead of manual drawing.
- Layer-based compositing - Stack and blend visual elements with opacity, blending modes, and masks in a nondestructive timeline-style workflow.
- WebAssembly and WebGPU powered - Achieve high-performance rendering and complex computations directly in the browser or native app without JavaScript overhead.
- Offline-first, server-free workflow - All editing happens locally on your device—no cloud uploads, no data tracking, no subscription fees.
Common Use Cases
- Creating scalable brand assets - A designer uses Graphite to build logos with procedural patterns that scale infinitely without rasterization, ensuring print and web consistency.
- Designing animated motion graphics - A motion designer generates dynamic transitions and visual effects using node graphs to control position, color, and shape over time.
- Producing magazine layouts with procedural elements - A publication designer uses Graphite’s upcoming desktop publishing tools to embed procedurally generated illustrations and textures into page layouts.
- Developing generative art for exhibitions - An artist creates unique, algorithm-driven visuals like Mandelbrot fractals with noise fills, exporting them as high-res SVG or PNG for display.
Under The Hood
Architecture
- Modular monorepo structure isolates editor frontend, node-graph execution engine, and platform-specific wrappers via workspace crates, enforcing clear domain boundaries
- Node-graph architecture implements dataflow programming with graph-craft for graph representation, node-macro for declarative node definitions, and interpreted-executor for runtime evaluation
- Dependency injection leverages Rust’s type system and trait objects, with core types defining interfaces and nodes implementing them for plug-in style extensibility
- Render pipeline is decoupled through wgpu-executor and abstracted shader systems, enabling type-safe raster and vector pipelines
- Build and dependency management uses Cargo workspaces with strict license compliance and third-party attribution, ensuring enterprise-grade supply chain hygiene
- Static, compile-time dependency resolution replaces traditional DI containers, eliminating runtime overhead while enhancing safety
Tech Stack
- Rust 1.88+ with extensive use of procedural macros and type-safe abstractions across editor, graph, and rendering layers
- WGPU 27.0 powers GPU-accelerated rendering with SPIR-V shaders and WASM-compatible configurations
- WebAssembly frontend interfaces with Rust backend via typed channels and async runtime, serving as the single source of truth for all operations
- Comprehensive dependency management with cargo-deny and about.toml ensures license compliance and auditability
- Build tooling enforces consistency across Rust, JavaScript, and Svelte with rustfmt, editorconfig, and Prettier
- Custom graph-based dataflow system replaces traditional web frameworks and SQL databases, using JSON serialization and in-memory state
Code Quality
- Extensive test suite covers unit, integration, and regression scenarios with utilities for editor state manipulation and graph evaluation
- Robust error handling uses structured propagation and descriptive messages, with panic-on-failure in critical paths
- Clear module boundaries separate editor core, node execution, and testing utilities, enabling maintainable and composable tests
- Strong type safety is enforced through explicit annotations, domain-specific types, and disciplined enum usage
- Automated test execution supports parallel runs and conditional compilation via feature flags for performance and relevance
- Consistent idiomatic Rust patterns and declarative test builders simplify complex state transitions
What Makes It Unique
- Native Svelte-based editor with bidirectional prop bindings that eliminate boilerplate for UI-engine state sync
- WebAssembly module serves as the unified runtime for all editing logic, ensuring cross-platform consistency and performance
- Dynamic floating menus adapt positioning and layout contextually based on viewport and interaction patterns
- Rasterized SVG viewport rendering preserves vector fidelity while enabling GPU-accelerated previews without external dependencies
- Extensible widget system allows plugin-driven UI extensions without modifying core components
- Built-in eyedropper with live color preview and gradient stop integration is implemented as a compositional floating menu, not a modal