Graphite
An open source graphics editor for 2025: comprehensive 2D content creation tool suite for graphic design, digital art, and interactive real-time motion graphics — featuring node-based procedural editing
Top Related Projects
Animated sprite editor & pixel art tool (Windows, macOS, Linux)
A simple web-based tool for Spriting and Pixel art.
draw.io is a JavaScript, client-side editor for general diagramming.
Virtual whiteboard for sketching hand-drawn like diagrams
Quick Overview
Graphite is an open-source, cross-platform 2D vector graphics editor and illustration tool. It aims to provide a powerful, user-friendly alternative to commercial software like Adobe Illustrator, with a focus on performance and extensibility. Graphite is built using Rust and WebAssembly, allowing it to run both natively and in web browsers.
Pros
- Cross-platform compatibility (Windows, macOS, Linux, and web browsers)
- Open-source and free to use
- Built with modern technologies (Rust, WebAssembly) for performance and security
- Extensible architecture allowing for custom tools and plugins
Cons
- Still in early development, with some features missing or incomplete
- Smaller community and ecosystem compared to established commercial alternatives
- Limited documentation and learning resources due to its early stage
- May lack some advanced features found in mature commercial software
Getting Started
To get started with Graphite, follow these steps:
- Visit the official website: https://graphite.rs/
- Choose your preferred platform:
- For desktop: Download the appropriate installer for your operating system
- For web: Use the online version directly in your browser
- Launch Graphite and start creating your vector graphics
- Explore the available tools and features through the user interface
- Join the community on Discord or GitHub to stay updated and get support
Note: As Graphite is an application rather than a code library, there are no code examples or quick start instructions for developers. However, if you're interested in contributing to the project, you can find the source code and development guidelines on the GitHub repository.
Competitor Comparisons
Animated sprite editor & pixel art tool (Windows, macOS, Linux)
Pros of Aseprite
- Mature and stable project with a long development history
- Extensive feature set for pixel art and animation
- Cross-platform support (Windows, macOS, Linux)
Cons of Aseprite
- Closed-source and paid software (though source code is available)
- Limited to pixel art and sprite creation
- Less frequent updates compared to Graphite
Code Comparison
Aseprite (C++):
void Image::putPixel(int x, int y, color_t color)
{
if (x >= 0 && x < m_width &&
y >= 0 && y < m_height)
*(m_bits + y*m_rowstride + x) = color;
}
Graphite (Rust):
pub fn put_pixel(&mut self, x: u32, y: u32, color: Color) {
if x < self.width && y < self.height {
let index = (y * self.width + x) as usize;
self.pixels[index] = color;
}
}
Both examples show similar pixel manipulation functions, with Aseprite using C++ and Graphite using Rust. The core functionality is comparable, but Graphite's implementation benefits from Rust's safety features and more modern syntax.
A simple web-based tool for Spriting and Pixel art.
Pros of Piskel
- Web-based application, accessible from any browser without installation
- Simpler interface, potentially easier for beginners to use
- Focused specifically on pixel art and animated sprites
Cons of Piskel
- Limited feature set compared to Graphite's more comprehensive toolset
- Less active development, with fewer recent updates
- Primarily targets pixel art, while Graphite supports various graphic styles
Code Comparison
Piskel (JavaScript):
ns.SpriteSheet.prototype.clone = function () {
var clonedFrames = this.frames.map(function (frame) {
return frame.clone();
});
return new pskl.model.SpriteSheet(clonedFrames, this.width, this.height);
};
Graphite (Rust):
pub fn clone_selected(&mut self) -> Option<EntityId> {
let selected = self.selection.selected_entities();
if selected.is_empty() {
return None;
}
let cloned = self.clone_entities(&selected);
Some(cloned[0])
}
Both repositories implement cloning functionality, but Graphite's implementation in Rust potentially offers better performance and memory safety. Piskel's JavaScript code focuses on sprite sheet cloning, while Graphite's Rust code handles entity cloning within a more complex graphics editing context.
draw.io is a JavaScript, client-side editor for general diagramming.
Pros of draw.io
- Mature and widely adopted project with a large user base
- Extensive feature set for creating various types of diagrams
- Available as both web-based and desktop applications
Cons of draw.io
- Primarily focused on diagramming, less suitable for general-purpose vector graphics
- Steeper learning curve due to the abundance of features
- Less modern UI compared to newer vector graphics tools
Code Comparison
draw.io (JavaScript):
var graph = new mxGraph(container);
var parent = graph.getDefaultParent();
graph.getModel().beginUpdate();
try {
var v1 = graph.insertVertex(parent, null, 'Hello,', 20, 20, 80, 30);
var v2 = graph.insertVertex(parent, null, 'World!', 200, 150, 80, 30);
var e1 = graph.insertEdge(parent, null, '', v1, v2);
} finally {
graph.getModel().endUpdate();
}
Graphite (Rust):
let mut document = Document::new();
let layer = Layer::new();
let rect = Rectangle::new(Point::new(100.0, 100.0), 200.0, 150.0);
let circle = Circle::new(Point::new(300.0, 300.0), 50.0);
layer.add_shape(rect);
layer.add_shape(circle);
document.add_layer(layer);
Note: The code snippets demonstrate basic shape creation in each project, but may not reflect the most current syntax or best practices.
Virtual whiteboard for sketching hand-drawn like diagrams
Pros of Excalidraw
- Lightweight and fast, with a focus on simplicity and ease of use
- Extensive library of pre-made shapes and icons for quick diagramming
- Collaborative features for real-time editing with multiple users
Cons of Excalidraw
- Limited advanced drawing tools and features compared to Graphite
- Less suitable for complex illustrations or professional graphic design work
- Primarily web-based, which may limit offline functionality
Code Comparison
Excalidraw (JavaScript):
export const renderElement = (
element: ExcalidrawElement,
rc: RoughCanvas,
context: CanvasRenderingContext2D,
renderConfig: RenderConfig
) => {
// Rendering logic
};
Graphite (Rust):
pub fn render_element(
element: &Element,
canvas: &mut Canvas,
context: &mut RenderContext,
config: &RenderConfig,
) -> Result<(), RenderError> {
// Rendering logic
}
Both projects use similar rendering approaches, but Graphite's implementation in Rust may offer performance benefits for more complex rendering tasks.
Convert 
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
Your procedural toolbox for 2D content creation
Graphite is a free, open source vector and raster graphics engine, available now in alpha. Get creative with a fully nondestructive editing workflow that combines layer-based compositing with node-based generative design.
Having begun life as a vector editor, Graphite continues evolving into a generalized, all-in-one graphics toolbox that's built more like a game engine than a conventional creative app. The editor's tools wrap its node graph core, providing user-friendly workflows for vector, raster, and beyond. Photo editing, motion graphics, digital painting, desktop publishing, and VFX compositing are additional competencies on the planned roadmap making Graphite into a highly versatile content creation tool.
Learn more from the website, subscribe to the newsletter, consider volunteering or donating, and remember to give this repository a â!
https://github.com/user-attachments/assets/f4604aea-e8f1-45ce-9218-46ddc666f11d
Support our mission â¤ï¸
Graphite is 100% community built and funded. Please become a part of keeping the project alive and thriving with a donation if you share a belief in our mission:
Graphite strives to unshackle the creativity of every budding artist and seasoned professional by building the best comprehensive art and design tool that's accessible to all.
Mission success will come when Graphite is an industry standard. A cohesive product vision and focus on innovation over imitation is the strategy that will make that possible.
Screenshots
Contributing/building the code
Are you a graphics programmer or Rust developer? Graphite aims to be one of the most approachable projects for putting your engineering skills to use in the world of open source. See instructions here for setting up the project and getting started.
By submitting code for inclusion in the project, you are agreeing to license your changes under the Apache 2.0 license, and that you have the authority to do so. Some directories may have other licenses, like dual-licensed MIT/Apache 2.0, and code submissions to those directories mean you agree to the applicable license(s).
Top Related Projects
Animated sprite editor & pixel art tool (Windows, macOS, Linux)
A simple web-based tool for Spriting and Pixel art.
draw.io is a JavaScript, client-side editor for general diagramming.
Virtual whiteboard for sketching hand-drawn like diagrams
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot