diff --git a/src/lib.rs b/src/lib.rs
index d48d15b..7e68958 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -3,14 +3,89 @@ use godot::{
     prelude::{Color, Transform3D, Vector3},
 };
 use rosc::{OscMessage, OscType};
+use std::fmt;
 
 pub trait MessageBehavior {
     fn to_osc_message(&self) -> OscMessage;
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String>
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr>
     where
         Self: Sized;
 }
 
+pub struct ArgCountErr {
+    expected_in: Vec<usize>,
+    actual: usize,
+    addr: String,
+}
+
+impl fmt::Display for ArgCountErr {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Invalid number of arguments for message with address {}. Expected {:?}, received {}.", self.addr, self.expected_in, self.actual)
+    }
+}
+
+pub struct ArgTypeErr {
+    expected: Vec<OscType>,
+    actual: OscType,
+    addr: String,
+    arg_count: usize,
+}
+
+impl fmt::Display for ArgTypeErr {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Invalid type of argument {} for message with address {}. Expected {:?}, received {:?}.", self.arg_count, self.addr, self.expected, self.actual)
+    }
+}
+
+pub struct IntRangeErr {
+    expected_lower: i32,
+    expected_upper: i32,
+    actual: i32,
+    addr: String,
+    arg_count: usize,
+}
+
+impl fmt::Display for IntRangeErr {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Invalid value of integer argument {} for message with address {}. Expected in range [{}, {}], received {}.", self.arg_count, self.addr, self.expected_lower, self.expected_upper, self.actual)
+    }
+}
+
+pub struct IntValErr {
+    expected_in: Vec<i32>,
+    actual: i32,
+    addr: String,
+    arg_count: usize,
+}
+
+impl fmt::Display for IntValErr {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Invalid value of integer argument {} for message with address {}. Expected {:?}, received {:?}.", self.arg_count, self.addr, self.expected_in, self.actual)
+    }
+}
+
+pub struct StrValErr {
+    expected_in: Vec<String>,
+    actual: String,
+    addr: String,
+    arg_count: usize,
+}
+
+impl fmt::Display for StrValErr {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Invalid value of string argument {} for message with address {}. Expected {:?}, received {:?}.", self.arg_count, self.addr, self.expected_in, self.actual)
+    }
+}
+
+pub enum FromMessageErr {
+    ArgCount(ArgCountErr),
+    ArgType(ArgTypeErr),
+    IntRange(IntRangeErr),
+    IntVal(IntValErr),
+    StrVal(StrValErr),
+}
+
+#[derive(Debug)]
 struct VmcExtOk {
     loaded: i32,
     calibration_state: Option<i32>,
@@ -33,7 +108,7 @@ impl MessageBehavior for VmcExtOk {
         }
         return OscMessage { addr, args };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         let mut result = VmcExtOk {
             loaded: -1,
             calibration_state: None,
@@ -46,11 +121,11 @@ impl MessageBehavior for VmcExtOk {
                     result.loaded = i;
                 }
                 _ => {
-                    return Err(String::from("arg type invalid"));
+                    return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[0].to_owned(),addr: msg.addr.to_owned(), arg_count: 0}));
                 }
             }
         } else {
-            return Err(String::from("arg count invalid"));
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![1, 3, 4], actual: msg.args.len(), addr: msg.addr.to_owned()}));
         }
         if msg.args.len() == 3 || msg.args.len() == 4 {
             match msg.args[1] {
@@ -58,7 +133,7 @@ impl MessageBehavior for VmcExtOk {
                     result.calibration_state = Some(i);
                 }
                 _ => {
-                    return Err(String::from("arg type invalid"));
+                    return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[1].to_owned(), addr: msg.addr.to_owned(), arg_count: 1}));
                 }
             }
             match msg.args[2] {
@@ -66,7 +141,7 @@ impl MessageBehavior for VmcExtOk {
                     result.calibration_mode = Some(i);
                 }
                 _ => {
-                    return Err(String::from("arg type invalid"));
+                    return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[2].to_owned(), addr: msg.addr.to_owned(), arg_count: 2}));
                 }
             }
         }
@@ -76,7 +151,7 @@ impl MessageBehavior for VmcExtOk {
                     result.tracking_status = Some(i);
                 }
                 _ => {
-                    return Err(String::from("arg type invalid"));
+                    return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[3].to_owned(), addr: msg.addr.to_owned(), arg_count: 3}));
                 }
             }
         }
@@ -84,6 +159,7 @@ impl MessageBehavior for VmcExtOk {
     }
 }
 
+#[derive(Debug)]
 struct VmcExtT {
     time: f32,
 }
@@ -95,17 +171,18 @@ impl MessageBehavior for VmcExtT {
             args: vec![OscType::from(self.time)],
         };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         if msg.args.len() != 1 {
-            return Err(String::from("arg count invalid"));
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![1], actual: msg.args.len(), addr: msg.addr}));
         }
         match msg.args[0] {
             OscType::Float(f) => return Ok(VmcExtT { time: f }),
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0})),
         }
     }
 }
 
