RUNTIME WORKS FUCK YEA

src-tauri/Cargo.lock

···
 version = "0.1.0"
 dependencies = [
  "anyhow",
+ "crossbeam-channel",
  "dirs",
  "flate2",
  "serde",

src-tauri/Cargo.toml

···
 anyhow = "1.0.99"
 flate2 = "1.1.2"
 tauri-plugin-dialog = "2"
+crossbeam-channel = "0.5.15"
 

src-tauri/src/frontend_calls/sync_tab.rs

···
-use std::sync::mpsc::Sender;
+use crossbeam_channel::Sender;
 
 use tauri::State;
 
 use crate::{ runtime::commands::RuntimeCommand, structs::nodes::Node };
 
 #[tauri::command]
-pub fn sync_tab( graph: Vec<Node>, id: String, cmd: State<Sender<RuntimeCommand>> ) {
+pub fn sync_tab( graph: Vec<Node>, id: String, cmd: State<Sender<RuntimeCommand>> ){
   cmd.send(RuntimeCommand::AddTab(graph, id)).unwrap();
 }
 
 #[tauri::command]
-pub fn discard_tab( id: String, cmd: State<Sender<RuntimeCommand>> ) {
+pub fn discard_tab( id: String, cmd: State<Sender<RuntimeCommand>> ){
   cmd.send(RuntimeCommand::RemoveTab(id)).unwrap();
 }

src-tauri/src/lib.rs

···
-use std::{collections::HashMap, fs, sync::{self, Arc, Mutex}};
+use std::{ fs, sync::Mutex };
+use crossbeam_channel::bounded;
+use tokio::sync;
 
 use frontend_calls::*;
 
-use crate::{ osc::OSCMessage, runtime::nodes::RuntimeNodeTree, setup::setup, utils::config::Config };
+use crate::{ osc::OSCMessage, setup::setup, utils::config::Config };
 
 mod frontend_calls;
 mod osc;
···
 
   static ADDRESSES: Mutex<Vec<OSCMessage>> = Mutex::new(Vec::new());
 
-  let ( runtime_sender, runtime_receiver ) = sync::mpsc::channel();
+  let ( runtime_sender, runtime_receiver ) = bounded(1024);
 
   tauri::Builder::default()
     .plugin(tauri_plugin_dialog::init())

src-tauri/src/osc.rs

···
 // https://gist.github.com/phaze-the-dumb/634daacb5141eae2f846e20987dba7a8
-
-use std::{net::UdpSocket, sync::mpsc::Sender};
+use std::net::UdpSocket;
 
+use crossbeam_channel::Sender;
 use serde::Serialize;
 
 use crate::structs::parameter_types::ParameterType;

src-tauri/src/runtime.rs

···
 
 // This is horrible. I know, I'm sorry.
 
-pub fn runtime_dry( entry: String, parameters: &Vec<ParameterType>, tab: &RuntimeNodeTree ) -> Result<()>{
-  let node = tab.nodes.get(&entry);
+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"); }
 
-  let mut node = node.unwrap().lock().unwrap();
+  let node = node.unwrap();
 
   let output_map = node.outputs();
   let args = node.execute_dry(parameters);
 
-  drop(node);
-
   if args.is_some(){
     let args = args.unwrap();
 
···
       for output in &output_map[i]{
         if output.2 == 5{ break; } // Ignore flow outputs
 
-        let next_node = tab.nodes.get(&output.0);
+        let next_node = tab.nodes.get_mut(&output.0);
         if next_node.is_none(){ bail!("Cannot find node {}", output.0) }
 
-        let mut next_node = next_node.unwrap().lock().unwrap();
+        let next_node = next_node.unwrap();
         let can_update = next_node.update_arg(output.1 as usize, arg.clone());
 
         if can_update{
-          drop(next_node);
-          // ^^ Drop this MutexGuard before we enter the runtime,
-          //    as it blocks the runtime for gaining a lock on the node
-          //    TODO: Please find a better way of making it mutable
-
-          runtime_dry(output.0.clone(), &vec![], &tab)?;
+          runtime_dry(output.0.clone(), &vec![], tab)?;
         }
       }
     }
···
   Ok(())
 }
 
-
-pub fn runtime( entry: String, tab: &RuntimeNodeTree ) -> Result<()>{
-  let node = tab.nodes.get(&entry);
+pub fn runtime( entry: String, tab: &mut RuntimeNodeTree ) -> Result<()>{
+  let node = tab.nodes.get_mut(&entry);
   if node.is_none(){ bail!("Cannot find node"); }
 
-  let mut node = node.unwrap().lock().unwrap();
+  let node = node.unwrap();
 
   let next = node.execute();
-  if next{
+  if next.is_some(){
+    let next = next.unwrap();
+
     let outputs = node.outputs();
 
-    drop(node);
+    for i in 0..next.len(){
+      let arg = &next[i];
+      if i >= outputs.len() { break; }
 
-    for outputs in outputs{
-      for output in outputs{
-        if output.2 == 5{
-          // This is a flow output, continue
-          runtime(output.0, &tab)?;
+      for output in &outputs[i]{
+        if let ParameterType::Flow(next) = arg{
+          if *next{
+            // This is a flow output, continue
+            runtime(output.0.clone(), tab)?;
+          }
         }
       }
     }

src-tauri/src/runtime/commands.rs

···
 use crate::{ osc::OSCMessage, structs::nodes::Node };
 
+#[derive(Debug)]
 pub enum RuntimeCommand{
   OSCMessage(OSCMessage),
 

src-tauri/src/runtime/nodes.rs

···
-use std::{collections::HashMap, sync::Mutex};
+use std::collections::HashMap;
 
-use crate::{ runtime::nodes::{ debug::Debug, osctrigger::OSCTrigger }, structs::{ nodes::Node, parameter_types::ParameterType } };
+use crate::{ runtime::nodes::{ conditional::{ ifequal::ConditionalIfEqual, iffalse::ConditionalIfFalse, iftrue::ConditionalIfTrue }, debug::Debug, osctrigger::OSCTrigger, statics::{ float::StaticFloat, int::StaticInt, string::StaticString } }, structs::{ nodes::Node, parameter_types::ParameterType } };
 
 mod osctrigger;
 mod debug;
+mod statics;
+mod conditional;
 
 pub struct RuntimeNodeTree{
-  pub nodes: HashMap<String, Mutex<Box<dyn RuntimeNode>>>
+  pub nodes: HashMap<String, Box<dyn RuntimeNode>>
 }
 
+unsafe impl Send for RuntimeNodeTree{}
+
 impl RuntimeNodeTree{
   pub fn from( tree: Vec<Node> ) -> Self{
-    let mut runtime_nodes: HashMap<String, Mutex<Box<dyn RuntimeNode>>> = HashMap::new();
+    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(), Mutex::new(OSCTrigger::new(node))); }
-        "debug" => { runtime_nodes.insert(node.id.clone(), Mutex::new(Debug::new(node))); }
+        "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)); }
+
+        "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)); }
+
+        "debug" => { runtime_nodes.insert(node.id.clone(), Debug::new(node)); }
         _ => {}
       }
     }
···
 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 ) -> bool; // Then call functions on the second loop
+  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 } };
+
+pub struct ConditionalIfEqual{
+  outputs: Vec<Vec<( String, isize, isize )>>,
+  value1: ParameterType,
+  value2: ParameterType
+}
+
+impl ConditionalIfEqual{
+  pub fn new( node: Node ) -> Box<Self>{
+    dbg!(&node);
+
+    Box::new(Self {
+      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![]) }
+
+  fn execute( &mut self ) -> Option<Vec<ParameterType>> {
+    if self.value1 == ParameterType::None && self.value2 == ParameterType::None{
+      None
+    } else{
+      let equal = self.value1 == self.value2;
+      Some(vec![ ParameterType::Flow(equal), ParameterType::Flow(!equal) ])
+    }
+  }
+
+  fn update_arg( &mut self, index: usize, arg: ParameterType ) -> bool {
+    match index{
+      1 => {
+        self.value1 = arg;
+      }
+      2 => {
+        self.value2 = arg;
+      }
+      _ => {}
+    }
+
+    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 } };
+
+pub struct ConditionalIfFalse{
+  outputs: Vec<Vec<( String, isize, isize )>>,
+  runtime_active: bool
+}
+
+impl ConditionalIfFalse{
+  pub fn new( node: Node ) -> Box<Self>{
+    dbg!(&node);
+
+    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
+    })
+  }
+}
+
+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 update_arg( &mut self, _: usize, arg: ParameterType ) -> bool {
+    if let ParameterType::Boolean(boolean) = arg{
+      if boolean{
+        self.runtime_active = true;
+        true
+      } else{
+        self.runtime_active = false;
+        false
+      }
+    } else{
+      self.runtime_active = false;
+      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 } };
+
+pub struct ConditionalIfTrue{
+  outputs: Vec<Vec<( String, isize, isize )>>,
+  runtime_active: bool
+}
+
+impl ConditionalIfTrue{
+  pub fn new( node: Node ) -> Box<Self>{
+    dbg!(&node);
+
+    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
+    })
+  }
+}
+
+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 update_arg( &mut self, _: usize, arg: ParameterType ) -> bool {
+    if let ParameterType::Boolean(boolean) = arg{
+      if boolean{
+        self.runtime_active = true;
+        true
+      } else{
+        self.runtime_active = false;
+        false
+      }
+    } else{
+      self.runtime_active = false;
+      false
+    }
+  }
+
+  fn is_entrypoint( &self ) -> bool { false }
+}

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

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

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

···
 }
 
 impl Debug{
-  pub fn new( node: Node ) -> Box<Self>{
+  pub fn new( _: Node ) -> Box<Self>{
     Box::new(Self { to_log: None })
   }
 }
···
   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 ) -> bool {
+  fn execute( &mut self ) -> Option<Vec<ParameterType>> {
     dbg!(&self.to_log);
     self.to_log = None;
 
-    false
+    None
   }
 
   fn update_arg( &mut self, index: usize, value: ParameterType ) -> bool {

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

···
 
 pub struct OSCTrigger{
   outputs: Vec<Vec<( String, isize, isize )>>,
-  address: String,
+  address: Option<String>,
   runtime_active: bool
 }
 
···
   pub fn new( node: Node ) -> Box<Self>{
     dbg!(&node);
 
+    let value = &node.statics[0].value;
+
     Box::new(Self {
-      address: node.statics[0].value.as_str().unwrap().to_owned(),
+      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()
···
   }
 
   fn execute_dry( &mut self, msg: &Vec<ParameterType> ) -> Option<Vec<ParameterType>> {
+    if self.address.is_none(){
+      self.runtime_active = false;
+      return None
+    }
+
     if let ParameterType::String(address) = &msg[0]{
-      if *address == self.address{
+      if *address == *self.address.as_ref().unwrap(){
         self.runtime_active = true;
         Some(msg.clone())
         // The first value is technically the address value,
···
     }
   }
 
-  fn execute( &mut self ) -> bool {
+  fn execute( &mut self ) -> Option<Vec<ParameterType>> {
     let execute = self.runtime_active;
     self.runtime_active = false;
 
-    execute
+    Some(vec![ ParameterType::Flow(execute) ])
   }
 
   fn update_arg( &mut self, _: usize, _: ParameterType ) -> bool { false }

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

···
+use crate::{ runtime::nodes::RuntimeNode, structs::{ nodes::Node, parameter_types::ParameterType } };
+
+pub struct StaticFloat{
+  outputs: Vec<Vec<( String, isize, isize )>>,
+  value: Option<f32>
+}
+
+impl StaticFloat{
+  pub fn new( node: Node ) -> Box<Self>{
+    dbg!(&node);
+
+    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(),
+    })
+  }
+}
+
+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{
+      None
+    }
+  }
+
+  fn execute( &mut self ) -> Option<Vec<ParameterType>> { None }
+
+  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 } };
+
+pub struct StaticInt{
+  outputs: Vec<Vec<( String, isize, isize )>>,
+  value: Option<i32>
+}
+
+impl StaticInt{
+  pub fn new( node: Node ) -> Box<Self>{
+    dbg!(&node);
+
+    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(),
+    })
+  }
+}
+
+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{
+      None
+    }
+  }
+
+  fn execute( &mut self ) -> Option<Vec<ParameterType>> { None }
+
+  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 int;
+pub mod float;

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

