GraphiteEditor/Graphite
41.8
Weak · 14 November 2026
248k
lines of production code
Rust
with TypeScript
5
measurements over time
What this system is
Features
Add Rust-based editor message tree generator tool
Introduces a new Rust utility in \tools/editor-message-tree\ that generates a hierarchical visualization of the editor's message system. The tool outputs both a plain-text outline and an interactive HTML page, including file paths and line numbers for code navigation, as well as warnings for messages that do not follow the standard naming conventions (ending in 'Message', 'MessageHandler', or 'MessageContext').
tools/editor-message-tree · high confidence
Add animation curve evaluation and keyframe management
The animation library now supports defining and evaluating animation curves with keyframes. Users can create curves using linear, constant, or cubic Bézier interpolation behaviors. The \AnimationCurve\ struct provides methods to insert, remove, and evaluate keyframes at specific times, handling edge cases like out-of-bounds time values and ensuring curve validity during deserialization.
node-graph/libraries/animation · high confidence
Add desktop application entry for Graphite
A new .desktop file has been added to define the Graphite application in the desktop environment, enabling it to appear in application menus and launchers. The entry specifies the executable as 'graphite', sets the icon to 'art.graphite.Graphite', and categorizes the application under Graphics, VectorGraphics, and RasterGraphics.
desktop/assets · high confidence
Add export command to Graphene CLI for SVG, PNG, JPG, and animated GIF
The Graphene CLI now includes an \export\ subcommand that allows users to render and save documents from \.graphite\ or \.gdd\ files to disk. Supported output formats include SVG, PNG, JPG, and animated GIF. Users can control the export scale, specify exact output dimensions, enable transparent backgrounds for PNGs, and configure animation parameters (FPS, frame count, or duration) for GIF exports.
node-graph/graphene-cli · high confidence
Add styling for contributor guide interactive tools
The contributor guide now includes dedicated SCSS styles for three new interactive sections: the build link bisect tool, the crate dependency graph visualization, and the editor structure outline. These styles define the layout, typography, and interactive states (such as hover effects, focus rings, and expand/collapse toggles) for the bisect tool's input fields and progress indicators, the crate hierarchy's zoom controls and SVG viewport, and the editor structure's tree view with nested message and subsystem highlighting.
website/sass/page/contributor-guide · high confidence
Added DynAny derive macro for automatic StaticType implementation
A new \DynAny\ derive macro has been added to the \dyn-any-derive\ crate, allowing users to automatically implement the \StaticType\ trait for structs. This macro generates an unsafe implementation that maps generic lifetime parameters to \'static\ for the static type and \'dyn\_any\ for the dynamic type, simplifying the integration of custom structs into the dynamic any system.
libraries/dyn-any/derive · high confidence
Added runtime profiling benchmarks using gungraun
New benchmark files have been added to the graph-craft crate to enable manual runtime profiling. The project has migrated from iai-callgrind to the successor library gungraun, introducing a new benchmark (compile\_demo\_art\_gungraun.rs) that uses gungraun's library benchmarking capabilities. Additionally, a criterion-based benchmark (compile\_demo\_art\_criterion.rs) was added, which utilizes std::hint::black\_box for proper benchmarking isolation.
node-graph/graph-craft · high confidence
Auto-generated node catalog for the user manual
The user manual now includes an automatically generated node catalog. A new tool in \tools/node-docs\ reads the internal node registry and produces Markdown pages for the catalog index, individual category pages, and detailed node documentation. This ensures the manual always reflects the current set of available nodes, their categories, descriptions, input/output types, and context dependencies without manual maintenance.
tools/node-docs · high confidence
Core node-graph data types and node definition infrastructure introduced
This change establishes the foundational data types and node definition system for the node-graph library. It introduces the core \Node\ trait and \NodeIO\ interface, enabling the definition of graph nodes with single inputs and typed outputs. A new attribute system is implemented via constants in \list.rs\ (e.g., \ATTR\_TRANSFORM\, \ATTR\_OPACITY\, \ATTR\_GRADIENT\_SPREAD\) to standardize how properties like transforms, opacity, and gradient behaviors are passed between nodes. The \context.rs\ module adds a feature-rich context system allowing nodes to extract and inject runtime data such as pointer position, animation time, and footprint. Additionally, the \registry.rs\ module provides a global node registry and metadata structure, supporting features like multi-output nodes via the \Destructure\ trait and configurable UI widgets through \FieldMetadata\. The \ops.rs\ module defines conversion traits (\Convert\) with specific rounding behavior for number types, and \bounds.rs\ introduces bounding box logic for rendering and thumbnails.
node-graph/libraries/core-types/src · high confidence
Desktop app now runs on Linux, macOS, and Windows
The desktop application is now available on Linux, macOS, and Windows. This change introduces platform-specific entry points that initialize the core desktop logic on all three operating systems, with macOS additionally launching a separate helper process for UI rendering.
desktop/platform/linux, desktop/platform/mac, desktop/platform/win · high confidence
Editor build script adds Git commit metadata and release series info
The editor now includes a build script that embeds Git commit details (hash, date, branch) and the current release series (Alpha 5) into the binary at compile time. This allows the application to display accurate version and build information, with fallbacks to 'unknown' if Git is unavailable or environment variables are not set by CI.
editor · high confidence
Frontend migration to Svelte and Vite with service worker support
The frontend application has been rewritten using the Svelte framework and the Vite build system, replacing the previous Vue-based architecture. This change introduces a new application entry point (\App.svelte\) that initializes the WebAssembly editor wrapper and a subscriptions router to handle backend messages. To improve reliability and offline capabilities, a service worker has been added to cache application assets and deferred content like demo artwork. The codebase also includes new TypeScript type definitions for global browser APIs and Vite-specific environments to support the new tooling.
frontend/src · high confidence
Introduce DynAny library for non-static type erasure
The \libraries/dyn-any\ crate has been added, providing a \DynAny\ trait and derive macros that enable type erasure and downcasting for types with non-\'static\ lifetimes. This library introduces \Upcast\ and \UpcastFrom\ traits to safely cast concrete types to dynamic trait objects (\dyn DynAny\) and back, supporting both reference and boxed ownership. It also includes implementations for standard collections like \Cow\ and slices, along with Apache-2.0 and MIT dual licensing.
libraries/dyn-any · high confidence
Introduce Export Dialog with configurable file type, scale, and bounds
The editor now includes a dedicated Export dialog that allows users to customize export settings before saving. Users can select from a range of file formats including vector (SVG) and raster types (PNG, JPG, WEBP, TIFF, BMP, TGA, ICO), adjust the scale factor for resolution, and define the export area as All Artwork, Selection, or specific Artboards. The dialog intelligently handles edge cases, such as falling back to 'All Artwork' if 'Selection' is chosen but no items are currently selected, and disables scale adjustment for vector exports.
_editor/src/messages/dialog/export\dialog · high confidence
Introduce Nix-based build and development environment
Added .nix/default.nix and .nix/dev.nix to define a reproducible Nix build for the Graphite project, exposing packages such as graphite, graphite-dev, and graphite-cef, along with multiple devShells (default, full, minimal, x11, playwright) that configure toolchains (rustc, cargo, rust-analyzer, clippy, rustfmt), build helpers (lld, mold, wasm-bindgen-cli, binaryen), and optional desktop/X11/Playwright dependencies and environment variables.
.nix · high confidence
Introduce Preferences Dialog for Editor Settings
Adds a new Preferences dialog that allows users to customize editor options, specifically including Navigation settings (Zoom Rate and Zoom with Scroll) and Editing settings (Selection mode: Touched, Enclosed, or Directional). The dialog handles state management by tracking unmodified preferences to detect changes requiring a restart and provides a confirmation flow for such changes.
_editor/src/messages/dialog/preferences\dialog · high confidence
Introduce Rawkit library for Sony camera raw file support
Added the Rawkit library, a Rust-based component for extracting images from Sony camera raw files (specifically .arw formats). This addition includes the core decoding logic for ARW1, ARW2, and uncompressed raw variants, a comprehensive set of camera-specific color calibration data (xyz\_to\_camera matrices) for numerous Sony models, and procedural macros to bundle this data into the binary. Users can now decode raw pixel data and associated metadata from supported Sony cameras.
libraries/rawkit · high confidence
Introduce SVG and Peniko rendering backends
The rendering library now supports exporting to SVG and rendering via the Peniko graphics library (used by Vello). This adds a new \convert\_usvg\_path\ module to translate SVG paths into the internal BezPath format, implements SVG generation logic in \render\_ext.rs\ and \renderer.rs\ (handling gradients, masks, and blend modes), and provides a \to\_peniko\ module to map internal blend modes and colors to Peniko types. This enables SVG preview/export capabilities and integrates the rendering pipeline with the Peniko/Vello stack.
node-graph/libraries/rendering · high confidence
Introduce app window message types and handler for window management
The editor now exposes a dedicated message system for controlling the application window state. Users can trigger actions such as closing, minimizing, maximizing, entering fullscreen, dragging the window, focusing, hiding, or restarting the application through this new \AppWindowMessage\ interface. This change establishes the backend plumbing for window lifecycle and state management, supporting both desktop and web platforms.
_editor/src/messages/app\window · high confidence
Introduce content-addressed resource storage with mmap and OPFS backends
The application now uses content-addressed storage for raster images and other resources, implemented via two new storage backends in the resource module: \MmapResourceStorage\ for local file systems using memory-mapped I/O, and \OpfsResourceStorage\ for browser environments using the Origin Private File System. Resources are now identified and stored by their content hash, enabling efficient caching, deduplication, and garbage collection of unused assets across both desktop and web platforms.
_node-graph/graph-craft/src/application\io/resource · high confidence
Introduce core Resource and ResourceHash types for content-addressed storage
This change introduces the foundational \Resource\ and \ResourceHash\ types in the \node-graph/libraries/resources\ crate. Users can now store and reference data blobs using a content-addressed model, where each resource is automatically assigned a 32-byte Blake3 hash. This enables efficient caching, deduplication, and integrity verification of assets like fonts and graphics within the application.
node-graph/libraries/resources · high confidence
Introduce deferred message execution for graph and navigation events
The editor now supports a new mechanism to defer and batch message processing, specifically for graph evaluation results and navigation readiness. This change introduces a \DeferMessage\ system that allows the application to queue messages (such as those resulting from a graph run) and process them in a controlled order once specific triggers occur, such as when a graph submission is ready or when navigation is complete. This enables smoother updates by preventing immediate, potentially conflicting state changes during complex operations like graph rendering or viewport resizing.
editor/src/messages/defer · high confidence
Introduce dynamic node graph executor
The node graph execution engine now supports a dynamic, runtime-interpreted mode via the new \DynamicExecutor\. This executor evaluates node graphs using \Box\<dyn ...\>\ and \async\ execution without requiring an online compilation server, enabling features like runtime introspection and safer execution with panic recovery. It is accompanied by a \node\_registry\ that registers available nodes and a \util\ module that wraps document networks into a standardized rendering scope.
node-graph/interpreted-executor/src · high confidence
Introduce graph preprocessor for resource and animation curve handling
The node-graph preprocessor now automatically converts embedded resource IDs and animation curves in node inputs into dedicated graph nodes (resource loaders and curve evaluators) before execution. It also handles scope injections and expands proto nodes to reconcile input counts with current definitions, ensuring documents with outdated node structures or missing inputs are processed correctly without manual intervention.
node-graph/preprocessor · high confidence
Introduce in-memory resource storage implementation
Added a new \HashMapResourceStorage\ implementation for the \ResourceStorage\ trait, providing an in-memory backend for raster images and other resources. This component uses a thread-safe hash map to store and retrieve resources by their content hash, supporting operations like loading, storing, checking existence, and garbage collection. Platform-specific storage backends (MmapResourceStorage for native, OpfsResourceStorage for WebAssembly) are also re-exported from this module.
_node-graph/graph-craft/src/application\io · high confidence
Introduce input preprocessor for normalized event handling
The editor now includes a dedicated input preprocessor module that normalizes raw mouse, keyboard, and wheel events into a consistent message format. This component handles coordinate translation from viewport to document space, tracks modifier key states, and implements logic for detecting double-taps and pointer shakes, ensuring that downstream message handlers receive clean, standardized input data.
_editor/src/messages/input\preprocessor · high confidence
Introduce layout message system for UI state and widget interaction
The editor now uses a dedicated layout message system to manage UI widget states and interactions. This change introduces \LayoutMessage\ variants that allow the backend to send, resend, and destroy layout definitions for specific targets, as well as handle widget value updates, commits, and drag-and-drop events. It also adds support for analyzing and evaluating math expressions within widgets, providing syntax highlighting, tooltips, and completions to the frontend. This system centralizes how the editor communicates UI structure and user input back to the frontend.
editor/src/messages/layout · high confidence
Introduce native desktop application with local-first persistence and single-instance support
The desktop application now runs as a native client using the Winit windowing toolkit and WGPU for rendering, replacing the previous embedded browser approach. This change introduces local-first persistence, storing user preferences, application state, and autosaved documents in platform-specific data directories (e.g., \preferences.ron\, \state.ron\) rather than relying solely on browser storage. To ensure a seamless user experience, the app enforces a single-instance constraint using a file lock; if a second instance is launched, it communicates with the running instance via a local Unix socket (or named pipe on Windows) to open requested files. The application also supports command-line arguments for startup files and disabling hardware-accelerated UI rendering, and it automatically restarts with acceleration disabled if the UI runtime fails to initialize.
desktop/src · high confidence
Introduce new frontend utility functions for clipboard, colors, and input handling
The frontend now includes a new set of utility functions in the \utility-functions\ directory to support core editor capabilities. \clipboard.ts\ implements custom logic for reading and writing text to the system clipboard, including handling browser permission states and pasting images or layer data. \colors.ts\ provides utilities for converting between color formats (SRGBA8, HSV, Hex) and calculating WCAG-style contrast for UI elements. \input.ts\ and \keyboard-entry.ts\ centralize keyboard and pointer event handling, featuring improved support for non-US keyboard layouts and localized scan codes. Additional utilities include \decimal.ts\ for exact arithmetic on written numbers, \files.ts\ for file uploads and downloads, and \math-expression.ts\ for rendering mathematical glyphs.
frontend/src/utility-functions · high confidence
Introduce new node macro with multi-output, shader, and choice-type support
The node definition system has been replaced with a new macro-based approach that simplifies node implementation and expands capabilities. Users can now define multi-output nodes by returning a struct derived with \\#\[derive(Destructure)\]\, which automatically generates extractor nodes for each field and supports a primary output. The macro also introduces \\#\[derive(ChoiceType)\]\ for enums, allowing automatic generation of radio buttons or dropdown menus with custom labels, icons, and descriptions. Additionally, \\#\[derive(BufferStruct)\]\ enables shader node support by generating buffer-compatible structs for GPU execution. The new system enforces stricter validation on input types (requiring ranked \Item\<T\>\ or \List\<T\>\ wires) and supports async nodes, data fields for internal state, and scope injection.
node-graph/node-macro · high confidence
Introduce new snapping engine library
A new snapping engine library has been added to the codebase, providing the core logic for snapping behavior. This includes geometric primitives like Bounds and Curve, spatial indexing via BoundsTree, and a comprehensive set of snapping candidates (anchors, midpoints, alignments, tangents, etc.). The library also handles grid snapping, frame transformations, and scene context management, serving as the foundation for subsequent editor integrations.
libraries/snapping · high confidence
Introduce new website templates for structured content and navigation
The website now includes dedicated templates for articles, books, and sections, enabling richer content presentation. The article template displays blog posts with author details, publication dates, and social sharing links for Reddit, Twitter, and Bluesky. The book template provides a three-column layout with a chapter sidebar, table of contents, and previous/next navigation for structured documentation. A new 404 error page offers a user-friendly message and a link back to the homepage. These templates extend the base layout, which now includes a navigation bar with a ripple effect and improved SEO meta tags.
website/templates · high confidence
Introduce structured preferences system with new selection and layout options
The editor now uses a dedicated message-based system to manage user preferences, exposing several new configuration options in the Preferences dialog. Users can now choose how selection boxes behave via the SelectionMode setting (Touched, Enclosed, or Directional), toggle the Brush tool independently, and adjust the viewport zoom speed with the ViewportZoomWheelRate. Additional controls include toggling 'Zoom with Scroll', changing the node graph wire style, adjusting the UI scale, and disabling UI acceleration (which requires a restart on macOS and Linux). A new 'Save as GDD' toggle and storage round-trip validation options are also available for document management.
editor/src/messages/preferences · high confidence
Introduce the Basic Brush node for GPU-accelerated raster painting
A new 'Basic Brush' node has been added to the Raster: Brush category, replacing the legacy brush tool implementation. This node leverages the GPU (via wgpu) to render brush strokes with high performance, utilizing custom shaders for kernel scattering, density resolution, and color conversion. It supports configurable stroke attributes including color, diameter, hardness, and flow, and implements internal caching of baked brush kernels to optimize repeated painting operations.
node-graph/nodes/brush/src · high confidence
Introduction of experimental animation playback controls
The editor now includes an experimental animation subsystem that allows users to control playback via live preview, frame stepping, and time setting. This change introduces the \AnimationMessage\ enum and its handler, enabling features such as toggling live preview, restarting animations, setting specific frame indices or timestamps, and switching between time-based and frame-based timing modes. These controls are integrated into the document bar, providing users with basic playback capabilities within the editor interface.
editor/src/messages/animation · high confidence
Introduction of the Graph.svelte component for node graph visualization
The frontend now includes a new Graph.svelte component located in frontend/src/components/views, which serves as the primary view for the node graph interface. This component manages the rendering of the graph canvas, including grid snapping, node placement, and wire connections, while handling user interactions such as creating nodes, renaming layers, and managing import/export ports. It integrates with the backend via the EditorWrapper context and utilizes Svelte stores for state management of the node graph, wires, and document state.
frontend/src/components/views · high confidence
Introduction of the editor control protocol library
A new library has been added to define the control protocol for the Graphite editor, enabling scripts, QA tools, and agents to operate the interface programmatically. This library specifies the data structures for commands such as mouse movements, clicks, drags, keyboard input, scrolling, and screenshots, as well as the response formats for locating elements and reporting session status. All messages are transmitted as single lines of JSON, establishing the contract for external automation of the editor.
libraries/control-protocol · high confidence
Native desktop execution of the node graph
The node graph now executes natively on the desktop platform, moving away from the previous web-based rendering pipeline. This change introduces a dedicated runtime (\NodeRuntime\) and communication layer (\NodeRuntimeIO\) that handle graph updates, execution requests, and eyedropper previews via message passing. Users benefit from improved performance and stability when working with complex node networks on desktop, as the rendering and computation are no longer bound by the browser's JavaScript thread limitations.
_editor/src/node\_graph\executor · high confidence
New Artboard node and general-purpose list manipulation nodes
This change introduces a new 'Create Artboard' node that constructs an Artboard item from content, location, dimensions, background color, and a clip setting, storing these as row attributes. It also adds several new nodes for general list operations: 'Remove at Index', 'Item at Index', 'Filter', 'Reverse', 'Shift', and 'Shuffle', which operate on lists of various types including Strings, booleans, numbers, vectors, graphics, rasters, colors, gradients, and artboards.
node-graph/nodes/graphic · high confidence
New Document dialog supports infinite canvas and custom dimensions
The editor now includes a dedicated dialog for creating new documents, allowing users to specify a name, choose between an infinite canvas or a finite artboard with custom width and height, and submit the creation. When an infinite canvas is selected, a locked white background layer is added; for finite canvases, an artboard is created with the specified dimensions, the view is panned to fit, and the document graph is executed. The dialog also handles post-creation tasks like deselecting layers, marking the document as saved, and triggering an auto-save.
_editor/src/messages/dialog/new\_document\dialog · high confidence
New Grab, Rotate, and Scale (GRS) tool for layer transformations
The editor now includes a dedicated tool for transforming layers using Blender-inspired G, R, and S keys. This feature allows users to grab, rotate, and scale selected layers with precise control, including support for typing exact values, snapping angles with Ctrl, and slowing transformations with Shift. The tool integrates with the document graph, supports pivot gizmos, and handles both standard layers and path tool points, providing visual overlays and ghost outlines to show pre-transform geometry.
_editor/src/messages/tool/transform\layer · high confidence
New Lorem Ipsum generator library with Latin corpus training
Added a new \libraries/ipsum\ crate that generates placeholder text by training on Cicero's 'De finibus bonorum et malorum'. The library uses a build script to process a Latin corpus into a compact, front-coded vocabulary and token index at compile time, allowing the runtime to produce varied, sentence-structured Latin text suitable for design mockups.
libraries/ipsum · high confidence
New Repeat node family for generating item lists
This change introduces a new set of nodes in the Repeat category: Repeat, Repeat Array, Repeat Radial, and Repeat on Points. These nodes allow users to generate lists of items (such as graphics, vectors, or colors) by repeating a source content a specified number of times. The Repeat node simply duplicates content, optionally in reverse order. Repeat Array distributes copies along a linear direction with a specified angle and count. Repeat Radial arranges copies in a circular pattern around a center point with a given radius and count. Repeat on Points places copies at specific vector coordinates. All nodes support a wide range of data types and use a unified List/Item data model.
node-graph/nodes/repeat · high confidence
New Rust-based desktop bundler for Mac and Windows
The desktop application now uses a new Rust-based bundler (desktop/bundle) to assemble the final application packages for Mac and Windows. On Mac, this introduces native file handling for .graphite, SVG, and image files, registers the app as a document editor, and includes the Chromium Embedded Framework (CEF) and app icons in the .app bundle. On Windows, the bundler assembles the executable and CEF runtime while stripping unnecessary build artifacts and documentation files. Linux support is stubbed out with a placeholder that builds the binary but does not yet create a distributable bundle.
desktop/bundle · high confidence
New animation, context, and utility nodes in gcore
The gcore node library now includes new nodes for animation and context handling: Evaluate Curve, Real Time, Animation Time, Quantize Real Time, Quantize Animation Time, and Pointer Position in the Animation category; Read Graphic, Read Vector, Read Raster, Read Color, Read Gradient, Read Number, Read Position, and Read Index in the Context category; and Log to Console in Debug. It also introduces a Context Nullification node to control which context components are kept during evaluation, Memoize and Monitor nodes for caching and editor inspection, and a suite of General and \_Adapters nodes (Passthrough, Into, Item to List, Item to Attribute Value, List to Attribute Value, Bundle, Unbundle, Into Item, Into List, Embed Item, Embed List, Convert Item, Convert List) to help route, wrap, and convert data types within the node graph.
node-graph/nodes/gcore · high confidence
New brush stroke data types and GPU caching infrastructure
The brush-types library now includes a new \Stroke\ data structure representing brush input with position, pressure, tilt, twist, and time channels, along with a \BrushCache\ component that caches opaque render state per footprint to optimize GPU brush nodes. This change introduces the underlying data model for strokes and the caching mechanism to improve rendering performance by reusing computed state across similar viewports.
node-graph/libraries/brush-types · high confidence
New canvas-utils library for WebAssembly canvas management
A new \canvas-utils\ library has been added to provide utilities for working with HTML canvases in WebAssembly contexts. This library introduces traits and handles (\CanvasHandle\, \CanvasSurfaceHandle\) to manage canvas elements, including automatic garbage collection prevention by storing references in the global scope. It also integrates with WGPU to allow presenting textures to the canvas surface, handling surface configuration and texture blitting for rendering.
node-graph/libraries/canvas-utils · high confidence
New core math types for geometry and precision handling
The core-types math module now includes new data structures and utilities to support geometry operations and numerical stability. Users can now work with \AxisAlignedBbox\ and \Bbox\ for bounding box calculations, \Quad\ and \Rect\ for 2D shape definitions and transformations, and a generic \Polynomial\ type for evaluating and manipulating polynomial equations derived from bezier curves. Additionally, a new \round\_away\_float\_noise\ function is available to clean up floating-point imprecision in display values without altering high-precision data.
node-graph/libraries/core-types/src/math · high confidence
New crate hierarchy visualization tool
A new Rust-based tool (\tools/crate-hierarchy-viz\) has been added to generate an SVG diagram of the workspace's crate dependencies. It parses \Cargo.toml\ files to build a dependency graph, removes transitive dependencies for clarity, and outputs a visual representation (\crate-hierarchy.svg\) that is marked with a specific data attribute for integration with the website.
tools/crate-hierarchy-viz · high confidence
New floating menu components for color picking, dialogs, and node selection
The floating-menus area now includes new Svelte components: ColorPicker (a floating menu for selecting colors and gradients), Dialog (a centered dialog for alerts and confirmations), EyedropperPreview (a cursor-following color preview), MenuList (an interactive, searchable menu list with virtual scrolling), NodeCatalog (a searchable, categorized node selection catalog), and Tooltip (rich tooltips with markdown support). These components replace previous implementations and integrate with the editor's store and layout system.
frontend/src/components/floating-menus · high confidence
New interactive frontend components for carousels, image comparisons, and media
The website now includes new JavaScript components for enhanced media interaction: a carousel with drag-to-fling, jostle hints, and video sync; an image comparison slider that auto-reecenters after interaction; an autoplay video component that triggers playback when 25% visible; and a lazy-loaded YouTube embed that loads the iframe only on user click or keyboard activation.
website/static/js/component · high confidence
New interactive tools and visualizations in the Contributor Guide
The Contributor Guide now includes three new interactive features to help developers understand the project. A build link bisect tool allows contributors to identify the specific commit that introduced a regression by testing builds between two points in the repository history. A crate dependency graph visualization provides an interactive, zoomable, and pannable view of the Rust crate hierarchy, while an editor structure outline offers an expandable tree view of the codebase organization.
website/static/js/page/contributor-guide · high confidence
New layout and floating menu components for Svelte frontend
The layout area now includes new Svelte components: ConditionalWrapper for conditional DOM wrapping, and LayoutCol and LayoutRow for flex-based column and row layouts with support for custom classes, styles, and scrollable states. A comprehensive FloatingMenu component handles positioning, resizing, and interaction for popovers, tooltips, dropdowns, and dialogs, including specific workarounds for Safari rendering bugs and pointer stray detection.
frontend/src/components/layout · high confidence
New math expression parser library with advanced math capabilities
The \libraries/math-parser\ crate introduces a complete rewrite of the math expression parser, migrating from Pest to the Chumsky parsing library. This new parser supports a richer expression language including piecewise functions, matrix literals with swizzle and range syntax, quaternion support, and \where\-keyword bindings for local definitions. It provides exact integer arithmetic for whole numbers, extends factorial via the gamma function, and allows expression results to become complex numbers instead of returning NaN. The library also includes editor integration features such as syntax highlighting, auto-completion, and documentation tooltips for built-in functions and constants.
libraries/math-parser · high confidence
New node-graph infrastructure and rendering capabilities
This change introduces the core \gstd\ node library, establishing the foundational types and execution model for the node graph. It adds a tile-based render cache (\render\_cache.rs\) to optimize viewport panning performance, and implements new rendering modes including a checkered background for transparent areas and a pixel-preview mode for accurate on-screen representation. The update also adds a suite of new nodes: web request tools (\get\_request\, \post\_request\, \load\_resource\, \decode\_image\) for handling external resources, text processing nodes (\text\, \text\_to\_vector\, \text\_to\_vector\_glyphs\) for typography, and general-purpose utility nodes for type erasure and context creation. These components collectively enable more complex, performant, and flexible node-based workflows.
node-graph/nodes/gstd · high confidence
New proc-macros for editor message hierarchy and widget builders
The \proc-macros\ crate now provides a suite of derive macros and attributes to automate the editor's message system and widget construction. The \ToDiscriminant\ macro generates lightweight discriminant enums for message types, while \TransitiveChild\ and \AsMessage\ establish parent-child relationships and hierarchical naming for the message tree. The \HierarchicalTree\ macro enables runtime visualization of the message structure, and \EditorCommand\ automates the generation of command enums and their WASM bindings. Additionally, \WidgetBuilder\ generates builder-pattern constructors for layout structs, and \ExtractField\ provides compile-time field metadata.
proc-macros · high confidence
New raster adjustment and filter nodes with expanded color management
This update introduces several new nodes in the Raster: Adjustment and Raster: Filter categories, including Desaturate (replacing the old Luminance node with multiple methods like OkLab and Rec. 709), Color Lookup (supporting CUBE, 3DL, LOOK, and ICC formats), Dehaze, Median Filter, and Gamma Correction. It also adds the Image to Channels node for splitting images into RGBA components, and introduces a Color Overlay adjustment. These changes enhance color grading capabilities, provide more precise desaturation and filtering options, and support professional color management workflows through standardized LUT formats.
node-graph/nodes/raster · high confidence
New raster type definitions and image decoding infrastructure
This change introduces the core data structures for handling raster images within the node-graph library. It defines the \Image\<P\>\ struct to store pixel data and dimensions, along with \Bitmap\ and \BitmapMut\ traits that provide a unified interface for reading and modifying pixel values. The \Raster\<T\>\ wrapper type is added to abstract over storage backends, specifically introducing \Raster\<CPU\>\ for in-memory processing and \Raster\<GPU\>\ (via \Texture\) for GPU-accelerated rendering using \wgpu\. Additionally, the \Image::from\_encoded\ method is implemented to decode various image formats into the internal \Color\ representation, handling necessary conversions for gamma space and alpha premultiplication.
node-graph/libraries/raster-types · high confidence
New shared tooling infrastructure for drawing, selection, and transformation
The editor now uses a unified \common\_functionality\ module to manage core tool behaviors, introducing dedicated modules for auto-panning, color selection, compass rose navigation, pivot control, and resize logic. This change standardizes how drawing tools handle fill and stroke options, how the Select tool manages pivot reference points, and how the viewport automatically pans when dragging near edges, providing a consistent foundation for the Path, Shape, and Pen tools.
_editor/src/messages/tool/common\functionality · high confidence
New text processing nodes and improved text selection
The Text node area now includes new nodes for JSON manipulation (Format JSON, Query JSON, Query JSON All) and regular expressions (Regex Contains, Regex Replace, Regex Find, Regex Find All, Regex Split), alongside string processing capabilities like Capitalization. Additionally, the Text node's output now generates individual click targets for each glyph, removing gaps between them to make selecting specific characters within text layers more reliable.
node-graph/nodes/text · high confidence
New transform manipulation nodes and support for skew
The transform node group now includes new nodes for resetting, replacing, extracting, inverting, and decomposing transforms (translation, rotation, scale). Additionally, the primary Transform node and its list counterpart now support a skew parameter, allowing users to apply shear transformations alongside translation, rotation, and scaling.
node-graph/nodes/transform · high confidence
New vector path algorithms and shape generators
The vector algorithms module now includes new implementations for Bezier path operations, including splitting, evaluation, and tangent calculation, as well as robust intersection detection using analytical methods for cubic curves. It introduces Poisson-disk sampling for point distribution, spatial and topological point merging, and Bézier path offsetting with configurable joins (bevel, miter, round). Additionally, it provides constructors for primitive shapes such as rectangles, rounded rectangles, ellipses, arcs, polygons, stars, lines, and arrows, along with cubic spline handle solving for smooth curves. Also in this area: New vector shape algorithms and geometry caching improvements; Improved vector path welding, contour stitching, and grid options.
node-graph/libraries/vector-types/src/vector/algorithms · high confidence
New vector shape and modification nodes
The vector node graph now includes new shape generators for circles, arcs, spirals, ellipses, rectangles, regular polygons, and stars, alongside a 'Box Corners' node for managing corner radii. Vector modification capabilities have been expanded with 'Bake Transform' to bake transforms into geometry, and 'Path Modify' to apply differential edits while managing layer paths and click targets. Additionally, the system now supports generating Voronoi diagrams and Delaunay triangulations from point sets, including a 'Relax Sites' function for Lloyd's relaxation to even out point distributions.
node-graph/nodes/vector · high confidence
New web editor driver tool for automated interaction and QA
A new \web-editor-driver\ tool has been added to the tools directory, enabling automated, human-like interaction with the Graphite web editor. It drives a dedicated, isolated Chromium instance via Playwright, delivering real mouse and keyboard inputs to the page and capturing screenshots. This tool supports scripts, QA testing, and AI agents by providing a control protocol for commands like clicking, dragging, and typing, along with scenario files for end-to-end validation and expect assertions to verify UI state.
tools · high confidence
New website macros for book outlines, blog posts, and generated content
The website templates now include new macros to improve content rendering and structure. The \book-outline.html\ macro adds recursive rendering for page and book chapter tables of contents, as well as a flattened outline for sequential navigation. The \replacements.html\ macro introduces a \blog\_posts\ component to display recent blog articles with lazy-loaded images, a \text\_balancer\ macro to apply CSS text balancing with a JavaScript fallback, and macros to embed generated content like the hierarchical message system tree and crate dependency graph visualizations.
website/templates/macros · high confidence
Nix packaging for Graphite Desktop on Linux
The project now includes a complete Nix build infrastructure for the Graphite desktop application on Linux. This introduces new package definitions that fetch and bundle the Chromium Embedded Framework (CEF) version 151, handle branded assets (icons, metadata), and compile the application binary along with its Rust-based raster node shaders. The build process produces a distributable bundle (tar, gz, xz) and a Flatpak manifest, enabling users to install Graphite via Nix or Flatpak with proper library paths, GPU support, and embedded CEF resources.
.nix/pkgs · high confidence
Project initialization and repository structure setup
The repository is initialized with a comprehensive set of configuration files to standardize the development environment and project governance. This includes a Nix flake for reproducible builds, license compliance configuration via \cargo-deny\ and \about.toml\, and code formatting rules for Rust (\rustfmt.toml\) and JavaScript/TypeScript (\.prettierrc\). The project also establishes a dual MIT/Apache-2.0 licensing model, defines branding assets, and sets up Git attributes for consistent line endings and syntax highlighting.
(repo-wide) · high confidence
Unified Shape tool with interactive gizmos for Arc, Grid, Spiral, and Arrow
The Shape tool now consolidates previously separate drawing tools into a single interface, adding dedicated modes for Arc, Grid, Spiral, and Arrow shapes. Each mode includes interactive gizmos for real-time parameter adjustment: Arc and Circle tools feature radius and sweep-angle handles, the Grid tool offers row/column controls, and the Polygon/Star tool provides a points dial. The tool also supports modifier keys for center-drawing, angle locking, and snapping, and correctly accounts for viewport zoom when calculating shape dimensions.
_editor/src/messages/tool/common\functionality/shapes · high confidence
Unified shape gizmo system for interactive editing
The Shape tool now features a centralized gizmo manager that coordinates interactive handles for Star, Polygon, Arc, Circle, Grid, and Spiral shapes. This change introduces a unified interface for detecting, activating, and routing user interactions (hover, click, drag) to the correct shape-specific handler, allowing for consistent editing experiences across all supported shape types. Users can now directly manipulate shape parameters—such as the number of points for stars and polygons, radius for circles and arcs, rows and columns for grids, and turns for spirals—through intuitive on-canvas gizmos with visual feedback like snapping guides and cursor changes.
_editor/src/messages/tool/common\functionality/gizmos · high confidence
Removals
Removed obsolete source modules and legacy rendering code
Deleted multiple source files including application.rs, color\_palette.rs, gui\_rect.rs, main.rs, pipeline.rs, program\_state.rs, render\_state.rs, shader\_cache.rs, texture.rs, and texture\_cache.rs. This removes the previous application entry point, hardcoded pipeline and vertex data, legacy color palette, GUI rectangle structures, and shader/texture caching implementations from the source tree.
src · high confidence
Architecture
Editor core restructured into a Rust-native message-driven architecture
The editor's internal architecture has been rewritten in Rust, replacing the previous TypeScript frontend with a backend-defined message system. This change introduces a central Dispatcher that routes messages to specialized handlers (e.g., for tools, layout, and the node graph) and a new NodeGraphExecutor that handles asynchronous graph evaluation. Users benefit from improved performance, better type safety, and a unified codebase that supports native desktop features like tablet input and native file dialogs, while maintaining the same visual interface and node-based workflow. Also in this area: 2 commits (0 fixes) modifying editor.
editor/src, editor/src/messages/future · medium confidence
Frontend project structure and tooling configuration
The frontend directory now establishes its foundational build and development environment. It is configured as a Svelte application using Vite for bundling, with TypeScript for type safety. The setup includes specific ESLint rules to enforce code quality, such as requiring DOM queries to use data attributes and banning the null literal in favor of undefined. Additionally, the configuration supports WebAssembly integration for the backend editor, handles static asset serving, and includes plugins for third-party license generation and WebKit-specific CSS prefixing.
frontend · high confidence
Introduce WASM wrapper for editor communication
The \/frontend/wrapper\ directory now provides the Rust-based bridge that connects the JavaScript frontend to the editor backend. It exposes a set of editor commands (such as window management, widget updates, and file handling) that JavaScript can invoke, and handles the serialization and delivery of \FrontendMessage\s back to the UI. The wrapper supports both in-process WASM execution and native desktop communication via \native\_communication.rs\, ensuring consistent behavior across platforms while managing state like the editor instance and message buffers.
frontend/wrapper · high confidence
Introduce node graph document model and compilation pipeline
The node graph's internal data model and execution pipeline have been restructured. A new \DocumentNode\ and \NodeNetwork\ structure now defines the graph, replacing previous representations. The \RuntimeDelta\ enum provides a precise, index-based mechanism for tracking structural graph mutations (add, replace, remove nodes; set inputs/exports/visibility). A dedicated \Compiler\ in \graphene\_compiler.rs\ now handles the transformation of the \NodeNetwork\ into a \ProtoNetwork\ for execution, including scope resolution, path generation, and stable ID assignment. Additionally, \application\_io.rs\ introduces \PlatformApplicationIo\ to manage platform-specific resources and optional WGPU GPU execution.
node-graph/graph-craft/src · high confidence
Isolate CEF-rendered UI into a separate process with hardware-accelerated frame sharing
The desktop UI now runs the Chromium Embedded Framework (CEF) in a separate process to improve stability and security. This change introduces a new \desktop/ui\ crate that manages the CEF lifecycle and implements platform-specific accelerated paint pipelines: on Windows, it shares D3D11 textures with the main process via handle duplication and imports them into wgpu (supporting both D3D12 and Vulkan backends); on Linux, it transfers DMA-BUF file descriptors over Unix sockets and imports them via Vulkan; and on macOS, it passes IOSurface handles via Mach ports and imports them via Metal. The UI also includes a new constants module for scroll and zoom behavior, a temporary directory manager for CEF instance data, and an event queue for UI events. Also in this area: DMA-BUF import now uses queue ownership transfers for correct Vulkan memory handling; Updated wgpu to v30 and wasm-bindgen-cli to 0.2.127.
desktop/ui · high confidence
Restructure editor message system with new portfolio and broadcast modules
The editor's internal message architecture has been reorganized to support a more modular and scalable design. A new \BroadcastMessage\ system has been introduced, allowing components to subscribe to and receive specific events (like \EventMessage\) without tight coupling, facilitating better state synchronization across the application. The \PortfolioMessage\ hierarchy has been refined, with \DocumentMessage\ now explicitly managing sub-messages for the Data Panel, Node Graph, and Overlays, providing a clearer separation of concerns for document-level operations. Additionally, the \DataPanelMessage\ handler has been significantly expanded to support complex data visualization, including breadcrumb navigation for nested data structures and tabbed views for vector tables, enhancing the user's ability to inspect and debug node outputs directly within the editor.
editor/src/messages/portfolio · high confidence
Restructure the editor's tool system into a hierarchical message architecture
The tool subsystem has been reorganized to align with the editor's new hierarchical message system. This change introduces a central \ToolMessage\ enum that acts as a parent for specific tool messages (such as Select, Pen, Shape, and Brush), replacing the previous flat structure. It also establishes a dedicated \ToolMessageHandler\ to manage tool activation, deactivation, and state transitions, ensuring that switching tools properly handles context updates, hint refreshes, and cursor changes. This refactoring provides a more consistent and scalable foundation for adding and managing editor tools.
editor/src/messages/tool · high confidence
Vector types library restructured with new click target and style systems
The vector types library has been reorganized into a modular structure, introducing a new \ClickTarget\ system that uses compound \BezPath\ shapes to accurately exclude interior negative space from click detection, and a \FillChoice\ type that unifies solid colors and gradient ramps. The \Vector\ data model now relies on explicit \PointDomain\ and \SegmentDomain\ structures with procedural modification tracking, while style attributes like \StrokeCap\, \StrokeJoin\, and \DashPattern\ are standardized for consistent rendering and UI representation.
node-graph/libraries/vector-types/src/vector · high confidence
Viewport state is now managed by a dedicated message handler
The viewport's internal state (bounds, offset, and scale) is now encapsulated within a new \ViewportMessageHandler\ component, replacing the previous ad-hoc management. This change introduces a structured \ViewportMessage\ enum with \Update\ and \RepropagateUpdate\ variants, allowing the editor to process viewport changes through a consistent message-passing system. Users benefit from more robust viewport updates, including automatic propagation of physical bounds to the frontend and validation checks that prevent invalid scale values (e.g., zero or negative).
editor/src/messages/viewport · high confidence
Behavioural changes
1 commit (0 fixes) modifying (repo-wide)
A change to existing behaviour in (repo-wide) — 1 commit, 18 files: “Convert demo artworks to new save format (\#4943)” (refs \#4943).
document/loader · low confidence · unverified
1 commit (0 fixes) modifying website
A change to existing behaviour in website — 1 commit, 5 files: “Let members preview higher-tier rewards and change their email address”. Also in this area: Interactive donation amount selection with dynamic GitHub links.
website/static/js/page · medium confidence · unverified
104 commits (17 fixes) modifying demo-artwork
A change to existing behaviour in demo-artwork — 104 commits (17 fixs), 8 files: “Add layer node chains, import/export edge connectors, and refactor graph editing to go thru a NodeNetworkInterface (\#1794)”; “Add demo artwork”; “Rename the nodes 'Length' -\> 'Magnitude', 'Flatten Path' -\> 'Combine Paths', 'Vec2 Value' -\> 'Combine Vec2', and add a new 'Vec2 Value' node (\#4349)”; and 101 more (refs \#1794, \#4349, \#3009, \#4268, \#1546, …).
demo-artwork · medium confidence · unverified
15 commits (1 fix) modifying node-graph/interpreted-executor/src/dynamic\_executor
A change to existing behaviour in node-graph/interpreted-executor/src/dynamic\_executor — 15 commits (1 fix), 1 file: “New nodes: Sort, Filter, Reverse, Shift, Shuffle, Number Sequence, List Indices, List Slice, Read Number (\#4347)”; “Support embedding whole items into Graphic variants so their attributes survive the conversion (\#4440)”; “Make the data model use Item and List types universally, with nodes authored as rank-polymorphic kernels (\#4335)”; and 12 more (refs \#4347, \#4440, \#4335, \#4590, \#4397, …).
_node-graph/interpreted-executor/src/dynamic\executor · medium confidence · unverified
2 commits (0 fixes) modifying document/migrations/snapshot
A change to existing behaviour in document/migrations/snapshot — 2 commits, 8 files: “Add the migration CLI and CI checks (\#4864)”; “Let migrations choose a target per anchor, ask the compiler, and run on whole states” (refs \#4864).
document/migrations/snapshot · medium confidence · unverified
2 commits (0 fixes) modifying node-graph/nodes/vectorize
A change to existing behaviour in node-graph/nodes/vectorize — 2 commits, 3 files: “Simplify node graph runtime scheduling (\#4907)”; “New node: 'Vectorize' (\#4861)” (refs \#4907, \#4861).
node-graph/nodes/vectorize · medium confidence · unverified
26 commits (0 fixes) modifying document/format
A change to existing behaviour in document/format — 26 commits, 21 files: “Move stored types into a schema module and version node declarations (\#4862)”; “Change CRDT logic to use tombstoning instead of ad-hoc resurrection (\#4636)”; “Number hot ops per author, persist the CRDT state (\#4638)”; and 23 more (refs \#4862, \#4636, \#4638, \#4938, \#4571, …).
document/format · medium confidence · unverified
3 commits (0 fixes) modifying document/migrations/compiled
A change to existing behaviour in document/migrations/compiled — 3 commits, 3 files: “Let migrations choose a target per anchor, ask the compiler, and run on whole states”; “Replace 'Copy to Points' and 'Assign Colors' with a family of 'Vary' nodes (\#4906)”; “Store large node input values as delta-compressed blobs (\#4926)” (refs \#4906, \#4926).
document/migrations/compiled · medium confidence · unverified
3 commits (0 fixes) modifying document/migrations/core, document/migrations/runner
A change to existing behaviour in document/migrations/core, document/migrations/runner — 3 commits, 17 files: “Add .gdd migration system core components (\#4863)”; “Let migrations choose a target per anchor, ask the compiler, and run on whole states”; “Store large node input values as delta-compressed blobs (\#4926)” (refs \#4863, \#4926).
document/migrations/core, document/migrations/runner · medium confidence · unverified
3 commits (0 fixes) modifying document/migrations/formats
A change to existing behaviour in document/migrations/formats — 3 commits, 9 files: “Add the migration CLI and CI checks (\#4864)”; “Add the session operations for taking back, dropping and restoring interactions (\#4868)”; “Store large node input values as delta-compressed blobs (\#4926)” (refs \#4864, \#4868, \#4926).
document/migrations/formats · medium confidence · unverified
3 commits (0 fixes) modifying website/sass/template
A change to existing behaviour in website/sass/template — 3 commits, 2 files: “Add the auto-generated node catalog to the website's user manual (\#3662)”; “More website loading speed and code improvements”; “Replace 'Copy to Points' and 'Assign Colors' with a family of 'Vary' nodes (\#4906)” (refs \#3662, \#4906).
website/sass/template · medium confidence · unverified
3 commits (1 fix) modifying node-graph/libraries/core-types/src/color
A change to existing behaviour in node-graph/libraries/core-types/src/color — 3 commits (1 fix), 6 files: “Merge no std types into core-types (\#4881)”; “Fix Vivid Light burning and dodging the source by the backdrop instead of the backdrop by the source (\#4940)”; “Update the Tsify dependency (\#4600)” (refs \#4881, \#4940, \#4600).
node-graph/libraries/core-types/src/color · medium confidence · unverified
3 commits (1 fix) modifying tools/regression
A change to existing behaviour in tools/regression — 3 commits (1 fix), 7 files: “Add the regression corpus tool and the guide to writing migrations (\#4866)”; “Add a coverage command to check how many of the nodes in graphite appear in the corpus (\#4936)”; “Convert demo artworks to new save format (\#4943)” (refs \#4866, \#4936, \#4943).
tools/regression · medium confidence · unverified
35 commits (1 fix) modifying document/graph-storage/src
A change to existing behaviour in document/graph-storage/src — 35 commits (1 fix), 32 files: “Move stored types into a schema module and version node declarations (\#4862)”; “Fix multi user undo model (\#4639)”; “Change CRDT logic to use tombstoning instead of ad-hoc resurrection (\#4636)”; and 32 more (refs \#4862, \#4639, \#4636, \#4638, \#4938, …).
document/graph-storage/src · medium confidence · unverified
4 commits (0 fixes) modifying document/migrations/macros
A change to existing behaviour in document/migrations/macros — 4 commits, 3 files: “Add .gdd migration system core components (\#4863)”; “Let migrations choose a target per anchor, ask the compiler, and run on whole states”; “Bump the Rust dependencies (\#4605)”; and 1 more (refs \#4863, \#4605, \#4926).
document/migrations/macros · medium confidence · unverified
4 commits (0 fixes) modifying document/migrations/nodes
A change to existing behaviour in document/migrations/nodes — 4 commits, 11 files: “Add the migration CLI and CI checks (\#4864)”; “Replace 'Copy to Points' and 'Assign Colors' with a family of 'Vary' nodes (\#4906)”; “Rework the 'Math' expression family as 'Math Function' / 'Math Formula', and add 'Math Running' / 'Math Aggregate' (\#4917)”; and 1 more (refs \#4864, \#4906, \#4917, \#4865).
document/migrations/nodes · medium confidence · unverified
5 commits (0 fixes) modifying document/container
A change to existing behaviour in document/container — 5 commits, 11 files: “Add document-container crate (\#4191)”; “Move all documents into platform-provided document store (\#4573)”; “Bump the Rust dependencies (\#4605)”; and 2 more (refs \#4191, \#4573, \#4605, \#4872, \#4234).
document/container · medium confidence · unverified
5 commits (0 fixes) modifying tools/web-editor-driver
A change to existing behaviour in tools/web-editor-driver — 5 commits, 9 files: “Move the editor control protocol crate into the libraries folder (\#4694)”; “Add the web editor driver and control protocol (\#4657)”; “Add expect assertions, console error checks, and scenario folders to the web editor driver (\#4658)”; and 2 more (refs \#4694, \#4657, \#4658, \#4605, \#4660).
tools/web-editor-driver · medium confidence · unverified
8 commits (1 fix) modifying document/peer-transport
A change to existing behaviour in document/peer-transport — 8 commits (1 fix), 10 files: “Add the peer-transport crate syncing document sessions between peers (\#4869)”; “Fix a collaborative editing room panicking when polled after its socket loop ended (\#4932)”; “Add live sessions and the Session panel (\#4891)”; and 5 more (refs \#4869, \#4932, \#4891, \#4605, \#4893, …).
document/peer-transport · medium confidence · unverified
Add navbar ripple effect and improve text wrapping
The website now features a visual ripple effect on the navigation bar: hovering over buttons lifts them slightly, and releasing the mouse triggers a propagating wave animation that fades out. Additionally, long words in section paragraphs are now automatically broken with soft hyphens (\<wbr\>) to prevent horizontal overflow and improve readability on narrower screens.
website/static/js · high confidence
Blending nodes refactored to use Item-based data model and explicit attributes
The Blending node category (Blend Mode, Opacity, Clipping Mask) has been rewritten to use the new universal Item and List data types instead of the previous struct-based approach. Users will see that these nodes now operate on the 'Item' type, supporting Graphic, Vector, Raster, Color, Gradient, and String implementations. The Opacity node now explicitly handles separate 'Opacity' and 'Fill' properties with distinct enable toggles and percentage ranges, while Blend Mode and Clipping Mask nodes set specific attributes (ATTR\_BLEND\_MODE, ATTR\_OPACITY\_FILL, ATTR\_CLIPPING\_MASK) on the content item.
node-graph/nodes/blending · high confidence
Boolean Operation node now ignores raster, color, and gradient content
The Boolean Operation node now strictly processes vector geometry, automatically discarding any non-path content such as raster images, solid colors, or gradients from its input. This ensures that boolean calculations are performed only on the geometric outlines of vector paths, preventing errors or unexpected results when mixed content types are passed into the node.
node-graph/nodes/path-bool · high confidence
Color picker popover ported to Rust-defined layout
The color picker popover has been re-implemented using a Rust-defined layout system, replacing the previous frontend-only implementation. This change introduces a new message-based architecture (\ColorPickerMessage\ and \ColorPickerMessageHandler\) that manages state for solid colors, gradients, and their associated attributes (such as spread, space, cyclic behavior, and interpolation). Users benefit from improved consistency in how the picker integrates with the rest of the editor's UI framework, including better handling of gradient stops, color presets, and input widgets like the spectrum and slider inputs.
_editor/src/messages/color\picker · high confidence
Complete rewrite of editor tools to use a node-graph-based document model
The drawing, selection, and navigation tools (Artboard, Brush, Eyedropper, Fill, Freehand, Gradient, Navigate, Path, and Pen) have been rewritten to operate on the new document graph architecture. This change replaces the legacy document model with a node-based system, introducing new tool states, options, and behaviors that interact directly with graph nodes (such as Vector, Fill, and Gradient nodes) rather than legacy layer types. Users will experience updated tool interactions, new options for node-specific properties, and improved consistency across the editor as tools now share a unified graph-based data model.
_editor/src/messages/tool/tool\messages · high confidence
Complete rewrite of input widgets to Svelte
The input widgets in the frontend have been completely rewritten in Svelte, replacing the previous Vue implementation. This change introduces new components for checkboxes, color selection, dropdowns, numeric fields, radio buttons, and math expressions, bringing improved reactivity, consistent styling, and better browser compatibility to the user interface.
frontend/src/components/widgets/inputs · high confidence
Custom YouTube embed shortcode with lazy loading and fallback thumbnails
The website now uses a new \youtube\_embed\ shortcode to render YouTube videos. Instead of an inline iframe, this change introduces a lightweight placeholder that displays a lazy-loaded thumbnail (falling back to a lower-resolution image if the high-res version fails or is too small) and a play button. This approach improves page load performance and user experience by deferring the heavy iframe resource until the user explicitly interacts with the embed.
website/templates/shortcodes · high confidence
Custom window frame with native resize handles and taskbar icons on Windows
Windows users now see a custom window frame that retains native borders and shadows while hiding the standard title bar. The application correctly displays its icon in the Windows taskbar and supports resizing via native-style handles around the window edge, implemented through an invisible helper window that manages hit-testing. Rendering is automatically paused during minimize/restore animations to prevent visual glitches.
desktop/src/window/win · high confidence
Desktop app now supports optional embedded frontend resources
The desktop application no longer fails to build if the frontend assets are missing. A new build script checks for the presence of the frontend distribution directory (defaulting to \../../frontend/dist\ or a path specified via the \EMBEDDED\_RESOURCES\ environment variable). If the directory exists, the resources are embedded into the binary; if not, the build completes with a warning and the application runs without embedded assets. This allows for more flexible development workflows where the frontend may not be built yet.
desktop/embedded-resources · high confidence
Desktop wrapper now handles native file dialogs, window controls, and clipboard operations
The desktop wrapper has been refactored to intercept frontend messages and route them to native platform capabilities. Users will see native file open and save dialogs instead of web-based ones, and window management actions (minimize, maximize, fullscreen, close) are now handled by the OS. On macOS, the application menu bar is now driven by native system menus rather than the web view. Additionally, clipboard read/write operations and UI scaling updates are now processed through the native wrapper layer.
desktop/wrapper · high confidence
Editor message system restructured into a hierarchical tree
The editor's internal communication architecture has been reorganized into a strict hierarchical message system. The root \Message\ enum now acts as a dispatcher for specific sub-message categories (such as \Tool\, \Viewport\, \Clipboard\, and \Network\), replacing the previous flat structure. This change introduces a \Responses\ trait with explicit \add\ and \add\_front\ methods for message queuing, standardizing how the editor processes and prioritizes user actions and system events.
editor/src/messages · high confidence
Frontend panels migrated to Svelte
The core UI panels—Data, Document, Layers, Properties, and Welcome—have been rewritten in Svelte, replacing the previous Vue implementation. This migration introduces Svelte-specific features such as reactive state declarations ($:), the getContext API for accessing stores and the editor instance, and Svelte lifecycle hooks (onMount, onDestroy) for managing event listeners and cleanup. The change also updates component imports to use absolute paths (e.g., components/...) and integrates with the new WidgetLayout system for panel content rendering.
frontend/src/components/panels · high confidence
Frontend state management restructured into granular, HMR-resilient stores
The frontend application state has been reorganized into a set of specialized, modular stores (including app-window, color-picker, dialog, document, fullscreen, math-expression, node-graph, panel-drag, portfolio, and tooltip) that replace the previous monolithic structure. Each store now manages a specific domain of the UI—such as panel docking, node graph interactions, or color selection—and subscribes directly to backend messages via a SubscriptionsRouter. A key improvement is the addition of Hot Module Replacement (HMR) persistence, which ensures that reactive subscriptions and UI state survive code updates without breaking the page, significantly improving the developer experience and application stability during development. Also in this area: 2 commits (0 fixes) modifying (repo-wide); Fixes for UI reactivity regressions and layout sizing issues; Improved frontend performance via fine-grained reactivity.
frontend/src/stores · medium confidence · unverified
Integrate document-format resource storage into the editor
The editor now includes a dedicated message handler for managing document resources, enabling the storage and garbage collection of resource data (such as fonts) via the new \ResourceStorageMessage\. This change introduces a \ResourcesHandle\ that implements the \ResourceStorage\ trait, allowing the editor to interact with the underlying storage backend through standardized load, store, and garbage collection operations, which supports the fix for corrupted font resource loading in older documents.
_editor/src/messages/resource\storage · high confidence
Introduce Svelte-based Editor component with structured lifecycle management
The frontend now uses a new \Editor.svelte\ component as the root of the application, replacing the previous Vue-based initialization. This component manages the creation and destruction of core application stores (such as dialog, document, node graph, and color picker) and managers (including clipboard, input, and localization) via Svelte's lifecycle hooks. It also establishes the connection to the Rust/WASM backend by passing subscriptions and the editor wrapper through Svelte context, ensuring the backend is initialized and layouts are resent correctly upon mount or Hot Module Replacement (HMR) updates.
frontend/src/components · high confidence
Introduce Svelte-based window layout with interactive panel docking and fullscreen support
The window UI components (MainWindow, Panel, PanelSubdivision, TitleBar, StatusBar) have been rewritten in Svelte to support interactive panel docking, tab reordering, and double-click tab renaming. The TitleBar now handles native window controls and hides the menu bar in fullscreen mode on macOS, while the main window layout adapts to the platform's fullscreen state and viewport hole punch settings.
frontend/src/components/window · high confidence
Introduce WGPU executor with Vulkan priority and texture caching
The WGPU executor library has been rewritten to use a new context builder that prioritizes Vulkan on Linux and Discrete GPUs on Windows, improving rendering performance and stability. A new texture cache with configurable size limits and eviction logic reduces GPU memory usage and prevents out-of-memory crashes, while a new buffer abstraction and pipeline caching system streamline GPU resource management and execution. Also in this area: Shared Vello renderer with per-canvas frame resources; Switch rendering to Vello GPU with WebGL2 support on Web.
node-graph/libraries/wgpu-executor · high confidence
Introduce centralized dialog message system and handlers
The editor now uses a dedicated \DialogMessage\ enum and \DialogMessageHandler\ to manage the lifecycle and state of floating dialogs (Export, New Document, Preferences, and simple dialogs like About/Licenses). This change centralizes dialog dispatch, ensuring that opening a dialog correctly sets up its internal state (such as populating artboard lists for export or generating default document names) and handles dismissal sequences (like \CloseAndThen\) to prevent dialogs from reopening unexpectedly.
editor/src/messages/dialog · high confidence
Introduce dedicated CacheHash trait for deterministic cache invalidation
The graphene-hash library now provides a dedicated \CacheHash\ trait and a \CacheHash\ derive macro to replace the standard \Hash\ trait for cache invalidation. This change ensures deterministic hashing for floating-point values (like \f32\ and \f64\) by using their bit patterns, preventing issues with NaN values, and provides specific implementations for graphics types such as \glam\ vectors/matrices and \kurbo\ paths. Users can now derive \CacheHash\ for custom structs, optionally skipping fields with the \\#\[cache\_hash(skip)\]\ attribute, to ensure consistent cache keys across sessions.
node-graph/libraries/application-io, node-graph/libraries/graphene-hash · high confidence
Introduce dedicated input mapper message system
The editor now uses a new \InputMapperMessage\ system to handle keyboard and mouse events. This change introduces a dedicated message hierarchy for input events (such as key down/up, double-click, and pointer shake) and a handler that matches these raw inputs against configured key mappings to dispatch specific application actions. This centralizes input processing, allowing for more consistent and maintainable shortcut handling across tools like the node graph, select tool, and navigation.
_editor/src/messages/input\mapper · high confidence
Introduce dedicated menu bar message handling and layout persistence
The menu bar logic has been extracted into a dedicated \menu\_bar\ module containing a new \MenuBarMessage\ enum and \MenuBarMessageHandler\. This handler now manages the application's menu structure (File, Edit, View, etc.) and exposes a \SendLayout\ message, enabling the persistence of the menu bar's layout state alongside other panel configurations.
_editor/src/messages/menu\bar · high confidence
Introduce platform-specific window implementation layer
The desktop application now uses a dedicated abstraction layer for window management, with new platform-specific implementations in \desktop/src/window\ for Linux, macOS, and Windows. On Linux, the window configuration now explicitly supports Wayland (with client-side decorations) and X11. On macOS, the window is configured with a transparent titlebar and full-size content view, and the implementation integrates with native menu and app lifecycle handling. On Windows, the window initialization now attaches to the parent console and sets the explicit App User Model ID to ensure correct taskbar behavior.
desktop/src/window · high confidence
Math nodes now support Vec2 inputs and use a cached Chumsky-based expression parser
The math expression nodes in the node graph now accept Vec2 inputs, allowing vector operations to be performed directly within expressions. To support this and improve performance, the underlying expression parser has been migrated from Pest to Chumsky and includes a caching mechanism that reuses the parsed AST when the source expression remains unchanged, reducing redundant parsing overhead.
node-graph/nodes/math · high confidence
Native macOS menu bar and application integration
The macOS desktop client now uses native system menus and application handling. This change introduces a custom NSApplication subclass to route keyboard events directly to the key window, bypassing native menu shortcut interference, and implements a native NSApplicationDelegate to handle file-opening events via URL schemes. Additionally, a new menu system built on the muda library manages the native menu bar, supporting dynamic updates for actions, checkboxes, submenus, and separators, while ensuring menu events are correctly scheduled as application events.
desktop/src/window/mac · high confidence
New Svelte-based button widget components
The frontend now includes a set of new Svelte components for buttons (BreadcrumbTrailButtons, IconButton, ImageButton, ParameterExposeButton, PopoverButton, TextButton) that replace the previous implementation. These components provide a consistent, stylized interface for navigation, actions, and menus, featuring support for icons, tooltips, drag-and-drop targets, and nested menu lists.
frontend/src/components/widgets/buttons · high confidence
New Svelte-based label and shortcut components
The frontend now uses a new set of Svelte components for rendering labels and shortcuts: IconLabel, ImageLabel, Separator, ShortcutLabel, and TextLabel. These components replace the previous implementation, providing consistent styling for icons, images, and text labels, along with improved shortcut display logic that consolidates consecutive keys and adapts to the operating system (e.g., Mac-specific key icons). The TextLabel component also supports various styles (bold, italic, monospace, etc.) and interactive features like hover effects for associated checkboxes.
frontend/src/components/widgets/labels · high confidence
New composite shader and render state for improved UI/viewport blending
The desktop rendering subsystem now uses a new \composite\_shader.wgsl\ and \RenderState\ to handle compositing the UI, viewport, and overlays. This change introduces explicit sRGB/linear color space conversions in the fragment shader to fix color accuracy issues (such as doubly-applied gamma) and implements a specific blending logic that correctly handles transparency for UI elements over the viewport background. The \RenderState\ initializes the WGPU pipeline with this shader, managing surface configuration and texture bindings for the new compositing pass.
desktop/src/render · high confidence
New document value serialization format
The document format now uses a new \TaggedValue\ enum to serialize node inputs and outputs, replacing the previous serialization scheme. This change introduces compact storage for common types (like numbers, gradients, and strokes) and adds support for new data types such as \BrushCache\, \AnimationCurve\, and \Resource\ references. Existing documents are automatically migrated to this new format upon opening to ensure backwards compatibility.
node-graph/graph-craft/src/document · high confidence
New frontend message protocol for file operations and UI state
The editor now uses a new \FrontendMessage\ enum to handle communication with the frontend, introducing specific triggers for file dialogs (\TriggerBrowse\), document saving (\TriggerSaveDocument\), and image exporting (\TriggerExportImage\). This change also adds support for exporting to additional raster formats (WebP, TIFF, BMP, TGA, ICO) via the \FileType\ enum and its encoding logic, while standardizing UI state updates such as cursor icons, context menu information, and layer name editing in the graph view.
editor/src/messages/frontend · high confidence
New input mapping utility types and macros for keyboard and pointer events
The editor's input mapper now uses a new set of utility types and macros in \editor/src/messages/input\_mapper/utility\_types\ to define and process keyboard and pointer inputs. This includes a comprehensive \Key\ enum for keyboard codes, \ModifierKeys\ bitflags, and \KeyStates\ for tracking pressed keys, alongside \PointerState\ and \EditorPointerState\ to handle mouse/pen position, pressure, tilt, and scroll deltas. New macros (\entry\, \mapping\, \modifiers\) simplify the definition of input mappings by automatically generating the necessary \MappingEntry\ structures for key up/down, double-click, and pointer events, while \misc.rs\ provides the \Mapping\ and \KeyMappingEntries\ structures to match these inputs against available actions. This refactoring centralizes the low-level input data structures and provides a more consistent and type-safe foundation for the editor's hotkey and gesture handling.
_editor/src/messages/input\_mapper/utility\types · high confidence
New layout widget system and math expression parsing utilities
The editor introduces a new layout widget system that replaces the previous \WidgetHolder\ and \SubLayout\ structures with a \LayoutHolder\ trait and a \Layout\ struct, enabling deterministic widget IDs for more efficient UI diffing and updates. This change also adds a new math expression parsing module that provides syntax highlighting, auto-completion, and error reporting for math input widgets, along with utility functions for escaping and rendering Markdown in tooltips.
_editor/src/messages/layout/utility\types · high confidence
New styling for reading material layout
A new SCSS file has been added to define the visual presentation of reading material sections, such as blog posts and articles. This style sets a base font size of 16px with a line height of 1.625, constrains the content width, and applies specific margins to headings and horizontal rules. It also handles responsive adjustments for wide images and ensures captions appear correctly below images.
website/sass/layout · high confidence
New website component styles for carousels, code snippets, and media embeds
The website's visual presentation is updated with new SCSS styles for several key UI components. A new carousel component now supports responsive layouts with fade effects, touch interactions, and dynamic window sizing for images and videos. Code snippets are restyled with a dark navy background and specific syntax highlighting for Zola-generated code. Additionally, new styles are introduced for YouTube video embeds (featuring a custom overlay and play button), image comparison sliders with animated indicators, feature boxes with noise textures, and feature icon grids using sprite atlases.
website/sass/component · high confidence
New website visual design and responsive layout system
The website's styling has been replaced with a new design system defined in \website/sass/base.scss\. This introduces a custom color palette (e.g., navy, parchment, crimson) and CSS variables for consistent theming. The layout is now fully responsive, with specific breakpoints adjusting font sizes, padding, and navigation element heights for screens ranging from mobile (320px) to large desktops (1600px). The navigation bar and page structure have been restyled to support this new responsive behavior.
website/sass · high confidence
New widget definition types for buttons, inputs, and labels
The editor now defines a new set of widget structs in the \editor/src/messages/layout/utility\_types/widgets\ module, including \IconButton\, \TextButton\, \CheckboxInput\, \DropdownInput\, and \TextLabel\. These types establish the data structures for the UI layout system, introducing features such as drag-and-drop support for icon buttons, file drop handling for dropdowns, and deterministic IDs for checkboxes to improve diffing.
_editor/src/messages/layout/utility\types/widgets · high confidence
New widget layout system for Properties panel sections
The Properties panel now uses a new layout system that allows node sections to be reordered by dragging, and adds visibility and delete buttons to each section header. This change also introduces a new WidgetLayout component that renders sections, rows, and tables based on a unified layout structure, improving the consistency and flexibility of the UI. Also in this area: Fixes for UI reactivity regressions and layout sizing issues; Improved frontend performance via fine-grained reactivity.
frontend/src/components/widgets · high confidence
Redesign of graphic data model with cascading appearance and unified types
The graphic types library has been restructured to use a new \Appearance\ model that manages fill and stroke as an ordered list of paint passes (coverages) stored in attributes, replacing the previous direct \Fill\ and \Stroke\ fields. This enables cascading inheritance where undeclared appearances inherit from ancestors. The \Graphic\ enum now supports embedding whole items and lists, with new variants for \Text\ (including \String\ lists) and \StrokeList\. Legacy document formats are supported via migration code that converts old vector data, flat gradient stops, and bounding-box-relative gradients into the new absolute, ramp-based structures. The \Artboard\ type is now a nominal wrapper around \List\<Graphic\>\ to prevent arbitrary nesting.
node-graph/libraries/graphic-types · high confidence
Redesigned gradient data model with advanced interpolation and spread controls
The vector types library introduces a new internal data model for gradients, replacing legacy structures with a unified \GradientRamp\ and \GradientStops\ system. This change enables users to control gradient behavior through new attributes: \GradientForm\ (Linear/Radial), \GradientInterpolation\ (Stepped, Linear, Smooth), \GradientSpace\ (sRGB Gamma, sRGB Linear), \GradientSpread\ (including a new 'Clear' option), and \GradientCyclic\ for seamless loops. The model also supports per-stop midpoints and positions, allowing for more precise color ramp manipulation and better round-trip serialization fidelity.
node-graph/libraries/vector-types/src · high confidence
Redesigned simple dialogs with new layout system and content updates
The simple dialogs in the editor (About, Close All, Close Document, Restart, Demo Artwork, Error, Failed to Load/Open, and Licenses) have been rewritten to use the new widget builder pattern and layout system. This change introduces a refreshed UI for these dialogs, including a new Demo Artwork gallery with seven specific artworks (Isometric Fountain, Changing Seasons, Painted Dreams, Parametric Dunescape, Red Dress, Procedural String Lights, Valley of Spires) that can be opened directly from the dialog. The About dialog now includes links to Donate, Website, Volunteer, Credits, and a new Licenses button. The Licenses dialog has been updated to reflect the dual MIT/Apache-2.0 source code license and includes links to Source Code License, Branding License, and Dependency Licenses. The Failed to Load/Open dialogs now provide options to Download, Discard, or Dismiss the error, along with links to Discord and GitHub for reporting, and a link to the previous version of Graphite. The Confirm Restart dialog now lists specific preferences requiring a restart and assures users that open documents will be automatically restored.
_editor/src/messages/dialog/simple\dialogs · high confidence
Refactor frontend managers to use explicit create/destroy lifecycle
The frontend managers (clipboard, drag-toggle, hyperlink, input, localization, panic, and persistence) have been restructured to use explicit \create\ and \destroy\ functions instead of returning destructors from constructors. This change improves resource management by ensuring subscriptions and event listeners are properly cleaned up, and adds Hot Module Replacement (HMR) support so the application can reload these modules without breaking the page during development.
frontend/src/managers · high confidence
Removal of legacy GLSL shader files
The fragment and vertex shader source files (shader.frag and shader.vert) have been removed from the project. This deletion eliminates the previous GLSL implementation that handled texture sampling and vertex positioning, likely as part of the broader migration to the wgpu 0.5 graphics backend which requires updated shader logic.
shaders · high confidence
Replace npm build scripts with a custom cargo-run tool
The development workflow for the web and desktop applications now uses a new \cargo run\ tool instead of the previous \npm\ build scripts, \wasm-pack\, \cargo-watch\, and \concurrently\. This tool handles environment setup, including auto-installing dependencies like \wasm-opt\, and manages the build process for the Wasm wrapper and frontend assets. It also introduces auto-recovery mechanisms for common issues, such as clearing \node\_modules\ when installs are blocked by zombie processes and automatically cleaning up corrupt Wasm builds that emit undefined \env\ imports.
tools/cargo-run · high confidence
Switch web rendering to WebGL2 and update wgpu to v30
The web build now uses WebGL2 instead of WebGPU, requiring a new initialization flow via \create\_wgpu\_executor\ and enforcing opaque alpha modes and specific uniform padding for WebGL2 compatibility. The underlying wgpu library has been updated to version 30, introducing API changes such as explicit queue-based presentation, auto color space configuration, and a new \VelloSceneBuilder\ type for overlay rendering. Also in this area: Reorganized node catalog categories and display order; Introduce the Basic Brush node for GPU-accelerated raster painting.
_libraries/wgpu-sync, node-graph/nodes/brush/src/basic\brush · high confidence
Third-party license notice generation rewritten in Rust
The tool responsible for generating the third-party software license notices has been reimplemented as a Rust application, replacing the previous npm-based build scripts and dev-server tooling. This new tool collects license data from Cargo dependencies, NPM packages, and (on desktop builds) Chromium Embedded Framework (CEF) credits, then produces a formatted notice file. For desktop users, the output is now compressed as an XZ archive, while web users receive a plain text file; the generation process is optimized to skip writing if no license changes are detected.
tools/third-party-licenses · high confidence
Website build tooling modernized with TypeScript checking and font optimization
The website build process now uses a new TypeScript configuration (tsconfig.json) to enable strict type checking on build scripts and JavaScript files, and adopts the frontend's ESLint configuration for consistent linting. A new install script automatically downloads and optimizes web fonts (Inter, Bona Nova) by copying only the CSS and font files actually referenced in the stylesheets, removing unused assets to reduce bundle size. Additionally, the user manual now includes a generated node catalog with specific styling for tables, and the book template JavaScript handles table-of-contents navigation and chapter selection via data attributes.
website · high confidence
Website redesign with new page styles and responsive layouts
The website has been restyled with new SCSS files for all major pages (about, blog, donate, features, index, logo, volunteer) and templates (article, book). Key changes include a revamped donation page with a Stripe integration thanks banner and basic donation statistics, a new features page with video containers and a roadmap timeline, and improved responsive design across the site, including mobile-friendly layouts for the book reader and blog. The home page now features a logo, tagline, quick links, and an overview section with video support.
website/sass/page · high confidence
Windows build now embeds application metadata and branding
The Windows build process now includes a dedicated build script that embeds application metadata directly into the compiled binary. This ensures the application displays the correct Graphite icon in the Windows taskbar and file properties, and includes versioning and copyright information (set to 2026) within the executable.
desktop/platform · high confidence
Test coverage
27 commits adding/updating tests in document/graph-storage/src/tests; 6 commits adding/updating tests in document/migrations; Added runtime profiling benchmarks for the interpreted executor.
Dependencies
Rust workspace restructuring and frontend dependency updates
The project has reorganized its Rust dependency management by introducing a comprehensive workspace structure across multiple crates, including \graphite-desktop\, \graphite-editor\, \document-container\, and various \graphene-\*\ libraries, which now reference shared dependencies via \workspace = true\. This restructuring is accompanied by the addition of new platform-specific crates for the desktop application (Linux, macOS, Windows) and the introduction of new document storage crates (\document-container\, \document-format\, \document-graph-storage\). On the frontend, the project has updated its npm dependencies, notably upgrading Svelte to version 5.55.1, Vite to 8.0.3, and ESLint to 9.39.2, while also adding new font dependencies (Stix Two Math, Source Code Pro, Source Sans Pro).
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 40 → 42 (+2.1)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 36 → 40 (+3.3)
- Architecture 96 → 95 (-0.7)
- Maturity 63 → 77 (+13.9)
- Readiness 45 → 48 (+2.3)
- Security 54 → 68 (+14.0)
- Event-Driven 80 → 80 (+0.0)
- Event Sourcing 100 → 100 (+0.0)
- Accessibility 30 → 29 (-1.5)
- Performance 94 → 94 (+0.0)
Resolved (329)
- Base-context workflow trigger runs with an unscoped token (.github/workflows/comment-!build-commands.yml)
- Boundary-crossing change coupling: document_message_handler.rs ↔ editor_commands.rs (editor/src/messages/portfolio/document/document_message_handler.rs)
- Boundary-crossing change coupling: document_node_definitions.rs ↔ graphene_compiler.rs (editor/src/messages/portfolio/document/node_graph/document_node_definitions.rs)
- Boundary-crossing change coupling: node_inspector.rs ↔ blending_nodes.rs (editor/src/messages/portfolio/document/node_graph/node_inspector.rs)
- CI installs an unverified third-party binary (.github/workflows/build.yml)
- Change coupling: animation.rs ↔ context_modification.rs (node-graph/nodes/gcore/src/animation.rs)
- Change coupling: context_modification.rs ↔ graphic.rs (node-graph/nodes/gcore/src/context_modification.rs)
- Change coupling: document_migration.rs ↔ icons.ts (editor/src/messages/portfolio/document_migration.rs)
- Change coupling: graphic.rs ↔ repeat_nodes.rs (node-graph/nodes/graphic/src/graphic.rs)
- Change-coupling hub: vector_nodes.rs → artboard.rs, lib.rs, context_modification.rs, filter.rs, transform_nodes.rs (node-graph/nodes/vector/src/vector_nodes.rs)
- ClassTooLong: Color (node-graph/libraries/no-std-types/src/color/color_types.rs)
- ClassTooLong: Gradient (node-graph/libraries/vector-types/src/gradient.rs)
- ClassTooLong: NodeGraphExecutor (editor/src/node_graph_executor.rs)
- ClassTooLong: NodeNetwork (node-graph/graph-craft/src/document.rs)
- Classify ADR enforcement: Summary (node-graph/rfcs/async-execution-model.md)
- Classify ADR enforcement: Summary (node-graph/rfcs/document-format.md)
- Classify ADR enforcement: Summary (node-graph/rfcs/fine-grained-context-caching.md)
- Duplicated block (10 lines × 2) (document/container/src/lib.rs)
- Duplicated block (10 lines × 2) (document/graph-storage/src/document.rs)
- Duplicated block (10 lines × 2) (editor/src/messages/portfolio/document/data_panel/data_panel_message_handler.rs)
- …and 309 more
New (468)
- BlobStore::absorb (cognitive 16) (document/format/src/blob_store.rs)
- Boundary-crossing change coupling: data_panel_message_handler.rs ↔ vector_modification_nodes.rs (editor/src/messages/portfolio/document/data_panel/data_panel_message_handler.rs)
- Boundary-crossing change coupling: document_node_definitions.rs ↔ transform_nodes.rs (editor/src/messages/portfolio/document/node_graph/document_node_definitions.rs)
- Boundary-crossing change coupling: runtime.rs ↔ artboard.rs (editor/src/node_graph_executor/runtime.rs)
- Boundary-crossing change coupling: runtime.rs ↔ test.rs (editor/src/node_graph_executor/runtime.rs)
- CI installs an unverified third-party binary (.github/workflows/build.yml)
- CI installs an unverified third-party binary (.github/workflows/build.yml)
- CI installs an unverified third-party binary (.github/workflows/build.yml)
- Change coupling: lib.rs ↔ transform_nodes.rs (node-graph/nodes/blending/src/lib.rs)
- Change-coupling hub: graphic.rs → context_modification.rs, repeat_nodes.rs, vector_modification_nodes.rs (node-graph/nodes/graphic/src/graphic.rs)
- Change-coupling hub: vector_nodes.rs → artboard.rs, lib.rs, lib.rs, context_modification.rs, filter.rs, transform_nodes.rs, vector_modification_nodes.rs (node-graph/nodes/vector/src/vector_nodes.rs)
- ClassTooLong: Color (node-graph/libraries/core-types/src/color/color_types.rs)
- ClassTooLong: DocumentMessageHandler (editor/src/messages/portfolio/document/document_message_handler.rs)
- ClassTooLong: Replica (document/peer-transport/src/replica.rs)
- ClassTooLong: Session (document/graph-storage/src/session.rs)
- Duplicated block (10 lines × 2) (document/container/src/lib.rs)
- Duplicated block (10 lines × 2) (editor/src/messages/portfolio/document/document_message_handler.rs)
- Duplicated block (10 lines × 2) (editor/src/messages/tool/common_functionality/utility_functions.rs)
- Duplicated block (10 lines × 2) (editor/src/messages/tool/tool_messages/path_tool.rs)
- Duplicated block (10 lines × 2) (libraries/math-parser/src/parser.rs)
- …and 448 more
Changes since last survey
- 136 commits — 113 feature/other, 23 fixes
By area
- editor/src — 60 commits
- .github/workflows — 8 commits
- node-graph/graph-craft — 8 commits
- node-graph/libraries — 8 commits
- node-graph/nodes — 8 commits
- document/migrations — 7 commits
- document/graph-storage — 5 commits
- frontend/src — 5 commits
- (root) — 4 commits
- document/format — 4 commits
- desktop/src — 3 commits
- document/peer-transport — 3 commits
- node-graph/graphene-cli — 3 commits
- frontend/wrapper — 2 commits
- tools/regression — 2 commits
- .github/pr-title-review — 1 commit
- desktop/ui — 1 commit
- node-graph/interpreted-executor — 1 commit
- node-graph/node-macro — 1 commit
- website/content — 1 commit
Notable commits
- fix: Add the regression corpus tool and the guide to writing migrations (#4866)
- fix: Desktop: Fix dashed ellipses and hovered handle overlays (#4842)
- fix: Fix 'Combine Paths' hashing differently across platforms (#4911)
- fix: Fix 'Smooth Anchors' changing the path at a spread of 0 (#4896)
- fix: Fix Inspector outlines and wires rendering unevenly at fractional scales (#4828)
- fix: Fix Vivid Light burning and dodging the source by the backdrop instead of the backdrop by the source (#4940)
- fix: Fix a collaborative editing room panicking when polled after its socket loop ended (#4932)
- fix: Fix a crash when previewing a node with no output (#4899)
- fix: Fix clippy warnings (#4923)
- fix: Fix deleting the bottom layer leaving an empty graphic at the bottom of the stack (#4927)
- fix: Fix grouping layers leaving the layers below the group overlapping its contents in the graph (#4933)
- fix: Fix hints bar shortcuts going stale from in-place widget updates introduced in #4790
- fix: Fix layer thumbnails and node graph panics crashing the editor (#4895)
- fix: Fix numerous bugs relating to paint and color (#4831)
- fix: Fix numerous bugs with the Path and Pen tools (#4830)
- fix: Fix saving leaving the document marked as unsaved on web (#4909)
- fix: Fix the Data panel showing another node's output for some layers and remove Monitor nodes from Merge/Artboard (#4854)
- fix: Fix the Path tool's G G anchor slide so it doesn't jitter or distort as badly (#4948)
- fix: Fix the merge queue stalling on a missing check when it skips already-tested PRs
- fix: Fix the transform cage of a zero-width layer being offset by its traslation (#4931)
- …and 116 more
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
GraphiteEditor/Graphite was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit c974d41cbf8af891f7bd37fbdcfe9632f1df0cb9 — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.