+#[derive(Debug)]
 struct VmcExtRootPos {
     name: String,
     transform: Transform3D,
@@ -139,26 +216,26 @@ impl MessageBehavior for VmcExtRootPos {
         }
         return OscMessage { addr, args };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         let mut result: VmcExtRootPos;
         if msg.args.len() == 8 || msg.args.len() == 14 {
             let mut origin = Vector3::new(0.0, 0.0, 0.0);
             let name: String;
             match &msg.args[0] {
                 OscType::String(s) => name = s.to_owned(),
-                _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::String(String::new())], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0})),
             }
             match msg.args[1] {
                 OscType::Float(f) => origin.x = f,
-                _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[1].to_owned(), addr: msg.addr, arg_count: 1})),
             }
             match msg.args[2] {
                 OscType::Float(f) => origin.y = f,
-                _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[2].to_owned(), addr: msg.addr, arg_count: 2})),
             }
             match msg.args[3] {
                 OscType::Float(f) => origin.z = f,
-                _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[3].to_owned(), addr: msg.addr, arg_count: 3})),
             }
             let mut quat = Quaternion {
                 x: 0.0,
@@ -168,19 +245,19 @@ impl MessageBehavior for VmcExtRootPos {
             };
             match msg.args[4] {
                 OscType::Float(f) => quat.x = f,
-                _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[4].to_owned(), addr: msg.addr, arg_count: 4})),
             }
             match msg.args[5] {
                 OscType::Float(f) => quat.y = f,
-                _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[5].to_owned(), addr: msg.addr, arg_count: 5})),
             }
             match msg.args[6] {
                 OscType::Float(f) => quat.z = f,
-                _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[6].to_owned(), addr: msg.addr, arg_count: 6})),
             }
             match msg.args[7] {
                 OscType::Float(f) => quat.w = f,
-                _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[7].to_owned(), addr: msg.addr, arg_count: 7})),
             }
             result = VmcExtRootPos {
                 name,
@@ -189,7 +266,7 @@ impl MessageBehavior for VmcExtRootPos {
                 mr_offset: None,
             };
         } else {
-            return Err(String::from("arg count invalid"));
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![8, 14], actual: msg.args.len(), addr: msg.addr}));
         }
         if msg.args.len() == 14 {
             result.mr_scale = Some(Vector3 {
@@ -204,33 +281,34 @@ impl MessageBehavior for VmcExtRootPos {
             });
             match msg.args[8] {
                 OscType::Float(f) => result.mr_scale.unwrap().x = f,
-                _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[8].to_owned(), addr: msg.addr, arg_count: 8})),
             }
             match msg.args[9] {
                 OscType::Float(f) => result.mr_scale.unwrap().y = f,
-                _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[9].to_owned(), addr: msg.addr, arg_count: 9})),
             }
             match msg.args[10] {
                 OscType::Float(f) => result.mr_scale.unwrap().z = f,
-                _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[10].to_owned(), addr: msg.addr, arg_count: 10})),
             }
             match msg.args[11] {
                 OscType::Float(f) => result.mr_offset.unwrap().x = f,
-                _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[11].to_owned(), addr: msg.addr, arg_count: 11})),
             }
             match msg.args[12] {
                 OscType::Float(f) => result.mr_offset.unwrap().y = f,
-                _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[12].to_owned(), addr: msg.addr, arg_count: 12})),
             }
             match msg.args[13] {
                 OscType::Float(f) => result.mr_offset.unwrap().z = f,
-                _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[13].to_owned(), addr: msg.addr, arg_count: 13})),
             }
         }
         return Ok(result);
     }
 }
 
