copy / paste works

package.json

···
   "license": "MIT",
   "dependencies": {
     "@tauri-apps/api": "^2.9.0",
+    "@tauri-apps/plugin-clipboard-manager": "~2",
     "@tauri-apps/plugin-dialog": "~2.4.2",
     "@tauri-apps/plugin-opener": "^2.5.2",
     "animejs": "^4.2.2",

pnpm-lock.yaml

···
       '@tauri-apps/api':
         specifier: ^2.9.0
         version: 2.9.0
+      '@tauri-apps/plugin-clipboard-manager':
+        specifier: ~2
+        version: 2.3.2
       '@tauri-apps/plugin-dialog':
         specifier: ~2.4.2
         version: 2.4.2
···
     resolution: {integrity: sha512-BQ7iLUXTQcyG1PpzLWeVSmBCedYDpnA/6Cm/kRFGtqjTf/eVUlyYO5S2ee07tLum3nWwDBWTGFZeruO8yEukfA==}
     engines: {node: '>= 10'}
     hasBin: true
+
+  '@tauri-apps/plugin-clipboard-manager@2.3.2':
+    resolution: {integrity: sha512-CUlb5Hqi2oZbcZf4VUyUH53XWPPdtpw43EUpCza5HWZJwxEoDowFzNUDt1tRUXA8Uq+XPn17Ysfptip33sG4eQ==}
 
   '@tauri-apps/plugin-dialog@2.4.2':
     resolution: {integrity: sha512-lNIn5CZuw8WZOn8zHzmFmDSzg5zfohWoa3mdULP0YFh/VogVdMVWZPcWSHlydsiJhRQYaTNSYKN7RmZKE2lCYQ==}
···
       '@tauri-apps/cli-win32-arm64-msvc': 2.9.3
       '@tauri-apps/cli-win32-ia32-msvc': 2.9.3
       '@tauri-apps/cli-win32-x64-msvc': 2.9.3
+
+  '@tauri-apps/plugin-clipboard-manager@2.3.2':
+    dependencies:
+      '@tauri-apps/api': 2.9.0
 
   '@tauri-apps/plugin-dialog@2.4.2':
     dependencies:

src-tauri/Cargo.lock

···
  "serde_json",
  "tauri",
  "tauri-build",
+ "tauri-plugin-clipboard-manager",
  "tauri-plugin-dialog",
  "tauri-plugin-opener",
  "tokio",
···
 checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61"
 
 [[package]]
+name = "arboard"
+version = "3.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0348a1c054491f4bfe6ab86a7b6ab1e44e45d899005de92f58b3df180b36ddaf"
+dependencies = [
+ "clipboard-win",
+ "image",
+ "log",
+ "objc2 0.6.3",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-foundation 0.3.2",
+ "parking_lot",
+ "percent-encoding",
+ "windows-sys 0.60.2",
+ "wl-clipboard-rs",
+ "x11rb",
+]
+
+[[package]]
 name = "ashpd"
 version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "futures-lite",
  "parking",
  "polling",
- "rustix",
+ "rustix 1.1.2",
  "slab",
  "windows-sys 0.61.2",
 ]
···
  "cfg-if",
  "event-listener",
  "futures-lite",
- "rustix",
+ "rustix 1.1.2",
 ]
 
 [[package]]
···
  "cfg-if",
  "futures-core",
  "futures-io",
- "rustix",
+ "rustix 1.1.2",
  "signal-hook-registry",
  "slab",
  "windows-sys 0.61.2",
···
  "num-traits",
  "serde",
  "windows-link 0.2.1",
+]
+
+[[package]]
+name = "clipboard-win"
+version = "5.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bde03770d3df201d4fb868f2c9c59e66a3e4e2bd06692a0fe701e7103c7e84d4"
+dependencies = [
+ "error-code",
 ]
 
 [[package]]
···
 checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
+name = "crunchy"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+
+[[package]]
 name = "crypto-common"
 version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "error-code"
+version = "3.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dea2df4cf52843e0452895c455a1a2cfbb842a1e7329671acf418fdc53ed4c59"
+
+[[package]]
 name = "event-listener"
 version = "5.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
 [[package]]
+name = "fax"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f05de7d48f37cd6730705cbca900770cab77a89f413d23e100ad7fad7795a0ab"
+dependencies = [
+ "fax_derive",
+]
+
+[[package]]
+name = "fax_derive"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0aca10fb742cb43f9e7bb8467c91aa9bcb8e3ffbc6a6f7389bb93ffc920577d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.109",
+]
+
+[[package]]
 name = "fdeflate"
 version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "52051878f80a721bb68ebfbc930e07b65ba72f2da88968ea5c06fd6ca3d3a127"
 
 [[package]]
+name = "fixedbitset"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
+
+[[package]]
 name = "flate2"
 version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
 
 [[package]]
 name = "foreign-types"
···
 ]
 
 [[package]]
+name = "gethostname"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bd49230192a3797a9a4d6abe9b3eed6f7fa4c8a8a4947977c6f80025f92cbd8"
+dependencies = [
+ "rustix 1.1.2",
+ "windows-link 0.2.1",
+]
+
+[[package]]
 name = "getrandom"
 version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "half"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+ "zerocopy",
+]
+
+[[package]]
 name = "hashbrown"
 version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash",
+]
 
 [[package]]
 name = "hashbrown"
···
  "moxcms",
  "num-traits",
  "png 0.18.0",
+ "tiff",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "linux-raw-sys"
+version = "0.4.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
+
+[[package]]
+name = "linux-raw-sys"
 version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
···
 version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
 [[package]]
 name = "miniz_oxide"
···
 checksum = "72ef4a56884ca558e5ddb05a1d1e7e1bfd9a68d9ed024c21704cc98872dae1bb"
 
 [[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
 name = "num-conv"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "os_pipe"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
 name = "pango"
 version = "0.18.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
 [[package]]
+name = "petgraph"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455"
+dependencies = [
+ "fixedbitset",
+ "hashbrown 0.15.5",
+ "indexmap 2.12.0",
+]
+
+[[package]]
 name = "phf"
 version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "concurrent-queue",
  "hermit-abi",
  "pin-project-lite",
- "rustix",
+ "rustix 1.1.2",
  "windows-sys 0.61.2",
 ]
 
···
 dependencies = [
  "num-traits",
 ]
+
+[[package]]
+name = "quick-error"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
 
 [[package]]
 name = "quick-xml"
···
 
 [[package]]
 name = "rustix"
+version = "0.38.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
+dependencies = [
+ "bitflags 2.10.0",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.4.15",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "rustix"
 version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cd15f8a2c5551a84d56efdc1cd049089e409ac19a3072d5037a17fd70719ff3e"
···
  "bitflags 2.10.0",
  "errno",
  "libc",
- "linux-raw-sys",
+ "linux-raw-sys 0.11.0",
  "windows-sys 0.61.2",
 ]
 
···
 ]
 
 [[package]]
+name = "tauri-plugin-clipboard-manager"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "206dc20af4ed210748ba945c2774e60fd0acd52b9a73a028402caf809e9b6ecf"
+dependencies = [
+ "arboard",
+ "log",
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-plugin",
+ "thiserror 2.0.17",
+]
+
+[[package]]
 name = "tauri-plugin-dialog"
 version = "2.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "fastrand",
  "getrandom 0.3.4",
  "once_cell",
- "rustix",
+ "rustix 1.1.2",
  "windows-sys 0.61.2",
 ]
 
···
 ]
 
 [[package]]
+name = "tiff"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af9605de7fee8d9551863fd692cce7637f548dbd9db9180fcc07ccc6d26c336f"
+dependencies = [
+ "fax",
+ "flate2",
+ "half",
+ "quick-error",
+ "weezl",
+ "zune-jpeg",
+]
+
+[[package]]
 name = "time"
 version = "0.3.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "tree_magic_mini"
+version = "3.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52fac5f7d176f7f7f7e827299ead28ef98de642c5d93a97e0cd0816d17557f19"
+dependencies = [
+ "memchr",
+ "nom",
+ "petgraph",
+]
+
+[[package]]
 name = "try-lock"
 version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "cc",
  "downcast-rs",
- "rustix",
+ "rustix 1.1.2",
  "scoped-tls",
  "smallvec",
  "wayland-sys",
