Deploy from GitHub repository

.cargo/config.toml

@@ -0,0 +1,12 @@
+[target.wasm32-unknown-unknown]
+rustflags = [
+	# Currently disabled because of https://github.com/GraphiteEditor/Graphite/issues/1262
+	# The current simd implementation leads to undefined behavior
+	#"-C",
+	#"target-feature=+simd128",
+	"-C",
+	"target-feature=+bulk-memory",
+	"-C",
+	"link-arg=--max-memory=4294967296",
+	"--cfg=web_sys_unstable_apis",
+]

.devcontainer/devcontainer.json

@@ -0,0 +1,32 @@
+{
+	"image": "mcr.microsoft.com/devcontainers/base:debian",
+	"features": {
+		"ghcr.io/devcontainers/features/rust:1": {
+			"profile": "default"
+		},
+		"ghcr.io/devcontainers/features/node:1": {}
+	},
+	"onCreateCommand": "cargo install cargo-watch wasm-pack cargo-about && cargo install -f [email protected]",
+	"customizations": {
+		"vscode": {
+			// NOTE: Keep this in sync with `.vscode/extensions.json`
+			"extensions": [
+				// Rust
+				"rust-lang.rust-analyzer",
+				"tamasfe.even-better-toml",
+				// Web
+				"dbaeumer.vscode-eslint",
+				"svelte.svelte-vscode",
+				"vitaliymaz.vscode-svg-previewer",
+				// Code quality
+				"wayou.vscode-todo-highlight",
+				"streetsidesoftware.code-spell-checker",
+				// Helpful
+				"mhutchie.git-graph",
+				"waderyan.gitblame",
+				"qezhu.gitlink",
+				"wmaurer.change-case"
+			]
+		}
+	}
+}

.editorconfig

@@ -0,0 +1,7 @@
+[*.{rs,js,ts,svelte,json,toml,svg,html,css,scss}]
+indent_style = tab
+indent_size = 4
+end_of_line = lf
+trim_trailing_whitespace = true
+insert_final_newline = true
+max_line_length = 200

.envrc

@@ -0,0 +1 @@
+use flake .nix

.gitattributes

@@ -33,3 +33,12 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+frontend/src-tauri/icons/icon.icns filter=lfs diff=lfs merge=lfs -text
+node-graph/graphene-cli/test_files/cat.jpg filter=lfs diff=lfs merge=lfs -text
+node-graph/graphene-cli/test_files/cow_transparent.png filter=lfs diff=lfs merge=lfs -text
+node-graph/graphene-cli/test_files/duck.jpg filter=lfs diff=lfs merge=lfs -text
+node-graph/graphene-cli/test_files/football.jpg filter=lfs diff=lfs merge=lfs -text
+node-graph/graphene-cli/test_files/mansion.jpg filter=lfs diff=lfs merge=lfs -text
+node-graph/graphene-cli/test_files/paper.jpg filter=lfs diff=lfs merge=lfs -text
+node-graph/graphene-cli/test_files/pizza.jpg filter=lfs diff=lfs merge=lfs -text
+node-graph/graphene-cli/test_files/pizza_transparent.png filter=lfs diff=lfs merge=lfs -text

.nix/flake.lock