+#[derive(Debug)]
 struct VmcExtBonePos {
     name: String,
     transform: Transform3D,
@@ -253,27 +331,27 @@ impl MessageBehavior for VmcExtBonePos {
             ],
         };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         let name: String;
         let mut origin = Vector3::new(0.0, 0.0, 0.0);
         if msg.args.len() != 8 {
-            return Err(String::from("arg count invalid"));
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![8], actual: msg.args.len(), addr: msg.addr}));
         }
         match &msg.args[0] {
             OscType::String(s) => name = s.to_owned(),
-            _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::String(String::new())], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0})),
         }
         match msg.args[1] {
             OscType::Float(f) => origin.x = f,
-            _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[1].to_owned(), addr: msg.addr, arg_count: 1})),
         }
         match msg.args[2] {
             OscType::Float(f) => origin.y = f,
-            _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[2].to_owned(), addr: msg.addr, arg_count: 2})),
         }
         match msg.args[3] {
             OscType::Float(f) => origin.z = f,
-            _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[3].to_owned(), addr: msg.addr, arg_count: 3})),
         }
         let mut quat = Quaternion {
             x: 0.0,
@@ -283,19 +361,19 @@ impl MessageBehavior for VmcExtBonePos {
         };
         match msg.args[4] {
             OscType::Float(f) => quat.x = f,
-            _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[4].to_owned(), addr: msg.addr, arg_count: 4})),
         }
         match msg.args[5] {
             OscType::Float(f) => quat.y = f,
-            _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[5].to_owned(), addr: msg.addr, arg_count: 5})),
         }
         match msg.args[6] {
             OscType::Float(f) => quat.z = f,
-            _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[6].to_owned(), addr: msg.addr, arg_count: 6})),
         }
         match msg.args[7] {
             OscType::Float(f) => quat.w = f,
-            _ => return Err(String::from("arg type invalid")),
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[7].to_owned(), addr: msg.addr, arg_count: 7})),
         }
         return Ok(VmcExtBonePos {
             name,
@@ -304,6 +382,7 @@ impl MessageBehavior for VmcExtBonePos {
     }
 }
 
+#[derive(Debug)]
 struct VmcExtBlendVal {
     name: String,
     value: f32,
@@ -319,24 +398,25 @@ impl MessageBehavior for VmcExtBlendVal {
             ],
         };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         let name: String;
         let value: f32;
         if msg.args.len() != 2 {
-            return Err(String::from("arg count invalid"));
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![2], actual: msg.args.len(), addr: msg.addr}));
         }
         match &msg.args[0] {
             OscType::String(s) => name = s.to_owned(),
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::String(String::new())], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0})),
         }
         match msg.args[1] {
             OscType::Float(f) => value = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[1].to_owned(), addr: msg.addr, arg_count: 1})),
         }
         return Ok(VmcExtBlendVal { name, value });
     }
 }
 
+#[derive(Debug)]
 struct VmcExtCam {
     name: String,
     transform: Transform3D,
@@ -361,9 +441,9 @@ impl MessageBehavior for VmcExtCam {
             ],
         };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         if msg.args.len() != 9 {
-            return Err(String::from("arg count invalid"));
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![9], actual: msg.args.len(), addr: msg.addr}));
         }
         let name: String;
         let mut origin = Vector3::new(0.0, 0.0, 0.0);
@@ -371,39 +451,39 @@ impl MessageBehavior for VmcExtCam {
         let fov: f32;
         match &msg.args[0] {
             OscType::String(s) => name = s.to_owned(),
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::String(String::new())], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0})),
         }
         match msg.args[1] {
             OscType::Float(f) => origin.x = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[1].to_owned(), addr: msg.addr, arg_count: 1})),
         }
         match msg.args[2] {
             OscType::Float(f) => origin.y = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[2].to_owned(), addr: msg.addr, arg_count: 2})),
         }
         match msg.args[3] {
             OscType::Float(f) => origin.z = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[3].to_owned(), addr: msg.addr, arg_count: 3})),
         }
         match msg.args[4] {
             OscType::Float(f) => quat.x = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[4].to_owned(), addr: msg.addr, arg_count: 4})),
         }
         match msg.args[5] {
             OscType::Float(f) => quat.y = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[5].to_owned(), addr: msg.addr, arg_count: 5})),
         }
         match msg.args[6] {
             OscType::Float(f) => quat.z = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[6].to_owned(), addr: msg.addr, arg_count: 6})),
         }
         match msg.args[7] {
             OscType::Float(f) => quat.w = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[7].to_owned(), addr: msg.addr, arg_count: 7})),
         }
         match msg.args[8] {
             OscType::Float(f) => fov = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[8].to_owned(), addr: msg.addr, arg_count: 8})),
         }
         return Ok(VmcExtCam {
             name,
@@ -413,6 +493,7 @@ impl MessageBehavior for VmcExtCam {
     }
 }
 
+#[derive(Debug)]
 struct VmcExtCon {
     active: i32,
     name: String,
@@ -436,9 +517,9 @@ impl MessageBehavior for VmcExtCon {
             ],
         };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         if msg.args.len() != 7 {
-            return Err(String::from("arg count invalid"));
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![7], actual: msg.args.len(), addr: msg.addr}));
         }
         let active: i32;
         let name: String;