···
 checksum = "c66a47e840dc20793f2264eb4b3e4ecb4b75d91c0dd4af04b456128e0bdd449d"
 dependencies = [
  "bitflags 2.10.0",
- "rustix",
+ "rustix 1.1.2",
  "wayland-backend",
  "wayland-scanner",
 ]
···
  "bitflags 2.10.0",
  "wayland-backend",
  "wayland-client",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-protocols-wlr"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "efd94963ed43cf9938a090ca4f7da58eb55325ec8200c3848963e98dc25b78ec"
+dependencies = [
+ "bitflags 2.10.0",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
  "wayland-scanner",
 ]
 
···
  "windows",
  "windows-core 0.61.2",
 ]
+
+[[package]]
+name = "weezl"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"
 
 [[package]]
 name = "winapi"
···
 checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
 
 [[package]]
+name = "wl-clipboard-rs"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e5ff8d0e60065f549fafd9d6cb626203ea64a798186c80d8e7df4f8af56baeb"
+dependencies = [
+ "libc",
+ "log",
+ "os_pipe",
+ "rustix 0.38.44",
+ "tempfile",
+ "thiserror 2.0.17",
+ "tree_magic_mini",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "wayland-protocols-wlr",
+]
+
+[[package]]
 name = "writeable"
 version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "once_cell",
  "pkg-config",
 ]
+
+[[package]]
+name = "x11rb"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9993aa5be5a26815fe2c3eacfc1fde061fc1a1f094bf1ad2a18bf9c495dd7414"
+dependencies = [
+ "gethostname",
+ "rustix 1.1.2",
+ "x11rb-protocol",
+]
+
+[[package]]
+name = "x11rb-protocol"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd"
 
 [[package]]
 name = "yoke"
···
  "proc-macro2",
  "quote",
  "syn 2.0.109",
+]
+
+[[package]]
+name = "zune-core"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f423a2c17029964870cfaabb1f13dfab7d092a62a29a89264f4d36990ca414a"
+
+[[package]]
+name = "zune-jpeg"
+version = "0.4.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29ce2c8a9384ad323cf564b67da86e21d3cfdff87908bc1223ed5c99bc792713"
+dependencies = [
+ "zune-core",
 ]
 
 [[package]]

src-tauri/Cargo.toml

···
 flate2 = "1.1"
 tauri-plugin-dialog = "2"
 crossbeam-channel = "0.5"
+tauri-plugin-clipboard-manager = "2"
 

src-tauri/capabilities/default.json

···
     "core:default",
     "core:window:allow-destroy",
     "opener:default",
-    "dialog:default"
+    "dialog:default",
+    "clipboard-manager:allow-read-text",
+    "clipboard-manager:allow-write-text"
   ]
 }

src-tauri/src/frontend_calls/close_app.rs

···
 use crate::utils::config::Config;
 
 #[tauri::command]
-pub fn close_app( conf: State<Config> ){
+pub fn close_app(conf: State<Config>) {
   conf.save();
   std::process::exit(0);
-}
+}

src-tauri/src/frontend_calls/load_previous_tabs.rs

···
 
 use tauri::{State, Window};
 
-use crate::{ structs::nodes::Node, utils::config::Config };
+use crate::{structs::nodes::Node, utils::config::Config};
 
 #[tauri::command]
-pub fn load_previous_tabs( window: Window, conf: State<Config> ) -> HashMap<String, ( Vec<Node>, String, Option<String> )> {
+pub fn load_previous_tabs(
+  window: Window,
+  conf: State<Config>,
+) -> HashMap<String, (Vec<Node>, String, Option<String>)> {
   let config = conf.store.lock().unwrap();
 
-  if !config.hide_editor_on_start { window.show().unwrap(); }
+  if !config.hide_editor_on_start {
+    window.show().unwrap();
+  }
 
   let tabs = config.loaded_tabs.clone();
   tabs
-}
+}

src-tauri/src/frontend_calls/mod.rs

···
+pub mod close_app;
 pub mod get_addresses;
+pub mod load_previous_tabs;
 pub mod save_graph;
+pub mod settings;
 pub mod sync_tab;
-pub mod load_previous_tabs;
-pub mod close_app;
-pub mod settings;

src-tauri/src/frontend_calls/save_graph.rs

···
 use std::{fs::File, io::Write, path::PathBuf};
 
-use flate2::{ write::GzEncoder, Compression };
+use flate2::{write::GzEncoder, Compression};
 use tauri::State;
 
 use crate::utils::config::Config;
 
 #[tauri::command]