@@ -0,0 +1,99 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1748190013,
+        "narHash": "sha256-R5HJFflOfsP5FBtk+zE8FpL8uqE7n62jqOsADvVshhE=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "62b852f6c6742134ade1abdd2a21685fd617a291",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs-unstable": {
+      "locked": {
+        "lastModified": 1748190013,
+        "narHash": "sha256-R5HJFflOfsP5FBtk+zE8FpL8uqE7n62jqOsADvVshhE=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "62b852f6c6742134ade1abdd2a21685fd617a291",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs",
+        "nixpkgs-unstable": "nixpkgs-unstable",
+        "rust-overlay": "rust-overlay"
+      }
+    },
+    "rust-overlay": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1748399823,
+        "narHash": "sha256-kahD8D5hOXOsGbNdoLLnqCL887cjHkx98Izc37nDjlA=",
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "rev": "d68a69dc71bc19beb3479800392112c2f6218159",
+        "type": "github"
+      },
+      "original": {
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "type": "github"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

.nix/flake.nix

@@ -0,0 +1,115 @@
+# This is a helper file for people using NixOS as their operating system.
+# If you don't know what this file does, you can safely ignore it.
+# This file defines both the development environment for the project.
+#
+# Development Environment:
+# - Provides all necessary tools for Rust/WASM development
+# - Includes Tauri dependencies for desktop app development
+# - Sets up profiling and debugging tools
+# - Configures mold as the default linker for faster builds
+#
+#
+# Usage:
+# - Development shell: `nix develop`
+# - Run in dev shell with direnv: add `use flake` to .envrc
+{
+  description = "Development environment and build configuration";
+
+  inputs = {
+    # This url should be changed to match your system packages if you work on tauri because you need to use the same graphics library versions as the ones used by your system
+    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
+    nixpkgs-unstable.url = "github:nixos/nixpkgs/nixos-unstable";
+    rust-overlay = {
+      url = "github:oxalica/rust-overlay";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+    flake-utils.url = "github:numtide/flake-utils";
+  };
+
+  outputs = { nixpkgs, nixpkgs-unstable, rust-overlay, flake-utils, ... }:
+    flake-utils.lib.eachDefaultSystem (system:
+      let
+        overlays = [ (import rust-overlay) ];
+        pkgs = import nixpkgs {
+          inherit system overlays;
+        };
+        pkgs-unstable = import nixpkgs-unstable {
+          inherit system overlays;
+        };
+        
+        rustc-wasm = pkgs.rust-bin.stable.latest.default.override {
+          targets = [ "wasm32-unknown-unknown" ];
+          extensions = [ "rust-src" "rust-analyzer" "clippy" "cargo" ];
+        };
+
+        # Shared build inputs - system libraries that need to be in LD_LIBRARY_PATH
+        buildInputs = with pkgs; [
+          # System libraries
+          openssl
+          vulkan-loader
+          mesa
+          libraw
+
+
+          # Tauri dependencies: keep in sync with https://v2.tauri.app/start/prerequisites/#system-dependencies (under the NixOS tab)
+          at-spi2-atk
+          atkmm
+          cairo
+          gdk-pixbuf
+          glib
+          gtk3
+          harfbuzz
+          librsvg
+          libsoup_3
+          pango
+          webkitgtk_4_1
+          openssl
+        ];
+
+        # Development tools that don't need to be in LD_LIBRARY_PATH
+        buildTools =  [
+          rustc-wasm
+          pkgs.nodejs
+          pkgs.nodePackages.npm
+          pkgs.binaryen
+          pkgs.wasm-bindgen-cli
+          pkgs-unstable.wasm-pack
+          pkgs.pkg-config
+          pkgs.git
+          pkgs.gobject-introspection
+          pkgs-unstable.cargo-tauri
+          pkgs-unstable.cargo-about
+
+          # Linker
+          pkgs.mold
+        ];
+        # Development tools that don't need to be in LD_LIBRARY_PATH
+        devTools = with pkgs; [
+          cargo-watch
+          cargo-nextest
+          cargo-expand
+          
+          # Profiling tools
+          gnuplot
+          samply
+          cargo-flamegraph
+
+        ];
+      in
+      {
+        # Development shell configuration
+        devShells.default = pkgs.mkShell {
+          packages = buildInputs ++ buildTools ++ devTools;
+
+          LD_LIBRARY_PATH = pkgs.lib.makeLibraryPath buildInputs;
+          GIO_MODULE_DIR="${pkgs.glib-networking}/lib/gio/modules/";
+          XDG_DATA_DIRS="${pkgs.gsettings-desktop-schemas}/share/gsettings-schemas/${pkgs.gsettings-desktop-schemas.name}:${pkgs.gtk3}/share/gsettings-schemas/${pkgs.gtk3.name}:$XDG_DATA_DIRS";
+          
+
+          shellHook = ''
+            alias cargo='mold --run cargo'
+          '';
+        };
+      }
+    );
+}

.nvmrc

@@ -0,0 +1 @@
+20

.prettierrc

@@ -0,0 +1,18 @@
+{
+	"singleQuote": false,
+	"useTabs": true,
+	"tabWidth": 4,
+	"printWidth": 200,
+	"overrides": [
+		{
+			"files": [
+				"*.yml",
+				"*.yaml"
+			],
+			"options": {
+				"useTabs": false,
+				"tabWidth": 2
+			}
+		}
+	]
+}

.vscode/extensions.json

@@ -0,0 +1,20 @@
+{
+	// NOTE: Keep this in sync with `.devcontainer/devcontainer.json`
+	"recommendations": [
+		// Rust
+		"rust-lang.rust-analyzer",
+		"tamasfe.even-better-toml",
+		// Web
+		"dbaeumer.vscode-eslint",
+		"svelte.svelte-vscode",
+		"vitaliymaz.vscode-svg-previewer",
+		// Code quality
+		"wayou.vscode-todo-highlight",
+		"streetsidesoftware.code-spell-checker",
+		// Helpful
+		"mhutchie.git-graph",
+		"waderyan.gitblame",
+		"qezhu.gitlink",
+		"wmaurer.change-case"
+	]
+}

.vscode/launch.json

@@ -0,0 +1,48 @@
+{
+	// Use IntelliSense to learn about possible attributes.
+	// Hover to view descriptions of existing attributes.
+	// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+	"version": "0.2.0",
+	"configurations": [
+		{
+			"type": "lldb",
+			"request": "launch",
+			"name": "Graphite debug executable",
+			"cargo": {
+				"args": [
+					"build",
+					"--bin=graphite",
+					"--package=graphite",
+				],
+				"filter": {
+					"name": "graphite",
+					"kind": "bin",
+				},
+			},
+			"args": [],
+			"cwd": "${workspaceFolder}",
+			"env": {
+				"RUST_LOG": "error",
+			},
+		},
+		{
+			"type": "lldb",
+			"request": "launch",
+			"name": "Debug unit tests in executable 'graphite'",
+			"cargo": {
+				"args": [
+					"test",
+					"--no-run",
+					"--bin=graphite",
+					"--package=graphite",
+				],
+				"filter": {
+					"name": "graphite",
+					"kind": "bin",
+				},
+			},
+			"args": [],
+			"cwd": "${workspaceFolder}",
+		},
+	],
+}

.vscode/settings.json

@@ -0,0 +1,56 @@
+{
+	// Rust: save on format
+	"[rust]": {
+		"editor.formatOnSave": true,
+		"editor.formatOnPaste": true,
+		"editor.defaultFormatter": "rust-lang.rust-analyzer"
+	},
+	// Web: save on format
+	"[javascript][typescript][svelte]": {
+		"editor.codeActionsOnSave": {
+			"source.fixAll.eslint": "explicit"
+		},
+		"editor.formatOnSave": true,
+		"editor.defaultFormatter": "dbaeumer.vscode-eslint"
+	},
+	"[scss]": {
+		"editor.codeActionsOnSave": {
+			"source.fixAll.eslint": "explicit"
+		},
+		"editor.formatOnSave": true,
+		// Configured in `.prettierrc`
+		"editor.defaultFormatter": "esbenp.prettier-vscode"
+	},
+	"[json][jsonc][yaml][github-actions-workflow]": {
+		"editor.formatOnSave": true,
+		// Configured in `.prettierrc`
+		"editor.defaultFormatter": "esbenp.prettier-vscode"
+	},
+	// Handlebars: don't save on format
+	// (`about.hbs` is used by Cargo About to encode license information)
+	"[handlebars]": {
+		"editor.formatOnSave": false
+	},
+	// Rust Analyzer config
+	"rust-analyzer.cargo.allTargets": false,
+	// ESLint config
+	"eslint.format.enable": true,
+	"eslint.workingDirectories": ["./frontend", "./website/other/bezier-rs-demos", "./website"],
+	"eslint.validate": ["javascript", "typescript", "svelte"],
+	// Svelte config
+	"svelte.plugin.svelte.compilerWarnings": {
+		// NOTICE: Keep this list in sync with the list in `frontend/vite.config.ts`
+		"css-unused-selector": "ignore",
+		"vite-plugin-svelte-css-no-scopable-elements": "ignore",
+		"a11y-no-static-element-interactions": "ignore",
+		"a11y-no-noninteractive-element-interactions": "ignore",
+		"a11y-click-events-have-key-events": "ignore"
+	},
+	// VS Code config
+	"html.format.wrapLineLength": 200,
+	"files.eol": "\n",
+	"files.insertFinalNewline": true,
+	"files.associations": {
+		"*.graphite": "json"
+	}
+}

Cargo.toml

@@ -0,0 +1,179 @@
+[workspace]
+members = [
+	"editor",
+	"proc-macros",
+	"frontend/wasm",
+	"frontend/src-tauri",
+	"node-graph/gapplication-io",
+	"node-graph/gbrush",
+	"node-graph/gcore",
+	"node-graph/gstd",
+	"node-graph/gmath-nodes",
+	"node-graph/gpath-bool",
+	"node-graph/graph-craft",
+	"node-graph/graphene-cli",
+	"node-graph/graster-nodes",
+	"node-graph/gsvg-renderer",
+	"node-graph/interpreted-executor",
+	"node-graph/node-macro",
+	"node-graph/preprocessor",
+	"libraries/dyn-any",
+	"libraries/path-bool",
+	"libraries/bezier-rs",
+	"libraries/math-parser",
+	"website/other/bezier-rs-demos/wasm",
+]
+default-members = [
+	"editor",
+	"frontend/wasm",
+	"node-graph/gbrush",
+	"node-graph/gcore",
+	"node-graph/gstd",
+	"node-graph/gmath-nodes",
+	"node-graph/gpath-bool",
+	"node-graph/graph-craft",
+	"node-graph/graphene-cli",
+	"node-graph/graster-nodes",
+	"node-graph/gsvg-renderer",
+	"node-graph/interpreted-executor",
+	"node-graph/node-macro",
+]
+resolver = "2"
+
+[workspace.dependencies]
+# Local dependencies
+bezier-rs = { path = "libraries/bezier-rs", features = ["dyn-any", "serde"] }
+dyn-any = { path = "libraries/dyn-any", features = ["derive", "glam", "reqwest", "log-bad-types", "rc"] }
+preprocessor = { path = "node-graph/preprocessor"}
+math-parser = { path = "libraries/math-parser" }
+path-bool = { path = "libraries/path-bool" }
+graphene-application-io = { path = "node-graph/gapplication-io" }
+graphene-brush = { path = "node-graph/gbrush" }
+graphene-core = { path = "node-graph/gcore" }
+graphene-math-nodes = { path = "node-graph/gmath-nodes" }
+graphene-path-bool = { path = "node-graph/gpath-bool" }
+graph-craft = { path = "node-graph/graph-craft" }
+graphene-raster-nodes = { path = "node-graph/graster-nodes" }
+graphene-std = { path = "node-graph/gstd" }
+graphene-svg-renderer = { path = "node-graph/gsvg-renderer" }
+interpreted-executor = { path = "node-graph/interpreted-executor" }
+node-macro = { path = "node-graph/node-macro" }
+wgpu-executor = { path = "node-graph/wgpu-executor" }
+graphite-proc-macros = { path = "proc-macros" }
+
+# Workspace dependencies
+rustc-hash = "2.0"
+bytemuck = { version = "1.13", features = ["derive"] }
+serde = { version = "1.0", features = ["derive", "rc"] }
+serde_json = "1.0"
+serde-wasm-bindgen = "0.6"
+reqwest = { version = "0.12", features = ["blocking", "rustls-tls", "json"] }
+futures = "0.3"
+env_logger = "0.11"
+log = "0.4"
+bitflags = { version = "2.4", features = ["serde"] }
+ctor = "0.2"
+convert_case = "0.7"
+derivative = "2.2"
+thiserror = "2"
+anyhow = "1.0"
+proc-macro2 = { version = "1", features = [ "span-locations" ] }
+quote = "1.0"
+axum = "0.8"
+chrono = "0.4"
+ron = "0.8"
+fastnoise-lite = "1.1"
+wgpu = { version = "23", features = [
+	# We don't have wgpu on multiple threads (yet) https://github.com/gfx-rs/wgpu/blob/trunk/CHANGELOG.md#wgpu-types-now-send-sync-on-wasm
+	"fragile-send-sync-non-atomic-wasm",
+	"spirv",
+	"strict_asserts",
+] }
+once_cell = "1.13" # Remove when `core::cell::LazyCell` (<https://doc.rust-lang.org/core/cell/struct.LazyCell.html>) is stabilized in Rust 1.80 and we bump our MSRV
+wasm-bindgen = "=0.2.100" # NOTICE: ensure this stays in sync with the `wasm-bindgen-cli` version in `website/content/volunteer/guide/project-setup/_index.md`. We pin this version because wasm-bindgen upgrades may break various things.
+wasm-bindgen-futures = "0.4"
+js-sys = "=0.3.77"
+web-sys = { version = "=0.3.77", features = [
+	"Document",
+	"DomRect",
+	"Element",
+	"HtmlCanvasElement",
+	"CanvasRenderingContext2d",
+	"CanvasPattern",
+	"OffscreenCanvas",
+	"OffscreenCanvasRenderingContext2d",
+	"TextMetrics",
+	"Window",
+	"IdleRequestOptions",
+	"ImageData",
+	"Navigator",
+	"Gpu",
+	"HtmlImageElement",
+	"ImageBitmapRenderingContext",
+] }
+winit = "0.29"
+url = "2.5"
+tokio = { version = "1.29", features = ["fs", "macros", "io-std", "rt"] }
+vello = { git = "https://github.com/linebender/vello.git", rev = "3275ec8" } # TODO switch back to stable when a release is made
+resvg = "0.44"
+usvg = "0.44"
+rand = { version = "0.9", default-features = false, features = ["std_rng"] }
+rand_chacha = "0.9"
+glam = { version = "0.29", default-features = false, features = ["serde", "scalar-math", "debug-glam-assert"] }
+base64 = "0.22"
+image = { version = "0.25", default-features = false, features = ["png", "jpeg", "bmp"] }
+parley = "0.5.0"
+skrifa = "0.32.0"
+pretty_assertions = "1.4.1"
+fern = { version = "0.7", features = ["colored"] }
+num_enum = "0.7"
+num-derive = "0.4"
+num-traits = { version = "0.2", default-features = false, features = ["i128"] }
+specta = { version = "2.0.0-rc.22", features = [
+	"glam",
+	"derive",
+	# "typescript",
+] }
+syn = { version = "2.0", default-features = false, features = [
+	"full",
+	"derive",
+	"parsing",
+	"printing",
+	"visit-mut",
+	"visit",
+	"clone-impls",
+	"extra-traits",
+	"proc-macro",
+] }
+kurbo = { version = "0.11.0", features = ["serde"] }
+petgraph = { version = "0.7.1", default-features = false, features = [
+	"graphmap",
+] }
+half = { version = "2.4.1", default-features = false, features = ["bytemuck", "serde"] }
+tinyvec = { version = "1", features = ["std"] }
+criterion = { version = "0.5", features = ["html_reports"] }
+iai-callgrind = { version = "0.12.3" }
+ndarray = "0.16.1"
+
+[profile.dev]
+opt-level = 1
+
+[profile.dev.package]
+graphite-editor = { opt-level = 1 }
+graphene-core = { opt-level = 1 }
+graphene-std = { opt-level = 1 }
+interpreted-executor = { opt-level = 1 } # This is a mitigation for https://github.com/rustwasm/wasm-pack/issues/981 which is needed because the node_registry function is too large
+graphite-proc-macros = { opt-level = 1 }
+image = { opt-level = 2 }
+rustc-hash = { opt-level = 3 }
+serde_derive = { opt-level = 1 }
+specta-macros = { opt-level = 1 }
+syn = { opt-level = 1 }
+
+[profile.release]
+lto = "thin"
+debug = true
+
+[profile.profiling]
+inherits = "release"
+debug = true

LICENSE.txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,12 +1,22 @@
 ---
 title: Graphite2
-emoji: 📉
-colorFrom: pink
-colorTo: yellow
+emoji: 🚀
+colorFrom: blue
+colorTo: green
 sdk: gradio
-sdk_version: 5.35.0
+sdk_version: "5.35.0"
 app_file: app.py
 pinned: false
 ---
 
+# Graphite2
+
+<a href="https://graphite.rs/">
+
+Deployed from: https://github.com/seawolf2357/Graphite
+
+## Features
+This Space provides a Gradio interface for the repository's main functionality.
+The app.py was automatically generated based on repository analysis.
+
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

about.hbs

@@ -0,0 +1,27 @@
+{{!
+Be careful to prevent auto-formatting from breaking this file's indentation.
+Replace this file with JSON output once this is resolved: https://github.com/EmbarkStudios/cargo-about/issues/73
+
+The `GENERATED_BY_CARGO_ABOUT` prefix is a JS labeled statement
+(<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/label>)
+used so the reader of the generated file can verify the file does indeed start with that string,
+while remaining valid JS for subsequent parsing.
+}}
+GENERATED_BY_CARGO_ABOUT: [
+	{{#each licenses}}
+	{
+		licenseName: `{{name}}`,
+		licenseText: `{{text}}`,
+		packages: [
+			{{#each used_by}}
+			{
+				name: `{{crate.name}}`,
+				version: `{{crate.version}}`,
+				author: `{{crate.authors}}`,
+				repository: `{{crate.repository}}`,
+			},
+			{{/each}}
+		],
+	},
+	{{/each}}
+]

about.toml

@@ -0,0 +1,36 @@
+# Keep this list in sync with those in `/deny.toml` and `/frontend/vite.config.ts`.
+accepted = [
+	"Apache-2.0 WITH LLVM-exception",
+	"Apache-2.0",
+	"BSD-2-Clause",
+	"BSD-3-Clause",
+	"BSL-1.0",
+	"CC0-1.0",
+	"ISC",
+	"MIT-0",
+	"MIT",
+	"MPL-2.0",
+	"OpenSSL",
+	"Unicode-3.0",
+	"Unicode-DFS-2016",
+	"Zlib",
+]
+workarounds = ["ring"]
+ignore-build-dependencies = true
+ignore-dev-dependencies = true
+# Clearly Defined's API would occasionally (every few months) return errors for at least a full day (maybe some weird rate limiting?), but we can just disable to perform local checking (see #1653)
+no-clearly-defined = true
+
+# https://raw.githubusercontent.com/briansmith/webpki/main/LICENSE
+# is the ISC license but test code within the repo is BSD-3-Clause, but is not compiled into the crate when we use it
+[webpki.clarify]
+license = "ISC"
+[[webpki.clarify.files]]
+path = "LICENSE"
+checksum = "5b698ca13897be3afdb7174256fa1574f8c6892b8bea1a66dd6469d3fe27885a"
+
+[rustls-webpki.clarify]
+license = "ISC"
+[[rustls-webpki.clarify.files]]
+path = "LICENSE"
+checksum = "5b698ca13897be3afdb7174256fa1574f8c6892b8bea1a66dd6469d3fe27885a"

app.py

@@ -0,0 +1,29 @@
+import gradio as gr
+
+# Function to simulate the Graphite tool functionality
+
+def create_graphics_tool(api_key, description):
+    if not api_key:
+        return "Error: API key is required. Please enter a valid API key."
+    if not description:
+        return "Error: Description is required. Please provide a description for the graphics tool."
+    # Simulate some processing (this would be replaced with actual functionality)
+    return f"Graphics tool created with description: '{description}'!"
+
+# Gradio interface setup
+
+def main():
+    with gr.Blocks() as demo:
+        gr.Markdown("# Graphite Graphics Tool\n\nCreate your own graphics tool using Graphite!\n\n## Instructions:\n1. Enter your API key (required).\n2. Provide a description for your graphics tool (required).\n3. Click 'Create Tool' to simulate the creation of a graphics tool.")
+
+        api_key = gr.Textbox(label="API Key", placeholder="Enter your API key here...")
+        description = gr.Textbox(label="Tool Description", placeholder="Describe your graphics tool...")
+        create_button = gr.Button("Create Tool")
+        output = gr.Textbox(label="Output")
+
+        create_button.click(create_graphics_tool, inputs=[api_key, description], outputs=output)
+
+    demo.launch()
+
+if __name__ == '__main__':
+    main()

demo-artwork/marbled-mandelbrot.graphite

@@ -0,0 +1 @@
+{"network_interface":{"network":{"exports":[{"Node":{"node_id":12241147352993594415,"output_index":0,"lambda":false}}],"nodes":[[4388711862172196665,{"inputs":[],"manual_composition":{"Concrete":{"name":"core::option::Option<alloc::sync::Arc<graphene_core::context::OwnedContextImpl>>","alias":null}},"implementation":{"ProtoNode":{"name":"graphene_std::raster::MandelbrotNode"}},"visible":true,"skip_deduplication":false}],[3606681156406984991,{"inputs":[{"Node":{"node_id":6323350524796370485,"output_index":0,"lambda":false}},{"Value":{"tagged_value":{"GradientStops":[[0.3237704918032787,{"red":1.0,"green":0.0,"blue":1.0,"alpha":0.1}],[0.5655737704918032,{"red":0.8901961,"green":0.8117647,"blue":0.39215687,"alpha":1.0}],[0.8155737704918032,{"red":0.0,"green":1.0,"blue":1.0,"alpha":0.5}]]},"exposed":false}},{"Value":{"tagged_value":{"Bool":true},"exposed":false}}],"manual_composition":{"Concrete":{"name":"core::option::Option<alloc::sync::Arc<graphene_core::context::OwnedContextImpl>>","alias":null}},"implementation":{"ProtoNode":{"name":"graphene_core::raster::adjustments::GradientMapNode"}},"visible":true,"skip_deduplication":false}],[6029481207635803402,{"inputs":[{"Node":{"node_id":4388711862172196665,"output_index":0,"lambda":false}},{"Value":{"tagged_value":{"DVec2":[0.0,0.0]},"exposed":false}},{"Value":{"tagged_value":{"F64":0.0},"exposed":false}},{"Value":{"tagged_value":{"DVec2":[1000.0,1000.0]},"exposed":false}},{"Value":{"tagged_value":{"DVec2":[0.0,0.0]},"exposed":false}},{"Value":{"tagged_value":{"DVec2":[0.5,0.5]},"exposed":false}}],"manual_composition":null,"implementation":{"Network":{"exports":[{"Node":{"node_id":1,"output_index":0,"lambda":false}}],"nodes":[[0,{"inputs":[{"Network":{"import_type":{"Concrete":{"name":"graphene_core::instances::Instances<graphene_core::vector::vector_data::VectorData>","alias":null}},"import_index":0}}],"manual_composition":{"Generic":"T"},"implementation":{"ProtoNode":{"name":"graphene_core::memo::MonitorNode"}},"visible":true,"skip_deduplication":true}],[1,{"inputs":[{"Node":{"node_id":0,"output_index":0,"lambda":false}},{"Network":{"import_type":{"Concrete":{"name":"glam::f64::dvec2::DVec2","alias":null}},"import_index":1}},{"Network":{"import_type":{"Concrete":{"name":"f64","alias":null}},"import_index":2}},{"Network":{"import_type":{"Concrete":{"name":"glam::f64::dvec2::DVec2","alias":null}},"import_index":3}},{"Network":{"import_type":{"Concrete":{"name":"glam::f64::dvec2::DVec2","alias":null}},"import_index":4}},{"Network":{"import_type":{"Concrete":{"name":"glam::f64::dvec2::DVec2","alias":null}},"import_index":5}}],"manual_composition":{"Generic":"T"},"implementation":{"ProtoNode":{"name":"graphene_core::transform_nodes::TransformNode"}},"visible":true,"skip_deduplication":false}]],"scope_injections":[]}},"visible":true,"skip_deduplication":false}],[7624113397561636853,{"inputs":[{"Value":{"tagged_value":{"GraphicGroup":{"instance":[],"transform":[],"alpha_blending":[],"source_node_id":[]}},"exposed":true}},{"Node":{"node_id":3606681156406984991,"output_index":0,"lambda":false}}],"manual_composition":null,"implementation":{"Network":{"exports":[{"Node":{"node_id":3,"output_index":0,"lambda":false}}],"nodes":[[0,{"inputs":[{"Network":{"import_type":{"Generic":"T"},"import_index":1}}],"manual_composition":{"Generic":"T"},"implementation":{"ProtoNode":{"name":"graphene_core::graphic_element::ToElementNode"}},"visible":true,"skip_deduplication":false}],[3,{"inputs":[{"Node":{"node_id":1,"output_index":0,"lambda":false}},{"Node":{"node_id":2,"output_index":0,"lambda":false}},{"Reflection":"DocumentNodePath"}],"manual_composition":{"Generic":"T"},"implementation":{"ProtoNode":{"name":"graphene_core::graphic_element::LayerNode"}},"visible":true,"skip_deduplication":false}],[2,{"inputs":[{"Node":{"node_id":0,"output_index":0,"lambda":false}}],"manual_composition":{"Generic":"T"},"implementation":{"ProtoNode":{"name":"graphene_core::memo::MonitorNode"}},"visible":true,"skip_deduplication":true}],[1,{"inputs":[{"Network":{"import_type":{"Generic":"T"},"import_index":0}}],"manual_composition":{"Generic":"T"},"implementation":{"ProtoNode":{"name":"graphene_core::graphic_element::ToGroupNode"}},"visible":true,"skip_deduplication":false}]],"scope_injections":[]}},"visible":true,"skip_deduplication":false}],[80924370013313595,{"inputs":[{"Node":{"node_id":6029481207635803402,"output_index":0,"lambda":false}},{"Value":{"tagged_value":{"GradientStops":[[0.0,{"red":0.19607843,"green":0.0,"blue":0.21176471,"alpha":1.0}],[0.12704918032786883,{"red":0.0627451,"green":0.19215687,"blue":0.39607844,"alpha":1.0}],[0.5,{"red":0.8901961,"green":0.8117647,"blue":0.39215687,"alpha":1.0}],[1.0,{"red":0.58431375,"green":0.92941177,"blue":0.92941177,"alpha":0.01}]]},"exposed":false}},{"Value":{"tagged_value":{"Bool":false},"exposed":false}}],"manual_composition":{"Concrete":{"name":"core::option::Option<alloc::sync::Arc<graphene_core::context::OwnedContextImpl>>","alias":null}},"implementation":{"ProtoNode":{"name":"graphene_core::raster::adjustments::GradientMapNode"}},"visible":true,"skip_deduplication":false}],[6323350524796370485,{"inputs":[{"Value":{"tagged_value":"None","exposed":false}},{"Value":{"tagged_value":{"Bool":false},"exposed":false}},{"Value":{"tagged_value":{"U32":0},"exposed":false}},{"Value":{"tagged_value":{"F64":35.0},"exposed":false}},{"Value":{"tagged_value":{"NoiseType":"OpenSimplex2"},"exposed":false}},{"Value":{"tagged_value":{"DomainWarpType":"OpenSimplex2"},"exposed":false}},{"Value":{"tagged_value":{"F64":100.0},"exposed":false}},{"Value":{"tagged_value":{"FractalType":"PingPong"},"exposed":false}},{"Value":{"tagged_value":{"U32":3},"exposed":false}},{"Value":{"tagged_value":{"F64":2.0},"exposed":false}},{"Value":{"tagged_value":{"F64":0.5},"exposed":false}},{"Value":{"tagged_value":{"F64":0.0},"exposed":false}},{"Value":{"tagged_value":{"F64":2.0},"exposed":false}},{"Value":{"tagged_value":{"CellularDistanceFunction":"Hybrid"},"exposed":false}},{"Value":{"tagged_value":{"CellularReturnType":"CellValue"},"exposed":false}},{"Value":{"tagged_value":{"F64":1.0},"exposed":false}}],"manual_composition":{"Concrete":{"name":"core::option::Option<alloc::sync::Arc<graphene_core::context::OwnedContextImpl>>","alias":null}},"implementation":{"ProtoNode":{"name":"graphene_std::raster::NoisePatternNode"}},"visible":true,"skip_deduplication":false}],[6565638614909771142,{"inputs":[{"Node":{"node_id":7624113397561636853,"output_index":0,"lambda":false}},{"Node":{"node_id":80924370013313595,"output_index":0,"lambda":false}}],"manual_composition":null,"implementation":{"Network":{"exports":[{"Node":{"node_id":3,"output_index":0,"lambda":false}}],"nodes":[[0,{"inputs":[{"Network":{"import_type":{"Generic":"T"},"import_index":1}}],"manual_composition":{"Generic":"T"},"implementation":{"ProtoNode":{"name":"graphene_core::graphic_element::ToElementNode"}},"visible":true,"skip_deduplication":false}],[3,{"inputs":[{"Node":{"node_id":1,"output_index":0,"lambda":false}},{"Node":{"node_id":2,"output_index":0,"lambda":false}},{"Reflection":"DocumentNodePath"}],"manual_composition":{"Generic":"T"},"implementation":{"ProtoNode":{"name":"graphene_core::graphic_element::LayerNode"}},"visible":true,"skip_deduplication":false}],[2,{"inputs":[{"Node":{"node_id":0,"output_index":0,"lambda":false}}],"manual_composition":{"Generic":"T"},"implementation":{"ProtoNode":{"name":"graphene_core::memo::MonitorNode"}},"visible":true,"skip_deduplication":true}],[1,{"inputs":[{"Network":{"import_type":{"Generic":"T"},"import_index":0}}],"manual_composition":{"Generic":"T"},"implementation":{"ProtoNode":{"name":"graphene_core::graphic_element::ToGroupNode"}},"visible":true,"skip_deduplication":false}]],"scope_injections":[]}},"visible":true,"skip_deduplication":false}],[12241147352993594415,{"inputs":[{"Value":{"tagged_value":{"ArtboardGroup":{"instance":[],"transform":[],"alpha_blending":[],"source_node_id":[]}},"exposed":true}},{"Node":{"node_id":6565638614909771142,"output_index":0,"lambda":false}},{"Value":{"tagged_value":{"IVec2":[0,0]},"exposed":false}},{"Value":{"tagged_value":{"IVec2":[1000,1000]},"exposed":false}},{"Value":{"tagged_value":{"Color":{"red":0.0,"green":0.0,"blue":0.0,"alpha":1.0}},"exposed":false}},{"Value":{"tagged_value":{"Bool":true},"exposed":false}}],"manual_composition":null,"implementation":{"Network":{"exports":[{"Node":{"node_id":2,"output_index":0,"lambda":false}}],"nodes":[[0,{"inputs":[{"Network":{"import_type":{"Concrete":{"name":"graph_craft::document::value::TaggedValue","alias":null}},"import_index":1}},{"Value":{"tagged_value":{"String":"Artboard"},"exposed":false}},{"Network":{"import_type":{"Concrete":{"name":"graph_craft::document::value::TaggedValue","alias":null}},"import_index":2}},{"Network":{"import_type":{"Concrete":{"name":"graph_craft::document::value::TaggedValue","alias":null}},"import_index":3}},{"Network":{"import_type":{"Concrete":{"name":"graph_craft::document::value::TaggedValue","alias":null}},"import_index":4}},{"Network":{"import_type":{"Concrete":{"name":"graph_craft::document::value::TaggedValue","alias":null}},"import_index":5}}],"manual_composition":{"Generic":"T"},"implementation":{"ProtoNode":{"name":"graphene_core::graphic_element::ToArtboardNode"}},"visible":true,"skip_deduplication":false}],[2,{"inputs":[{"Network":{"import_type":{"Fn":[{"Concrete":{"name":"core::option::Option<alloc::sync::Arc<graphene_core::context::OwnedContextImpl>>","alias":null}},{"Concrete":{"name":"graphene_core::instances::Instances<graphene_core::graphic_element::Artboard>","alias":null}}]},"import_index":0}},{"Node":{"node_id":1,"output_index":0,"lambda":false}},{"Reflection":"DocumentNodePath"}],"manual_composition":{"Concrete":{"name":"core::option::Option<alloc::sync::Arc<graphene_core::context::OwnedContextImpl>>","alias":null}},"implementation":{"ProtoNode":{"name":"graphene_core::graphic_element::AppendArtboardNode"}},"visible":true,"skip_deduplication":false}],[1,{"inputs":[{"Node":{"node_id":0,"output_index":0,"lambda":false}}],"manual_composition":{"Generic":"T"},"implementation":{"ProtoNode":{"name":"graphene_core::memo::MonitorNode"}},"visible":true,"skip_deduplication":true}]],"scope_injections":[]}},"visible":true,"skip_deduplication":false}]],"scope_injections":[]},"network_metadata":{"persistent_metadata":{"node_metadata":[[6029481207635803402,{"persistent_metadata":{"reference":"Transform","display_name":"","input_properties":[{"input_data":{"input_name":"Vector Data"},"widget_override":null},{"input_data":{"x":"X","input_name":"Translation","unit":" px","y":"Y"},"widget_override":"vec2"},{"input_data":{"input_name":"Rotation"},"widget_override":"transform_rotation"},{"input_data":{"x":"W","unit":"x","y":"H","input_name":"Scale"},"widget_override":"vec2"},{"input_data":{"input_name":"Skew"},"widget_override":"hidden"},{"input_data":{"input_name":"Pivot"},"widget_override":"hidden"}],"output_names":["Data"],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Node":{"position":"Chain"}},"network_metadata":{"persistent_metadata":{"node_metadata":[[0,{"persistent_metadata":{"reference":null,"display_name":"Monitor","input_properties":[{"input_data":{"input_name":""},"widget_override":null}],"output_names":[],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Node":{"position":{"Absolute":[0,0]}}},"network_metadata":null}}],[1,{"persistent_metadata":{"reference":null,"display_name":"Transform","input_properties":[{"input_data":{"input_name":""},"widget_override":null},{"input_data":{"input_name":""},"widget_override":null},{"input_data":{"input_name":""},"widget_override":null},{"input_data":{"input_name":""},"widget_override":null},{"input_data":{"input_name":""},"widget_override":null},{"input_data":{"input_name":""},"widget_override":null}],"output_names":[],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Node":{"position":{"Absolute":[0,0]}}},"network_metadata":null}}]],"previewing":"No","navigation_metadata":{"node_graph_ptz":{"pan":[0.0,0.0],"tilt":0.0,"zoom":1.0,"flip":false},"node_graph_to_viewport":[1.0,0.0,0.0,1.0,0.0,0.0],"node_graph_top_right":[0.0,0.0]},"selection_undo_history":[],"selection_redo_history":[]}}}}],[7624113397561636853,{"persistent_metadata":{"reference":"Merge","display_name":"Swirly Noise","input_properties":[{"input_data":{"input_name":"Graphical Data"},"widget_override":null},{"input_data":{"input_name":"Over"},"widget_override":null}],"output_names":["Out"],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Layer":{"position":{"Stack":0}}},"network_metadata":{"persistent_metadata":{"node_metadata":[[2,{"persistent_metadata":{"reference":null,"display_name":"Monitor","input_properties":[{"input_data":{"input_name":""},"widget_override":null}],"output_names":[],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Node":{"position":{"Absolute":[-7,-1]}}},"network_metadata":null}}],[0,{"persistent_metadata":{"reference":null,"display_name":"To Element","input_properties":[{"input_data":{"input_name":""},"widget_override":null}],"output_names":[],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Node":{"position":{"Absolute":[-14,-1]}}},"network_metadata":null}}],[3,{"persistent_metadata":{"reference":null,"display_name":"Layer","input_properties":[{"input_data":{"input_name":""},"widget_override":null},{"input_data":{"input_name":""},"widget_override":null},{"input_data":{"input_name":""},"widget_override":null}],"output_names":[],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Node":{"position":{"Absolute":[1,-3]}}},"network_metadata":null}}],[1,{"persistent_metadata":{"reference":null,"display_name":"To Group","input_properties":[{"input_data":{"input_name":""},"widget_override":null}],"output_names":[],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Node":{"position":{"Absolute":[-14,-3]}}},"network_metadata":null}}]],"previewing":"No","navigation_metadata":{"node_graph_ptz":{"pan":[0.0,0.0],"tilt":0.0,"zoom":1.0,"flip":false},"node_graph_to_viewport":[1.0,0.0,0.0,1.0,0.0,0.0],"node_graph_top_right":[0.0,0.0]},"selection_undo_history":[],"selection_redo_history":[]}}}}],[4388711862172196665,{"persistent_metadata":{"reference":"Mandelbrot","display_name":"","input_properties":[],"output_names":["Raster"],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Node":{"position":"Chain"}},"network_metadata":null}}],[6323350524796370485,{"persistent_metadata":{"reference":"Noise Pattern","display_name":"","input_properties":[{"input_data":{"input_name":"Spacer"},"widget_override":null},{"input_data":{"input_name":"Clip"},"widget_override":null},{"input_data":{"input_name":"Seed"},"widget_override":null},{"input_data":{"input_name":"Scale"},"widget_override":"noise_properties_scale"},{"input_data":{"input_name":"Noise Type"},"widget_override":"noise_properties_noise_type"},{"input_data":{"input_name":"Domain Warp Type"},"widget_override":"noise_properties_domain_warp_type"},{"input_data":{"input_name":"Domain Warp Amplitude"},"widget_override":"noise_properties_domain_warp_amplitude"},{"input_data":{"input_name":"Fractal Type"},"widget_override":"noise_properties_fractal_type"},{"input_data":{"input_name":"Fractal Octaves"},"widget_override":"noise_properties_fractal_octaves"},{"input_data":{"input_name":"Fractal Lacunarity"},"widget_override":"noise_properties_fractal_lacunarity"},{"input_data":{"input_name":"Fractal Gain"},"widget_override":"noise_properties_fractal_gain"},{"input_data":{"input_name":"Fractal Weighted Strength"},"widget_override":"noise_properties_fractal_weighted_strength"},{"input_data":{"input_name":"Fractal Ping Pong Strength"},"widget_override":"noise_properties_ping_pong_strength"},{"input_data":{"input_name":"Cellular Distance Function"},"widget_override":"noise_properties_cellular_distance_function"},{"input_data":{"input_name":"Cellular Return Type"},"widget_override":"noise_properties_cellular_return_type"},{"input_data":{"input_name":"Cellular Jitter"},"widget_override":"noise_properties_cellular_jitter"}],"output_names":["Image"],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Node":{"position":"Chain"}},"network_metadata":{"persistent_metadata":{"node_metadata":[[0,{"persistent_metadata":{"reference":null,"display_name":"Noise Pattern","input_properties":[],"output_names":[],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Node":{"position":{"Absolute":[0,0]}}},"network_metadata":null}}],[1,{"persistent_metadata":{"reference":null,"display_name":"Cull","input_properties":[],"output_names":[],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Node":{"position":{"Absolute":[0,0]}}},"network_metadata":null}}]],"previewing":"No","navigation_metadata":{"node_graph_ptz":{"pan":[0.0,0.0],"tilt":0.0,"zoom":1.0,"flip":false},"node_graph_to_viewport":[1.0,0.0,0.0,1.0,0.0,0.0],"node_graph_top_right":[0.0,0.0]},"selection_undo_history":[],"selection_redo_history":[]}}}}],[12241147352993594415,{"persistent_metadata":{"reference":"Artboard","display_name":"","input_properties":[{"input_data":{"input_name":"Artboards"},"widget_override":null},{"input_data":{"input_name":"Contents"},"widget_override":"hidden"},{"input_data":{"input_name":"Location","x":"X","y":"Y","unit":" px"},"widget_override":"vec2"},{"input_data":{"input_name":"Dimensions","unit":" px","x":"W","y":"H"},"widget_override":"vec2"},{"input_data":{"input_name":"Background"},"widget_override":"artboard_background"},{"input_data":{"input_name":"Clip"},"widget_override":null}],"output_names":["Out"],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Layer":{"position":{"Absolute":[-8,3]}}},"network_metadata":{"persistent_metadata":{"node_metadata":[[1,{"persistent_metadata":{"reference":null,"display_name":"Monitor","input_properties":[{"input_data":{"input_name":""},"widget_override":null}],"output_names":[],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Node":{"position":{"Absolute":[-2,-3]}}},"network_metadata":null}}],[0,{"persistent_metadata":{"reference":null,"display_name":"To Artboard","input_properties":[{"input_data":{"input_name":""},"widget_override":null},{"input_data":{"input_name":""},"widget_override":null},{"input_data":{"input_name":""},"widget_override":null},{"input_data":{"input_name":""},"widget_override":null},{"input_data":{"input_name":""},"widget_override":null},{"input_data":{"input_name":""},"widget_override":null}],"output_names":[],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Node":{"position":{"Absolute":[-10,-3]}}},"network_metadata":null}}],[2,{"persistent_metadata":{"reference":null,"display_name":"Append Artboards","input_properties":[{"input_data":{"input_name":""},"widget_override":null},{"input_data":{"input_name":""},"widget_override":null},{"input_data":{"input_name":""},"widget_override":null}],"output_names":[],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Node":{"position":{"Absolute":[6,-4]}}},"network_metadata":null}}]],"previewing":"No","navigation_metadata":{"node_graph_ptz":{"pan":[0.0,0.0],"tilt":0.0,"zoom":1.0,"flip":false},"node_graph_to_viewport":[1.0,0.0,0.0,1.0,0.0,0.0],"node_graph_top_right":[0.0,0.0]},"selection_undo_history":[],"selection_redo_history":[]}}}}],[6565638614909771142,{"persistent_metadata":{"reference":"Merge","display_name":"Mandelbrot Set","input_properties":[{"input_data":{"input_name":"Graphical Data"},"widget_override":null},{"input_data":{"input_name":"Over"},"widget_override":null}],"output_names":["Out"],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Layer":{"position":{"Absolute":[-16,6]}}},"network_metadata":{"persistent_metadata":{"node_metadata":[[0,{"persistent_metadata":{"reference":null,"display_name":"To Element","input_properties":[{"input_data":{"input_name":""},"widget_override":null}],"output_names":[],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Node":{"position":{"Absolute":[-14,-1]}}},"network_metadata":null}}],[2,{"persistent_metadata":{"reference":null,"display_name":"Monitor","input_properties":[{"input_data":{"input_name":""},"widget_override":null}],"output_names":[],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Node":{"position":{"Absolute":[-7,-1]}}},"network_metadata":null}}],[1,{"persistent_metadata":{"reference":null,"display_name":"To Group","input_properties":[{"input_data":{"input_name":""},"widget_override":null}],"output_names":[],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Node":{"position":{"Absolute":[-14,-3]}}},"network_metadata":null}}],[3,{"persistent_metadata":{"reference":null,"display_name":"Layer","input_properties":[{"input_data":{"input_name":""},"widget_override":null},{"input_data":{"input_name":""},"widget_override":null},{"input_data":{"input_name":""},"widget_override":null}],"output_names":[],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Node":{"position":{"Absolute":[1,-3]}}},"network_metadata":null}}]],"previewing":"No","navigation_metadata":{"node_graph_ptz":{"pan":[0.0,0.0],"tilt":0.0,"zoom":1.0,"flip":false},"node_graph_to_viewport":[1.0,0.0,0.0,1.0,0.0,0.0],"node_graph_top_right":[0.0,0.0]},"selection_undo_history":[],"selection_redo_history":[]}}}}],[3606681156406984991,{"persistent_metadata":{"reference":"Gradient Map","display_name":"","input_properties":[{"input_data":{"input_name":"Image"},"widget_override":null},{"input_data":{"input_name":"Gradient"},"widget_override":null},{"input_data":{"input_name":"Reverse"},"widget_override":null}],"output_names":["Image"],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Node":{"position":"Chain"}},"network_metadata":null}}],[80924370013313595,{"persistent_metadata":{"reference":"Gradient Map","display_name":"","input_properties":[{"input_data":{"input_name":"Image"},"widget_override":null},{"input_data":{"input_name":"Gradient"},"widget_override":null},{"input_data":{"input_name":"Reverse"},"widget_override":null}],"output_names":["Image"],"has_primary_output":true,"locked":false,"pinned":false,"node_type_metadata":{"Node":{"position":"Chain"}},"network_metadata":null}}]],"previewing":"No","navigation_metadata":{"node_graph_ptz":{"pan":[345.0,-187.0],"tilt":0.0,"zoom":1.0,"flip":false},"node_graph_to_viewport":[1.0,0.0,0.0,1.0,1336.0,394.0],"node_graph_top_right":[1468.796875,0.0]},"selection_undo_history":[[12241147352993594415]],"selection_redo_history":[]}}},"collapsed":[],"name":"marbled-mandelbrot.graphite","commit_hash":"f6ffa45a8180183d70a67d3e41249934a8fcacc9","document_ptz":{"pan":[-339.3903349049215,-502.62390663267854],"tilt":0.0,"zoom":4.0,"flip":false},"document_mode":"DesignMode","view_mode":"Normal","overlays_visibility_settings":{"all":true,"artboard_name":true,"compass_rose":true,"quick_measurement":true,"transform_measurement":true,"transform_cage":true,"hover_outline":true,"selection_outline":true,"pivot":true,"path":true,"anchors":true,"handles":true},"rulers_visible":true,"snapping_state":{"snapping_enabled":true,"grid_snapping":false,"artboards":true,"tolerance":8.0,"bounding_box":{"center_point":true,"corner_point":true,"edge_midpoint":true,"align_with_edges":true,"distribute_evenly":true},"path":{"anchor_point":true,"line_midpoint":true,"along_path":true,"normal_to_path":true,"tangent_to_path":true,"path_intersection_point":true,"align_with_anchor_point":true,"perpendicular_from_endpoint":true},"grid":{"origin":[0.0,0.0],"grid_type":{"Rectangular":{"spacing":[1.0,1.0]}},"rectangular_spacing":[1.0,1.0],"isometric_y_spacing":1.0,"isometric_angle_a":30.0,"isometric_angle_b":30.0,"grid_color":{"red":0.6038274,"green":0.6038274,"blue":0.6038274,"alpha":1.0},"dot_display":false}},"graph_view_overlay_open":false,"graph_fade_artwork_percentage":80.0}