@@ -447,40 +528,40 @@ impl MessageBehavior for VmcExtCon {
         let mut axis = Vector3::new(0.0, 0.0, 0.0);
         match msg.args[0] {
             OscType::Int(i) => active = i,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0})),
         }
         if active > 2 || active < 0 {
-            return Err(String::from("arg value invalid"));
+            return Err(FromMessageErr::IntRange(IntRangeErr { expected_lower: 0, expected_upper: 2, actual: active, addr: msg.addr, arg_count: 0}));
         }
         match &msg.args[1] {
             OscType::String(s) => name = s.to_owned(),
-            _ => return Err(String::from("arg value invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::String(String::new())], actual: msg.args[1].to_owned(), addr: msg.addr, arg_count: 1})),
         }
         match msg.args[2] {
             OscType::Int(i) => is_left = i,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[2].to_owned(), addr: msg.addr, arg_count: 2})),
         }
         if is_left < 0 || is_left > 1 {
-            return Err(String::from("arg value invalid"));
+            return Err(FromMessageErr::IntRange(IntRangeErr { expected_lower: 0, expected_upper: 1, actual: active, addr: msg.addr, arg_count: 2}));
         }
         match msg.args[3] {
             OscType::Int(i) => is_touch = i,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[3].to_owned(), addr: msg.addr, arg_count: 3})),
         }
         if is_touch < 0 || is_touch > 1 {
-            return Err(String::from("arg value invalid"));
+            return Err(FromMessageErr::IntRange(IntRangeErr { expected_lower: 0, expected_upper: 1, actual: active, addr: msg.addr, arg_count: 3}));
         }
         match msg.args[4] {
             OscType::Float(f) => axis.x = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[4].to_owned(), addr: msg.addr, arg_count: 4})),
         }
         match msg.args[5] {
             OscType::Float(f) => axis.y = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[5].to_owned(), addr: msg.addr, arg_count: 5})),
         }
         match msg.args[6] {
             OscType::Float(f) => axis.z = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[6].to_owned(), addr: msg.addr, arg_count: 6})),
         }
         return Ok(VmcExtCon {
             active,
@@ -492,6 +573,7 @@ impl MessageBehavior for VmcExtCon {
     }
 }
 
+#[derive(Debug)]
 struct VmcExtKey {
     active: bool,
     name: String,
@@ -515,9 +597,9 @@ impl MessageBehavior for VmcExtKey {
             args,
         };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         if msg.args.len() != 3 {
-            return Err(String::from("arg count invalid"));
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![3], actual: msg.args.len(), addr: msg.addr}));
         }
         let active: bool;
         let name: String;
@@ -529,18 +611,18 @@ impl MessageBehavior for VmcExtKey {
                 } else if i == 0 {
                     active = false;
                 } else {
-                    return Err(String::from("arg value invalid"));
+                    return Err(FromMessageErr::IntRange(IntRangeErr { expected_lower: 0, expected_upper: 1, actual: i, addr: msg.addr, arg_count: 0}));
                 }
             }
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0})),
         }
         match &msg.args[1] {
             OscType::String(s) => name = s.to_owned(),
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::String(String::new())], actual: msg.args[1].to_owned(), addr: msg.addr, arg_count: 1})),
         }
         match msg.args[2] {
             OscType::Int(i) => keycode = i,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[2].to_owned(), addr: msg.addr, arg_count: 2})),
         }
         return Ok(VmcExtKey {
             active,
@@ -550,6 +632,7 @@ impl MessageBehavior for VmcExtKey {
     }
 }
 
+#[derive(Debug)]
 struct VmcExtMidiNote {
     active: bool,
     channel: i32,
@@ -575,9 +658,9 @@ impl MessageBehavior for VmcExtMidiNote {
             args,
         };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         if msg.args.len() != 4 {
-            return Err(String::from("arg count invalid"));
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![4], actual: msg.args.len(), addr:  msg.addr}));
         }
         let active: bool;
         let channel: i32;
@@ -590,22 +673,22 @@ impl MessageBehavior for VmcExtMidiNote {
                 } else if i == 0 {
                     active = false;
                 } else {
-                    return Err(String::from("arg value invalid"));
+                    return Err(FromMessageErr::IntRange(IntRangeErr { expected_lower: 0, expected_upper: 1, actual: i, addr: msg.addr, arg_count: 0}));
                 }
             }
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0})),
         }
         match msg.args[1] {
             OscType::Int(i) => channel = i,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[1].to_owned(), addr: msg.addr, arg_count: 1})),
         }
         match msg.args[2] {
             OscType::Int(i) => note = i,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[2].to_owned(), addr: msg.addr, arg_count: 2})),
         }
         match msg.args[3] {
             OscType::Float(f) => velocity = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[3].to_owned(), addr: msg.addr, arg_count: 3})),
         }
         return Ok(VmcExtMidiNote {
             active,
@@ -616,6 +699,7 @@ impl MessageBehavior for VmcExtMidiNote {
     }
 }
 
+#[derive(Debug)]
 struct VmcExtMidiCcVal {
     knob: i32,
     value: f32,
@@ -628,24 +712,25 @@ impl MessageBehavior for VmcExtMidiCcVal {
             args: vec![OscType::from(self.knob), OscType::from(self.value)],
         };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         if msg.args.len() != 2 {
-            return Err(String::from("arg count invalid"));
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![2], actual: msg.args.len(), addr: msg.addr}));
         }
         let knob: i32;
         let value: f32;
         match msg.args[0] {
             OscType::Int(i) => knob = i,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0})),
         }
         match msg.args[1] {
             OscType::Float(f) => value = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[1].to_owned(), addr: msg.addr, arg_count: 1})),
         }
         return Ok(VmcExtMidiCcVal { knob, value });
     }
 }
 
