buh

package.json

···
   "license": "MIT",
   "dependencies": {
     "@tauri-apps/api": "^2",
+    "@tauri-apps/plugin-dialog": "~2",
     "@tauri-apps/plugin-opener": "^2",
     "animejs": "^4.1.2",
     "solid-js": "^1.9.3"

pnpm-lock.yaml

···
       '@tauri-apps/api':
         specifier: ^2
         version: 2.7.0
+      '@tauri-apps/plugin-dialog':
+        specifier: ~2
+        version: 2.4.0
       '@tauri-apps/plugin-opener':
         specifier: ^2
         version: 2.4.0
···
   '@tauri-apps/api@2.7.0':
     resolution: {integrity: sha512-v7fVE8jqBl8xJFOcBafDzXFc8FnicoH3j8o8DNNs0tHuEBmXUDqrCOAzMRX0UkfpwqZLqvrvK0GNQ45DfnoVDg==}
 
+  '@tauri-apps/api@2.8.0':
+    resolution: {integrity: sha512-ga7zdhbS2GXOMTIZRT0mYjKJtR9fivsXzsyq5U3vjDL0s6DTMwYRm0UHNjzTY5dh4+LSC68Sm/7WEiimbQNYlw==}
+
   '@tauri-apps/cli-darwin-arm64@2.7.1':
     resolution: {integrity: sha512-j2NXQN6+08G03xYiyKDKqbCV2Txt+hUKg0a8hYr92AmoCU8fgCjHyva/p16lGFGUG3P2Yu0xiNe1hXL9ZuRMzA==}
     engines: {node: '>= 10'}
···
     resolution: {integrity: sha512-RcGWR4jOUEl92w3uvI0h61Llkfj9lwGD1iwvDRD2isMrDhOzjeeeVn9aGzeW1jubQ/kAbMYfydcA4BA0Cy733Q==}
     engines: {node: '>= 10'}
     hasBin: true
+
+  '@tauri-apps/plugin-dialog@2.4.0':
+    resolution: {integrity: sha512-OvXkrEBfWwtd8tzVCEXIvRfNEX87qs2jv6SqmVPiHcJjBhSF/GUvjqUNIDmKByb5N8nvDqVUM7+g1sXwdC/S9w==}
 
   '@tauri-apps/plugin-opener@2.4.0':
     resolution: {integrity: sha512-43VyN8JJtvKWJY72WI/KNZszTpDpzHULFxQs0CJBIYUdCRowQ6Q1feWTDb979N7nldqSuDOaBupZ6wz2nvuWwQ==}
···
 
   '@tauri-apps/api@2.7.0': {}
 
+  '@tauri-apps/api@2.8.0': {}
+
   '@tauri-apps/cli-darwin-arm64@2.7.1':
     optional: true
 
···
       '@tauri-apps/cli-win32-arm64-msvc': 2.7.1
       '@tauri-apps/cli-win32-ia32-msvc': 2.7.1
       '@tauri-apps/cli-win32-x64-msvc': 2.7.1
+
+  '@tauri-apps/plugin-dialog@2.4.0':
+    dependencies:
+      '@tauri-apps/api': 2.8.0
 
   '@tauri-apps/plugin-opener@2.4.0':
     dependencies:

public/assets/icons/floppy-disk-solid-full.svg

···
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640"><!--!Font Awesome Free 7.1.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2025 Fonticons, Inc.--><path fill="#fff" d="M160 96C124.7 96 96 124.7 96 160L96 480C96 515.3 124.7 544 160 544L480 544C515.3 544 544 515.3 544 480L544 237.3C544 220.3 537.3 204 525.3 192L448 114.7C436 102.7 419.7 96 402.7 96L160 96zM192 192C192 174.3 206.3 160 224 160L384 160C401.7 160 416 174.3 416 192L416 256C416 273.7 401.7 288 384 288L224 288C206.3 288 192 273.7 192 256L192 192zM320 352C355.3 352 384 380.7 384 416C384 451.3 355.3 480 320 480C284.7 480 256 451.3 256 416C256 380.7 284.7 352 320 352z"/></svg>

src-tauri/Cargo.lock

···
  "serde_json",
  "tauri",
  "tauri-build",
+ "tauri-plugin-dialog",
  "tauri-plugin-opener",
  "tokio",
 ]
···
 version = "1.0.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b0674a1ddeecb70197781e945de4b3b8ffb61fa939a5597bcf48503737663100"
+
+[[package]]
+name = "ashpd"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6cbdf310d77fd3aaee6ea2093db7011dc2d35d2eb3481e5607f1f8d942ed99df"
+dependencies = [
+ "enumflags2",
+ "futures-channel",
+ "futures-util",
+ "rand 0.9.2",
+ "raw-window-handle",
+ "serde",
+ "serde_repr",
+ "tokio",
+ "url",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "zbus",
+]
 
 [[package]]
 name = "async-broadcast"