deny.toml

@@ -0,0 +1,194 @@
+# This template contains all of the possible sections and their default values
+
+# Note that all fields that take a lint level have these possible values:
+# * deny - An error will be produced and the check will fail
+# * warn - A warning will be produced, but the check will not fail
+# * allow - No warning or error will be produced, though in some cases a note
+# will be
+
+# The values provided in this template are the default values that will be used
+# when any section or field is not specified in your own configuration
+
+[graph]
+# If 1 or more target triples (and optionally, target_features) are specified,
+# only the specified targets will be checked when running `cargo deny check`.
+# This means, if a particular package is only ever used as a target specific
+# dependency, such as, for example, the `nix` crate only being used via the
+# `target_family = "unix"` configuration, that only having windows targets in
+# this list would mean the nix crate, as well as any of its exclusive
+# dependencies not shared by any other crates, would be ignored, as the target
+# list here is effectively saying which targets you are building for.
+targets = [
+	# The triple can be any string, but only the target triples built in to
+	# rustc (as of 1.40) can be checked against actual config expressions
+	#{ triple = "x86_64-unknown-linux-musl" },
+	# You can also specify which target_features you promise are enabled for a
+	# particular target. target_features are currently not validated against
+	# the actual valid features supported by the target architecture.
+	#{ triple = "wasm32-unknown-unknown", features = ["atomics"] },
+]
+
+# Tauri produces too many nonsense warnings.
+exclude = ["tauri", "tauri-build"]
+
+
+# This section is considered when running `cargo deny check advisories`
+# More documentation for the advisories section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/advisories/cfg.html
+[advisories]
+# The path where the advisory database is cloned/fetched into
+db-path = "~/.cargo/advisory-db"
+# The url(s) of the advisory databases to use
+db-urls = ["https://github.com/rustsec/advisory-db"]
+# A list of advisory IDs to ignore. Note that ignored advisories will still
+# output a note when they are encountered.
+ignore = [
+	"RUSTSEC-2024-0370", # Unmaintained but still fully functional crate `proc-macro-error`
+	"RUSTSEC-2024-0388", # Unmaintained but still fully functional crate `derivative`
+	"RUSTSEC-2025-0007", # Unmaintained but still fully functional crate `ring`
+	"RUSTSEC-2024-0436", # Unmaintained but still fully functional crate `paste`
+	"RUSTSEC-2025-0014", # Unmaintained but still fully functional crate `humantime`
+]
+# Threshold for security vulnerabilities, any vulnerability with a CVSS score
+# lower than the range specified will be ignored. Note that ignored advisories
+# will still output a note when they are encountered.
+# * None - CVSS Score 0.0
+# * Low - CVSS Score 0.1 - 3.9
+# * Medium - CVSS Score 4.0 - 6.9
+# * High - CVSS Score 7.0 - 8.9
+# * Critical - CVSS Score 9.0 - 10.0
+#severity-threshold =
+
+# This section is considered when running `cargo deny check licenses`
+# More documentation for the licenses section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/licenses/cfg.html
+[licenses]
+# List of explicitly allowed licenses
+# See https://spdx.org/licenses/ for list of possible licenses
+# [possible values: any SPDX 3.11 short identifier (+ optional exception)].
+#
+# Keep this list in sync with those in `/about.toml` and `/frontend/vite.config.ts`.
+allow = [
+	"Apache-2.0 WITH LLVM-exception",
+	"Apache-2.0",
+	"BSD-2-Clause",
+	"BSD-3-Clause",
+	"BSL-1.0",
+	"CC0-1.0",
+	"ISC",
+	"MIT",
+	"MPL-2.0",
+	"OpenSSL",
+	"Unicode-3.0",
+	"Zlib",
+	"NCSA",
+]
+# The confidence threshold for detecting a license from license text.
+# The higher the value, the more closely the license text must be to the
+# canonical license text of a valid SPDX license file.
+# [possible values: any between 0.0 and 1.0].
+confidence-threshold = 0.8
+# Allow 1 or more licenses on a per-crate basis, so that particular licenses
+# aren't accepted for every possible crate as with the normal allow list
+exceptions = [
+	# Each entry is the crate and version constraint, and its specific allow
+	# list
+	#{ allow = ["Zlib"], name = "adler32", version = "*" },
+]
+
+# Some crates don't have (easily) machine readable licensing information,
+# adding a clarification entry for it allows you to manually specify the
+# licensing information
+[[licenses.clarify]]
+# The name of the crate the clarification applies to
+name = "ring"
+# The optional version constraint for the crate
+#version = "*"
+# The SPDX expression for the license requirements of the crate
+expression = "MIT AND ISC AND OpenSSL"
+# One or more files in the crate's source used as the "source of truth" for
+# the license expression. If the contents match, the clarification will be used
+# when running the license check, otherwise the clarification will be ignored
+# and the crate will be checked normally, which may produce warnings or errors
+# depending on the rest of your configuration
+license-files = [
+	# Each entry is a crate relative path, and the (opaque) hash of its contents
+	{ path = "LICENSE", hash = 0xbd0eed23 },
+]
+
+[licenses.private]
+# If true, ignores workspace crates that aren't published, or are only
+# published to private registries
+ignore = false
+# One or more private registries that you might publish crates to, if a crate
+# is only published to private registries, and ignore is true, the crate will
+# not have its license(s) checked
+registries = [
+	#"https://sekretz.com/registry
+]
+
+# This section is considered when running `cargo deny check bans`.
+# More documentation about the 'bans' section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/bans/cfg.html
+[bans]
+# Lint level for when multiple versions of the same crate are detected
+multiple-versions = "allow"
+
+# Lint level for when a crate version requirement is `*`
+wildcards = "allow"
+# The graph highlighting used when creating dotgraphs for crates
+# with multiple versions
+# * lowest-version - The path to the lowest versioned duplicate is highlighted
+# * simplest-path - The path to the version with the fewest edges is highlighted
+# * all - Both lowest-version and simplest-path are used
+highlight = "all"
+# List of crates that are allowed. Use with care!
+allow = [
+	#{ name = "ansi_term", version = "=0.11.0" },
+]
+# List of crates to deny
+deny = [
+	# Each entry the name of a crate and a version range. If version is
+	# not specified, all versions will be matched.
+	#{ name = "ansi_term", version = "=0.11.0" },
+	#
+	# Wrapper crates can optionally be specified to allow the crate when it
+	# is a direct dependency of the otherwise banned crate
+	#{ name = "ansi_term", version = "=0.11.0", wrappers = [] },
+]
+# Certain crates/versions that will be skipped when doing duplicate detection.
+skip = [
+	#{ name = "ansi_term", version = "=0.11.0" },
+	#{ name = "cfg-if", version = "=0.1.10" },
+]
+# Similarly to `skip` allows you to skip certain crates during duplicate
+# detection. Unlike skip, it also includes the entire tree of transitive
+# dependencies starting at the specified crate, up to a certain depth, which is
+# by default infinite
+skip-tree = [
+	#{ name = "ansi_term", version = "=0.11.0", depth = 20 },
+]
+
+# This section is considered when running `cargo deny check sources`.
+# More documentation about the 'sources' section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/sources/cfg.html
+[sources]
+# Lint level for what to happen when a crate from a crate registry that is not
+# in the allow list is encountered
+unknown-registry = "warn"
+# Lint level for what to happen when a crate from a git repository that is not
+# in the allow list is encountered
+unknown-git = "warn"
+# List of URLs for allowed crate registries. Defaults to the crates.io index
+# if not specified. If it is specified but empty, no registries are allowed.
+allow-registry = ["https://github.com/rust-lang/crates.io-index"]
+# List of URLs for allowed Git repositories
+allow-git = []
+
+[sources.allow-org]
+# 1 or more github.com organizations to allow git sources for
+github = ["linebender", "Rust-GPU", "specta-rs"]
+# 1 or more gitlab.com organizations to allow git sources for
+#gitlab = [""]
+# 1 or more bitbucket.org organizations to allow git sources for
+#bitbucket = [""]