+#[derive(Debug)]
 struct VmcExtMidiCcBit {
     knob: i32,
     active: bool,
@@ -664,15 +749,15 @@ impl MessageBehavior for VmcExtMidiCcBit {
             args,
         };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         if msg.args.len() != 2 {
-            return Err(String::from("arg count invalid"));
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![2], actual: msg.args.len(), addr: msg.addr}));
         }
         let knob: i32;
         let active: bool;
         match msg.args[0] {
             OscType::Int(i) => knob = i,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0})),
         }
         match msg.args[1] {
             OscType::Int(i) => {
@@ -681,15 +766,16 @@ impl MessageBehavior for VmcExtMidiCcBit {
                 } else if i == 1 {
                     active = true;
                 } else {
-                    return Err(String::from("arg value invalid"));
+                    return Err(FromMessageErr::IntRange(IntRangeErr { expected_lower: 0, expected_upper: 1, actual: i, addr: msg.addr, arg_count: 1}));
                 }
             }
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[1].to_owned(), addr: msg.addr, arg_count: 1})),
         }
         return Ok(VmcExtMidiCcBit { knob, active });
     }
 }
 
+#[derive(Debug)]
 struct DeviceTranform {
     addr: String,
     serial: String,
@@ -713,53 +799,44 @@ impl MessageBehavior for DeviceTranform {
             ],
         };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         if msg.args.len() != 8 {
-            return Err(String::from("arg count invalid"));
-        }
-        match msg.addr.as_str() {
-            "/VMC/Ext/Hmd/Pos"
-            | "/VMC/Ext/Con/Pos"
-            | "/VMC/Ext/Tra/Pos"
-            | "/VMC/Ext/Hmd/Pos/Local"
-            | "/VMC/Ext/Con/Pos/Local"
-            | "/VMC/Ext/Tra/Pos/Local" => {}
-            _ => return Err(String::from("addr invalid")),
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![8], actual: msg.args.len(), addr: msg.addr}));
         }
         let serial: String;
         let mut origin = Vector3::new(0.0, 0.0, 0.0);
         let mut quat = Quaternion::new(0.0, 0.0, 0.0, 0.0);
         match &msg.args[0] {
             OscType::String(s) => serial = s.to_owned(),
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::String(String::new())], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0})),
         }
         match msg.args[1] {
             OscType::Float(f) => origin.x = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[1].to_owned(), addr: msg.addr, arg_count: 1})),
         }
         match msg.args[2] {
             OscType::Float(f) => origin.y = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[2].to_owned(), addr: msg.addr, arg_count: 2})),
         }
         match msg.args[3] {
             OscType::Float(f) => origin.z = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[3].to_owned(), addr: msg.addr, arg_count: 3})),
         }
         match msg.args[4] {
             OscType::Float(f) => quat.x = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[4].to_owned(), addr: msg.addr, arg_count: 4})),
         }
         match msg.args[5] {
             OscType::Float(f) => quat.y = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[5].to_owned(), addr: msg.addr, arg_count: 5})),
         }
         match msg.args[6] {
             OscType::Float(f) => quat.z = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[6].to_owned(), addr: msg.addr, arg_count: 6})),
         }
         match msg.args[7] {
             OscType::Float(f) => quat.w = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[7].to_owned(), addr: msg.addr, arg_count: 7})),
         }
         return Ok(DeviceTranform {
             addr: msg.addr.to_owned(),
@@ -769,6 +846,7 @@ impl MessageBehavior for DeviceTranform {
     }
 }
 
+#[derive(Debug)]
 struct VmcExtRvc {
     enable: bool,
     port: u16,
@@ -792,9 +870,9 @@ impl MessageBehavior for VmcExtRvc {
             args,
         };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         if msg.args.len() < 2 || msg.args.len() > 3 {
-            return Err(String::from("arg count invalid"));
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![2, 3], actual: msg.args.len(), addr: msg.addr}));
         }
         let enable: bool;
         let port: u16;