···
 checksum = "89a09f22a6c6069a18470eb92d2298acf25463f14256d24778e1230d789a2aec"
 dependencies = [
  "bitflags 2.9.1",
+ "block2 0.6.1",
+ "libc",
  "objc2 0.6.1",
 ]
 
···
 ]
 
 [[package]]
+name = "dlib"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "330c60081dcc4c72131f8eb70510f1ac07223e5d4163db481a04a0befcffa412"
+dependencies = [
+ "libloading",
+]
+
+[[package]]
 name = "dlopen2"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "quote",
  "syn 2.0.104",
 ]
+
+[[package]]
+name = "downcast-rs"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2"
 
 [[package]]
 name = "dpi"
···
 dependencies = [
  "base64 0.22.1",
  "indexmap 2.10.0",
- "quick-xml",
+ "quick-xml 0.38.0",
  "serde",
  "time",
 ]
···
 
 [[package]]
 name = "quick-xml"
+version = "0.37.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "331e97a1af0bf59823e6eadffe373d7b27f485be8748f71471c662c1f269b7fb"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "quick-xml"
 version = "0.38.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8927b0664f5c5a98265138b7e3f90aa19a6b21353182469ace36d4ac527b7b1b"
···
 ]
 
 [[package]]
+name = "rand"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.3",
+]
+
+[[package]]
 name = "rand_chacha"
 version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.3",
+]
+
+[[package]]
 name = "rand_core"
 version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "rand_core"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
+dependencies = [
+ "getrandom 0.3.3",
+]
+
+[[package]]
 name = "rand_hc"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "rfd"
+version = "0.15.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef2bee61e6cffa4635c72d7d81a84294e28f0930db0ddcb0f66d10244674ebed"
+dependencies = [
+ "ashpd",
+ "block2 0.6.1",
+ "dispatch2",
+ "glib-sys",
+ "gobject-sys",
+ "gtk-sys",
+ "js-sys",
+ "log",
+ "objc2 0.6.1",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation 0.3.1",
+ "raw-window-handle",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
 name = "rustc-demangle"
 version = "0.1.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "scoped-tls"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
+
+[[package]]
 name = "scopeguard"
 version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "tauri-plugin-dialog"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37e5858cc7b455a73ab4ea2ebc08b5be33682c00ff1bf4cad5537d4fb62499d9"
+dependencies = [
+ "log",
+ "raw-window-handle",
+ "rfd",
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-plugin",
+ "tauri-plugin-fs",
+ "thiserror 2.0.12",
+ "url",
+]
+
+[[package]]
+name = "tauri-plugin-fs"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c6ef84ee2f2094ce093e55106d90d763ba343fad57566992962e8f76d113f99"
+dependencies = [
+ "anyhow",
+ "dunce",
+ "glob",
+ "percent-encoding",
+ "schemars 0.8.22",
+ "serde",
+ "serde_json",
+ "serde_repr",
+ "tauri",
+ "tauri-plugin",
+ "tauri-utils",
+ "thiserror 2.0.12",
+ "toml 0.8.23",
+ "url",
+]
+
+[[package]]
 name = "tauri-plugin-opener"
 version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "libc",
  "mio",
  "pin-project-lite",
+ "signal-hook-registry",
  "slab",
  "socket2",
  "tokio-macros",
+ "tracing",
  "windows-sys 0.59.0",
 ]
 
···
 ]
 
 [[package]]