-pub fn save_graph( graph: String, path: PathBuf, conf: State<Config> ) {
+pub fn save_graph(graph: String, path: PathBuf, conf: State<Config>) {
   let file = File::create(&path).unwrap();
   let mut encoder = GzEncoder::new(file, Compression::default());
 

src-tauri/src/frontend_calls/settings.rs

···
 use crate::utils::config::Config;
 
 #[tauri::command]
-pub fn set_hide_editor_on_app_start( value: bool, conf: State<Config> ){
+pub fn set_hide_editor_on_app_start(value: bool, conf: State<Config>) {
   let mut config = conf.store.lock().unwrap();
   config.hide_editor_on_start = value;
 }
 
 #[tauri::command]
-pub fn get_hide_editor_on_app_start( conf: State<Config> ) -> bool {
+pub fn get_hide_editor_on_app_start(conf: State<Config>) -> bool {
   let config = conf.store.lock().unwrap();
   config.hide_editor_on_start
-}
+}

src-tauri/src/frontend_calls/sync_tab.rs

···
 
 use tauri::State;
 
-use crate::{ runtime::commands::RuntimeCommand, structs::nodes::Node, utils::config::Config };
+use crate::{runtime::commands::RuntimeCommand, structs::nodes::Node, utils::config::Config};
 
 #[tauri::command]
-pub fn sync_tab( graph: Vec<Node>, id: String, name: String, location: Option<String>, cmd: State<Sender<RuntimeCommand>>, conf: State<Config> ){
-  cmd.send(RuntimeCommand::AddTab(graph.clone(), id.clone())).unwrap();
+pub fn sync_tab(
+  graph: Vec<Node>,
+  id: String,
+  name: String,
+  location: Option<String>,
+  cmd: State<Sender<RuntimeCommand>>,
+  conf: State<Config>,
+) {
+  cmd
+    .send(RuntimeCommand::AddTab(graph.clone(), id.clone()))
+    .unwrap();
 
   let mut config = conf.store.lock().unwrap();
-  config.loaded_tabs.insert(id, ( graph, name, location )); // TODO: When loading a tab into config, store the save state of it too
+  config.loaded_tabs.insert(id, (graph, name, location)); // TODO: When loading a tab into config, store the save state of it too
 }
 
 #[tauri::command]
-pub fn discard_tab( id: String, cmd: State<Sender<RuntimeCommand>>, conf: State<Config> ){
+pub fn discard_tab(id: String, cmd: State<Sender<RuntimeCommand>>, conf: State<Config>) {
   cmd.send(RuntimeCommand::RemoveTab(id.clone())).unwrap();
 
   let mut config = conf.store.lock().unwrap();
   config.loaded_tabs.remove(&id);
-}
+}

src-tauri/src/lib.rs

···
-use std::{ fs, sync::Mutex };
+use std::{fs, sync::Mutex};
 
 use crossbeam_channel::bounded;
 use frontend_calls::*;
 
-use crate::{ osc::OSCMessage, setup::setup, utils::config::Config };
+use crate::{osc::OSCMessage, setup::setup, utils::config::Config};
 
 mod frontend_calls;
 mod osc;
+mod runtime;
 mod setup;
 mod structs;
 mod utils;
-mod runtime;
 
 // TODO: Add built-in OSC endpoints
 
···
 
   static ADDRESSES: Mutex<Vec<OSCMessage>> = Mutex::new(Vec::new());
 
-  let ( runtime_sender, runtime_receiver ) = bounded(1024);
+  let (runtime_sender, runtime_receiver) = bounded(1024);
 
   tauri::Builder::default()
+    .plugin(tauri_plugin_clipboard_manager::init())
     .plugin(tauri_plugin_dialog::init())
     .plugin(tauri_plugin_opener::init())
     .invoke_handler(tauri::generate_handler![
···
       sync_tab::discard_tab,
       load_previous_tabs::load_previous_tabs,
       close_app::close_app,
-
       settings::set_hide_editor_on_app_start,
       settings::get_hide_editor_on_app_start,
     ])

src-tauri/src/runtime.rs

···
-use anyhow::{ bail, Result };
+use anyhow::{bail, Result};
 
-use crate::{ runtime::nodes::RuntimeNodeTree, structs::parameter_types::ParameterType };
+use crate::{runtime::nodes::RuntimeNodeTree, structs::parameter_types::ParameterType};
 
-pub mod nodes;
 pub mod commands;
+pub mod nodes;
 
 // This is horrible. I know, I'm sorry.
 
-pub fn runtime_dry( entry: String, parameters: &Vec<ParameterType>, tab: &mut RuntimeNodeTree ) -> Result<()>{
+pub fn runtime_dry(
+  entry: String,
+  parameters: &Vec<ParameterType>,
+  tab: &mut RuntimeNodeTree,
+) -> Result<()> {
   let node = tab.nodes.get_mut(&entry);
-  if node.is_none(){ bail!("Cannot find node"); }
+  if node.is_none() {
+    bail!("Cannot find node");
+  }
 
   let node = node.unwrap();
 
   let output_map = node.outputs();
   let args = node.execute_dry(parameters);
 
-  if args.is_some(){
+  if args.is_some() {
     let args = args.unwrap();
 
-    for i in 0..args.len(){
+    for i in 0..args.len() {
       let arg = &args[i];
 
-      for output in &output_map[i]{
-        if output.2 == 5{ break; } // Ignore flow outputs
+      for output in &output_map[i] {
+        if output.2 == 5 {
+          break;
+        } // Ignore flow outputs
 
         let next_node = tab.nodes.get_mut(&output.0);
-        if next_node.is_none(){ bail!("Cannot find node {}", output.0) }
+        if next_node.is_none() {
+          bail!("Cannot find node {}", output.0)
+        }
 
         let next_node = next_node.unwrap();
         let can_update = next_node.update_arg(output.1 as usize, arg.clone());
 
-        if can_update{
+        if can_update {
           runtime_dry(output.0.clone(), &vec![], tab)?;
         }
       }
···
   Ok(())
 }
 
-pub fn runtime( entry: String, tab: &mut RuntimeNodeTree ) -> Result<()>{
+pub fn runtime(entry: String, tab: &mut RuntimeNodeTree) -> Result<()> {
   let node = tab.nodes.get_mut(&entry);
-  if node.is_none(){ bail!("Cannot find node"); }
+  if node.is_none() {
+    bail!("Cannot find node");
+  }
 
   let node = node.unwrap();
 
   let next = node.execute();
-  if next.is_some(){
+  if next.is_some() {
     let next = next.unwrap();
 
     let outputs = node.outputs();
 
-    for i in 0..next.len(){
+    for i in 0..next.len() {
       let arg = &next[i];
-      if i >= outputs.len() { break; }
+      if i >= outputs.len() {
+        break;
+      }
 
-      for output in &outputs[i]{
-        if let ParameterType::Flow(next) = arg{
-          if *next{
+      for output in &outputs[i] {
+        if let ParameterType::Flow(next) = arg {
+          if *next {
             // This is a flow output, continue
             runtime(output.0.clone(), tab)?;
           }
···
   }
 
   Ok(())
-}
+}

src-tauri/src/runtime/commands.rs

···
-use crate::{ osc::OSCMessage, structs::nodes::Node };
+use crate::{osc::OSCMessage, structs::nodes::Node};
 
 #[derive(Debug)]
-pub enum RuntimeCommand{
+pub enum RuntimeCommand {
   OSCMessage(OSCMessage),
 
   AddTab(Vec<Node>, String),
-  RemoveTab(String)
-}
+  RemoveTab(String),
+}

src-tauri/src/runtime/nodes.rs

···
 use std::collections::HashMap;
 
-use crate::{ runtime::nodes::{ conditional::{ ifequal::ConditionalIfEqual, iffalse::ConditionalIfFalse, iftrue::ConditionalIfTrue }, debug::Debug, oscactions::sendchatbox::OSCActionsSendChatbox, osctrigger::OSCTrigger, statics::{ float::StaticFloat, int::StaticInt, string::StaticString } }, structs::{ nodes::Node, parameter_types::ParameterType } };
+use crate::{
+  runtime::nodes::{
+    conditional::{
+      ifequal::ConditionalIfEqual, iffalse::ConditionalIfFalse, iftrue::ConditionalIfTrue,
+    },
+    debug::Debug,
+    oscactions::sendchatbox::OSCActionsSendChatbox,
+    osctrigger::OSCTrigger,
+    statics::{float::StaticFloat, int::StaticInt, string::StaticString},
+  },
+  structs::{nodes::Node, parameter_types::ParameterType},
+};
 
-mod osctrigger;
+mod conditional;
 mod debug;
+mod oscactions;
+mod osctrigger;
 mod statics;
-mod conditional;
-mod oscactions;
 
-pub struct RuntimeNodeTree{
-  pub nodes: HashMap<String, Box<dyn RuntimeNode>>
+pub struct RuntimeNodeTree {
+  pub nodes: HashMap<String, Box<dyn RuntimeNode>>,
 }
 
-unsafe impl Send for RuntimeNodeTree{}
+unsafe impl Send for RuntimeNodeTree {}
 
-impl RuntimeNodeTree{
-  pub fn from( tree: Vec<Node> ) -> Self{
+impl RuntimeNodeTree {
+  pub fn from(tree: Vec<Node>) -> Self {
     let mut runtime_nodes: HashMap<String, Box<dyn RuntimeNode>> = HashMap::new();
-    for node in tree{
-      match node.type_id.as_str(){
-        "osctrigger" => { runtime_nodes.insert(node.id.clone(), OSCTrigger::new(node)); }
+    for node in tree {
+      match node.type_id.as_str() {
+        "osctrigger" => {
+          runtime_nodes.insert(node.id.clone(), OSCTrigger::new(node));
+        }
 
-        "staticstring" => { runtime_nodes.insert(node.id.clone(), StaticString::new(node)); }
-        "staticint" => { runtime_nodes.insert(node.id.clone(), StaticInt::new(node)); }
-        "staticfloat" => { runtime_nodes.insert(node.id.clone(), StaticFloat::new(node)); }
+        "staticstring" => {
+          runtime_nodes.insert(node.id.clone(), StaticString::new(node));
+        }
+        "staticint" => {
+          runtime_nodes.insert(node.id.clone(), StaticInt::new(node));
+        }
+        "staticfloat" => {
+          runtime_nodes.insert(node.id.clone(), StaticFloat::new(node));
+        }
 
-        "iftrue" => { runtime_nodes.insert(node.id.clone(), ConditionalIfTrue::new(node)); }
-        "iffalse" => { runtime_nodes.insert(node.id.clone(), ConditionalIfFalse::new(node)); }
-        "ifequal" => { runtime_nodes.insert(node.id.clone(), ConditionalIfEqual::new(node)); }
+        "iftrue" => {
+          runtime_nodes.insert(node.id.clone(), ConditionalIfTrue::new(node));
+        }
+        "iffalse" => {
+          runtime_nodes.insert(node.id.clone(), ConditionalIfFalse::new(node));
+        }
+        "ifequal" => {
+          runtime_nodes.insert(node.id.clone(), ConditionalIfEqual::new(node));
+        }
 
-        "oscsendchatbox" => { runtime_nodes.insert(node.id.clone(), OSCActionsSendChatbox::new(node)); }
+        "oscsendchatbox" => {
+          runtime_nodes.insert(node.id.clone(), OSCActionsSendChatbox::new(node));
+        }
 
-        "debug" => { runtime_nodes.insert(node.id.clone(), Debug::new(node)); }
+        "debug" => {
+          runtime_nodes.insert(node.id.clone(), Debug::new(node));
+        }
         _ => {}
       }
     }
 
-    Self { nodes: runtime_nodes }
+    Self {
+      nodes: runtime_nodes,
+    }
   }
 }
 
-pub trait RuntimeNode{
-  fn outputs( &self ) -> Vec<Vec<( String, isize, isize )>>; // Node ID, input index, output value type
-  fn execute_dry( &mut self, msg: &Vec<ParameterType> ) -> Option<Vec<ParameterType>>; // Only update values on the first loop through
-  fn execute( &mut self ) -> Option<Vec<ParameterType>>; // Then call functions on the second loop
-  fn update_arg( &mut self, index: usize, value: ParameterType ) -> bool;
-  fn is_entrypoint( &self ) -> bool;
-}
+pub trait RuntimeNode {
+  fn outputs(&self) -> Vec<Vec<(String, isize, isize)>>; // Node ID, input index, output value type
+  fn execute_dry(&mut self, msg: &Vec<ParameterType>) -> Option<Vec<ParameterType>>; // Only update values on the first loop through
+  fn execute(&mut self) -> Option<Vec<ParameterType>>; // Then call functions on the second loop
+  fn update_arg(&mut self, index: usize, value: ParameterType) -> bool;
+  fn is_entrypoint(&self) -> bool;
+}

src-tauri/src/runtime/nodes/conditional/ifequal.rs

···
-use crate::{ runtime::nodes::RuntimeNode, structs::{ nodes::Node, parameter_types::ParameterType } };
+use crate::{
+  runtime::nodes::RuntimeNode,
+  structs::{nodes::Node, parameter_types::ParameterType},
+};
 
-pub struct ConditionalIfEqual{
-  outputs: Vec<Vec<( String, isize, isize )>>,
+pub struct ConditionalIfEqual {
+  outputs: Vec<Vec<(String, isize, isize)>>,
   value1: ParameterType,
-  value2: ParameterType
+  value2: ParameterType,
 }
 
-impl ConditionalIfEqual{
-  pub fn new( node: Node ) -> Box<Self>{
+impl ConditionalIfEqual {
+  pub fn new(node: Node) -> Box<Self> {
     Box::new(Self {
-      outputs: node.outputs.iter()
-        .map(| x | {
-          x.connections.iter().map(| x | { ( x.node.clone(), x.index, x.value_type ) }).collect()
-        }).collect(),
+      outputs: node
+        .outputs
+        .iter()
+        .map(|x| {
+          x.connections
+            .iter()
+            .map(|x| (x.node.clone(), x.index, x.value_type))
+            .collect()
+        })
+        .collect(),
       value1: ParameterType::None,
       value2: ParameterType::None,
     })
   }
 }
 
-impl RuntimeNode for ConditionalIfEqual{
-  fn outputs( &self ) -> Vec<Vec<( String, isize, isize )>> { self.outputs.clone() }
-  fn execute_dry( &mut self, _: &Vec<ParameterType> ) -> Option<Vec<ParameterType>> { Some(vec![]) }
+impl RuntimeNode for ConditionalIfEqual {
+  fn outputs(&self) -> Vec<Vec<(String, isize, isize)>> {
+    self.outputs.clone()
+  }
+  fn execute_dry(&mut self, _: &Vec<ParameterType>) -> Option<Vec<ParameterType>> {
+    Some(vec![])
+  }
 
-  fn execute( &mut self ) -> Option<Vec<ParameterType>> {
-    if self.value1 == ParameterType::None && self.value2 == ParameterType::None{
+  fn execute(&mut self) -> Option<Vec<ParameterType>> {
+    if self.value1 == ParameterType::None && self.value2 == ParameterType::None {
       None
-    } else{
+    } else {
       let equal = self.value1 == self.value2;
-      Some(vec![ ParameterType::Flow(equal), ParameterType::Flow(!equal) ])
+      Some(vec![
+        ParameterType::Flow(equal),
+        ParameterType::Flow(!equal),
+      ])
     }
   }
 
-  fn update_arg( &mut self, index: usize, arg: ParameterType ) -> bool {
-    match index{
+  fn update_arg(&mut self, index: usize, arg: ParameterType) -> bool {
+    match index {
       1 => {
         self.value1 = arg;
       }
···
     false
   }
 
-  fn is_entrypoint( &self ) -> bool { false }
-}
+  fn is_entrypoint(&self) -> bool {
+    false
+  }
+}

src-tauri/src/runtime/nodes/conditional/iffalse.rs

···
-use crate::{ runtime::nodes::RuntimeNode, structs::{ nodes::Node, parameter_types::ParameterType } };
+use crate::{
+  runtime::nodes::RuntimeNode,
+  structs::{nodes::Node, parameter_types::ParameterType},
+};
 
-pub struct ConditionalIfFalse{
-  outputs: Vec<Vec<( String, isize, isize )>>,
-  runtime_active: bool
+pub struct ConditionalIfFalse {
+  outputs: Vec<Vec<(String, isize, isize)>>,
+  runtime_active: bool,
 }
 
-impl ConditionalIfFalse{
-  pub fn new( node: Node ) -> Box<Self>{
+impl ConditionalIfFalse {
+  pub fn new(node: Node) -> Box<Self> {
     Box::new(Self {
-      outputs: node.outputs.iter()
-        .map(| x | {
-          x.connections.iter().map(| x | { ( x.node.clone(), x.index, x.value_type ) }).collect()
-        }).collect(),
-      runtime_active: false
+      outputs: node
+        .outputs
+        .iter()
+        .map(|x| {
+          x.connections
+            .iter()
+            .map(|x| (x.node.clone(), x.index, x.value_type))
+            .collect()
+        })
+        .collect(),
+      runtime_active: false,
     })
   }
 }
 
-impl RuntimeNode for ConditionalIfFalse{
-  fn outputs( &self ) -> Vec<Vec<( String, isize, isize )>> { self.outputs.clone() }
-  fn execute_dry( &mut self, _: &Vec<ParameterType> ) -> Option<Vec<ParameterType>> { Some(vec![]) }
+impl RuntimeNode for ConditionalIfFalse {
+  fn outputs(&self) -> Vec<Vec<(String, isize, isize)>> {
+    self.outputs.clone()
+  }
+  fn execute_dry(&mut self, _: &Vec<ParameterType>) -> Option<Vec<ParameterType>> {
+    Some(vec![])
+  }
 
-  fn execute( &mut self ) -> Option<Vec<ParameterType>> {
-    Some(vec![ ParameterType::Flow(!self.runtime_active), ParameterType::Flow(self.runtime_active) ])
+  fn execute(&mut self) -> Option<Vec<ParameterType>> {
+    Some(vec![
+      ParameterType::Flow(!self.runtime_active),
+      ParameterType::Flow(self.runtime_active),
+    ])
   }
 
-  fn update_arg( &mut self, _: usize, arg: ParameterType ) -> bool {
-    if arg.as_bool().unwrap(){
+  fn update_arg(&mut self, _: usize, arg: ParameterType) -> bool {
+    if arg.as_bool().unwrap() {
       self.runtime_active = true;
       true
-    } else{
+    } else {
       self.runtime_active = false;
       false
     }
   }
 
-  fn is_entrypoint( &self ) -> bool { false }
-}
+  fn is_entrypoint(&self) -> bool {
+    false
+  }
+}

src-tauri/src/runtime/nodes/conditional/iftrue.rs

···
-use crate::{ runtime::nodes::RuntimeNode, structs::{ nodes::Node, parameter_types::ParameterType } };
+use crate::{
+  runtime::nodes::RuntimeNode,
+  structs::{nodes::Node, parameter_types::ParameterType},
+};
 
-pub struct ConditionalIfTrue{
-  outputs: Vec<Vec<( String, isize, isize )>>,
-  runtime_active: bool
+pub struct ConditionalIfTrue {
+  outputs: Vec<Vec<(String, isize, isize)>>,
+  runtime_active: bool,
 }
 
-impl ConditionalIfTrue{
-  pub fn new( node: Node ) -> Box<Self>{
+impl ConditionalIfTrue {
+  pub fn new(node: Node) -> Box<Self> {
     Box::new(Self {
-      outputs: node.outputs.iter()
-        .map(| x | {
-          x.connections.iter().map(| x | { ( x.node.clone(), x.index, x.value_type ) }).collect()
-        }).collect(),
-      runtime_active: false
+      outputs: node
+        .outputs
+        .iter()
+        .map(|x| {
+          x.connections
+            .iter()
+            .map(|x| (x.node.clone(), x.index, x.value_type))
+            .collect()
+        })
+        .collect(),
+      runtime_active: false,
     })
   }
 }
 
-impl RuntimeNode for ConditionalIfTrue{
-  fn outputs( &self ) -> Vec<Vec<( String, isize, isize )>> { self.outputs.clone() }
-  fn execute_dry( &mut self, _: &Vec<ParameterType> ) -> Option<Vec<ParameterType>> { Some(vec![]) }
+impl RuntimeNode for ConditionalIfTrue {
+  fn outputs(&self) -> Vec<Vec<(String, isize, isize)>> {
+    self.outputs.clone()
+  }
+  fn execute_dry(&mut self, _: &Vec<ParameterType>) -> Option<Vec<ParameterType>> {
+    Some(vec![])
+  }
 
-  fn execute( &mut self ) -> Option<Vec<ParameterType>> {
-    Some(vec![ ParameterType::Flow(self.runtime_active), ParameterType::Flow(!self.runtime_active) ])
+  fn execute(&mut self) -> Option<Vec<ParameterType>> {
+    Some(vec![
+      ParameterType::Flow(self.runtime_active),
+      ParameterType::Flow(!self.runtime_active),
+    ])
   }
 
-  fn update_arg( &mut self, _: usize, arg: ParameterType ) -> bool {
-    if arg.as_bool().unwrap(){
+  fn update_arg(&mut self, _: usize, arg: ParameterType) -> bool {
+    if arg.as_bool().unwrap() {
       self.runtime_active = true;
       true
-    } else{
+    } else {
       self.runtime_active = false;
       false
     }
   }
 
-  fn is_entrypoint( &self ) -> bool { false }
-}
+  fn is_entrypoint(&self) -> bool {
+    false
+  }
+}

src-tauri/src/runtime/nodes/conditional/mod.rs

···
-pub mod iftrue;
+pub mod ifequal;
 pub mod iffalse;
-pub mod ifequal;
+pub mod iftrue;

src-tauri/src/runtime/nodes/debug.rs

···
-use crate::{ runtime::nodes::RuntimeNode, structs::{ nodes::Node, parameter_types::ParameterType } };
+use crate::{
+  runtime::nodes::RuntimeNode,
+  structs::{nodes::Node, parameter_types::ParameterType},
+};
 
-pub struct Debug{
-  to_log: Option<ParameterType>
+pub struct Debug {
+  to_log: Option<ParameterType>,
 }
 
-impl Debug{
-  pub fn new( _: Node ) -> Box<Self>{
+impl Debug {
+  pub fn new(_: Node) -> Box<Self> {
     Box::new(Self { to_log: None })
   }
 }
 
-impl RuntimeNode for Debug{
-  fn outputs( &self ) -> Vec<Vec<( String, isize, isize )>> { vec![] }
-  fn execute_dry( &mut self, _: &Vec<ParameterType> ) -> Option<Vec<ParameterType>> { Some(vec![]) }
+impl RuntimeNode for Debug {
+  fn outputs(&self) -> Vec<Vec<(String, isize, isize)>> {
+    vec![]
+  }
+  fn execute_dry(&mut self, _: &Vec<ParameterType>) -> Option<Vec<ParameterType>> {
+    Some(vec![])
+  }
 
-  fn execute( &mut self ) -> Option<Vec<ParameterType>> {
+  fn execute(&mut self) -> Option<Vec<ParameterType>> {
     dbg!(&self.to_log);
     self.to_log = None;
 
     None
   }
 
-  fn update_arg( &mut self, index: usize, value: ParameterType ) -> bool {
-    if index == 1{
+  fn update_arg(&mut self, index: usize, value: ParameterType) -> bool {
+    if index == 1 {
       self.to_log = Some(value);
       true
-    } else{
+    } else {
       false
     }
   }
 
-  fn is_entrypoint( &self ) -> bool { false }
-}
+  fn is_entrypoint(&self) -> bool {
+    false
+  }
+}

src-tauri/src/runtime/nodes/oscactions/mod.rs

···
-pub mod sendchatbox;
+pub mod sendchatbox;

src-tauri/src/runtime/nodes/oscactions/sendchatbox.rs

···
 use std::vec;
 
-use crate::{ osc, runtime::nodes::RuntimeNode, structs::{ nodes::Node, parameter_types::ParameterType } };
+use crate::{
+  osc,
+  runtime::nodes::RuntimeNode,
+  structs::{nodes::Node, parameter_types::ParameterType},
+};
 
-pub struct OSCActionsSendChatbox{
-  to_log: String
+pub struct OSCActionsSendChatbox {
+  to_log: String,
 }
 
-impl OSCActionsSendChatbox{
-  pub fn new( _: Node ) -> Box<Self>{
+impl OSCActionsSendChatbox {
+  pub fn new(_: Node) -> Box<Self> {
     Box::new(Self { to_log: "".into() })
   }
 }
 
-impl RuntimeNode for OSCActionsSendChatbox{
-  fn outputs( &self ) -> Vec<Vec<( String, isize, isize )>> { vec![] }
-  fn execute_dry( &mut self, _: &Vec<ParameterType> ) -> Option<Vec<ParameterType>> { Some(vec![]) }
+impl RuntimeNode for OSCActionsSendChatbox {
+  fn outputs(&self) -> Vec<Vec<(String, isize, isize)>> {
+    vec![]
+  }
+  fn execute_dry(&mut self, _: &Vec<ParameterType>) -> Option<Vec<ParameterType>> {
+    Some(vec![])
+  }
 
-  fn execute( &mut self ) -> Option<Vec<ParameterType>> {
-    osc::send_message("/chatbox/input", vec![
-      ParameterType::String(self.to_log.clone()),
-      ParameterType::Boolean(true),
-      ParameterType::Boolean(false)
-    ], "127.0.0.1:9000");
+  fn execute(&mut self) -> Option<Vec<ParameterType>> {
+    osc::send_message(
+      "/chatbox/input",
+      vec![
+        ParameterType::String(self.to_log.clone()),
+        ParameterType::Boolean(true),
+        ParameterType::Boolean(false),
+      ],
+      "127.0.0.1:9000",
+    );
 
     None
   }
 
-  fn update_arg( &mut self, index: usize, value: ParameterType ) -> bool {
-    if index == 1{
+  fn update_arg(&mut self, index: usize, value: ParameterType) -> bool {
+    if index == 1 {
       self.to_log = value.as_string().unwrap();
       true
-    } else{
+    } else {
       false
     }
   }
 
-  fn is_entrypoint( &self ) -> bool { false }
-}
+  fn is_entrypoint(&self) -> bool {
+    false
+  }
+}

src-tauri/src/runtime/nodes/osctrigger.rs

···
-use crate::{ runtime::nodes::RuntimeNode, structs::{ nodes::Node, parameter_types::ParameterType } };
+use crate::{
+  runtime::nodes::RuntimeNode,
+  structs::{nodes::Node, parameter_types::ParameterType},
+};
 
-pub struct OSCTrigger{
-  outputs: Vec<Vec<( String, isize, isize )>>,
+pub struct OSCTrigger {
+  outputs: Vec<Vec<(String, isize, isize)>>,
   address: Option<String>,
-  runtime_active: bool
+  runtime_active: bool,
 }
 
-impl OSCTrigger{
-  pub fn new( node: Node ) -> Box<Self>{
+impl OSCTrigger {
+  pub fn new(node: Node) -> Box<Self> {
     let value = &node.statics[0].value;
 
     Box::new(Self {
-      address: if value.is_null(){ None } else { Some(value.as_str().unwrap().to_owned()) },
-      outputs: node.outputs.iter()
-        .map(| x | {
-          x.connections.iter().map(| x | { ( x.node.clone(), x.index, x.value_type ) }).collect()
-        }).collect(),
-      runtime_active: false
+      address: if value.is_null() {
+        None
+      } else {
+        Some(value.as_str().unwrap().to_owned())
+      },
+      outputs: node
+        .outputs
+        .iter()
+        .map(|x| {
+          x.connections
+            .iter()
+            .map(|x| (x.node.clone(), x.index, x.value_type))
+            .collect()
+        })
+        .collect(),
+      runtime_active: false,
     })
   }
 }
 
-impl RuntimeNode for OSCTrigger{
-  fn outputs( &self ) -> Vec<Vec<( String, isize, isize )>> {
+impl RuntimeNode for OSCTrigger {
+  fn outputs(&self) -> Vec<Vec<(String, isize, isize)>> {
     self.outputs.clone()
   }
 
-  fn execute_dry( &mut self, msg: &Vec<ParameterType> ) -> Option<Vec<ParameterType>> {
-    if self.address.is_none(){
+  fn execute_dry(&mut self, msg: &Vec<ParameterType>) -> Option<Vec<ParameterType>> {
+    if self.address.is_none() {
       self.runtime_active = false;
-      return None
+      return None;
     }
 
-    if let ParameterType::String(address) = &msg[0]{
-      if *address == *self.address.as_ref().unwrap(){
+    if let ParameterType::String(address) = &msg[0] {
+      if *address == *self.address.as_ref().unwrap() {
         self.runtime_active = true;
         Some(msg.clone())
         // The first value is technically the address value,
         // but this value gets ignored as the first output of
         // the osctrigger node is a flow output which gets ignored
         // on dry runs.
-      } else{
+      } else {
         self.runtime_active = false;
         None
       }
-    } else{
+    } else {
       self.runtime_active = false;
       None
     }
   }
 
-  fn execute( &mut self ) -> Option<Vec<ParameterType>> {
+  fn execute(&mut self) -> Option<Vec<ParameterType>> {
     let execute = self.runtime_active;
     self.runtime_active = false;
 
-    Some(vec![ ParameterType::Flow(execute) ])
+    Some(vec![ParameterType::Flow(execute)])
   }
 
-  fn update_arg( &mut self, _: usize, _: ParameterType ) -> bool { false }
-  fn is_entrypoint( &self ) -> bool { true }
-}
+  fn update_arg(&mut self, _: usize, _: ParameterType) -> bool {
+    false
+  }
+  fn is_entrypoint(&self) -> bool {
+    true
+  }
+}

src-tauri/src/runtime/nodes/statics/float.rs

···
-use crate::{ runtime::nodes::RuntimeNode, structs::{ nodes::Node, parameter_types::ParameterType } };
+use crate::{
+  runtime::nodes::RuntimeNode,
+  structs::{nodes::Node, parameter_types::ParameterType},
+};
 
-pub struct StaticFloat{
-  outputs: Vec<Vec<( String, isize, isize )>>,
-  value: Option<f32>
+pub struct StaticFloat {
+  outputs: Vec<Vec<(String, isize, isize)>>,
+  value: Option<f32>,
 }
 
-impl StaticFloat{
-  pub fn new( node: Node ) -> Box<Self>{
+impl StaticFloat {
+  pub fn new(node: Node) -> Box<Self> {
     let value = &node.statics[0].value;
 
     Box::new(Self {
-      value: if value.is_null(){ None } else { Some(value.as_f64().unwrap() as f32) },
-      outputs: node.outputs.iter()
-        .map(| x | {
-          x.connections.iter().map(| x | { ( x.node.clone(), x.index, x.value_type ) }).collect()
-        }).collect(),
+      value: if value.is_null() {
+        None
+      } else {
+        Some(value.as_f64().unwrap() as f32)
+      },
+      outputs: node
+        .outputs
+        .iter()
+        .map(|x| {
+          x.connections
+            .iter()
+            .map(|x| (x.node.clone(), x.index, x.value_type))
+            .collect()
+        })
+        .collect(),
     })
   }
 }
 
-impl RuntimeNode for StaticFloat{
-  fn outputs( &self ) -> Vec<Vec<( String, isize, isize )>> {
+impl RuntimeNode for StaticFloat {
+  fn outputs(&self) -> Vec<Vec<(String, isize, isize)>> {
     self.outputs.clone()
   }
 
-  fn execute_dry( &mut self, _: &Vec<ParameterType> ) -> Option<Vec<ParameterType>> {
-    if self.value.is_some(){
-      Some(vec![ ParameterType::Float(self.value.clone().unwrap()) ])
-    } else{
+  fn execute_dry(&mut self, _: &Vec<ParameterType>) -> Option<Vec<ParameterType>> {
+    if self.value.is_some() {
+      Some(vec![ParameterType::Float(self.value.clone().unwrap())])
+    } else {
       None
     }
   }
 
-  fn execute( &mut self ) -> Option<Vec<ParameterType>> { None }
+  fn execute(&mut self) -> Option<Vec<ParameterType>> {
+    None
+  }
 
-  fn update_arg( &mut self, _: usize, _: ParameterType ) -> bool { false }
-  fn is_entrypoint( &self ) -> bool { true }
-}
+  fn update_arg(&mut self, _: usize, _: ParameterType) -> bool {
+    false
+  }
+  fn is_entrypoint(&self) -> bool {
+    true
+  }
+}

src-tauri/src/runtime/nodes/statics/int.rs

···
-use crate::{ runtime::nodes::RuntimeNode, structs::{ nodes::Node, parameter_types::ParameterType } };
+use crate::{
+  runtime::nodes::RuntimeNode,
+  structs::{nodes::Node, parameter_types::ParameterType},
+};
 
-pub struct StaticInt{
-  outputs: Vec<Vec<( String, isize, isize )>>,
-  value: Option<i32>
+pub struct StaticInt {
+  outputs: Vec<Vec<(String, isize, isize)>>,
+  value: Option<i32>,
 }
 
-impl StaticInt{
-  pub fn new( node: Node ) -> Box<Self>{
+impl StaticInt {
+  pub fn new(node: Node) -> Box<Self> {
     let value = &node.statics[0].value;
 
     Box::new(Self {
-      value: if value.is_null(){ None } else { Some(value.as_i64().unwrap() as i32) },
-      outputs: node.outputs.iter()
-        .map(| x | {
-          x.connections.iter().map(| x | { ( x.node.clone(), x.index, x.value_type ) }).collect()
-        }).collect(),
+      value: if value.is_null() {
+        None
+      } else {
+        Some(value.as_i64().unwrap() as i32)
+      },
+      outputs: node
+        .outputs
+        .iter()
+        .map(|x| {
+          x.connections
+            .iter()
+            .map(|x| (x.node.clone(), x.index, x.value_type))
+            .collect()
+        })
+        .collect(),
     })
   }
 }
 
-impl RuntimeNode for StaticInt{
-  fn outputs( &self ) -> Vec<Vec<( String, isize, isize )>> {
+impl RuntimeNode for StaticInt {
+  fn outputs(&self) -> Vec<Vec<(String, isize, isize)>> {
     self.outputs.clone()
   }
 
-  fn execute_dry( &mut self, _: &Vec<ParameterType> ) -> Option<Vec<ParameterType>> {
-    if self.value.is_some(){
-      Some(vec![ ParameterType::Int(self.value.clone().unwrap()) ])
-    } else{
+  fn execute_dry(&mut self, _: &Vec<ParameterType>) -> Option<Vec<ParameterType>> {
+    if self.value.is_some() {
+      Some(vec![ParameterType::Int(self.value.clone().unwrap())])
+    } else {
       None
     }
   }
 
-  fn execute( &mut self ) -> Option<Vec<ParameterType>> { None }
+  fn execute(&mut self) -> Option<Vec<ParameterType>> {
+    None
+  }
 
-  fn update_arg( &mut self, _: usize, _: ParameterType ) -> bool { false }
-  fn is_entrypoint( &self ) -> bool { true }
-}
+  fn update_arg(&mut self, _: usize, _: ParameterType) -> bool {
+    false
+  }
+  fn is_entrypoint(&self) -> bool {
+    true
+  }
+}

src-tauri/src/runtime/nodes/statics/mod.rs

···
-pub mod string;
+pub mod float;
 pub mod int;
-pub mod float;
+pub mod string;

src-tauri/src/runtime/nodes/statics/string.rs

···
-use crate::{ runtime::nodes::RuntimeNode, structs::{ nodes::Node, parameter_types::ParameterType } };
+use crate::{
+  runtime::nodes::RuntimeNode,
+  structs::{nodes::Node, parameter_types::ParameterType},
+};
 
-pub struct StaticString{
-  outputs: Vec<Vec<( String, isize, isize )>>,
-  value: Option<String>
+pub struct StaticString {
+  outputs: Vec<Vec<(String, isize, isize)>>,
+  value: Option<String>,
 }
 
-impl StaticString{
-  pub fn new( node: Node ) -> Box<Self>{
+impl StaticString {
+  pub fn new(node: Node) -> Box<Self> {
     let value = &node.statics[0].value;
 
     Box::new(Self {
-      value: if value.is_null(){ None } else { Some(value.as_str().unwrap().to_owned()) },
-      outputs: node.outputs.iter()
-        .map(| x | {
-          x.connections.iter().map(| x | { ( x.node.clone(), x.index, x.value_type ) }).collect()
-        }).collect(),
+      value: if value.is_null() {
+        None
+      } else {
+        Some(value.as_str().unwrap().to_owned())
+      },
+      outputs: node
+        .outputs
+        .iter()
+        .map(|x| {
+          x.connections
+            .iter()
+            .map(|x| (x.node.clone(), x.index, x.value_type))
+            .collect()
+        })
+        .collect(),
     })
   }
 }
 
-impl RuntimeNode for StaticString{
-  fn outputs( &self ) -> Vec<Vec<( String, isize, isize )>> {
+impl RuntimeNode for StaticString {
+  fn outputs(&self) -> Vec<Vec<(String, isize, isize)>> {
     self.outputs.clone()
   }
 
-  fn execute_dry( &mut self, _: &Vec<ParameterType> ) -> Option<Vec<ParameterType>> {
-    if self.value.is_some(){
-      Some(vec![ ParameterType::String(self.value.clone().unwrap()) ])
-    } else{
+  fn execute_dry(&mut self, _: &Vec<ParameterType>) -> Option<Vec<ParameterType>> {
+    if self.value.is_some() {
+      Some(vec![ParameterType::String(self.value.clone().unwrap())])
+    } else {
       None
     }
   }
 
-  fn execute( &mut self ) -> Option<Vec<ParameterType>> { None }
+  fn execute(&mut self) -> Option<Vec<ParameterType>> {
+    None
+  }
 
-  fn update_arg( &mut self, _: usize, _: ParameterType ) -> bool { false }
-  fn is_entrypoint( &self ) -> bool { true }
-}
+  fn update_arg(&mut self, _: usize, _: ParameterType) -> bool {
+    false
+  }
+  fn is_entrypoint(&self) -> bool {
+    true
+  }
+}

src-tauri/src/setup.rs

···
-use std::{ collections::HashMap, fs::File, io::Read, sync::Mutex };
-use crossbeam_channel::{ Receiver, bounded };
+use crossbeam_channel::{bounded, Receiver};
+use std::{collections::HashMap, fs::File, io::Read, sync::Mutex};
 
 use flate2::read::GzDecoder;
-use serde_json::{ Map, Value };
-use tauri::{ App, Emitter, Listener, Manager, WindowEvent };
+use serde_json::{Map, Value};
+use tauri::{App, Emitter, Listener, Manager, WindowEvent};
 
-use crate::{ osc::{ self, OSCMessage }, runtime::{ commands::RuntimeCommand, nodes::RuntimeNodeTree, runtime, runtime_dry }, structs::parameter_types::ParameterType, utils::setup_traymenu::setup_traymenu };
+use crate::{
+  osc::{self, OSCMessage},
+  runtime::{commands::RuntimeCommand, nodes::RuntimeNodeTree, runtime, runtime_dry},
+  structs::parameter_types::ParameterType,
+  utils::setup_traymenu::setup_traymenu,
+};
 
 pub fn setup(
   app: &mut App,
   addresses: &'static Mutex<Vec<OSCMessage>>,
-  runtime_command_receiver: Receiver<RuntimeCommand>
+  runtime_command_receiver: Receiver<RuntimeCommand>,
 ) {
   let window = app.get_webview_window("main").unwrap();
   window.hide().unwrap();
 
   let win_handle = window.clone();
-  window.on_window_event(move | event | {
-    match event{
-      WindowEvent::CloseRequested { api, .. } => {
-        api.prevent_close();
+  window.on_window_event(move |event| match event {
+    WindowEvent::CloseRequested { api, .. } => {
+      api.prevent_close();
 
-        win_handle.hide().unwrap();
-        win_handle.emit("hide-window", ()).unwrap();
-      }
-      _ => {}
+      win_handle.hide().unwrap();
+      win_handle.emit("hide-window", ()).unwrap();
     }
+    _ => {}
   });
 
   setup_traymenu(app.handle());
···
     handle.emit("load_new_tab", Value::Object(map)).unwrap();
   });
 
-  let ( sender, receiver ) = bounded(1024);
+  let (sender, receiver) = bounded(1024);
 
   tokio::spawn(async move {
     osc::start_server(sender, "127.0.0.1:9001");
   });
 
-  let ( runtime_sender, runtime_receiver ) = bounded(1024);
+  let (runtime_sender, runtime_receiver) = bounded(1024);
 
   let runtime_sender_1 = runtime_sender.clone();
   tokio::spawn(async move {
···
 
       let msg = message.clone();
       let mut addrs = addresses.lock().unwrap();
-      if !addrs.contains(&msg) { addrs.push(msg); }
+      if !addrs.contains(&msg) {
+        addrs.push(msg);
+      }
 
-      runtime_sender.send(RuntimeCommand::OSCMessage(message)).unwrap();
+      runtime_sender
+        .send(RuntimeCommand::OSCMessage(message))
+        .unwrap();
     }
   });
 
···
     loop {
       let cmd = runtime_receiver.recv().unwrap();
 
-      match cmd{
-        RuntimeCommand::OSCMessage( msg ) => {
-          for ( _, mut tab ) in &mut tabs{
-            let keys: Vec<String> = tab.nodes.keys().map(| x | { x.clone() }).collect();
+      match cmd {
+        RuntimeCommand::OSCMessage(msg) => {
+          for (_, mut tab) in &mut tabs {
+            let keys: Vec<String> = tab.nodes.keys().map(|x| x.clone()).collect();
 
-            for id in keys.clone(){
+            for id in keys.clone() {
               let entry = tab.nodes[&id].is_entrypoint();
 
-              if entry{
+              if entry {
                 let args = vec![
-                  vec![ ParameterType::String(msg.address.clone()) ], msg.values.clone()
-                ].concat();
+                  vec![ParameterType::String(msg.address.clone())],
+                  msg.values.clone(),
+                ]
+                .concat();
 
                 runtime_dry(id.clone(), &args, &mut tab).unwrap();
               }
             }
 
-            for id in keys{
+            for id in keys {
               let entry = tab.nodes[&id].is_entrypoint();
 
-              if entry{
+              if entry {
                 let _ = runtime(id.clone(), &mut tab);
               }
             }
           }
-        },
+        }
 
-        RuntimeCommand::AddTab( graph, id ) => {
+        RuntimeCommand::AddTab(graph, id) => {
           tabs.insert(id, RuntimeNodeTree::from(graph));
-        },
-        RuntimeCommand::RemoveTab( id ) => {
+        }
+        RuntimeCommand::RemoveTab(id) => {
           tabs.remove(&id);
         }
       }
     }
   });
-}
+}

src-tauri/src/structs/mod.rs

···
+pub mod nodes;
 pub mod parameter_types;
-pub mod nodes;

src-tauri/src/structs/nodes.rs

···
-use serde::{ Deserialize, Serialize };
+use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Node{
+pub struct Node {
   pub id: String,
   pub name: String,
   pub outputs: Vec<NodeOutput>,
-  pub pos: [ f32; 2 ],
+  pub pos: [f32; 2],
   pub statics: Vec<NodeStatic>,
 
   #[serde(rename = "typeId")]
-  pub type_id: String
+  pub type_id: String,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct NodeStatic{
+pub struct NodeStatic {
   pub name: String,
 
   #[serde(rename = "type")]
   pub value_type: isize,
-  pub value: Value
+  pub value: Value,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct NodeOutput{
+pub struct NodeOutput {
   pub name: String,
 
   #[serde(rename = "type")]
   pub value_type: isize,
-  pub connections: Vec<NodeOutputConnections>
+  pub connections: Vec<NodeOutputConnections>,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct NodeOutputConnections{
+pub struct NodeOutputConnections {
   pub name: String,
   pub node: String,
   pub index: isize,
 
   #[serde(rename = "type")]
-  pub value_type: isize
-}
+  pub value_type: isize,
+}

src-tauri/src/structs/parameter_types.rs

···
-use anyhow::{ Result, bail };
+use anyhow::{bail, Result};
 use serde::Serialize;
 
 #[derive(Serialize, Clone, Debug, PartialEq)]
···
   String(String),
   Flow(bool),
 
-  None
+  None,
 }
 
-impl ParameterType{
-  pub fn as_bool( &self ) -> Result<bool>{
-    match self{
-      ParameterType::Boolean( val ) => Ok(val.clone()),
-      ParameterType::Int( val ) => if *val == 0{ Ok(false) } else { Ok(true) },
-      _ => bail!("Cannot cast to bool.")
+impl ParameterType {
+  pub fn as_bool(&self) -> Result<bool> {
+    match self {
+      ParameterType::Boolean(val) => Ok(val.clone()),
+      ParameterType::Int(val) => {
+        if *val == 0 {
+          Ok(false)
+        } else {
+          Ok(true)
+        }
+      }
+      _ => bail!("Cannot cast to bool."),
     }
   }
 
-  pub fn as_int( &self ) -> Result<i32>{
-    match self{
-      ParameterType::Boolean( val ) => if *val{ Ok(1) } else { Ok(0) },
-      ParameterType::Int( val ) => Ok(val.clone()),
-      ParameterType::Float( val ) => Ok(val.round().clone() as i32),
-      ParameterType::String( val ) => Ok(val.clone().parse()?),
-      _ => bail!("Cannot cast to int.")
+  pub fn as_int(&self) -> Result<i32> {
+    match self {
+      ParameterType::Boolean(val) => {
+        if *val {
+          Ok(1)
+        } else {
+          Ok(0)
+        }
+      }
+      ParameterType::Int(val) => Ok(val.clone()),
+      ParameterType::Float(val) => Ok(val.round().clone() as i32),
+      ParameterType::String(val) => Ok(val.clone().parse()?),
+      _ => bail!("Cannot cast to int."),
     }
   }
 
-  pub fn as_float( &self ) -> Result<f32>{
-    match self{
-      ParameterType::Int( val ) => Ok(val.clone() as f32),
-      ParameterType::Float( val ) => Ok(val.clone()),
-      ParameterType::String( val ) => Ok(val.clone().parse()?),
-      _ => bail!("Cannot cast to float.")
+  pub fn as_float(&self) -> Result<f32> {
+    match self {
+      ParameterType::Int(val) => Ok(val.clone() as f32),
+      ParameterType::Float(val) => Ok(val.clone()),
+      ParameterType::String(val) => Ok(val.clone().parse()?),
+      _ => bail!("Cannot cast to float."),
     }
   }
 
-  pub fn as_string( &self ) -> Result<String>{
-    match self{
-      ParameterType::Boolean( val ) => Ok(val.clone().to_string()),
-      ParameterType::Int( val ) => Ok(val.clone().to_string()),
-      ParameterType::Float( val ) => Ok(val.clone().to_string()),
-      ParameterType::String( val ) => Ok(val.clone()),
-      _ => bail!("Cannot cast to string.")
+  pub fn as_string(&self) -> Result<String> {
+    match self {
+      ParameterType::Boolean(val) => Ok(val.clone().to_string()),
+      ParameterType::Int(val) => Ok(val.clone().to_string()),
+      ParameterType::Float(val) => Ok(val.clone().to_string()),
+      ParameterType::String(val) => Ok(val.clone()),
+      _ => bail!("Cannot cast to string."),
     }
   }
-}
+}

src-tauri/src/utils/config.rs

···
-use std::{ collections::HashMap, fs::File, io::{ Read, Write }, path::PathBuf, sync::Mutex };
+use std::{
+  collections::HashMap,
+  fs::File,
+  io::{Read, Write},
+  path::PathBuf,
+  sync::Mutex,
+};
 
-use flate2::{ read::GzDecoder, write::GzEncoder, Compression };
-use serde::{ Deserialize, Serialize };
+use flate2::{read::GzDecoder, write::GzEncoder, Compression};
+use serde::{Deserialize, Serialize};
 
 use crate::structs::nodes::Node;
 
 #[derive(Clone, Serialize, Deserialize, Debug)]
-pub struct ConfigValues{
+pub struct ConfigValues {
   #[serde(default)]
-  pub loaded_tabs: HashMap<String, ( Vec<Node>, String, Option<String> )>,
+  pub loaded_tabs: HashMap<String, (Vec<Node>, String, Option<String>)>,
 
   #[serde(default)]
-  pub hide_editor_on_start: bool
+  pub hide_editor_on_start: bool,
 }
 
 pub struct Config {

src-tauri/src/utils/mod.rs

···
 pub mod config;
-pub mod setup_traymenu;
+pub mod setup_traymenu;

src-tauri/src/utils/setup_traymenu.rs

···
-use tauri::{ AppHandle, Emitter, Manager, menu::{ MenuBuilder, MenuItemBuilder }, tray::TrayIconBuilder };
+use tauri::{
+  menu::{MenuBuilder, MenuItemBuilder},
+  tray::TrayIconBuilder,
+  AppHandle, Emitter, Manager,
+};
 
-pub fn setup_traymenu( handle: &AppHandle ) {
+pub fn setup_traymenu(handle: &AppHandle) {
   // Setup the tray icon and menu buttons
   let quit = MenuItemBuilder::new("Quit")
     .id("quit")

src/App.tsx

···
 
 let App = () => {
   let [ selectedNodes, setSelectedNodes ] = createSignal<Node[]>([], { equals: false });
+  let [ mousePos, setMousePos ] = createSignal<[ number, number ]>([ 0, 0 ]);
 
   let canvas!: HTMLCanvasElement;
   let ctx: CanvasRenderingContext2D;
···
     }
 
     canvas.onmousemove = ( e ) => {
+      setMousePos([ e.clientX, e.clientY ]);
+
       if(e.shiftKey && isMouseDown){
         let nodes = NodeManager.Instance.GetNodes();
         let hoveredNode: Node | null = null;
···
       isMouseDown = false;
     }
 
-    keybinds.load(selectedNodes, setSelectedNodes);
+    keybinds.load(mousePos, selectedNodes, setSelectedNodes);
     requestAnimationFrame(update);
 
     let unlisten_0 = await listen('hide-window', () => {

src/keybinds.ts

···
 import { Accessor, Setter } from "solid-js";
 import { NodeManager } from "./Mangers/NodeManager";
 import { Node } from "./structs/node";
+import { readText, writeText } from "@tauri-apps/plugin-clipboard-manager";
+import { decodeNodeList, encodeNodeList } from "./utils/clipboard";
 
 let isKeyDown: any = {};
 
-export let load = ( selectedNode: Accessor<Node[]>, setSelectedNode: Setter<Node[]> ) => {
-  // TODO: Copy / paste
+export let load = ( mousePos: Accessor<[ number, number ]>, selectedNode: Accessor<Node[]>, setSelectedNode: Setter<Node[]> ) => {
   // TODO: Add undo / redo -ing
 
-  window.onkeydown = ( e ) => {
+  window.onkeydown = async ( e ) => {
     isKeyDown[e.key] = true;
-
-    console.log(e.key);
 
     switch(e.key){
       case 'Delete':
···
 
           // Save
           NodeManager.Instance.SaveTab(currentTab, true);
+        }
+        break;
+      case 'c':
+        if(e.ctrlKey){
+          let nodes = selectedNode();
+          await writeText(encodeNodeList(nodes, mousePos()));
+        }
+        break;
+      case 'v':
+        if(e.ctrlKey){
+          let text = await readText();
+
+          let nodes = await decodeNodeList(text, mousePos());
+          if(!nodes)return;
+
+          for(let node of nodes)
+            NodeManager.Instance.AddNode(node);
+
+          setSelectedNode(nodes);
         }
         break;
     }

src/utils/clipboard.ts

···
+import { NodeManager } from "../Mangers/NodeManager";
+import { NodesByID } from "../Nodes/Nodes";
+import { Node } from "../structs/node";
+
+export let encodeNodeList = ( selectedNodes: Node[], mousePos: [ number, number ] ): string => {
+  let arr: any[] = [];
+
+  for(let node of selectedNodes){
+    arr.push({
+      type_id: node.typeId,
+      statics: node.statics,
+      x: node.x - mousePos[0],
+      y: node.y - mousePos[1]
+    })
+  }
+
+  return 'VRCMACRO' + btoa(JSON.stringify(arr));
+}
+
+export let decodeNodeList = async ( text: string, mousePos: [ number, number ] ): Promise<Node[] | null> => {
+  if(!text.startsWith("VRCMACRO"))return null;
+
+  let data = text.slice(8);
+  let json = JSON.parse(atob(data));
+
+  let nodes: Node[] = [];
+  for(let node of json){
+    let n = new Node(
+      [ node.x + mousePos[0] + 10, node.y + mousePos[1] + 10 ],
+      NodesByID[node.type_id],
+      await NodeManager.Instance.GetNewNodeId()
+    );
+
+    n.statics = node.statics;
+    await n.onStaticsUpdate(n);
+
+    nodes.push(n);
+  }
+
+  return nodes;
+}