@@ -806,25 +884,25 @@ impl MessageBehavior for VmcExtRvc {
                 } else if i == 1 {
                     enable = true;
                 } else {
-                    return Err(String::from("arg value invalid"));
+                    return Err(FromMessageErr::IntRange(IntRangeErr { expected_lower: 0, expected_upper: 1, actual: i, addr: msg.addr, arg_count: 0}));
                 }
             }
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0})),
         }
         match msg.args[1] {
             OscType::Int(i) => {
                 if i >= 0 && i <= 65535 {
                     port = i as u16;
                 } else {
-                    return Err(String::from("arg value invalid"));
+                    return Err(FromMessageErr::IntRange(IntRangeErr { expected_lower: 0, expected_upper: 65535, actual: i, addr: msg.addr, arg_count: 1}));
                 }
             }
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[1].to_owned(), addr: msg.addr, arg_count: 1})),
         }
         if msg.args.len() == 3 {
             match &msg.args[2] {
                 OscType::String(s) => ip_addr = Some(s.to_owned()),
-                _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::String(String::new())], actual: msg.args[2].to_owned(), addr: msg.addr, arg_count: 2})),
             }
         }
         return Ok(VmcExtRvc {
@@ -835,6 +913,7 @@ impl MessageBehavior for VmcExtRvc {
     }
 }
 
+#[derive(Debug)]
 struct VmcExtLight {
     name: String,
     transform: Transform3D,
@@ -862,9 +941,9 @@ impl MessageBehavior for VmcExtLight {
             ],
         };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         if msg.args.len() != 12 {
-            return Err(String::from("arg count invalid"));
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![12], actual: msg.args.len(), addr: msg.addr}));
         }
         let name: String;
         let mut origin = Vector3::new(0.0, 0.0, 0.0);
@@ -872,51 +951,51 @@ impl MessageBehavior for VmcExtLight {
         let mut color = Color::from_rgba(0.0, 0.0, 0.0, 0.0);
         match &msg.args[0] {
             OscType::String(s) => name = s.to_owned(),
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::String(String::new())], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0})),
         }
         match msg.args[1] {
             OscType::Float(f) => origin.x = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[1].to_owned(), addr: msg.addr, arg_count: 1})),
         }
         match msg.args[2] {
             OscType::Float(f) => origin.y = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[2].to_owned(), addr: msg.addr, arg_count: 2})),
         }
         match msg.args[3] {
             OscType::Float(f) => origin.z = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[3].to_owned(), addr: msg.addr, arg_count: 3})),
         }
         match msg.args[4] {
             OscType::Float(f) => quat.x = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[4].to_owned(), addr: msg.addr, arg_count: 4})),
         }
         match msg.args[5] {
             OscType::Float(f) => quat.y = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[5].to_owned(), addr: msg.addr, arg_count: 5})),
         }
         match msg.args[6] {
             OscType::Float(f) => quat.z = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[6].to_owned(), addr: msg.addr, arg_count: 6})),
         }
         match msg.args[7] {
             OscType::Float(f) => quat.w = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[7].to_owned(), addr: msg.addr, arg_count: 7})),
         }
         match msg.args[8] {
             OscType::Float(f) => color.r = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[8].to_owned(), addr: msg.addr, arg_count: 8})),
         }
         match msg.args[9] {
             OscType::Float(f) => color.g = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[9].to_owned(), addr: msg.addr, arg_count: 9})),
         }
         match msg.args[10] {
             OscType::Float(f) => color.b = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[10].to_owned(), addr: msg.addr, arg_count: 10})),
         }
         match msg.args[11] {
             OscType::Float(f) => color.a = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[11].to_owned(), addr: msg.addr, arg_count: 11})),
         }
         return Ok(VmcExtLight {
             name,
@@ -926,6 +1005,7 @@ impl MessageBehavior for VmcExtLight {
     }
 }
 
+#[derive(Debug)]
 struct VmcExtVrm {
     path: String,
     title: String,
@@ -946,31 +1026,32 @@ impl MessageBehavior for VmcExtVrm {
             args,
         };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         if msg.args.len() < 2 || msg.args.len() > 3 {
-            return Err(String::from("arg count invalid"));
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![2, 3], actual: msg.args.len(), addr: msg.addr}));
         }
         let path: String;
         let title: String;
         let mut hash: Option<String> = None;
         match &msg.args[0] {
             OscType::String(s) => path = s.to_owned(),
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::String(String::new())], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0})),
         }
         match &msg.args[1] {
             OscType::String(s) => title = s.to_owned(),
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::String(String::new())], actual: msg.args[1].to_owned(), addr: msg.addr, arg_count: 1})),
         }
         if msg.args.len() == 3 {
             match &msg.args[2] {
                 OscType::String(s) => hash = Some(s.to_owned()),
-                _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::String(String::new())], actual: msg.args[2].to_owned(), addr: msg.addr, arg_count: 2})),
             }
         }
         return Ok(VmcExtVrm { path, title, hash });
     }
 }
 
+#[derive(Debug)]
 struct VmcExtRemote {
     service: String,
     json: String,
@@ -986,24 +1067,25 @@ impl MessageBehavior for VmcExtRemote {
             ],
         };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         if msg.args.len() != 2 {
-            return Err(String::from("arg count invalid"));
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![2], actual: msg.args.len(), addr: msg.addr}));
         }
         let service: String;
         let json: String;
         match &msg.args[0] {
             OscType::String(s) => service = s.to_owned(),
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::String(String::new())], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0})),
         }
         match &msg.args[1] {
             OscType::String(s) => json = s.to_owned(),
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::String(String::new())], actual: msg.args[1].to_owned(), addr: msg.addr, arg_count: 1})),
         }
         return Ok(VmcExtRemote { service, json });
     }
 }
 