editor/Cargo.toml

@@ -0,0 +1,71 @@
+[package]
+name = "graphite-editor"
+publish = false
+version = "0.0.0"
+rust-version = "1.85"
+authors = ["Graphite Authors <[email protected]>"]
+edition = "2024"
+readme = "../README.md"
+homepage = "https://graphite.rs"
+repository = "https://github.com/GraphiteEditor/Graphite"
+license = "Apache-2.0"
+
+[features]
+default = ["wasm"]
+wasm = ["wasm-bindgen", "graphene-std/wasm", "wasm-bindgen-futures"]
+gpu = ["interpreted-executor/gpu", "wgpu-executor"]
+tauri = ["ron", "decouple-execution"]
+decouple-execution = []
+resvg = ["graphene-std/resvg"]
+vello = ["graphene-std/vello", "resvg"]
+ron = ["dep:ron"]
+
+[dependencies]
+# Local dependencies
+graphite-proc-macros = { workspace = true }
+graph-craft = { workspace = true }
+interpreted-executor = { workspace = true }
+graphene-std = { workspace = true }
+preprocessor = { workspace = true }
+
+# Workspace dependencies
+js-sys = { workspace = true }
+log = { workspace = true }
+bitflags = { workspace = true }
+thiserror = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+bezier-rs = { workspace = true }
+kurbo = { workspace = true }
+futures = { workspace = true }
+glam = { workspace = true }
+derivative = { workspace = true }
+specta = { workspace = true }
+dyn-any = { workspace = true }
+num_enum = { workspace = true }
+usvg = { workspace = true }
+once_cell = { workspace = true }
+web-sys = { workspace = true }
+
+# Required dependencies
+spin = "0.9.8"
+
+# Optional local dependencies
+wgpu-executor = { workspace = true, optional = true }
+
+# Optional workspace dependencies
+wasm-bindgen = { workspace = true, optional = true }
+wasm-bindgen-futures = { workspace = true, optional = true }
+ron = { workspace = true, optional = true }
+
+[dev-dependencies]
+# Workspace dependencies
+env_logger = { workspace = true }
+futures = { workspace = true }
+tokio = { workspace = true }
+
+[lints.rust]
+# TODO: figure out why we check these features when they do not exist
+unexpected_cfgs = { level = "warn", check-cfg = [
+	'cfg(feature, values("resvg", "vello"))',
+] }

editor/build.rs