+name = "wayland-backend"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "673a33c33048a5ade91a6b139580fa174e19fb0d23f396dca9fa15f2e1e49b35"
+dependencies = [
+ "cc",
+ "downcast-rs",
+ "rustix",
+ "scoped-tls",
+ "smallvec",
+ "wayland-sys",
+]
+
+[[package]]
+name = "wayland-client"
+version = "0.31.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c66a47e840dc20793f2264eb4b3e4ecb4b75d91c0dd4af04b456128e0bdd449d"
+dependencies = [
+ "bitflags 2.9.1",
+ "rustix",
+ "wayland-backend",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-protocols"
+version = "0.32.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "efa790ed75fbfd71283bd2521a1cfdc022aabcc28bdcff00851f9e4ae88d9901"
+dependencies = [
+ "bitflags 2.9.1",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-scanner"
+version = "0.31.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54cb1e9dc49da91950bdfd8b848c49330536d9d1fb03d4bfec8cae50caa50ae3"
+dependencies = [
+ "proc-macro2",
+ "quick-xml 0.37.5",
+ "quote",
+]
+
+[[package]]
+name = "wayland-sys"
+version = "0.31.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34949b42822155826b41db8e5d0c1be3a2bd296c747577a43a3e6daefc296142"
+dependencies = [
+ "dlib",
+ "log",
+ "pkg-config",
+]
+
+[[package]]
 name = "web-sys"
 version = "0.3.77"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "ordered-stream",
  "serde",
  "serde_repr",
+ "tokio",
  "tracing",
  "uds_windows",
  "windows-sys 0.59.0",
···
  "endi",
  "enumflags2",
  "serde",
+ "url",
  "winnow 0.7.12",
  "zvariant_derive",
  "zvariant_utils",

src-tauri/Cargo.toml

···
 dirs = "6.0.0"
 anyhow = "1.0.99"
 flate2 = "1.1.2"
+tauri-plugin-dialog = "2"
 

src-tauri/capabilities/default.json

···
   "$schema": "../gen/schemas/desktop-schema.json",
   "identifier": "default",
   "description": "Capability for the main window",
-  "windows": ["main"],
+  "windows": [
+    "main"
+  ],
   "permissions": [
     "core:default",
-    "opener:default"
+    "opener:default",
+    "dialog:default"
   ]
-}
+}

src-tauri/src/frontend_calls/get_addresses.rs

···
 use crate::osc::OSCMessage;
 
 #[tauri::command]
-pub fn get_addresses( addresses: State<&Mutex<Vec<OSCMessage>>> ) -> Vec<OSCMessage> {
-  let addresses = addresses.lock().unwrap();
-  addresses.clone()
-}
+pub fn get_addresses(addresses: State<&Mutex<Vec<OSCMessage>>>) -> Vec<OSCMessage> {
+    let addresses = addresses.lock().unwrap();
+    addresses.clone()
+}

src-tauri/src/frontend_calls/mod.rs

···
 pub mod get_addresses;
-pub mod save_graph;
+pub mod save_graph;

src-tauri/src/frontend_calls/save_graph.rs

···
-use std::{ fs::File, io::Write };
+use std::{fs::File, io::Write};
 
-use flate2::{ write::GzEncoder, Compression };
+use flate2::{write::GzEncoder, Compression};
 
 #[tauri::command]
-pub fn save_graph( tab_name: String, graph: String ) {
-  dbg!(&graph);
+pub fn save_graph(tab_name: String, graph: String) {
+    dbg!(&graph);
 
-  let path = dirs::config_dir().unwrap().join("VRCMacros").join(format!("{}.macro", tab_name));
+    let path = dirs::config_dir()
+        .unwrap()
+        .join("VRCMacros")
+        .join(format!("{}.macro", tab_name));
 
-  let file = File::create(&path).unwrap();
-  let mut encoder = GzEncoder::new(file, Compression::default());
+    let file = File::create(&path).unwrap();
+    let mut encoder = GzEncoder::new(file, Compression::default());
 
-  encoder.write_all(graph.as_bytes()).unwrap();
-  encoder.finish().unwrap();
-}
+    encoder.write_all(graph.as_bytes()).unwrap();
+    encoder.finish().unwrap();
+}

src-tauri/src/lib.rs

···
-use std::{ fs, sync::Mutex };
+use std::{fs, sync::Mutex};
 
 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 structs;
+mod osc;
 mod setup;
+mod structs;
 mod utils;
-mod osc;
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 #[tokio::main]
 pub async fn run() {
-  let container_folder = dirs::config_dir().unwrap().join("VRCMacros");
+    let container_folder = dirs::config_dir().unwrap().join("VRCMacros");
 
-  match fs ::metadata(&container_folder){
-    Ok(meta) => {
-      if meta.is_file(){
-        panic!("document.write('Cannot launch app as the container path is a file not a directory')");
-      }
-    }
-    Err(_) => {
-      fs::create_dir(&container_folder).unwrap();
+    match fs::metadata(&container_folder) {
+        Ok(meta) => {
+            if meta.is_file() {
+                panic!("document.write('Cannot launch app as the container path is a file not a directory')");
+            }
+        }
+        Err(_) => {
+            fs::create_dir(&container_folder).unwrap();
+        }
     }
-  }
 
-  let conf_file = container_folder.join("conf");
-  let conf = Config::new(conf_file);
-
-  static ADDRESSES: Mutex<Vec<OSCMessage>> = Mutex::new(Vec::new());
+    let conf_file = container_folder.join("conf");
+    let conf = Config::new(conf_file);
 
-  tauri::Builder::default()
-    .plugin(tauri_plugin_opener::init())
-    .invoke_handler(tauri::generate_handler![
-      get_addresses::get_addresses,
+    static ADDRESSES: Mutex<Vec<OSCMessage>> = Mutex::new(Vec::new());
 
-      save_graph::save_graph
-    ])
-    .manage(conf)
-    .manage(&ADDRESSES)
-    .setup(| app | {
-      setup(app, &ADDRESSES);
-      Ok(())
-    })
-    .run(tauri::generate_context!())
-    .expect("error while running tauri application");
-}
+    tauri::Builder::default()
+        .plugin(tauri_plugin_dialog::init())
+        .plugin(tauri_plugin_opener::init())
+        .invoke_handler(tauri::generate_handler![
+            get_addresses::get_addresses,
+            save_graph::save_graph
+        ])
+        .manage(conf)
+        .manage(&ADDRESSES)
+        .setup(|app| {
+            setup(app, &ADDRESSES);
+            Ok(())
+        })
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}