+#[derive(Debug)]
 struct VmcExtOpt {
     option: String,
 }
@@ -1015,9 +1097,9 @@ impl MessageBehavior for VmcExtOpt {
             args: vec![OscType::from(self.option.to_owned())],
         };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         if msg.args.len() != 1 {
-            return Err(String::from("arg count invalid"));
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![1], actual: msg.args.len(), addr: msg.addr}));
         }
         match &msg.args[0] {
             OscType::String(s) => {
@@ -1025,11 +1107,12 @@ impl MessageBehavior for VmcExtOpt {
                     option: s.to_owned(),
                 })
             }
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::String(String::new())], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0})),
         }
     }
 }
 
+#[derive(Debug)]
 struct VmcExtSettingColor {
     color: Color,
 }
@@ -1046,31 +1129,32 @@ impl MessageBehavior for VmcExtSettingColor {
             ],
         };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         if msg.args.len() != 4 {
-            return Err(String::from("argj count invalid"));
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![4], actual: msg.args.len(), addr: msg.addr}));
         }
         let mut color = Color::from_rgba(0.0, 0.0, 0.0, 0.0);
         match msg.args[0] {
             OscType::Float(f) => color.r = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0})),
         }
         match msg.args[1] {
             OscType::Float(f) => color.g = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[1].to_owned(), addr: msg.addr, arg_count: 1})),
         }
         match msg.args[2] {
             OscType::Float(f) => color.b = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[2].to_owned(), addr: msg.addr, arg_count: 2})),
         }
         match msg.args[3] {
             OscType::Float(f) => color.a = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[3].to_owned(), addr: msg.addr, arg_count: 3})),
         }
         return Ok(VmcExtSettingColor { color });
     }
 }
 
+#[derive(Debug)]
 struct VmcExtSettingWin {
     is_top_most: bool,
     is_transparent: bool,
@@ -1100,9 +1184,9 @@ impl MessageBehavior for VmcExtSettingWin {
             args,
         };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         if msg.args.len() != 4 {
-            return Err(String::from("arg count invalid"));
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![4], actual: msg.args.len(), addr: msg.addr}));
         }
         let mut result = Self {
             is_top_most: false,
@@ -1115,33 +1199,34 @@ impl MessageBehavior for VmcExtSettingWin {
                 if i == 1 {
                     result.is_top_most = true;
                 } else if i != 0 {
-                    return Err(String::from("arg value invalid"));
+                    return Err(FromMessageErr::IntRange(IntRangeErr { expected_lower: 0, expected_upper: 1, actual: i, addr: msg.addr, arg_count: 0}));
                 }
             }
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0})),
         }
         match msg.args[1] {
             OscType::Int(i) => {
                 if i == 1 {
                     result.is_transparent = true;
                 } else if i != 0 {
-                    return Err(String::from("arg value invalid"));
+                    return Err(FromMessageErr::IntRange(IntRangeErr { expected_lower: 0, expected_upper: 1, actual: i, addr: msg.addr, arg_count: 1}));
                 }
             }
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[1].to_owned(), addr: msg.addr, arg_count: 1})),
         }
         match msg.args[2] {
             OscType::Int(i) => result.window_click_through = i,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[2].to_owned(), addr: msg.addr, arg_count: 2})),
         }
-        match msg.args[2] {
+        match msg.args[3] {
             OscType::Int(i) => result.hide_border = i,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[3].to_owned(), addr: msg.addr, arg_count: 3})),
         }
         return Ok(result);
     }
 }
 
+#[derive(Debug)]
 struct VmcExtConfig {
     path: String,
 }
@@ -1153,23 +1238,24 @@ impl MessageBehavior for VmcExtConfig {
             args: vec![OscType::from(self.path.to_owned())],
         };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
-        if msg.addr.len() != 1 {
-            return Err(String::from("arg count invalid"));
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
+        if msg.args.len() != 1 {
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![1], actual: msg.args.len(), addr: msg.addr }));
         }
         match &msg.args[0] {
             OscType::String(s) => return Ok(VmcExtConfig { path: s.to_owned() }),
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::String(String::new())], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0})),
         }
     }
 }
 
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug)]
 enum ThruType {
     Float(f32),
     Int(i32),
 }
 