@@ -0,0 +1,24 @@
+use std::process::Command;
+
+const GRAPHITE_RELEASE_SERIES: &str = "Alpha 4";
+
+fn main() {
+	// Execute a Git command for its stdout. Early exit if it fails for any of the possible reasons.
+	let try_git_command = |args: &[&str]| -> Option<String> {
+		let git_output = Command::new("git").args(args).output().ok()?;
+		let maybe_empty = String::from_utf8(git_output.stdout).ok()?;
+		let command_result = (!maybe_empty.is_empty()).then_some(maybe_empty)?;
+		Some(command_result)
+	};
+	// Execute a Git command for its output. Return "unknown" if it fails for any of the possible reasons.
+	let git_command = |args| -> String { try_git_command(args).unwrap_or_else(|| String::from("unknown")) };
+
+	// Rather than printing to any terminal, these commands set environment variables in the Cargo toolchain.
+	// They are accessed with the `env!("...")` macro in the codebase.
+	println!("cargo:rustc-env=GRAPHITE_GIT_COMMIT_DATE={}", git_command(&["log", "-1", "--format=%cd"]));
+	println!("cargo:rustc-env=GRAPHITE_GIT_COMMIT_HASH={}", git_command(&["rev-parse", "HEAD"]));
+	let branch = std::env::var("GITHUB_HEAD_REF").unwrap_or_default();
+	let branch = if branch.is_empty() { git_command(&["name-rev", "--name-only", "HEAD"]) } else { branch };
+	println!("cargo:rustc-env=GRAPHITE_GIT_COMMIT_BRANCH={branch}");
+	println!("cargo:rustc-env=GRAPHITE_RELEASE_SERIES={GRAPHITE_RELEASE_SERIES}");
+}

editor/src/application.rs

@@ -0,0 +1,57 @@
+use crate::dispatcher::Dispatcher;
+use crate::messages::prelude::*;
+pub use graphene_std::uuid::*;
+
+// TODO: serialize with serde to save the current editor state
+pub struct Editor {
+	pub dispatcher: Dispatcher,
+}
+
+impl Editor {
+	/// Construct the editor.
+	/// Remember to provide a random seed with `editor::set_uuid_seed(seed)` before any editors can be used.
+	pub fn new() -> Self {
+		Self { dispatcher: Dispatcher::new() }
+	}
+
+	#[cfg(test)]
+	pub(crate) fn new_local_executor() -> (Self, crate::node_graph_executor::NodeRuntime) {
+		let (runtime, executor) = crate::node_graph_executor::NodeGraphExecutor::new_with_local_runtime();
+		let dispatcher = Dispatcher::with_executor(executor);
+		(Self { dispatcher }, runtime)
+	}
+
+	pub fn handle_message<T: Into<Message>>(&mut self, message: T) -> Vec<FrontendMessage> {
+		self.dispatcher.handle_message(message, true);
+
+		std::mem::take(&mut self.dispatcher.responses)
+	}
+
+	pub fn poll_node_graph_evaluation(&mut self, responses: &mut VecDeque<Message>) -> Result<(), String> {
+		self.dispatcher.poll_node_graph_evaluation(responses)
+	}
+}
+
+impl Default for Editor {
+	fn default() -> Self {
+		Self::new()
+	}
+}
+
+pub const GRAPHITE_RELEASE_SERIES: &str = env!("GRAPHITE_RELEASE_SERIES");
+pub const GRAPHITE_GIT_COMMIT_DATE: &str = env!("GRAPHITE_GIT_COMMIT_DATE");
+pub const GRAPHITE_GIT_COMMIT_HASH: &str = env!("GRAPHITE_GIT_COMMIT_HASH");
+pub const GRAPHITE_GIT_COMMIT_BRANCH: &str = env!("GRAPHITE_GIT_COMMIT_BRANCH");
+
+pub fn commit_info_localized(localized_commit_date: &str) -> String {
+	format!(
+		"Release Series: {}\n\
+		Branch: {}\n\
+		Commit: {}\n\
+		{}",
+		GRAPHITE_RELEASE_SERIES,
+		GRAPHITE_GIT_COMMIT_BRANCH,
+		&GRAPHITE_GIT_COMMIT_HASH[..8],
+		localized_commit_date
+	)
+}

editor/src/consts.rs

@@ -0,0 +1,151 @@
+// GRAPH
+pub const GRID_SIZE: u32 = 24;
+pub const EXPORTS_TO_TOP_EDGE_PIXEL_GAP: u32 = 72;
+pub const EXPORTS_TO_RIGHT_EDGE_PIXEL_GAP: u32 = 120;
+pub const IMPORTS_TO_TOP_EDGE_PIXEL_GAP: u32 = 72;
+pub const IMPORTS_TO_LEFT_EDGE_PIXEL_GAP: u32 = 120;
+
+// VIEWPORT
+pub const VIEWPORT_ZOOM_WHEEL_RATE: f64 = (1. / 600.) * 3.;
+pub const VIEWPORT_ZOOM_MOUSE_RATE: f64 = 1. / 400.;
+pub const VIEWPORT_ZOOM_SCALE_MIN: f64 = 0.000_000_1;
+pub const VIEWPORT_ZOOM_SCALE_MAX: f64 = 10_000.;
+pub const VIEWPORT_ZOOM_MIN_FRACTION_COVER: f64 = 0.01;
+pub const VIEWPORT_ZOOM_LEVELS: [f64; 74] = [
+	0.0001, 0.000125, 0.00016, 0.0002, 0.00025, 0.00032, 0.0004, 0.0005, 0.00064, 0.0008, 0.001, 0.0016, 0.002, 0.0025, 0.0032, 0.004, 0.005, 0.0064, 0.008, 0.01, 0.01125, 0.015, 0.02, 0.025, 0.03,
+	0.04, 0.05, 0.06, 0.08, 0.1, 0.125, 0.15, 0.2, 0.25, 0.33333333, 0.4, 0.5, 0.66666666, 0.8, 1., 1.25, 1.6, 2., 2.5, 3.2, 4., 5., 6.4, 8., 10., 12.5, 16., 20., 25., 32., 40., 50., 64., 80., 100.,
+	128., 160., 200., 256., 320., 400., 512., 640., 800., 1024., 1280., 1600., 2048., 2560.,
+];
+/// Higher values create a steeper curve (a faster zoom rate change)
+pub const VIEWPORT_ZOOM_WHEEL_RATE_CHANGE: f64 = 3.;
+
+/// Helps push values that end in approximately half, plus or minus some floating point imprecision, towards the same side of the round() function.
+pub const VIEWPORT_GRID_ROUNDING_BIAS: f64 = 0.002;
+
+pub const VIEWPORT_SCROLL_RATE: f64 = 0.6;
+
+pub const VIEWPORT_ROTATE_SNAP_INTERVAL: f64 = 15.;
+
+pub const VIEWPORT_ZOOM_TO_FIT_PADDING_SCALE_FACTOR: f64 = 0.95;
+
+pub const DRAG_BEYOND_VIEWPORT_MAX_OVEREXTENSION_PIXELS: f64 = 50.;
+pub const DRAG_BEYOND_VIEWPORT_SPEED_FACTOR: f64 = 20.;
+
+// SNAPPING POINT
+pub const SNAP_POINT_TOLERANCE: f64 = 5.;
+/// These are layers whose bounding boxes are used for alignment.
+pub const MAX_ALIGNMENT_CANDIDATES: usize = 100;
+/// These are layers that are used for the layer snapper.
+pub const MAX_SNAP_CANDIDATES: usize = 10;
+/// These are points (anchors and bounding box corners etc.) in the layer snapper.
+pub const MAX_LAYER_SNAP_POINTS: usize = 100;
+
+pub const DRAG_THRESHOLD: f64 = 1.;
+
+// TRANSFORMING LAYER
+pub const ROTATE_INCREMENT: f64 = 15.;
+pub const SCALE_INCREMENT: f64 = 0.1;
+pub const SLOWING_DIVISOR: f64 = 10.;
+pub const NUDGE_AMOUNT: f64 = 1.;
+pub const BIG_NUDGE_AMOUNT: f64 = 10.;
+
+// TOOLS
+pub const DEFAULT_STROKE_WIDTH: f64 = 2.;
+
+// SELECT TOOL
+pub const SELECTION_TOLERANCE: f64 = 5.;
+pub const DRAG_DIRECTION_MODE_DETERMINATION_THRESHOLD: f64 = 15.;
+pub const SELECTION_DRAG_ANGLE: f64 = 90.;
+
+// PIVOT
+pub const PIVOT_CROSSHAIR_THICKNESS: f64 = 1.;
+pub const PIVOT_CROSSHAIR_LENGTH: f64 = 9.;
+pub const PIVOT_DIAMETER: f64 = 5.;
+
+// COMPASS ROSE
+pub const COMPASS_ROSE_RING_INNER_DIAMETER: f64 = 13.;
+pub const COMPASS_ROSE_MAIN_RING_DIAMETER: f64 = 15.;
+pub const COMPASS_ROSE_HOVER_RING_DIAMETER: f64 = 23.;
+pub const COMPASS_ROSE_ARROW_SIZE: f64 = 5.;
+// Angle to either side of the compass arrows where they are targetted by the cursor (in degrees, must be less than 45°)
+pub const COMPASS_ROSE_ARROW_CLICK_TARGET_ANGLE: f64 = 20.;
+
+// TRANSFORM OVERLAY
+pub const ANGLE_MEASURE_RADIUS_FACTOR: f64 = 0.04;
+pub const ARC_MEASURE_RADIUS_FACTOR_RANGE: (f64, f64) = (0.05, 0.15);
+
+// TRANSFORM CAGE
+pub const RESIZE_HANDLE_SIZE: f64 = 6.;
+pub const BOUNDS_SELECT_THRESHOLD: f64 = 10.;
+pub const BOUNDS_ROTATE_THRESHOLD: f64 = 20.;
+pub const MIN_LENGTH_FOR_MIDPOINT_VISIBILITY: f64 = 20.;
+pub const MIN_LENGTH_FOR_CORNERS_VISIBILITY: f64 = 12.;
+/// The width or height that the transform cage needs to be (at least) before the corner resize handle click targets take up their full surroundings. Otherwise, when less than this value, the interior edge resize handle takes precedence so the corner handles don't eat into the edge area, making it harder to resize the cage from its edges.
+pub const MIN_LENGTH_FOR_EDGE_RESIZE_PRIORITY_OVER_CORNERS: f64 = 10.;
+/// When the width or height of the transform cage is less than this value, only the exterior of the bounding box will act as a click target for resizing.
+pub const MIN_LENGTH_FOR_RESIZE_TO_INCLUDE_INTERIOR: f64 = 40.;
+/// When dragging the edge of a cage with Alt, it centers around the pivot.
+/// However if the pivot is on or near the same edge you are dragging, we should avoid scaling by a massive factor caused by the small denominator.
+///
+/// The motion of the user's cursor by an `x` pixel offset results in `x * scale_factor` pixels of offset on the other side.
+pub const MAXIMUM_ALT_SCALE_FACTOR: f64 = 25.;
+/// The width or height that the transform cage needs before it is considered to have no width or height.
+pub const MAX_LENGTH_FOR_NO_WIDTH_OR_HEIGHT: f64 = 1e-4;
+
+// SKEW TRIANGLES
+pub const SKEW_TRIANGLE_SIZE: f64 = 7.;
+pub const SKEW_TRIANGLE_OFFSET: f64 = 4.;
+pub const MIN_LENGTH_FOR_SKEW_TRIANGLE_VISIBILITY: f64 = 48.;
+
+// PATH TOOL
+pub const MANIPULATOR_GROUP_MARKER_SIZE: f64 = 6.;
+pub const SELECTION_THRESHOLD: f64 = 10.;
+pub const HIDE_HANDLE_DISTANCE: f64 = 3.;
+pub const HANDLE_ROTATE_SNAP_ANGLE: f64 = 15.;
+pub const SEGMENT_INSERTION_DISTANCE: f64 = 5.;
+pub const SEGMENT_OVERLAY_SIZE: f64 = 10.;
+pub const HANDLE_LENGTH_FACTOR: f64 = 0.5;
+
+// PEN TOOL
+pub const CREATE_CURVE_THRESHOLD: f64 = 5.;
+
+// SPLINE TOOL
+pub const PATH_JOIN_THRESHOLD: f64 = 5.;
+
+// LINE TOOL
+pub const LINE_ROTATE_SNAP_ANGLE: f64 = 15.;
+
+// BRUSH TOOL
+pub const BRUSH_SIZE_CHANGE_KEYBOARD: f64 = 5.;
+pub const DEFAULT_BRUSH_SIZE: f64 = 20.;
+
+// GIZMOS
+pub const POINT_RADIUS_HANDLE_SNAP_THRESHOLD: f64 = 8.;
+pub const POINT_RADIUS_HANDLE_SEGMENT_THRESHOLD: f64 = 7.9;
+pub const NUMBER_OF_POINTS_DIAL_SPOKE_EXTENSION: f64 = 1.2;
+pub const NUMBER_OF_POINTS_DIAL_SPOKE_LENGTH: f64 = 10.;
+pub const GIZMO_HIDE_THRESHOLD: f64 = 20.;
+
+// SCROLLBARS
+pub const SCROLLBAR_SPACING: f64 = 0.1;
+pub const ASYMPTOTIC_EFFECT: f64 = 0.5;
+pub const SCALE_EFFECT: f64 = 0.5;
+
+// COLORS
+pub const COLOR_OVERLAY_BLUE: &str = "#00a8ff";
+pub const COLOR_OVERLAY_BLUE_50: &str = "rgba(0, 168, 255, 0.5)";
+pub const COLOR_OVERLAY_YELLOW: &str = "#ffc848";
+pub const COLOR_OVERLAY_GREEN: &str = "#63ce63";
+pub const COLOR_OVERLAY_RED: &str = "#ef5454";
+pub const COLOR_OVERLAY_GRAY: &str = "#cccccc";
+pub const COLOR_OVERLAY_WHITE: &str = "#ffffff";
+pub const COLOR_OVERLAY_LABEL_BACKGROUND: &str = "#000000cc";
+
+// DOCUMENT
+pub const DEFAULT_DOCUMENT_NAME: &str = "Untitled Document";
+pub const FILE_SAVE_SUFFIX: &str = ".graphite";
+pub const MAX_UNDO_HISTORY_LEN: usize = 100; // TODO: Add this to user preferences
+pub const AUTO_SAVE_TIMEOUT_SECONDS: u64 = 15;
+
+// INPUT
+pub const DOUBLE_CLICK_MILLISECONDS: u64 = 500;

editor/src/dispatcher.rs