src-tauri/src/main.rs

···
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
 fn main() {
-  #[cfg(target_os = "linux")]
-  std::env::set_var("WEBKIT_DISABLE_DMABUF_RENDERER", "1"); // Fix webkit being shit
+    #[cfg(target_os = "linux")]
+    std::env::set_var("WEBKIT_DISABLE_DMABUF_RENDERER", "1"); // Fix webkit being shit
 
-  vrcmacros_lib::run()
+    vrcmacros_lib::run()
 }

src-tauri/src/osc.rs

···
 // https://gist.github.com/phaze-the-dumb/634daacb5141eae2f846e20987dba7a8
 
-use std::{ net::UdpSocket, sync::mpsc::Sender };
+use std::{net::UdpSocket, sync::mpsc::Sender};
 
 use serde::Serialize;
 
 use crate::structs::parameter_types::ParameterType;
 
 #[derive(Debug, Clone, Serialize)]
-pub struct OSCMessage{
-  pub address: String,
-  pub values: Vec<ParameterType>
+pub struct OSCMessage {
+    pub address: String,
+    pub values: Vec<ParameterType>,
 }
 
-impl PartialEq for OSCMessage{
-  // Technically this isn't exactly equal, but the only time i'm checking if OSCMessage's are equal
-  // Is when i'm checking for the "address" value
+impl PartialEq for OSCMessage {
+    // Technically this isn't exactly equal, but the only time i'm checking if OSCMessage's are equal
+    // Is when i'm checking for the "address" value
 
-  fn eq(&self, other: &Self) -> bool {
-    self.address == other.address
-  }
+    fn eq(&self, other: &Self) -> bool {
+        self.address == other.address
+    }
 
-  fn ne(&self, other: &Self) -> bool {
-    self.address != other.address
-  }
+    fn ne(&self, other: &Self) -> bool {
+        self.address != other.address
+    }
 }
 
 // TODO: Implement osc bundles
-pub fn start_server( sender: Sender<OSCMessage>, addr: &str ) {
-  let socket = UdpSocket::bind(addr).unwrap();
+pub fn start_server(sender: Sender<OSCMessage>, addr: &str) {
+    let socket = UdpSocket::bind(addr).unwrap();
 
-  loop {
-    let mut buf = [0; 1024];
-    let (amt, _src) = socket.recv_from(&mut buf).unwrap();
+    loop {
+        let mut buf = [0; 1024];
+        let (amt, _src) = socket.recv_from(&mut buf).unwrap();
 
-    let buf = &mut buf[..amt];
-    if buf[0] != 0x2F { panic!("Packet is not an OSC Message"); }
+        let buf = &mut buf[..amt];
+        if buf[0] != 0x2F {
+            panic!("Packet is not an OSC Message");
+        }
 
-    let mut addr: Vec<u8> = Vec::new();
-    let mut value_start = 0;
+        let mut addr: Vec<u8> = Vec::new();
+        let mut value_start = 0;
 
-    loop{
-      let byte = buf[value_start];
-      if byte == 0x00{ break; }
+        loop {
+            let byte = buf[value_start];
+            if byte == 0x00 {
+                break;
+            }
 
-      value_start += 1;
-      addr.push(byte);
-    }
+            value_start += 1;
+            addr.push(byte);
+        }
 
-    loop{
-      let byte = buf[value_start];
-      value_start += 1;
+        loop {
+            let byte = buf[value_start];
+            value_start += 1;
 
-      if byte == 0x2C{ break; }
-    }
+            if byte == 0x2C {
+                break;
+            }
+        }
 
-    let mut types: Vec<u8> = Vec::new();
+        let mut types: Vec<u8> = Vec::new();
 
-    loop{
-      let byte = buf[value_start];
-      if byte == 0x00{ break; }
+        loop {
+            let byte = buf[value_start];
+            if byte == 0x00 {
+                break;
+            }
 
-      types.push(byte);
-      value_start += 1;
-    }
+            types.push(byte);
+            value_start += 1;
+        }
 
-    value_start = ((value_start as f32 / 4.0).ceil() * 4.0) as usize;
-    let mut values = Vec::new();
+        value_start = ((value_start as f32 / 4.0).ceil() * 4.0) as usize;
+        let mut values = Vec::new();
 
-    for tp in types{
-      match tp{
-        0x69 => {
-          let val_buf = &buf[value_start..value_start + 4];
+        for tp in types {
+            match tp {
+                0x69 => {
+                    let val_buf = &buf[value_start..value_start + 4];
 
-          let bytes = <&[u8; 4]>::try_from(val_buf).unwrap().clone();
-          let int = i32::from_be_bytes(bytes);
+                    let bytes = <&[u8; 4]>::try_from(val_buf).unwrap().clone();
+                    let int = i32::from_be_bytes(bytes);
 
-          values.push(ParameterType::Int(int));
-          value_start += 4;
-        },
-        0x66 => {
-          let val_buf = &buf[value_start..value_start + 4];
+                    values.push(ParameterType::Int(int));
+                    value_start += 4;
+                }
+                0x66 => {
+                    let val_buf = &buf[value_start..value_start + 4];
 
-          let bytes = <&[u8; 4]>::try_from(val_buf).unwrap().clone();
-          let float = f32::from_be_bytes(bytes);
+                    let bytes = <&[u8; 4]>::try_from(val_buf).unwrap().clone();
+                    let float = f32::from_be_bytes(bytes);
 
-          values.push(ParameterType::Float(float));
-          value_start += 4;
-        },
-        0x54 => values.push(ParameterType::Boolean(true)),
-        0x46 => values.push(ParameterType::Boolean(false)),
-        _ => {}
-      }
-    }
+                    values.push(ParameterType::Float(float));
+                    value_start += 4;
+                }
+                0x54 => values.push(ParameterType::Boolean(true)),
+                0x46 => values.push(ParameterType::Boolean(false)),
+                _ => {}
+            }
+        }
 
-    let message = OSCMessage {
-      address: String::from_utf8(addr.clone()).unwrap(),
-      values: values
-    };
+        let message = OSCMessage {
+            address: String::from_utf8(addr.clone()).unwrap(),
+            values: values,
+        };
 
-    sender.send(message).unwrap();
-  }
+        sender.send(message).unwrap();
+    }
 }
 
-pub fn send_message( address: &str, values: Vec<ParameterType>, ip_addr: &str ){
-  let socket = UdpSocket::bind("127.0.0.1:0").unwrap();
-  let mut buf: Vec<u8> = Vec::new();
+pub fn send_message(address: &str, values: Vec<ParameterType>, ip_addr: &str) {
+    let socket = UdpSocket::bind("127.0.0.1:0").unwrap();
+    let mut buf: Vec<u8> = Vec::new();
 
-  buf.append(&mut address.as_bytes().to_vec());
+    buf.append(&mut address.as_bytes().to_vec());
 
-  let rounded_len = ((((buf.len() as f64) + 1.0) / 4.0).ceil() * 4.0) as usize;
-  let original_len = buf.len();
+    let rounded_len = ((((buf.len() as f64) + 1.0) / 4.0).ceil() * 4.0) as usize;
+    let original_len = buf.len();
 
-  for _i in original_len..rounded_len {
-    buf.push(0);
-  }
+    for _i in original_len..rounded_len {
+        buf.push(0);
+    }
 
-  buf.push(0x2C);
+    buf.push(0x2C);
 
-  let mut value_count = 1;
-  for value in values.clone() {
-    match value {
-      ParameterType::Boolean( val ) => buf.push(if val { 0x54 } else { 0x46 }),
-      ParameterType::Float(_) => buf.push(0x66),
-      ParameterType::Int(_) => buf.push(0x69),
-      ParameterType::String(_) => buf.push(0x73),
-      _ => {}
-    };
+    let mut value_count = 1;
+    for value in values.clone() {
+        match value {
+            ParameterType::Boolean(val) => buf.push(if val { 0x54 } else { 0x46 }),
+            ParameterType::Float(_) => buf.push(0x66),
+            ParameterType::Int(_) => buf.push(0x69),
+            ParameterType::String(_) => buf.push(0x73),
+            _ => {}
+        };
 
-    value_count += 1;
-  }
+        value_count += 1;
+    }
 
-  for _i in 0..4 - (value_count  % 4) {
-    buf.push(0);
-  }
+    for _i in 0..4 - (value_count % 4) {
+        buf.push(0);
+    }
 
-  for value in values{
-    match value{
-      ParameterType::Float( val ) => buf.append(&mut val.to_be_bytes().to_vec()),
-      ParameterType::Int( val ) => buf.append(&mut val.to_be_bytes().to_vec()),
-      ParameterType::String( val ) => {
-        let mut str_buf = val.as_bytes().to_vec();
-        let buf_len = str_buf.len().clone();
+    for value in values {
+        match value {
+            ParameterType::Float(val) => buf.append(&mut val.to_be_bytes().to_vec()),
+            ParameterType::Int(val) => buf.append(&mut val.to_be_bytes().to_vec()),
+            ParameterType::String(val) => {
+                let mut str_buf = val.as_bytes().to_vec();
+                let buf_len = str_buf.len().clone();
 
-        buf.append(&mut str_buf);
+                buf.append(&mut str_buf);
 
-        for _i in 0..4 - (buf_len  % 4) {
-          buf.push(0);
+                for _i in 0..4 - (buf_len % 4) {
+                    buf.push(0);
+                }
+            }
+            _ => {}
         }
-      }
-      _ => {}
     }
-  }
 
-  println!("{:X?}", &buf);
-  socket.send_to(&buf, ip_addr).unwrap();
-}
+    println!("{:X?}", &buf);
+    socket.send_to(&buf, ip_addr).unwrap();
+}

src-tauri/src/setup.rs

···
-use std::{ fs::File, io::Read, sync::{ self, Mutex } };
+use std::{
+    fs::File,
+    io::Read,
+    sync::{self, Mutex},
+};
 
 use flate2::read::GzDecoder;
 use serde_json::Value;
-use tauri::{ App, Emitter, Listener, Manager };
+use tauri::{App, Emitter, Listener, Manager};
 
-use crate::osc::{ self, OSCMessage };
+use crate::osc::{self, OSCMessage};
 
-pub fn setup( app: &mut App, addresses: &'static Mutex<Vec<OSCMessage>> ){
-  let window = app.get_webview_window("main").unwrap();
+pub fn setup(app: &mut App, addresses: &'static Mutex<Vec<OSCMessage>>) {
+    let window = app.get_webview_window("main").unwrap();
 
-  let handle = window.clone();
-  window.listen("tauri://drag-drop", move | ev | {
-    let path: Value = serde_json::from_str(ev.payload()).unwrap();
-    let path = path["paths"][0].as_str().unwrap();
+    let handle = window.clone();
+    window.listen("tauri://drag-drop", move |ev| {
+        let path: Value = serde_json::from_str(ev.payload()).unwrap();
+        let path = path["paths"][0].as_str().unwrap();
 
-    let file = File::open(path).unwrap();
-    let mut decoder = GzDecoder::new(file);
-    let mut string = String::new();
+        let file = File::open(path).unwrap();
+        let mut decoder = GzDecoder::new(file);
+        let mut string = String::new();
 
-    decoder.read_to_string(&mut string).unwrap();
+        decoder.read_to_string(&mut string).unwrap();
 
-    handle.emit("load_new_tab", Value::String(string)).unwrap();
-  });
+        handle.emit("load_new_tab", Value::String(string)).unwrap();
+    });
 
-  let ( sender, receiver ) = sync::mpsc::channel();
+    let (sender, receiver) = sync::mpsc::channel();
 
-  tokio::spawn(async move {
-    osc::start_server(sender, "127.0.0.1:9001");
-  });
+    tokio::spawn(async move {
+        osc::start_server(sender, "127.0.0.1:9001");
+    });
 
-  tokio::spawn(async move {
-    loop {
-      let message = receiver.recv().unwrap();
+    tokio::spawn(async move {
+        loop {
+            let message = receiver.recv().unwrap();
 
-      window.emit("osc-message", &message).unwrap();
+            window.emit("osc-message", &message).unwrap();
 
-      let msg = message.clone();
-      let mut addresses = addresses.lock().unwrap();
-      if !addresses.contains(&msg){ addresses.push(msg); }
-    }
-  });
-}
+            let msg = message.clone();
+            let mut addresses = addresses.lock().unwrap();
+            if !addresses.contains(&msg) {
+                addresses.push(msg);
+            }
+        }
+    });
+}

src-tauri/src/structs/mod.rs

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

src-tauri/src/structs/parameter_types.rs

···
 
 #[derive(Serialize, Clone, Debug)]
 #[serde(tag = "key", content = "value")]
-pub enum ParameterType{
-  AnyType(String),
-  Label(&'static str),
+pub enum ParameterType {
+    AnyType(String),
+    Label(&'static str),
 
-  Int(i32),
-  Float(f32),
-  Boolean(bool),
-  String(String),
-}
+    Int(i32),
+    Float(f32),
+    Boolean(bool),
+    String(String),
+}

src-tauri/src/utils/config.rs

···
-use std::{ collections::HashMap, fs::File, io::{ Read, Write }, path::PathBuf, sync::Mutex };
-
-use flate2::{ read::GzDecoder, write::GzEncoder, Compression };
-use serde_json::Value;
-
-pub struct Config{
-  store: Mutex<HashMap<String, Value>>,
-  path: PathBuf
-}
-
-impl Config{
-  pub fn new( path: PathBuf ) -> Self{
-    let json_string = if path.exists(){
-      let mut decoder = GzDecoder::new(File::open(&path).unwrap());
-      let mut string = String::new();
-
-      decoder.read_to_string(&mut string).unwrap();
-      string
-    } else{
-      "{}".into()
-    };
-
-    let json: Value = serde_json::from_str(&json_string).unwrap();
-
-    let mut hashmap = HashMap::new();
-
-    let obj = json.as_object().unwrap();
-    for ( key, val ) in obj{
-      hashmap.insert(key.clone(), val.clone());
-    }
-
-    Config {
-      store: Mutex::new(hashmap),
-      path: path
-    }
-  }
-
-  pub fn set( &self, key: &str, value: Value ){
-    self.store.lock().unwrap().insert(key.to_owned(), value);
-  }
-
-  pub fn get( &self, key: &str ) -> Option<Value>{
-    let store = self.store.lock().unwrap();
-    let val = store.get(&key.to_owned());
-
-    if val.is_none(){
-      None
-    } else{
-      Some(val.unwrap().clone())
-    }
-  }
-
-  pub fn save( &self ){
-    let dat = serde_json::to_string(&self.store.lock().unwrap().clone()).unwrap();
-    dbg!(&dat);
-
-    let file = File::create(&self.path).unwrap();
-    let mut encoder = GzEncoder::new(file, Compression::default());
-
-    encoder.write_all(dat.as_bytes()).unwrap();
-    encoder.finish().unwrap();
-  }
-}
+use std::{
+    collections::HashMap,
+    fs::File,
+    io::{Read, Write},
+    path::PathBuf,
+    sync::Mutex,
+};
+
+use flate2::{read::GzDecoder, write::GzEncoder, Compression};
+use serde_json::Value;
+
+pub struct Config {
+    store: Mutex<HashMap<String, Value>>,
+    path: PathBuf,
+}
+
+impl Config {
+    pub fn new(path: PathBuf) -> Self {
+        let json_string = if path.exists() {
+            let mut decoder = GzDecoder::new(File::open(&path).unwrap());
+            let mut string = String::new();
+
+            decoder.read_to_string(&mut string).unwrap();
+            string
+        } else {
+            "{}".into()
+        };
+
+        let json: Value = serde_json::from_str(&json_string).unwrap();
+
+        let mut hashmap = HashMap::new();
+
+        let obj = json.as_object().unwrap();
+        for (key, val) in obj {
+            hashmap.insert(key.clone(), val.clone());
+        }
+
+        Config {
+            store: Mutex::new(hashmap),
+            path: path,
+        }
+    }
+
+    pub fn set(&self, key: &str, value: Value) {
+        self.store.lock().unwrap().insert(key.to_owned(), value);
+    }
+
+    pub fn get(&self, key: &str) -> Option<Value> {
+        let store = self.store.lock().unwrap();
+        let val = store.get(&key.to_owned());
+
+        if val.is_none() {
+            None
+        } else {
+            Some(val.unwrap().clone())
+        }
+    }
+
+    pub fn save(&self) {
+        let dat = serde_json::to_string(&self.store.lock().unwrap().clone()).unwrap();
+        dbg!(&dat);
+
+        let file = File::create(&self.path).unwrap();
+        let mut encoder = GzEncoder::new(file, Compression::default());
+
+        encoder.write_all(dat.as_bytes()).unwrap();
+        encoder.finish().unwrap();
+    }
+}

src-tauri/src/utils/mod.rs

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

src/Mangers/NodeManager.tsx

···
 import { listen } from "@tauri-apps/api/event";
 import { getVersion } from "@tauri-apps/api/app";
 import { NodesByID } from "../Nodes/Nodes";
+import { save } from "@tauri-apps/plugin-dialog";
 
 export interface TabHashMap {
   [details: string] : Tab;
···
   private _tabs: TabHashMap = {};
 
   private _nodes: Node[] = [];
-  private _needsSave = false;
 
   constructor(){
     NodeManager.Instance = this;
 
-    setInterval(() => {
-      // Save config every 1 second
-      if(this._needsSave)this._saveConfigToDisk();
-    }, 1_000);
-
     listen('load_new_tab', ( ev: any ) => {
       this._loadFromConfig(ev.payload);
     })
···
 
   public async AddTab( name: string ){
     let [ selected, setSelected ] = createSignal(false);
+    let [ needsSave, setNeedsSave ] = createSignal(false);
 
     let tab: Tab = {
       name: name,
       id: await NodeManager.Instance.GetNewNodeId(),
       nodes: [],
-      selected: selected,
-      setSelected: setSelected
+
+      selected,
+      setSelected,
+
+      needsSave,
+      setNeedsSave
     };
 
     this._tabs[tab.id] = tab;
···
     }
   }
 
+  public async SaveTab( tab: Tab ){
+    let path = await save({ defaultPath: tab.name + '.macro', filters: [ { name: 'Macro Files', extensions: [ 'macro' ] } ] });
+
+    console.log(path);
+
+    // TODO: Add location metadata to tab interface so it knows where to save
+    // TODO: store file
+  }
+
   public HookTabUpdate( cb: ( tabs: TabHashMap ) => void ){
     this._tabUpdateHook = cb;
   }
···
 
 
   public UpdateConfig(){
-    this._needsSave = true;
+    if(!this._selectedTab)return;
+    let tab = this._tabs[this._selectedTab];
+    if(!tab)return;
+
+    tab.setNeedsSave(true);
   }
 
   private async _loadFromConfig( config: string ){
···
   }
 
   private async _saveConfigToDisk(){
-    this._needsSave = false;
     // Convert it into a structure we can actually save...
 
     if(!this._selectedTab)return;

src/components/TabMenu.css

···
 }
 
 .tab-new-dropdown{
-  opacity: 0;
   position: absolute;
   width: 180px;
   transform: translate(-10px, 35px);
   border-radius: 10px;
   background: #fff1;
-  transition: 0.1s;
 }

src/components/TabMenu.tsx

···
-import { createSignal, For, onMount } from 'solid-js';
+import { createSignal, For, onMount, Show } from 'solid-js';
 import './TabMenu.css';
 import { NodeManager } from '../Mangers/NodeManager';
 import { Tab } from '../structs/Tab';
···
       <For each={Object.values(tabs())}>
         {
           tab =>
-          <div class={ tab.selected() ? 'tab-selected ' : 'tab' }>
-            <div class="tab-icon" onClick={() => {
-              NodeManager.Instance.SelectTab(tab.id);
-            }}><img src="/assets/icons/pen-to-square-regular-full.svg" width="15" /></div>
-            <div class="tab-meta" onClick={() => {
-              NodeManager.Instance.SelectTab(tab.id);
-            }} onDblClick={( e ) => {
+          <div class={ tab.selected() ? 'tab-selected ' : 'tab' } onClick={() => {
+            NodeManager.Instance.SelectTab(tab.id);
+          }}>
+            <div class="tab-icon" onClick={async () => {
+              if(tab.selected()){
+                NodeManager.Instance.SaveTab(tab);
+              }
+            }}>
+              <Show when={tab.selected() && tab.needsSave()} fallback={
+                <img src="/assets/icons/pen-to-square-regular-full.svg" width="15" />
+              }>
+                <img src="/assets/icons/floppy-disk-solid-full.svg" width="15" />
+              </Show>
+
+            </div>
+            <div class="tab-meta" onDblClick={( e ) => {
               let input = <input class="tab-meta-input" value={ e.target.innerHTML } /> as HTMLInputElement;
 
               e.target.innerHTML = '';
···
               }
             }}>{ tab.name }</div>
             <div class="tab-close" onClick={() => {
-              NodeManager.Instance.CloseTab(tab.id);
+              setTimeout(() => {
+                NodeManager.Instance.CloseTab(tab.id);
+              }, 50)
             }}><img src="/assets/icons/xmark-solid-full.svg" width="12" /></div>
           </div>
         }
···
 
           window.addEventListener('click', closeTabImportMenu);
         }}>
-        <div class="tab-new-dropdown" style={{ opacity: tabImportOpen() ? 1 : 0 }}>
+        <div class="tab-new-dropdown" style={{ display: tabImportOpen() ? 'block' : 'none' }}>
           <div class="tab">Import from file</div>
           <div class="tab">Import from URL</div>
         </div>

src/structs/Tab.ts

···
   name: string,
   id: string,
   nodes: Node[],
+
   selected: Accessor<boolean>,
   setSelected: Setter<boolean>
+
+  needsSave: Accessor<boolean>,
+  setNeedsSave: Setter<boolean>
 }