···
+use crate::{ runtime::nodes::RuntimeNode, structs::{ nodes::Node, parameter_types::ParameterType } };
+
+pub struct StaticString{
+  outputs: Vec<Vec<( String, isize, isize )>>,
+  value: Option<String>
+}
+
+impl StaticString{
+  pub fn new( node: Node ) -> Box<Self>{
+    dbg!(&node);
+
+    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(),
+    })
+  }
+}
+
+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{
+      None
+    }
+  }
+
+  fn execute( &mut self ) -> Option<Vec<ParameterType>> { None }
+
+  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::{ self, mpsc::Receiver, Mutex } };
+use std::{ collections::HashMap, fs::File, io::Read, sync::Mutex };
+use crossbeam_channel::{ Receiver, bounded };
 
 use flate2::read::GzDecoder;
 use serde_json::{ Map, Value };
···
 pub fn setup(
   app: &mut App,
   addresses: &'static Mutex<Vec<OSCMessage>>,
-  runtime_command_receiver: Receiver<RuntimeCommand>
+  mut runtime_command_receiver: Receiver<RuntimeCommand>
 ) {
   let window = app.get_webview_window("main").unwrap();
 
···
     handle.emit("load_new_tab", Value::Object(map)).unwrap();
   });
 
-  let ( sender, receiver ) = sync::mpsc::channel();
+  let ( sender, receiver ) = bounded(1024);
 
   tokio::spawn(async move {
     osc::start_server(sender, "127.0.0.1:9001");
   });
 