@@ -0,0 +1,562 @@
+use crate::messages::debug::utility_types::MessageLoggingVerbosity;
+use crate::messages::dialog::DialogMessageData;
+use crate::messages::portfolio::document::node_graph::document_node_definitions;
+use crate::messages::prelude::*;
+
+#[derive(Debug, Default)]
+pub struct Dispatcher {
+	buffered_queue: Option<Vec<VecDeque<Message>>>,
+	message_queues: Vec<VecDeque<Message>>,
+	pub responses: Vec<FrontendMessage>,
+	pub message_handlers: DispatcherMessageHandlers,
+}
+
+#[derive(Debug, Default)]
+pub struct DispatcherMessageHandlers {
+	animation_message_handler: AnimationMessageHandler,
+	broadcast_message_handler: BroadcastMessageHandler,
+	debug_message_handler: DebugMessageHandler,
+	dialog_message_handler: DialogMessageHandler,
+	globals_message_handler: GlobalsMessageHandler,
+	input_preprocessor_message_handler: InputPreprocessorMessageHandler,
+	key_mapping_message_handler: KeyMappingMessageHandler,
+	layout_message_handler: LayoutMessageHandler,
+	pub portfolio_message_handler: PortfolioMessageHandler,
+	preferences_message_handler: PreferencesMessageHandler,
+	tool_message_handler: ToolMessageHandler,
+	workspace_message_handler: WorkspaceMessageHandler,
+}
+
+impl DispatcherMessageHandlers {
+	pub fn with_executor(executor: crate::node_graph_executor::NodeGraphExecutor) -> Self {
+		Self {
+			portfolio_message_handler: PortfolioMessageHandler::with_executor(executor),
+			..Default::default()
+		}
+	}
+}
+
+/// For optimization, these are messages guaranteed to be redundant when repeated.
+/// The last occurrence of the message in the message queue is sufficient to ensure correct behavior.
+/// In addition, these messages do not change any state in the backend (aside from caches).
+const SIDE_EFFECT_FREE_MESSAGES: &[MessageDiscriminant] = &[
+	MessageDiscriminant::Portfolio(PortfolioMessageDiscriminant::Document(DocumentMessageDiscriminant::PropertiesPanel(
+		PropertiesPanelMessageDiscriminant::Refresh,
+	))),
+	MessageDiscriminant::Portfolio(PortfolioMessageDiscriminant::Document(DocumentMessageDiscriminant::DocumentStructureChanged)),
+	MessageDiscriminant::Portfolio(PortfolioMessageDiscriminant::Document(DocumentMessageDiscriminant::Overlays(OverlaysMessageDiscriminant::Draw))),
+	MessageDiscriminant::Portfolio(PortfolioMessageDiscriminant::Document(DocumentMessageDiscriminant::RenderRulers)),
+	MessageDiscriminant::Portfolio(PortfolioMessageDiscriminant::Document(DocumentMessageDiscriminant::RenderScrollbars)),
+	MessageDiscriminant::Frontend(FrontendMessageDiscriminant::UpdateDocumentLayerStructure),
+	MessageDiscriminant::Frontend(FrontendMessageDiscriminant::TriggerFontLoad),
+];
+const DEBUG_MESSAGE_BLOCK_LIST: &[MessageDiscriminant] = &[MessageDiscriminant::Broadcast(BroadcastMessageDiscriminant::TriggerEvent(BroadcastEventDiscriminant::AnimationFrame))];
+// TODO: Find a way to combine these with the list above. We use strings for now since these are the standard variant names used by multiple messages. But having these also type-checked would be best.
+const DEBUG_MESSAGE_ENDING_BLOCK_LIST: &[&str] = &["PointerMove", "PointerOutsideViewport", "Overlays", "Draw", "CurrentTime", "Time"];
+
+impl Dispatcher {
+	pub fn new() -> Self {
+		Self::default()
+	}
+
+	pub fn with_executor(executor: crate::node_graph_executor::NodeGraphExecutor) -> Self {
+		Self {
+			message_handlers: DispatcherMessageHandlers::with_executor(executor),
+			..Default::default()
+		}
+	}
+
+	// If the deepest queues (higher index in queues list) are now empty (after being popped from) then remove them
+	fn cleanup_queues(&mut self, leave_last: bool) {
+		while self.message_queues.last().filter(|queue| queue.is_empty()).is_some() {
+			if leave_last && self.message_queues.len() == 1 {
+				break;
+			}
+			self.message_queues.pop();
+		}
+	}
+
+	/// Add a message to a queue so that it can be executed.
+	/// If `process_after_all_current` is set, all currently queued messages (including children) will be processed first.
+	/// If not set, it (and its children) will be processed as soon as possible.
+	pub fn schedule_execution(message_queues: &mut Vec<VecDeque<Message>>, process_after_all_current: bool, messages: impl IntoIterator<Item = Message>) {
+		match message_queues.first_mut() {
+			// If there are currently messages being processed and we are processing after them, add to the end of the first queue
+			Some(queue) if process_after_all_current => queue.extend(messages),
+			// In all other cases, make a new inner queue and add our message there
+			_ => message_queues.push(VecDeque::from_iter(messages)),
+		}
+	}
+
+	pub fn handle_message<T: Into<Message>>(&mut self, message: T, process_after_all_current: bool) {
+		let message = message.into();
+		// Add all additional messages to the buffer if it exists (except from the end buffer message)
+		if !matches!(message, Message::EndBuffer(_)) {
+			if let Some(buffered_queue) = &mut self.buffered_queue {
+				Self::schedule_execution(buffered_queue, true, [message]);
+
+				return;
+			}
+		}
+
+		// If we are not maintaining the buffer, simply add to the current queue
+		Self::schedule_execution(&mut self.message_queues, process_after_all_current, [message]);
+
+		while let Some(message) = self.message_queues.last_mut().and_then(VecDeque::pop_front) {
+			// Skip processing of this message if it will be processed later (at the end of the shallowest level queue)
+			if SIDE_EFFECT_FREE_MESSAGES.contains(&message.to_discriminant()) {
+				let already_in_queue = self.message_queues.first().filter(|queue| queue.contains(&message)).is_some();
+				if already_in_queue {
+					self.log_deferred_message(&message, &self.message_queues, self.message_handlers.debug_message_handler.message_logging_verbosity);
+					self.cleanup_queues(false);
+					continue;
+				} else if self.message_queues.len() > 1 {
+					self.log_deferred_message(&message, &self.message_queues, self.message_handlers.debug_message_handler.message_logging_verbosity);
+					self.cleanup_queues(true);
+					self.message_queues[0].add(message);
+					continue;
+				}
+			}
+
+			// Print the message at a verbosity level of `info`
+			self.log_message(&message, &self.message_queues, self.message_handlers.debug_message_handler.message_logging_verbosity);
+
+			// Create a new queue for the child messages
+			let mut queue = VecDeque::new();
+
+			// Process the action by forwarding it to the relevant message handler, or saving the FrontendMessage to be sent to the frontend
+			match message {
+				Message::StartBuffer => {
+					self.buffered_queue = Some(std::mem::take(&mut self.message_queues));
+				}
+				Message::EndBuffer(render_metadata) => {
+					// Assign the message queue to the currently buffered queue
+					if let Some(buffered_queue) = self.buffered_queue.take() {
+						self.cleanup_queues(false);
+						assert!(self.message_queues.is_empty(), "message queues are always empty when ending a buffer");
+						self.message_queues = buffered_queue;
+					};
+
+					let graphene_std::renderer::RenderMetadata {
+						upstream_footprints: footprints,
+						local_transforms,
+						click_targets,
+						clip_targets,
+					} = render_metadata;
+
+					// Run these update state messages immediately
+					let messages = [
+						DocumentMessage::UpdateUpstreamTransforms {
+							upstream_footprints: footprints,
+							local_transforms,
+						},
+						DocumentMessage::UpdateClickTargets { click_targets },
+						DocumentMessage::UpdateClipTargets { clip_targets },
+					];
+					Self::schedule_execution(&mut self.message_queues, false, messages.map(Message::from));
+				}
+				Message::NoOp => {}
+				Message::Init => {
+					// Load persistent data from the browser database
+					queue.add(FrontendMessage::TriggerLoadFirstAutoSaveDocument);
+					queue.add(FrontendMessage::TriggerLoadPreferences);
+
+					// Display the menu bar at the top of the window
+					queue.add(MenuBarMessage::SendLayout);
+
+					// Send the information for tooltips and categories for each node/input.
+					queue.add(FrontendMessage::SendUIMetadata {
+						node_descriptions: document_node_definitions::collect_node_descriptions(),
+						node_types: document_node_definitions::collect_node_types(),
+					});
+
+					// Finish loading persistent data from the browser database
+					queue.add(FrontendMessage::TriggerLoadRestAutoSaveDocuments);
+				}
+				Message::Animation(message) => {
+					self.message_handlers.animation_message_handler.process_message(message, &mut queue, ());
+				}
+				Message::Batched(messages) => {
+					messages.iter().for_each(|message| self.handle_message(message.to_owned(), false));
+				}
+				Message::Broadcast(message) => self.message_handlers.broadcast_message_handler.process_message(message, &mut queue, ()),
+				Message::Debug(message) => {
+					self.message_handlers.debug_message_handler.process_message(message, &mut queue, ());
+				}
+				Message::Dialog(message) => {
+					let data = DialogMessageData {
+						portfolio: &self.message_handlers.portfolio_message_handler,
+						preferences: &self.message_handlers.preferences_message_handler,
+					};
+					self.message_handlers.dialog_message_handler.process_message(message, &mut queue, data);
+				}
+				Message::Frontend(message) => {
+					// Handle these messages immediately by returning early
+					if let FrontendMessage::TriggerFontLoad { .. } = message {
+						self.responses.push(message);
+						self.cleanup_queues(false);
+
+						// Return early to avoid running the code after the match block
+						return;
+					} else {
+						// `FrontendMessage`s are saved and will be sent to the frontend after the message queue is done being processed
+						self.responses.push(message);
+					}
+				}
+				Message::Globals(message) => {
+					self.message_handlers.globals_message_handler.process_message(message, &mut queue, ());
+				}
+				Message::InputPreprocessor(message) => {
+					let keyboard_platform = GLOBAL_PLATFORM.get().copied().unwrap_or_default().as_keyboard_platform_layout();
+
+					self.message_handlers
+						.input_preprocessor_message_handler
+						.process_message(message, &mut queue, InputPreprocessorMessageData { keyboard_platform });
+				}
+				Message::KeyMapping(message) => {
+					let input = &self.message_handlers.input_preprocessor_message_handler;
+					let actions = self.collect_actions();
+
+					self.message_handlers
+						.key_mapping_message_handler
+						.process_message(message, &mut queue, KeyMappingMessageData { input, actions });
+				}
+				Message::Layout(message) => {
+					let action_input_mapping = &|action_to_find: &MessageDiscriminant| self.message_handlers.key_mapping_message_handler.action_input_mapping(action_to_find);
+
+					self.message_handlers.layout_message_handler.process_message(message, &mut queue, action_input_mapping);
+				}
+				Message::Portfolio(message) => {
+					let ipp = &self.message_handlers.input_preprocessor_message_handler;
+					let preferences = &self.message_handlers.preferences_message_handler;
+					let current_tool = &self.message_handlers.tool_message_handler.tool_state.tool_data.active_tool_type;
+					let message_logging_verbosity = self.message_handlers.debug_message_handler.message_logging_verbosity;
+					let reset_node_definitions_on_open = self.message_handlers.portfolio_message_handler.reset_node_definitions_on_open;
+					let timing_information = self.message_handlers.animation_message_handler.timing_information();
+					let animation = &self.message_handlers.animation_message_handler;
+
+					self.message_handlers.portfolio_message_handler.process_message(
+						message,
+						&mut queue,
+						PortfolioMessageData {
+							ipp,
+							preferences,
+							current_tool,
+							message_logging_verbosity,
+							reset_node_definitions_on_open,
+							timing_information,
+							animation,
+						},
+					);
+				}
+				Message::Preferences(message) => {
+					self.message_handlers.preferences_message_handler.process_message(message, &mut queue, ());
+				}
+				Message::Tool(message) => {
+					let document_id = self.message_handlers.portfolio_message_handler.active_document_id().unwrap();
+					let Some(document) = self.message_handlers.portfolio_message_handler.documents.get_mut(&document_id) else {
+						warn!("Called ToolMessage without an active document.\nGot {message:?}");
+						return;
+					};
+
+					let data = ToolMessageData {
+						document_id,
+						document,
+						input: &self.message_handlers.input_preprocessor_message_handler,
+						persistent_data: &self.message_handlers.portfolio_message_handler.persistent_data,
+						node_graph: &self.message_handlers.portfolio_message_handler.executor,
+						preferences: &self.message_handlers.preferences_message_handler,
+					};
+
+					self.message_handlers.tool_message_handler.process_message(message, &mut queue, data);
+				}
+				Message::Workspace(message) => {
+					self.message_handlers.workspace_message_handler.process_message(message, &mut queue, ());
+				}
+			}
+
+			// If there are child messages, append the queue to the list of queues
+			if !queue.is_empty() {
+				self.message_queues.push(queue);
+			}
+
+			self.cleanup_queues(false);
+		}
+	}
+
+	pub fn collect_actions(&self) -> ActionList {
+		// TODO: Reduce the number of heap allocations
+		let mut list = Vec::new();
+		list.extend(self.message_handlers.dialog_message_handler.actions());
+		list.extend(self.message_handlers.animation_message_handler.actions());
+		list.extend(self.message_handlers.input_preprocessor_message_handler.actions());
+		list.extend(self.message_handlers.key_mapping_message_handler.actions());
+		list.extend(self.message_handlers.debug_message_handler.actions());
+		if let Some(document) = self.message_handlers.portfolio_message_handler.active_document() {
+			if !document.graph_view_overlay_open {
+				list.extend(self.message_handlers.tool_message_handler.actions());
+			}
+		}
+		list.extend(self.message_handlers.portfolio_message_handler.actions());
+		list
+	}
+
+	pub fn poll_node_graph_evaluation(&mut self, responses: &mut VecDeque<Message>) -> Result<(), String> {
+		self.message_handlers.portfolio_message_handler.poll_node_graph_evaluation(responses)
+	}
+
+	/// Create the tree structure for logging the messages as a tree
+	fn create_indents(queues: &[VecDeque<Message>]) -> String {
+		String::from_iter(queues.iter().enumerate().skip(1).map(|(index, queue)| {
+			if index == queues.len() - 1 {
+				if queue.is_empty() { "└── " } else { "├── " }
+			} else if queue.is_empty() {
+				"   "
+			} else {
+				"│    "
+			}
+		}))
+	}
+
+	/// Logs a message that is about to be executed, either as a tree
+	/// with a discriminant or the entire payload (depending on settings)
+	fn log_message(&self, message: &Message, queues: &[VecDeque<Message>], message_logging_verbosity: MessageLoggingVerbosity) {
+		let discriminant = MessageDiscriminant::from(message);
+		let is_blocked = DEBUG_MESSAGE_BLOCK_LIST.contains(&discriminant) || DEBUG_MESSAGE_ENDING_BLOCK_LIST.iter().any(|blocked_name| discriminant.local_name().ends_with(blocked_name));
+
+		if !is_blocked {
+			match message_logging_verbosity {
+				MessageLoggingVerbosity::Off => {}
+				MessageLoggingVerbosity::Names => {
+					info!("{}{:?}", Self::create_indents(queues), message.to_discriminant());
+				}
+				MessageLoggingVerbosity::Contents => {
+					if !(matches!(message, Message::InputPreprocessor(_))) {
+						info!("Message: {}{:?}", Self::create_indents(queues), message);
+					}
+				}
+			}
+		}
+	}
+
+	/// Logs into the tree that the message is in the side effect free messages and its execution will be deferred
+	fn log_deferred_message(&self, message: &Message, queues: &[VecDeque<Message>], message_logging_verbosity: MessageLoggingVerbosity) {
+		if let MessageLoggingVerbosity::Names = message_logging_verbosity {
+			info!("{}Deferred \"{:?}\" because it's a SIDE_EFFECT_FREE_MESSAGE", Self::create_indents(queues), message.to_discriminant());
+		}
+	}
+}
+
+#[cfg(test)]
+mod test {
+	pub use crate::test_utils::test_prelude::*;
+
+	/// Create an editor with three layers
+	/// 1. A red rectangle
+	/// 2. A blue shape
+	/// 3. A green ellipse
+	async fn create_editor_with_three_layers() -> EditorTestUtils {
+		let mut editor = EditorTestUtils::create();
+
+		editor.new_document().await;
+
+		editor.select_primary_color(Color::RED).await;
+		editor.draw_rect(100., 200., 300., 400.).await;
+
+		editor.select_primary_color(Color::BLUE).await;
+		editor.draw_polygon(10., 1200., 1300., 400.).await;
+
+		editor.select_primary_color(Color::GREEN).await;
+		editor.draw_ellipse(104., 1200., 1300., 400.).await;
+
+		editor
+	}
+
+	/// - create rect, shape and ellipse
+	/// - copy
+	/// - paste
+	/// - assert that ellipse was copied
+	#[tokio::test]
+	async fn copy_paste_single_layer() {
+		let mut editor = create_editor_with_three_layers().await;
+
+		let layers_before_copy = editor.active_document().metadata().all_layers().collect::<Vec<_>>();
+		editor.handle_message(PortfolioMessage::Copy { clipboard: Clipboard::Internal }).await;
+		editor
+			.handle_message(PortfolioMessage::PasteIntoFolder {
+				clipboard: Clipboard::Internal,
+				parent: LayerNodeIdentifier::ROOT_PARENT,
+				insert_index: 0,
+			})
+			.await;
+
+		let layers_after_copy = editor.active_document().metadata().all_layers().collect::<Vec<_>>();
+
+		assert_eq!(layers_before_copy.len(), 3);
+		assert_eq!(layers_after_copy.len(), 4);
+
+		// Existing layers are unaffected
+		for i in 0..=2 {
+			assert_eq!(layers_before_copy[i], layers_after_copy[i + 1]);
+		}
+	}
+
+	#[cfg_attr(miri, ignore)]
+	/// - create rect, shape and ellipse
+	/// - select shape
+	/// - copy
+	/// - paste
+	/// - assert that shape was copied
+	#[tokio::test]
+	async fn copy_paste_single_layer_from_middle() {
+		let mut editor = create_editor_with_three_layers().await;
+
+		let layers_before_copy = editor.active_document().metadata().all_layers().collect::<Vec<_>>();
+		let shape_id = editor.active_document().metadata().all_layers().nth(1).unwrap();
+
+		editor.handle_message(NodeGraphMessage::SelectedNodesSet { nodes: vec![shape_id.to_node()] }).await;
+		editor.handle_message(PortfolioMessage::Copy { clipboard: Clipboard::Internal }).await;
+		editor
+			.handle_message(PortfolioMessage::PasteIntoFolder {
+				clipboard: Clipboard::Internal,
+				parent: LayerNodeIdentifier::ROOT_PARENT,
+				insert_index: 0,
+			})
+			.await;
+
+		let layers_after_copy = editor.active_document().metadata().all_layers().collect::<Vec<_>>();
+
+		assert_eq!(layers_before_copy.len(), 3);
+		assert_eq!(layers_after_copy.len(), 4);
+
+		// Existing layers are unaffected
+		for i in 0..=2 {
+			assert_eq!(layers_before_copy[i], layers_after_copy[i + 1]);
+		}
+	}
+
+	#[cfg_attr(miri, ignore)]
+	/// - create rect, shape and ellipse
+	/// - select ellipse and rect
+	/// - copy
+	/// - delete
+	/// - create another rect
+	/// - paste
+	/// - paste
+	#[tokio::test]
+	async fn copy_paste_deleted_layers() {
+		let mut editor = create_editor_with_three_layers().await;
+		assert_eq!(editor.active_document().metadata().all_layers().count(), 3);
+
+		let layers_before_copy = editor.active_document().metadata().all_layers().collect::<Vec<_>>();
+		let rect_id = layers_before_copy[0];
+		let shape_id = layers_before_copy[1];
+		let ellipse_id = layers_before_copy[2];
+
+		editor
+			.handle_message(NodeGraphMessage::SelectedNodesSet {
+				nodes: vec![rect_id.to_node(), ellipse_id.to_node()],
+			})
+			.await;
+		editor.handle_message(PortfolioMessage::Copy { clipboard: Clipboard::Internal }).await;
+		editor.handle_message(NodeGraphMessage::DeleteSelectedNodes { delete_children: true }).await;
+		editor.draw_rect(0., 800., 12., 200.).await;
+		editor
+			.handle_message(PortfolioMessage::PasteIntoFolder {
+				clipboard: Clipboard::Internal,
+				parent: LayerNodeIdentifier::ROOT_PARENT,
+				insert_index: 0,
+			})
+			.await;
+		editor
+			.handle_message(PortfolioMessage::PasteIntoFolder {
+				clipboard: Clipboard::Internal,
+				parent: LayerNodeIdentifier::ROOT_PARENT,
+				insert_index: 0,
+			})
+			.await;
+
+		let layers_after_copy = editor.active_document().metadata().all_layers().collect::<Vec<_>>();
+
+		assert_eq!(layers_before_copy.len(), 3);
+		assert_eq!(layers_after_copy.len(), 6);
+
+		println!("{:?} {:?}", layers_after_copy, layers_before_copy);
+
+		assert_eq!(layers_after_copy[5], shape_id);
+	}
+
+	#[tokio::test]
+	/// This test will fail when you make changes to the underlying serialization format for a document.
+	async fn check_if_demo_art_opens() {
+		use crate::messages::layout::utility_types::widget_prelude::*;
+
+		let print_problem_to_terminal_on_failure = |value: &String| {
+			println!();
+			println!("-------------------------------------------------");
+			println!("Failed test due to receiving a DisplayDialogError while loading a Graphite demo file.");
+			println!();
+			println!("NOTE:");
+			println!("Document upgrading isn't performed in tests like when opening in the actual editor.");
+			println!("You may need to open and re-save a document in the editor to apply its migrations.");
+			println!();
+			println!("DisplayDialogError details:");
+			println!();
+			println!("Description:");
+			println!("{value}");
+			println!("-------------------------------------------------");
+			println!();
+
+			panic!()
+		};
+
+		let mut editor = EditorTestUtils::create();
+
+		// UNCOMMENT THIS FOR RUNNING UNDER MIRI
+		//
+		// let files = [
+		// 	include_str!("../../demo-artwork/changing-seasons.graphite"),
+		// 	include_str!("../../demo-artwork/isometric-fountain.graphite"),
+		// 	include_str!("../../demo-artwork/painted-dreams.graphite"),
+		// 	include_str!("../../demo-artwork/procedural-string-lights.graphite"),
+		// 	include_str!("../../demo-artwork/parametric-dunescape.graphite"),
+		// 	include_str!("../../demo-artwork/red-dress.graphite"),
+		// 	include_str!("../../demo-artwork/valley-of-spires.graphite"),
+		// ];
+		// for (id, document_serialized_content) in files.iter().enumerate() {
+		// let document_name = format!("document {id}");
+
+		for (document_name, _, file_name) in crate::messages::dialog::simple_dialogs::ARTWORK {
+			let document_serialized_content = std::fs::read_to_string(format!("../demo-artwork/{file_name}")).unwrap();
+
+			assert_eq!(
+				document_serialized_content.lines().count(),
+				1,
+				"Demo artwork '{document_name}' has more than 1 line (remember to open and re-save it in Graphite)",
+			);
+
+			let responses = editor.editor.handle_message(PortfolioMessage::OpenDocumentFile {
+				document_name: document_name.into(),
+				document_serialized_content,
+			});
+
+			// Check if the graph renders
+			if let Err(e) = editor.eval_graph().await {
+				print_problem_to_terminal_on_failure(&format!("Failed to evaluate the graph for document '{document_name}':\n{e}"));
+			}
+
+			for response in responses {
+				// Check for the existence of the file format incompatibility warning dialog after opening the test file
+				if let FrontendMessage::UpdateDialogColumn1 { layout_target: _, diff } = response {
+					if let DiffUpdate::SubLayout(sub_layout) = &diff[0].new_value {
+						if let LayoutGroup::Row { widgets } = &sub_layout[0] {
+							if let Widget::TextLabel(TextLabel { value, .. }) = &widgets[0].widget {
+								print_problem_to_terminal_on_failure(value);
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

editor/src/generate_ts_types.rs

@@ -0,0 +1,34 @@
+/// Running this test will generate a `types.ts` file at the root of the repo,
+/// containing every type annotated with `specta::Type`
+// #[cfg(all(test, feature = "specta-export"))]
+#[ignore]
+#[test]
+fn generate_ts_types() {
+	// TODO: Un-comment this out when we figure out how to reenable the "typescript` Specta feature flag
+
+	// use crate::messages::prelude::FrontendMessage;
+	// use specta::ts::{export_named_datatype, BigIntExportBehavior, ExportConfig};
+	// use specta::{NamedType, TypeMap};
+	// use std::fs::File;
+	// use std::io::Write;
+
+	// let config = ExportConfig::new().bigint(BigIntExportBehavior::Number);
+
+	// let mut type_map = TypeMap::default();
+
+	// let datatype = FrontendMessage::definition_named_data_type(&mut type_map);
+
+	// let mut export = String::new();
+
+	// export += &export_named_datatype(&config, &datatype, &type_map).unwrap();
+
+	// type_map
+	// 	.iter()
+	// 	.map(|(_, v)| v)
+	// 	.flat_map(|v| export_named_datatype(&config, v, &type_map))
+	// 	.for_each(|e| export += &format!("\n\n{e}"));
+
+	// let mut file = File::create("../types.ts").unwrap();
+
+	// write!(file, "{export}").ok();
+}

editor/src/lib.rs

@@ -0,0 +1,17 @@
+extern crate graphite_proc_macros;
+
+// `macro_use` puts these macros into scope for all descendant code files
+#[macro_use]
+mod macros;
+mod generate_ts_types;
+#[macro_use]
+extern crate log;
+
+pub mod application;
+pub mod consts;
+pub mod dispatcher;
+pub mod messages;
+pub mod node_graph_executor;
+#[cfg(test)]
+pub mod test_utils;
+pub mod utility_traits;

editor/src/macros.rs

@@ -0,0 +1,56 @@
+/// Syntax sugar for initializing an `ActionList`
+///
+/// # Example
+///
+/// ```ignore
+/// actions!(DocumentMessage::Undo, DocumentMessage::Redo);
+/// ```
+///
+/// expands to:
+/// ```ignore
+/// vec![vec![DocumentMessage::Undo, DocumentMessage::Redo]];
+/// ```
+///
+/// and
+/// ```ignore
+/// actions!(DocumentMessage;
+///     Undo,
+///     Redo,
+/// );
+/// ```
+///
+/// expands to:
+/// ```ignore
+/// vec![vec![DocumentMessage::Undo, DocumentMessage::Redo]];
+/// ```
+///
+macro_rules! actions {
+	($($v:expr_2021),* $(,)?) => {{
+		vec![$(vec![$v.into()]),*]
+	}};
+
+	($name:ident; $($v:ident),* $(,)?) => {{
+		vec![vec![$(($name::$v).into()),*]]
+	}};
+}
+
+/// Does the same thing as the `actions!` macro but wraps everything in:
+///
+/// ```ignore
+/// fn actions(&self) -> ActionList {
+///     actions!(…)
+/// }
+/// ```
+macro_rules! advertise_actions {
+	($($v:expr_2021),* $(,)?) => {
+		fn actions(&self) -> $crate::utility_traits::ActionList {
+			actions!($($v),*)
+		}
+	};
+
+	($name:ident; $($v:ident),* $(,)?) => {
+		fn actions(&self) -> $crate::utility_traits::ActionList {
+			actions!($name; $($v),*)
+		}
+	}
+}

editor/src/messages/animation/animation_message.rs

@@ -0,0 +1,17 @@
+use crate::messages::prelude::*;
+
+use super::animation_message_handler::AnimationTimeMode;
+
+#[impl_message(Message, Animation)]
+#[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)]
+pub enum AnimationMessage {
+	ToggleLivePreview,
+	EnableLivePreview,
+	DisableLivePreview,
+	RestartAnimation,
+	SetFrameIndex(f64),
+	SetTime(f64),
+	UpdateTime,
+	IncrementFrameCounter,
+	SetAnimationTimeMode(AnimationTimeMode),
+}

editor/src/messages/animation/animation_message_handler.rs

@@ -0,0 +1,133 @@
+use std::time::Duration;
+
+use crate::messages::prelude::*;
+
+use super::TimingInformation;
+
+#[derive(PartialEq, Clone, Default, Debug, serde::Serialize, serde::Deserialize)]
+pub enum AnimationTimeMode {
+	#[default]
+	TimeBased,
+	FrameBased,
+}
+
+#[derive(Default, Debug, Clone, PartialEq)]
+enum AnimationState {
+	#[default]
+	Stopped,
+	Playing {
+		start: f64,
+	},
+	Paused {
+		start: f64,
+		pause_time: f64,
+	},
+}
+
+#[derive(Default, Debug, Clone, PartialEq)]
+pub struct AnimationMessageHandler {
+	/// Used to re-send the UI on the next frame after playback starts
+	live_preview_recently_zero: bool,
+	timestamp: f64,
+	frame_index: f64,
+	animation_state: AnimationState,
+	fps: f64,
+	animation_time_mode: AnimationTimeMode,
+}
+impl AnimationMessageHandler {
+	pub(crate) fn timing_information(&self) -> TimingInformation {
+		let animation_time = self.timestamp - self.animation_start();
+		let animation_time = match self.animation_time_mode {
+			AnimationTimeMode::TimeBased => Duration::from_millis(animation_time as u64),
+			AnimationTimeMode::FrameBased => Duration::from_secs((self.frame_index / self.fps) as u64),
+		};
+		TimingInformation { time: self.timestamp, animation_time }
+	}
+
+	pub(crate) fn animation_start(&self) -> f64 {
+		match self.animation_state {
+			AnimationState::Stopped => self.timestamp,
+			AnimationState::Playing { start } => start,
+			AnimationState::Paused { start, pause_time } => start + self.timestamp - pause_time,
+		}
+	}
+
+	pub fn is_playing(&self) -> bool {
+		matches!(self.animation_state, AnimationState::Playing { .. })
+	}
+}
+
+impl MessageHandler<AnimationMessage, ()> for AnimationMessageHandler {
+	fn process_message(&mut self, message: AnimationMessage, responses: &mut VecDeque<Message>, _data: ()) {
+		match message {
+			AnimationMessage::ToggleLivePreview => match self.animation_state {
+				AnimationState::Stopped => responses.add(AnimationMessage::EnableLivePreview),
+				AnimationState::Playing { .. } => responses.add(AnimationMessage::DisableLivePreview),
+				AnimationState::Paused { .. } => responses.add(AnimationMessage::EnableLivePreview),
+			},
+			AnimationMessage::EnableLivePreview => {
+				self.animation_state = AnimationState::Playing { start: self.animation_start() };
+
+				// Update the restart and pause/play buttons
+				responses.add(PortfolioMessage::UpdateDocumentWidgets);
+			}
+			AnimationMessage::DisableLivePreview => {
+				match self.animation_state {
+					AnimationState::Stopped => (),
+					AnimationState::Playing { start } => self.animation_state = AnimationState::Paused { start, pause_time: self.timestamp },
+					AnimationState::Paused { .. } => (),
+				}
+
+				// Update the restart and pause/play buttons
+				responses.add(PortfolioMessage::UpdateDocumentWidgets);
+			}
+			AnimationMessage::SetFrameIndex(frame) => {
+				self.frame_index = frame;
+				responses.add(PortfolioMessage::SubmitActiveGraphRender);
+				// Update the restart and pause/play buttons
+				responses.add(PortfolioMessage::UpdateDocumentWidgets);
+			}
+			AnimationMessage::SetTime(time) => {
+				self.timestamp = time;
+				responses.add(AnimationMessage::UpdateTime);
+			}
+			AnimationMessage::IncrementFrameCounter => {
+				if self.is_playing() {
+					self.frame_index += 1.;
+					responses.add(AnimationMessage::UpdateTime);
+				}
+			}
+			AnimationMessage::UpdateTime => {
+				if self.is_playing() {
+					responses.add(PortfolioMessage::SubmitActiveGraphRender);
+
+					if self.live_preview_recently_zero {
+						// Update the restart and pause/play buttons
+						responses.add(PortfolioMessage::UpdateDocumentWidgets);
+						self.live_preview_recently_zero = false;
+					}
+				}
+			}
+			AnimationMessage::RestartAnimation => {
+				self.frame_index = 0.;
+				self.animation_state = match self.animation_state {
+					AnimationState::Playing { .. } => AnimationState::Playing { start: self.timestamp },
+					_ => AnimationState::Stopped,
+				};
+				self.live_preview_recently_zero = true;
+				responses.add(PortfolioMessage::SubmitActiveGraphRender);
+				// Update the restart and pause/play buttons
+				responses.add(PortfolioMessage::UpdateDocumentWidgets);
+			}
+			AnimationMessage::SetAnimationTimeMode(animation_time_mode) => {
+				self.animation_time_mode = animation_time_mode;
+			}
+		}
+	}
+
+	advertise_actions!(AnimationMessageDiscriminant;
+		ToggleLivePreview,
+		SetFrameIndex,
+		RestartAnimation,
+	);
+}

editor/src/messages/animation/mod.rs

@@ -0,0 +1,9 @@
+mod animation_message;
+mod animation_message_handler;
+
+#[doc(inline)]
+pub use animation_message::{AnimationMessage, AnimationMessageDiscriminant};
+#[doc(inline)]
+pub use animation_message_handler::AnimationMessageHandler;
+
+pub use graphene_std::application_io::TimingInformation;

editor/src/messages/broadcast/broadcast_event.rs

@@ -0,0 +1,12 @@
+use crate::messages::prelude::*;
+
+#[derive(PartialEq, Eq, Clone, Debug, serde::Serialize, serde::Deserialize, Hash)]
+#[impl_message(Message, BroadcastMessage, TriggerEvent)]
+pub enum BroadcastEvent {
+	/// Triggered by requestAnimationFrame in JS
+	AnimationFrame,
+	CanvasTransformed,
+	ToolAbort,
+	SelectionChanged,
+	WorkingColorChanged,
+}

editor/src/messages/broadcast/broadcast_message.rs

@@ -0,0 +1,19 @@
+use crate::messages::prelude::*;
+
+#[impl_message(Message, Broadcast)]
+#[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)]
+pub enum BroadcastMessage {
+	// Sub-messages
+	#[child]
+	TriggerEvent(BroadcastEvent),
+
+	// Messages
+	SubscribeEvent {
+		on: BroadcastEvent,
+		send: Box<Message>,
+	},
+	UnsubscribeEvent {
+		on: BroadcastEvent,
+		message: Box<Message>,
+	},
+}

editor/src/messages/broadcast/broadcast_message_handler.rs

@@ -0,0 +1,27 @@
+use crate::messages::prelude::*;
+
+#[derive(Debug, Clone, Default)]
+pub struct BroadcastMessageHandler {
+	listeners: HashMap<BroadcastEvent, Vec<Message>>,
+}
+
+impl MessageHandler<BroadcastMessage, ()> for BroadcastMessageHandler {
+	fn process_message(&mut self, message: BroadcastMessage, responses: &mut VecDeque<Message>, _data: ()) {
+		match message {
+			// Sub-messages
+			BroadcastMessage::TriggerEvent(event) => {
+				for message in self.listeners.entry(event).or_default() {
+					responses.add_front(message.clone())
+				}
+			}
+
+			// Messages
+			BroadcastMessage::SubscribeEvent { on, send } => self.listeners.entry(on).or_default().push(*send),
+			BroadcastMessage::UnsubscribeEvent { on, message } => self.listeners.entry(on).or_default().retain(|msg| *msg != *message),
+		}
+	}
+
+	fn actions(&self) -> ActionList {
+		actions!(BroadcastEventDiscriminant;)
+	}
+}

editor/src/messages/broadcast/mod.rs

@@ -0,0 +1,9 @@
+mod broadcast_message;
+mod broadcast_message_handler;
+
+pub mod broadcast_event;
+
+#[doc(inline)]
+pub use broadcast_message::{BroadcastMessage, BroadcastMessageDiscriminant};
+#[doc(inline)]
+pub use broadcast_message_handler::BroadcastMessageHandler;

editor/src/messages/debug/debug_message.rs

@@ -0,0 +1,10 @@
+use crate::messages::prelude::*;
+
+#[impl_message(Message, Debug)]
+#[derive(PartialEq, Eq, Clone, Debug, Hash, serde::Serialize, serde::Deserialize)]
+pub enum DebugMessage {
+	ToggleTraceLogs,
+	MessageOff,
+	MessageNames,
+	MessageContents,
+}

editor/src/messages/debug/debug_message_handler.rs

@@ -0,0 +1,49 @@
+use super::utility_types::MessageLoggingVerbosity;
+use crate::messages::prelude::*;
+
+#[derive(Debug, Default)]
+pub struct DebugMessageHandler {
+	pub message_logging_verbosity: MessageLoggingVerbosity,
+}
+
+impl MessageHandler<DebugMessage, ()> for DebugMessageHandler {
+	fn process_message(&mut self, message: DebugMessage, responses: &mut VecDeque<Message>, _data: ()) {
+		match message {
+			DebugMessage::ToggleTraceLogs => {
+				if log::max_level() == log::LevelFilter::Debug {
+					log::set_max_level(log::LevelFilter::Trace);
+				} else {
+					log::set_max_level(log::LevelFilter::Debug);
+				}
+
+				// Refresh the checkmark beside the menu entry for this
+				responses.add(MenuBarMessage::SendLayout);
+			}
+			DebugMessage::MessageOff => {
+				self.message_logging_verbosity = MessageLoggingVerbosity::Off;
+
+				// Refresh the checkmark beside the menu entry for this
+				responses.add(MenuBarMessage::SendLayout);
+			}
+			DebugMessage::MessageNames => {
+				self.message_logging_verbosity = MessageLoggingVerbosity::Names;
+
+				// Refresh the checkmark beside the menu entry for this
+				responses.add(MenuBarMessage::SendLayout);
+			}
+			DebugMessage::MessageContents => {
+				self.message_logging_verbosity = MessageLoggingVerbosity::Contents;
+
+				// Refresh the checkmark beside the menu entry for this
+				responses.add(MenuBarMessage::SendLayout);
+			}
+		}
+	}
+
+	advertise_actions!(DebugMessageDiscriminant;
+		ToggleTraceLogs,
+		MessageOff,
+		MessageNames,
+		MessageContents,
+	);
+}

editor/src/messages/debug/mod.rs

@@ -0,0 +1,9 @@
+mod debug_message;
+mod debug_message_handler;
+
+pub mod utility_types;
+
+#[doc(inline)]
+pub use debug_message::{DebugMessage, DebugMessageDiscriminant};
+#[doc(inline)]
+pub use debug_message_handler::DebugMessageHandler;

editor/src/messages/debug/utility_types.rs

@@ -0,0 +1,7 @@
+#[derive(Debug, Default, Clone, Copy, Eq, PartialEq)]
+pub enum MessageLoggingVerbosity {
+	#[default]
+	Off,
+	Names,
+	Contents,
+}

editor/src/messages/dialog/dialog_message.rs

@@ -0,0 +1,38 @@
+use crate::messages::prelude::*;
+
+#[impl_message(Message, Dialog)]
+#[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)]
+pub enum DialogMessage {
+	// Sub-messages
+	#[child]
+	ExportDialog(ExportDialogMessage),
+	#[child]
+	NewDocumentDialog(NewDocumentDialogMessage),
+	#[child]
+	PreferencesDialog(PreferencesDialogMessage),
+
+	// Messages
+	CloseAllDocumentsWithConfirmation,
+	CloseDialogAndThen {
+		followups: Vec<Message>,
+	},
+	DisplayDialogError {
+		title: String,
+		description: String,
+	},
+	RequestAboutGraphiteDialog,
+	RequestAboutGraphiteDialogWithLocalizedCommitDate {
+		localized_commit_date: String,
+		localized_commit_year: String,
+	},
+	RequestComingSoonDialog {
+		issue: Option<u32>,
+	},
+	RequestDemoArtworkDialog,
+	RequestExportDialog,
+	RequestLicensesDialogWithLocalizedCommitDate {
+		localized_commit_year: String,
+	},
+	RequestNewDocumentDialog,
+	RequestPreferencesDialog,
+}

editor/src/messages/dialog/dialog_message_handler.rs

@@ -0,0 +1,118 @@
+use super::simple_dialogs::{self, AboutGraphiteDialog, ComingSoonDialog, DemoArtworkDialog, LicensesDialog};
+use crate::messages::layout::utility_types::widget_prelude::*;
+use crate::messages::prelude::*;
+
+pub struct DialogMessageData<'a> {
+	pub portfolio: &'a PortfolioMessageHandler,
+	pub preferences: &'a PreferencesMessageHandler,
+}
+
+/// Stores the dialogs which require state. These are the ones that have their own message handlers, and are not the ones defined in `simple_dialogs`.
+#[derive(Debug, Default, Clone)]
+pub struct DialogMessageHandler {
+	export_dialog: ExportDialogMessageHandler,
+	new_document_dialog: NewDocumentDialogMessageHandler,
+	preferences_dialog: PreferencesDialogMessageHandler,
+}
+
+impl MessageHandler<DialogMessage, DialogMessageData<'_>> for DialogMessageHandler {
+	fn process_message(&mut self, message: DialogMessage, responses: &mut VecDeque<Message>, data: DialogMessageData) {
+		let DialogMessageData { portfolio, preferences } = data;
+
+		match message {
+			DialogMessage::ExportDialog(message) => self.export_dialog.process_message(message, responses, ExportDialogMessageData { portfolio }),
+			DialogMessage::NewDocumentDialog(message) => self.new_document_dialog.process_message(message, responses, ()),
+			DialogMessage::PreferencesDialog(message) => self.preferences_dialog.process_message(message, responses, PreferencesDialogMessageData { preferences }),
+
+			DialogMessage::CloseAllDocumentsWithConfirmation => {
+				let dialog = simple_dialogs::CloseAllDocumentsDialog {
+					unsaved_document_names: portfolio.unsaved_document_names(),
+				};
+				dialog.send_dialog_to_frontend(responses);
+			}
+			DialogMessage::CloseDialogAndThen { followups } => {
+				for message in followups.into_iter() {
+					responses.add(message);
+				}
+
+				// This come after followups, so that the followups (which can cause the dialog to open) happen first, then we close it afterwards.
+				// If it comes before, the dialog reopens (and appears to not close at all).
+				responses.add(FrontendMessage::DisplayDialogDismiss);
+			}
+			DialogMessage::DisplayDialogError { title, description } => {
+				let dialog = simple_dialogs::ErrorDialog { title, description };
+				dialog.send_dialog_to_frontend(responses);
+			}
+			DialogMessage::RequestAboutGraphiteDialog => {
+				responses.add(FrontendMessage::TriggerAboutGraphiteLocalizedCommitDate {
+					commit_date: env!("GRAPHITE_GIT_COMMIT_DATE").into(),
+				});
+			}
+			DialogMessage::RequestAboutGraphiteDialogWithLocalizedCommitDate {
+				localized_commit_date,
+				localized_commit_year,
+			} => {
+				let dialog = AboutGraphiteDialog {
+					localized_commit_date,
+					localized_commit_year,
+				};
+
+				dialog.send_dialog_to_frontend(responses);
+			}
+			DialogMessage::RequestComingSoonDialog { issue } => {
+				let dialog = ComingSoonDialog { issue };
+				dialog.send_dialog_to_frontend(responses);
+			}
+			DialogMessage::RequestDemoArtworkDialog => {
+				let dialog = DemoArtworkDialog;
+				dialog.send_dialog_to_frontend(responses);
+			}
+			DialogMessage::RequestExportDialog => {
+				if let Some(document) = portfolio.active_document() {
+					let artboards = document
+						.metadata()
+						.all_layers()
+						.filter(|&layer| document.network_interface.is_artboard(&layer.to_node(), &[]))
+						.map(|layer| {
+							let name = document
+								.network_interface
+								.node_metadata(&layer.to_node(), &[])
+								.map(|node| node.persistent_metadata.display_name.clone())
+								.and_then(|name| if name.is_empty() { None } else { Some(name) })
+								.unwrap_or_else(|| "Artboard".to_string());
+							(layer, name)
+						})
+						.collect();
+
+					self.export_dialog.artboards = artboards;
+					self.export_dialog.has_selection = document.network_interface.selected_nodes().selected_layers(document.metadata()).next().is_some();
+					self.export_dialog.send_dialog_to_frontend(responses);
+				}
+			}
+			DialogMessage::RequestLicensesDialogWithLocalizedCommitDate { localized_commit_year } => {
+				let dialog = LicensesDialog { localized_commit_year };
+
+				dialog.send_dialog_to_frontend(responses);
+			}
+			DialogMessage::RequestNewDocumentDialog => {
+				self.new_document_dialog = NewDocumentDialogMessageHandler {
+					name: portfolio.generate_new_document_name(),
+					infinite: false,
+					dimensions: glam::UVec2::new(1920, 1080),
+				};
+				self.new_document_dialog.send_dialog_to_frontend(responses);
+			}
+			DialogMessage::RequestPreferencesDialog => {
+				self.preferences_dialog = PreferencesDialogMessageHandler {};
+				self.preferences_dialog.send_dialog_to_frontend(responses, preferences);
+			}
+		}
+	}
+
+	advertise_actions!(DialogMessageDiscriminant;
+		CloseAllDocumentsWithConfirmation,
+		RequestExportDialog,
+		RequestNewDocumentDialog,
+		RequestPreferencesDialog,
+	);
+}

editor/src/messages/dialog/export_dialog/export_dialog_message.rs

@@ -0,0 +1,13 @@
+use crate::messages::frontend::utility_types::{ExportBounds, FileType};
+use crate::messages::prelude::*;
+
+#[impl_message(Message, DialogMessage, ExportDialog)]
+#[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)]
+pub enum ExportDialogMessage {
+	FileType(FileType),
+	ScaleFactor(f64),
+	TransparentBackground(bool),
+	ExportBounds(ExportBounds),
+
+	Submit,
+}