+#[derive(Debug)]
 struct VmcThru {
     addr: String,
     arg1: String,
@@ -1188,27 +1274,28 @@ impl MessageBehavior for VmcThru {
         }
         return OscMessage { addr: self.addr.to_owned(), args}
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         if msg.args.len() > 2 || msg.args.len() < 1 {
-            return Err(String::from("arg count invalid"));
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![1, 2], actual: msg.args.len(), addr: msg.addr}));
         }
         let arg1: String;
         match &msg.args[0] {
             OscType::String(s) => arg1 = s.to_owned(),
-            _ => return Err(String::from("arg type invalid"))
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::String(String::new())], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0})),
         }
         let mut arg2: Option<ThruType> = None;
         if msg.args.len() == 2 {
             match msg.args[1] {
                 OscType::Int(i) => arg2 = Some(ThruType::Int(i)),
                 OscType::Float(f) => arg2 = Some(ThruType::Float(f)),
-                _ => return Err(String::from("arg type invalid"))
+                _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0), OscType::Float(0.0)], actual: msg.args[1].to_owned(), addr: msg.addr, arg_count: 1}))
             }
         }
         return Ok(VmcThru { addr: msg.addr, arg1 , arg2  })
     }
 }
 
+#[derive(Debug)]
 struct VmcExtSetPeriod {
     status: i32,
     root: i32,
@@ -1229,9 +1316,9 @@ impl MessageBehavior for VmcExtSetPeriod {
             OscType::from(self.devices),
         ] };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         if msg.args.len() != 6 {
-            return Err(String::from("arg count invalid"));
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![6], actual: msg.args.len(), addr: msg.addr}));
         }
         let status: i32;
         let root: i32;
@@ -1241,32 +1328,33 @@ impl MessageBehavior for VmcExtSetPeriod {
         let devices: i32;
         match msg.args[0] {
             OscType::Int(i) => status = i,
-            _ => return Err(String::from("arg type invalid"))
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0}))
         }
         match msg.args[1] {
             OscType::Int(i) => root = i,
-            _ => return Err(String::from("arg type invalid"))
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[1].to_owned(), addr: msg.addr, arg_count: 1}))
         }
         match msg.args[2] {
             OscType::Int(i) => bone = i,
-            _ => return Err(String::from("arg type invalid"))
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[2].to_owned(), addr: msg.addr, arg_count: 2}))
         }
         match msg.args[3] {
             OscType::Int(i) => blendshape = i,
-            _ => return Err(String::from("arg type invalid"))
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[3].to_owned(), addr: msg.addr, arg_count: 3}))
         }
         match msg.args[4] {
             OscType::Int(i) => camera = i,
-            _ => return Err(String::from("arg type invalid"))
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[4].to_owned(), addr: msg.addr, arg_count: 4}))
         }
         match msg.args[5] {
             OscType::Int(i) => devices = i,
-            _ => return Err(String::from("arg type invalid"))
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[5].to_owned(), addr: msg.addr, arg_count: 5}))
         }
         return Ok(VmcExtSetPeriod { status, root, bone, blendshape, camera, devices})
     }
 }
 
+#[derive(Debug)]
 struct VmcExtSetEye {
     enable: i32,
     position: Vector3,
@@ -1282,9 +1370,9 @@ impl MessageBehavior for VmcExtSetEye {
             ]
         };
     }
-    fn from_osc_message(msg: OscMessage) -> Result<Self, String> {
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
         if msg.args.len() != 4 {
-            return Err(String::from("arg count invalid"));
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![4], actual: msg.args.len(), addr: msg.addr}));
         }
         let enable: i32;
         let x: f32;
@@ -1292,21 +1380,41 @@ impl MessageBehavior for VmcExtSetEye {
         let z: f32;
         match msg.args[0] {
             OscType::Int(i) => enable = i,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Int(0)], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0}))
         }
         match msg.args[1] {
             OscType::Float(f) => x = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[1].to_owned(), addr: msg.addr, arg_count: 1}))
         }
 
         match msg.args[2] {
             OscType::Float(f) => y = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[2].to_owned(), addr: msg.addr, arg_count: 2}))
         }
         match msg.args[3] {
             OscType::Float(f) => z = f,
-            _ => return Err(String::from("arg type invalid")),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::Float(0.0)], actual: msg.args[3].to_owned(), addr: msg.addr, arg_count: 3}))
         }
         return Ok(VmcExtSetEye { enable, position: Vector3::new(x, y, z)})
     }
 }
+
+#[derive(Debug)]
+struct VmcExtSetRes {
+    response: String
+}
+
+impl MessageBehavior for VmcExtSetRes {
+    fn to_osc_message(&self) -> OscMessage {
+        return OscMessage{addr: String::from("/VMC/Ext/Set/Res"), args: vec![OscType::from(self.response.to_owned())]};
+    }
+    fn from_osc_message(msg: OscMessage) -> Result<Self, FromMessageErr> {
+        if msg.args.len() != 1 {
+            return Err(FromMessageErr::ArgCount(ArgCountErr { expected_in: vec![1], actual: msg.args.len(), addr: msg.addr}));
+        }
+        match &msg.args[0] {
+            OscType::String(s) => return Ok(VmcExtSetRes{response: s.to_owned()}),
+            _ => return Err(FromMessageErr::ArgType(ArgTypeErr { expected: vec![OscType::String(String::new())], actual: msg.args[0].to_owned(), addr: msg.addr, arg_count: 0}))
+        }
+    }
+}