-  let ( runtime_sender, runtime_receiver ) = sync::mpsc::channel();
+  let ( runtime_sender, runtime_receiver ) = bounded(1024);
 
   let runtime_sender_1 = runtime_sender.clone();
   tokio::spawn(async move {
···
       window.emit("osc-message", &message).unwrap();
 
       let msg = message.clone();
-      let mut addresses = addresses.lock().unwrap();
-      if !addresses.contains(&msg) { addresses.push(msg); }
+      let mut addrs = addresses.lock().unwrap();
+      if !addrs.contains(&msg) { addrs.push(msg); }
 
       runtime_sender.send(RuntimeCommand::OSCMessage(message)).unwrap();
     }
···
 
       match cmd{
         RuntimeCommand::OSCMessage( msg ) => {
-          for ( _, tab ) in &mut tabs{
-            for ( id, node ) in &tab.nodes{
-              let node = node.lock().unwrap();
+          for ( _, mut tab ) in &mut tabs{
+            let keys: Vec<String> = tab.nodes.keys().map(| x | { x.clone() }).collect();
 
-              if node.is_entrypoint(){
+            for id in keys.clone(){
+              let entry = tab.nodes[&id].is_entrypoint();
+
+              if entry{
                 let args = vec![
                   vec![ ParameterType::String(msg.address.clone()) ], msg.values.clone()
                 ].concat();
 
-                drop(node);
-                // ^^ Drop this MutexGuard before we enter the runtime,
-                //    as it blocks the runtime for gaining a lock on the node
-                //    TODO: Please find a better way of making it mutable
-
-                runtime_dry(id.clone(), &args, tab).unwrap();
+                runtime_dry(id.clone(), &args, &mut tab).unwrap();
               }
             }
 
-            for ( id, node ) in &tab.nodes{
-              let node = node.lock().unwrap();
-
-              if node.is_entrypoint(){
-                drop(node);
-                // ^^ Drop this MutexGuard before we enter the runtime,
-                //    as it blocks the runtime for gaining a lock on the node
-                //    TODO: Please find a better way of making it mutable
+            for id in keys{
+              let entry = tab.nodes[&id].is_entrypoint();
 
-                runtime(id.clone(), tab).unwrap();
+              if entry{
+                let _ = runtime(id.clone(), &mut tab);
               }
             }
           }
···
       }
     }
   });
-}
+}

src-tauri/src/structs/parameter_types.rs

···
 use serde::Serialize;
 
-#[derive(Serialize, Clone, Debug)]
+#[derive(Serialize, Clone, Debug, PartialEq)]
 #[serde(tag = "key", content = "value")]
 pub enum ParameterType {
   AnyType(String),
···
   Boolean(bool),
   String(String),
   Flow(bool),
+
+  None
 }

src/App.css

···
+@font-face{
+  font-family: Rubik;
+  src: url("/assets/fonts/Rubik-VariableFont_wght.ttf");
+}
+
 body{
   background: #1f2129;
   background-attachment: fixed;

src/Nodes/Statics.tsx

···
 import { NodeDefinition } from "./Nodes";
+import { NodeStaticsFloat } from "./Statics/Float";
 
 import { NodeStaticsInt } from "./Statics/Int";
 import { NodeStaticsString } from "./Statics/String";
···
   name: 'Statics',
   items: [
     NodeStaticsInt,
-    NodeStaticsString
+    NodeStaticsString,
+    NodeStaticsFloat
   ]
 }

src/Nodes/Statics/Float.tsx

···
+import { Node, NodeType } from "../../structs/node";
+import { NodeDefinition } from "../Nodes";
+
+export let NodeStaticsFloat: NodeDefinition = {
+  isSingle: true,
+  name: 'Float',
+  typeId: 'staticfloat',
+
+  w: 200,
+  h: 85,
+
+  statics: [{
+    type: NodeType.Float,
+    name: 'Value',
+    value: null
+  }],
+
+  outputs: [{ name: "Float", type: NodeType.Float }],
+
+  onStaticsUpdate: async ( _node: Node ) => {}
+}

src/Nodes/Statics/Int.tsx

···
 export let NodeStaticsInt: NodeDefinition = {
   isSingle: true,
   name: 'Int',
-  typeId: 'ifelse',
+  typeId: 'staticint',
 
   w: 200,
   h: 85,

src/components/ControlBar.tsx

···
 import './ControlBar.css';
 
-import { Accessor, createSignal, For, Match, Show, Switch } from 'solid-js';
+import { Accessor, createEffect, createSignal, For, Match, Show, Switch } from 'solid-js';
 import { Node, NodeType } from '../structs/node';
 import { TextInput } from './TextInput';
 import { invoke } from '@tauri-apps/api/core';
···
 }
 
 export let ControlBar = ( props: ControlBarProps ) => {
+  createEffect(() => {
+    console.log(props.node());
+  })
+
   return (
     <div class="control-bar">
       <For each={props.node()?.statics}>
···
                 <Match when={item.type == NodeType.String}>
                   { item.name }
                   <div style={{ display: 'inline-block', 'margin-left': '10px' }}>
+                    <input
+                      type="text"
+                      placeholder='Enter Value...'
+                      value={item.value || ''}
+                      onChange={( el ) => {
+                        let value = el.target.value;
+                        let node = props.node()!;
+
+                        item.value = value;
+                        node.onStaticsUpdate(node);
 
+                        NodeManager.Instance.UpdateConfig();
+                      }} />
                   </div>
                 </Match>
                 <Match when={item.type == NodeType.Int}>
                   { item.name }
                   <div style={{ display: 'inline-block', 'margin-left': '10px' }}>
+                    <input
+                      type="number"
+                      placeholder='Enter Value...'
+                      value={item.value !== undefined ? item.value : ''}
+                      onChange={( el ) => {
+                        let value = el.target.value;
+                        let node = props.node()!;
 
+                        item.value = parseInt(value);
+                        node.onStaticsUpdate(node);
+
+                        NodeManager.Instance.UpdateConfig();
+                      }} />
                   </div>
                 </Match>
                 <Match when={item.type == NodeType.Float}>
                   { item.name }
                   <div style={{ display: 'inline-block', 'margin-left': '10px' }}>
+                    <input
+                      type="number"
+                      placeholder='Enter Value...'
+                      value={item.value !== undefined ? item.value : ''}
+                      onChange={( el ) => {
+                        let value = el.target.value;
+                        let node = props.node()!;
 
+                        item.value = parseFloat(value);
+                        node.onStaticsUpdate(node);
+
+                        NodeManager.Instance.UpdateConfig();
+                      }} />
                   </div>
                 </Match>
                 <Match when={item.type == NodeType.OSCAddress}>

src/components/TabMenu.css

···
 .tab-meta{
   width: calc(100% - 40px);
   transform: translateY(1px);
+  display: flex;
+  align-items: center;
 }
 
 .tab-meta-input{

src/components/TextInput.css

···
   width: 400px;
 }
 
+input[type="number"]{
+  outline: none;
+  background: none;
+  border: none;
+  border-bottom: 2px solid #525252;
+  font-size: 15px;
+  font-family: Rubik, 'Courier New';
+  color: #fff;
+  width: 400px;
+}
+
 div[input-dropdown]{
   position: absolute;
   width: fit-content;