diff --git a/README.md b/README.md
index 5cf2eab..274e120 100644
--- a/README.md
+++ b/README.md
@@ -14,3 +14,19 @@ blockchains.
 The project is still at the very beginning. To compile the workspace and
 run the tests just run `cargo t`.
 
+## StoffelVM
+
+StoffelVM can be run as a standalone VM. Just pass some bytecode to it and start
+the execution.
+
+```rust
+use vm::StoffelVM;
+
+// Some fictious bytecode
+let mut bytecode: Vec<u8> = vec![0x01, 0x02, 0x03, 0x04];
+
+// Instantiate a new VM and run it
+let mut vm = StoffelVM::new();
+vm.load_byte_code(&byte_code);
+vm.execute();
+```
diff --git a/types/src/numbers/bit.rs b/types/src/numbers/bit.rs
index f5bab08..0b0d759 100644
--- a/types/src/numbers/bit.rs
+++ b/types/src/numbers/bit.rs
@@ -1,40 +1,15 @@
-use super::secret_sharing::SecretSharing;
-use super::MPCType;
+use super::{Number, SecretSharing};
 use std::ops::{Add, Mul};
 
 /// Public bit type
 ///
 /// This type is used for providing arithmetic for bits
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Copy, Default)]
-pub struct PubBit(bool);
+pub struct PubBit<T: Number>(T);
 
-impl MPCType for PubBit {
-    fn square(self) -> Self {
-        todo!();
-    }
-
-    fn pow(self, exp: usize) -> Self {
-        todo!();
-    }
-
-    fn min(self, a: Self) -> Self {
-        todo!();
-    }
-
-    fn max(self, a: Self) -> Self {
-        todo!();
-    }
-
-    fn if_else(self, a: Self, b: Self) -> Self {
-        todo!();
-    }
-
-    fn cond_swap(self, a: Self, b: Self) -> (Self, Self) {
-        todo!();
-    }
-}
+impl<T: Number> Number for PubBit<T> {}
 
-impl Add for PubBit {
+impl<T: Number> Add for PubBit<T> {
     type Output = Self;
 
     fn add(self, rhs: Self) -> Self {
@@ -42,7 +17,7 @@ impl Add for PubBit {
     }
 }
 
-impl Mul for PubBit {
+impl<T: Number> Mul for PubBit<T> {
     type Output = Self;
 
     fn mul(self, rhs: Self) -> Self {
@@ -55,35 +30,15 @@ impl Mul for PubBit {
 /// This type wraps different implementations for secret bit types
 /// in order to provide a stable API for every type it wraps.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Default)]
-pub struct SecBit<T: SecretSharing>(T);
+pub struct SecBit<T: Number>(T);
 
-impl<T: SecretSharing> MPCType for SecBit<T> {
-    fn square(self) -> Self {
-        todo!();
-    }
-
-    fn pow(self, exp: usize) -> Self {
-        todo!();
-    }
-
-    fn min(self, a: Self) -> Self {
-        todo!();
-    }
-
-    fn max(self, a: Self) -> Self {
-        todo!();
-    }
-
-    fn if_else(self, a: Self, b: Self) -> Self {
-        todo!();
-    }
+impl<T: Number> Number for SecBit<T> {}
 
-    fn cond_swap(self, a: Self, b: Self) -> (Self, Self) {
-        todo!();
-    }
+impl<T: Number> SecretSharing for SecBit<T> {
+    type Public = PubBit<T>;
 }
 
-impl<T: SecretSharing> Add for SecBit<T> {
+impl<T: Number> Add for SecBit<T> {
     type Output = Self;
 
     fn add(self, rhs: Self) -> Self {
@@ -91,7 +46,7 @@ impl<T: SecretSharing> Add for SecBit<T> {
     }
 }
 
-impl<T: SecretSharing> Mul for SecBit<T> {
+impl<T: Number> Mul for SecBit<T> {
     type Output = Self;
 
     fn mul(self, rhs: Self) -> Self {
@@ -99,3 +54,9 @@ impl<T: SecretSharing> Mul for SecBit<T> {
     }
 }
 
+impl<T: Number + std::fmt::Display> std::fmt::Display for SecBit<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let out = self.0.to_string();
+        write!(f, "{}", out.trim_start_matches('0'))
+    }
+}
diff --git a/types/src/numbers/fixed.rs b/types/src/numbers/fixed.rs
index dce4e6d..26199cb 100644
--- a/types/src/numbers/fixed.rs
+++ b/types/src/numbers/fixed.rs
@@ -1,40 +1,15 @@
-use super::secret_sharing::SecretSharing;
-use super::MPCType;
+use super::{Number, SecretSharing};
 use std::ops::{Add, Mul};
 
 /// Public fixed point type
 ///
 /// This type is used for providing arithmetic for fixed point numbers
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Copy, Default)]
-pub struct PubFixed();
+pub struct PubFixed<T: Number>(T);
 
-impl MPCType for PubFixed {
-    fn square(self) -> Self {
-        todo!();
-    }
-
-    fn pow(self, exp: usize) -> Self {
-        todo!();
-    }
-
-    fn min(self, a: Self) -> Self {
-        todo!();
-    }
-
-    fn max(self, a: Self) -> Self {
-        todo!();
-    }
-
-    fn if_else(self, a: Self, b: Self) -> Self {
-        todo!();
-    }
-
-    fn cond_swap(self, a: Self, b: Self) -> (Self, Self) {
-        todo!();
-    }
-}
+impl<T: Number> Number for PubFixed<T> {}
 
-impl Add for PubFixed {
+impl<T: Number> Add for PubFixed<T> {
     type Output = Self;
 
     fn add(self, rhs: Self) -> Self {
@@ -42,7 +17,7 @@ impl Add for PubFixed {
     }
 }
 
-impl Mul for PubFixed {
+impl<T: Number> Mul for PubFixed<T> {
     type Output = Self;
 
     fn mul(self, rhs: Self) -> Self {
@@ -55,35 +30,15 @@ impl Mul for PubFixed {
 /// This type wraps different implementations for secret fixed point types
 /// in order to provide a stable API for every type it wraps.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Default)]
-pub struct SecFixed<T: SecretSharing>(T);
+pub struct SecFixed<T: Number>(T);
 
-impl<T: SecretSharing> MPCType for SecFixed<T> {
-    fn square(self) -> Self {
-        todo!();
-    }
-
-    fn pow(self, exp: usize) -> Self {
-        todo!();
-    }
-
-    fn min(self, a: Self) -> Self {
-        todo!();
-    }
-
-    fn max(self, a: Self) -> Self {
-        todo!();
-    }
-
-    fn if_else(self, a: Self, b: Self) -> Self {
-        todo!();
-    }
+impl<T: Number> Number for SecFixed<T> {}
 
-    fn cond_swap(self, a: Self, b: Self) -> (Self, Self) {
-        todo!();
-    }
+impl<T: Number> SecretSharing for SecFixed<T> {
+    type Public = PubFixed<T>;
 }
 
-impl<T: SecretSharing> Add for SecFixed<T> {
+impl<T: Number> Add for SecFixed<T> {
     type Output = Self;
 
     fn add(self, rhs: Self) -> Self {
@@ -91,7 +46,7 @@ impl<T: SecretSharing> Add for SecFixed<T> {
     }
 }
 
-impl<T: SecretSharing> Mul for SecFixed<T> {
+impl<T: Number> Mul for SecFixed<T> {
     type Output = Self;
 
     fn mul(self, rhs: Self) -> Self {
@@ -99,3 +54,9 @@ impl<T: SecretSharing> Mul for SecFixed<T> {
     }
 }
 
+impl<T: Number + std::fmt::Display> std::fmt::Display for SecFixed<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let out = self.0.to_string();
+        write!(f, "{}", out.trim_start_matches('0'))
+    }
+}
diff --git a/types/src/numbers/float.rs b/types/src/numbers/float.rs
index 1f42631..f49ce2b 100644
--- a/types/src/numbers/float.rs
+++ b/types/src/numbers/float.rs
@@ -1,40 +1,15 @@
-use super::secret_sharing::SecretSharing;
-use super::MPCType;
+use super::{Number, SecretSharing};
 use std::ops::{Add, Mul};
 
 /// Public floating point type
 ///
 /// This type is used for providing arithmetic for floating point numbers
 #[derive(Debug, Clone, PartialEq, PartialOrd, Copy, Default)]
-pub struct PubFloat(f32);
+pub struct PubFloat<T: Number>(T);
 
-impl MPCType for PubFloat {
-    fn square(self) -> Self {
-        todo!();
-    }
-
-    fn pow(self, exp: usize) -> Self {
-        todo!();
-    }
-
-    fn min(self, a: Self) -> Self {
-        todo!();
-    }
-
-    fn max(self, a: Self) -> Self {
-        todo!();
-    }
-
-    fn if_else(self, a: Self, b: Self) -> Self {
-        todo!();
-    }
-
-    fn cond_swap(self, a: Self, b: Self) -> (Self, Self) {
-        todo!();
-    }
-}
+impl<T: Number> Number for PubFloat<T> {}
 
-impl Add for PubFloat {
+impl<T: Number> Add for PubFloat<T> {
     type Output = Self;
 
     fn add(self, rhs: Self) -> Self {
@@ -42,7 +17,7 @@ impl Add for PubFloat {
     }
 }
 
-impl Mul for PubFloat {
+impl<T: Number> Mul for PubFloat<T> {
     type Output = Self;
 
     fn mul(self, rhs: Self) -> Self {
@@ -55,35 +30,15 @@ impl Mul for PubFloat {
 /// This type wraps different implementations for secret floating point types
 /// in order to provide a stable API for every type it wraps.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Default)]
-pub struct SecFloat<T: SecretSharing>(T);
+pub struct SecFloat<T: Number>(T);
 
-impl<T: SecretSharing> MPCType for SecFloat<T> {
-    fn square(self) -> Self {
-        todo!();
-    }
-
-    fn pow(self, exp: usize) -> Self {
-        todo!();
-    }
-
-    fn min(self, a: Self) -> Self {
-        todo!();
-    }
-
-    fn max(self, a: Self) -> Self {
-        todo!();
-    }
-
-    fn if_else(self, a: Self, b: Self) -> Self {
-        todo!();
-    }
+impl<T: Number> Number for SecFloat<T> {}
 
-    fn cond_swap(self, a: Self, b: Self) -> (Self, Self) {
-        todo!();
-    }
+impl<T: Number> SecretSharing for SecFloat<T> {
+    type Public = PubFloat<T>;
 }
 
-impl<T: SecretSharing> Add for SecFloat<T> {
+impl<T: Number> Add for SecFloat<T> {
     type Output = Self;
 
     fn add(self, rhs: Self) -> Self {
@@ -91,7 +46,7 @@ impl<T: SecretSharing> Add for SecFloat<T> {
     }
 }
 
-impl<T: SecretSharing> Mul for SecFloat<T> {
+impl<T: Number> Mul for SecFloat<T> {
     type Output = Self;
 
     fn mul(self, rhs: Self) -> Self {
@@ -99,3 +54,9 @@ impl<T: SecretSharing> Mul for SecFloat<T> {
     }
 }
 
+impl<T: Number + std::fmt::Display> std::fmt::Display for SecFloat<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let out = self.0.to_string();
+        write!(f, "{}", out.trim_start_matches('0'))
+    }
+}
diff --git a/types/src/numbers/gf2.rs b/types/src/numbers/gf2.rs
index 52d1f69..e7a5f58 100644
--- a/types/src/numbers/gf2.rs
+++ b/types/src/numbers/gf2.rs
@@ -1,40 +1,15 @@
-use super::secret_sharing::SecretSharing;
-use super::MPCType;
+use super::Number;
 use std::ops::{Add, Mul};
 
 /// Public Gf2 type
 ///
 /// This type is used for providing finite field arithmetic over two elements
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Copy)]
-pub struct PubGf2<const N: usize>([bool; N]);
+pub struct PubGf2<T: Number + Default, const N: usize>([T; N]);
 
-impl<const N: usize> MPCType for PubGf2<N> {
-    fn square(self) -> Self {
-        todo!();
-    }
-
-    fn pow(self, exp: usize) -> Self {
-        todo!();
-    }
+impl<T: Number, const N: usize> Number for PubGf2<T, N> {}
 
-    fn min(self, a: Self) -> Self {
-        todo!();
-    }
-
-    fn max(self, a: Self) -> Self {
-        todo!();
-    }
-
-    fn if_else(self, a: Self, b: Self) -> Self {
-        todo!();
-    }
-
-    fn cond_swap(self, a: Self, b: Self) -> (Self, Self) {
-        todo!();
-    }
-}
-
-impl<const N: usize> Add for PubGf2<N> {
+impl<T: Number, const N: usize> Add for PubGf2<T, N> {
     type Output = Self;
 
     fn add(self, rhs: Self) -> Self {
@@ -42,7 +17,7 @@ impl<const N: usize> Add for PubGf2<N> {
     }
 }
 
-impl<const N: usize> Mul for PubGf2<N> {
+impl<T: Number, const N: usize> Mul for PubGf2<T, N> {
     type Output = Self;
 
     fn mul(self, rhs: Self) -> Self {
@@ -50,9 +25,9 @@ impl<const N: usize> Mul for PubGf2<N> {
     }
 }
 
-impl<const N: usize> Default for PubGf2<N> {
+impl<T: Number, const N: usize> Default for PubGf2<T, N> {
     fn default() -> Self {
-        PubGf2([false; N])
+        PubGf2([T::default(); N])
     }
 }
 
@@ -61,35 +36,11 @@ impl<const N: usize> Default for PubGf2<N> {
 /// This type wraps different implementation for secret Gf2 types
 /// in order to provide a stable API for every type it wraps.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Default)]
-pub struct SecGf2<T: SecretSharing>(T);
-
-impl<T: SecretSharing> MPCType for SecGf2<T> {
-    fn square(self) -> Self {
-        todo!();
-    }
-
-    fn pow(self, exp: usize) -> Self {
-        todo!();
-    }
+pub struct SecGf2<T: Number>(T);
 
-    fn min(self, a: Self) -> Self {
-        todo!();
-    }
-
-    fn max(self, a: Self) -> Self {
-        todo!();
-    }
+impl<T: Number> Number for SecGf2<T> {}
 
-    fn if_else(self, a: Self, b: Self) -> Self {
-        todo!();
-    }
-
-    fn cond_swap(self, a: Self, b: Self) -> (Self, Self) {
-        todo!();
-    }
-}
-
-impl<T: SecretSharing> Add for SecGf2<T> {
+impl<T: Number> Add for SecGf2<T> {
     type Output = Self;
 
     fn add(self, rhs: Self) -> Self {
@@ -97,7 +48,7 @@ impl<T: SecretSharing> Add for SecGf2<T> {
     }
 }
 
-impl<T: SecretSharing> Mul for SecGf2<T> {
+impl<T: Number> Mul for SecGf2<T> {
     type Output = Self;
 
     fn mul(self, rhs: Self) -> Self {
@@ -105,3 +56,9 @@ impl<T: SecretSharing> Mul for SecGf2<T> {
     }
 }
 
+impl<T: Number + std::fmt::Display> std::fmt::Display for SecGf2<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let out = self.0.to_string();
+        write!(f, "{}", out.trim_start_matches('0'))
+    }
+}
diff --git a/types/src/numbers/int.rs b/types/src/numbers/int.rs
deleted file mode 100644
index 885aa1a..0000000
--- a/types/src/numbers/int.rs
+++ /dev/null
@@ -1,170 +0,0 @@
-use super::secret_sharing::{shamir::Shamir, SecretSharing};
-use super::MPCType;
-use ark_ff::{BigInteger256, PrimeField};
-use num_bigint::BigUint;
-use std::ops::{Add, Mul};
-use thiserror::Error;
-
-/// Public integer
-///
-/// This type is used for providing public integers of arbitrary size.
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Copy, Default)]
-pub struct PubInt(BigInteger256);
-
-impl MPCType for PubInt {
-    fn square(self) -> Self {
-        todo!();
-    }
-
-    fn pow(self, exp: usize) -> Self {
-        todo!();
-    }
-
-    fn min(self, a: Self) -> Self {
-        todo!();
-    }
-
-    fn max(self, a: Self) -> Self {
-        todo!();
-    }
-
-    fn if_else(self, a: Self, b: Self) -> Self {
-        todo!();
-    }
-
-    fn cond_swap(self, a: Self, b: Self) -> (Self, Self) {
-        todo!();
-    }
-}
-
-impl Add for PubInt {
-    type Output = Self;
-
-    fn add(self, rhs: Self) -> Self {
-        todo!();
-    }
-}
-
-impl Mul for PubInt {
-    type Output = Self;
-
-    fn mul(self, rhs: Self) -> Self {
-        todo!();
-    }
-}
-
-/// Secret integer type
-///
-/// This type wraps different implementation for secret integers
-/// in order to provide a stable API for every type it wraps.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Default)]
-pub struct SecInt<T: SecretSharing>(T);
-
-impl<T: SecretSharing + Add<Output = T> + Mul<Output = T>> MPCType for SecInt<T> {
-    fn square(self) -> Self {
-        todo!();
-    }
-
-    fn pow(self, exp: usize) -> Self {
-        todo!();
-    }
-
-    fn min(self, a: Self) -> Self {
-        todo!();
-    }
-
-    fn max(self, a: Self) -> Self {
-        todo!();
-    }
-
-    fn if_else(self, a: Self, b: Self) -> Self {
-        todo!();
-    }
-
-    fn cond_swap(self, a: Self, b: Self) -> (Self, Self) {
-        todo!();
-    }
-}
-
-impl<T: SecretSharing + Add<Output = T>> Add for SecInt<T> {
-    type Output = Self;
-
-    fn add(self, rhs: Self) -> Self {
-        SecInt(self.0 + rhs.0)
-    }
-}
-
-impl<T: SecretSharing + Mul<Output = T>> Mul for SecInt<T> {
-    type Output = Self;
-
-    fn mul(self, rhs: Self) -> Self::Output {
-        SecInt(self.0 * rhs.0)
-    }
-}
-
-impl<T: PrimeField> SecInt<Shamir<T>> {
-    /// Creates a new secret integer using a Shamir secret
-    ///
-    /// This will return a Shamir secret wrapped in a `SecInt`
-    pub fn new(integer: impl Into<BigUint>) -> Result<Self, IntegerError> {
-        let integer: BigUint = integer.into();
-        Ok(SecInt(
-            Shamir::<T>::new(integer).map_err(|_| IntegerError::Init)?,
-        ))
-    }
-}
-
-impl<T: SecretSharing + std::fmt::Display> std::fmt::Display for SecInt<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let out = self.0.to_string();
-        write!(f, "{}", out.trim_start_matches('0'))
-    }
-}
-
-#[derive(Debug, Error)]
-pub enum IntegerError {
-    #[error("Unable to initialize SecInt")]
-    Init,
-}
-
-#[cfg(test)]
-mod tests {
-    use ark_bls12_381::{Fr, FrParameters};
-    use ark_ff::Fp256;
-
-    use super::*;
-
-    #[test]
-    fn sec_int_shamir_new() {
-        let _secret_int = SecInt::<Shamir<Fp256<FrParameters>>>::new(42_u64).unwrap();
-    }
-
-    #[test]
-    fn sec_int_shamir_add() {
-        let secret_int_1 = SecInt::<Shamir<Fr>>::new(42_u64).unwrap();
-        let secret_int_2 = SecInt::<Shamir<Fr>>::new(2_u64).unwrap();
-
-        assert_eq!(
-            secret_int_1 + secret_int_2,
-            SecInt::<Shamir<Fr>>::new(44_u64).unwrap()
-        );
-    }
-
-    #[test]
-    fn sec_int_shamir_multiply() {
-        let secret_int_1 = SecInt::<Shamir<Fr>>::new(42_u64).unwrap();
-        let secret_int_2 = SecInt::<Shamir<Fr>>::new(2_u64).unwrap();
-
-        assert_eq!(
-            secret_int_1 * secret_int_2,
-            SecInt::<Shamir<Fr>>::new(84_u64).unwrap()
-        );
-    }
-
-    #[test]
-    fn sec_int_shamir_display() {
-        let secret_int = SecInt::<Shamir<Fr>>::new(42_u64).unwrap();
-
-        assert_eq!(secret_int.to_string(), "2A");
-    }
-}
diff --git a/types/src/numbers/int/ark_integer.rs b/types/src/numbers/int/ark_integer.rs
new file mode 100644
index 0000000..355f039
--- /dev/null
+++ b/types/src/numbers/int/ark_integer.rs
@@ -0,0 +1,31 @@
+use crate::numbers::Number;
+use ark_ff::BigInteger256;
+use num_bigint::BigUint;
+use std::ops::{Add, Mul};
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Copy, Default)]
+pub struct ArkInt(BigInteger256);
+
+impl ArkInt {
+    pub fn new(int: BigUint) -> Result<Self, String> {
+        Ok(ArkInt(BigInteger256::try_from(int)?))
+    }
+}
+
+impl Number for ArkInt {}
+
+impl Add for ArkInt {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        todo!();
+    }
+}
+
+impl Mul for ArkInt {
+    type Output = Self;
+
+    fn mul(self, rhs: Self) -> Self::Output {
+        todo!();
+    }
+}
diff --git a/types/src/numbers/int/mod.rs b/types/src/numbers/int/mod.rs
new file mode 100644
index 0000000..578b37f
--- /dev/null
+++ b/types/src/numbers/int/mod.rs
@@ -0,0 +1,120 @@
+use super::{Number, SecretSharing};
+use ark_ff::PrimeField;
+use num_bigint::BigUint;
+use std::ops::{Add, Mul};
+
+mod ark_integer;
+use ark_integer::ArkInt;
+
+/// Public integer
+///
+/// This type is used for providing public integers of arbitrary size.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Copy, Default)]
+pub struct PubInt<T = ArkInt>(T)
+where
+    T: Number;
+
+impl<T: Number> Number for PubInt<T> {}
+
+impl<T: Number> Add for PubInt<T> {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self {
+        todo!();
+    }
+}
+
+impl<T: Number> Mul for PubInt<T> {
+    type Output = Self;
+
+    fn mul(self, rhs: Self) -> Self {
+        todo!();
+    }
+}
+
+/// Secret integer type
+///
+/// This type wraps different implementation for secret integers
+/// in order to provide a stable API for every type it wraps.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Default)]
+pub struct SecInt<T: Number>(T);
+
+impl<T: Number> Number for SecInt<T> {}
+
+impl<T: Number> SecretSharing for SecInt<T> {
+    type Public = PubInt;
+}
+
+impl<T: Number> Add for SecInt<T> {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self {
+        SecInt(self.0 + rhs.0)
+    }
+}
+
+impl<T: Number> Mul for SecInt<T> {
+    type Output = Self;
+
+    fn mul(self, rhs: Self) -> Self::Output {
+        SecInt(self.0 * rhs.0)
+    }
+}
+
+impl<T: Number + PrimeField> SecInt<T> {
+    /// Creates a new secret integer using an ark prime field
+    ///
+    /// This will return a `SecInt` using an ark prime field
+    /// as the underlying representation
+    pub fn new(integer: impl Into<BigUint>) -> Self {
+        let integer: BigUint = integer.into();
+        SecInt(T::from(integer))
+    }
+}
+
+impl<T: Number + std::fmt::Display> std::fmt::Display for SecInt<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let out = self.0.to_string();
+        write!(f, "{}", out)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::numbers::Number;
+    use ark_bls12_381::Fr;
+
+    impl Number for Fr {}
+
+    #[test]
+    fn sec_int_new() {
+        let _secret_int = SecInt::<Fr>::new(42_u64);
+    }
+
+    #[test]
+    fn sec_int_add() {
+        let secret_int_1 = SecInt::<Fr>::new(42_u64);
+        let secret_int_2 = SecInt::<Fr>::new(2_u64);
+
+        assert_eq!(secret_int_1 + secret_int_2, SecInt::<Fr>::new(44_u64));
+    }
+
+    #[test]
+    fn sec_int_multiply() {
+        let secret_int_1 = SecInt::<Fr>::new(42_u64);
+        let secret_int_2 = SecInt::<Fr>::new(2_u64);
+
+        assert_eq!(secret_int_1 * secret_int_2, SecInt::<Fr>::new(84_u64));
+    }
+
+    #[test]
+    fn sec_int_display() {
+        let secret_int = SecInt::<Fr>::new(42_u64);
+
+        assert_eq!(
+            secret_int.to_string(),
+            "Fp256 \"(000000000000000000000000000000000000000000000000000000000000002A)\""
+        );
+    }
+}
diff --git a/types/src/numbers/mod.rs b/types/src/numbers/mod.rs
index e16394d..797ee3f 100644
--- a/types/src/numbers/mod.rs
+++ b/types/src/numbers/mod.rs
@@ -5,27 +5,52 @@ pub mod gf2;
 pub mod int;
 use std::ops::{Add, Mul};
 
-pub mod secret_sharing;
-
 /// This trait is a catch-all for a type that is used
 /// within MPC protocols.
-pub trait MPCType: Sized + Add<Output = Self> + Mul<Output = Self> + Copy + Default {
+pub trait Number:
+    Add<Output = Self> + Mul<Output = Self> + Copy + Default + std::fmt::Debug + 'static
+{
     /// Returns the square of an MPCType
-    fn square(self) -> Self;
+    fn square(self) -> Self {
+        todo!();
+    }
 
     /// Returns the power of itself to an exponent
-    fn pow(self, exp: usize) -> Self;
+    fn pow(self, exp: usize) -> Self {
+        todo!();
+    }
 
     /// Returns the minimum between itself and another MPCType
-    fn min(self, a: Self) -> Self;
+    fn min(self, a: Self) -> Self {
+        todo!();
+    }
 
     /// Returns the maximum between itself and another MPCType
-    fn max(self, b: Self) -> Self;
+    fn max(self, b: Self) -> Self {
+        todo!();
+    }
 
     /// Returns a if self == 1 and b if self == 0
-    fn if_else(self, a: Self, b: Self) -> Self;
+    fn if_else(self, a: Self, b: Self) -> Self {
+        todo!();
+    }
 
     /// Returns (a, b) if self == 0 and (b, a) if self == 1
-    fn cond_swap(self, a: Self, b: Self) -> (Self, Self);
+    fn cond_swap(self, a: Self, b: Self) -> (Self, Self) {
+        todo!();
+    }
 }
 
+/// An abstraction for communication
+/// in MPC protocols
+pub trait SecretSharing {
+    type Public;
+
+    fn share(&self) {
+        todo!();
+    }
+
+    fn open(&self) -> Self::Public {
+        todo!();
+    }
+}
diff --git a/types/src/numbers/secret_sharing/mod.rs b/types/src/numbers/secret_sharing/mod.rs
deleted file mode 100644
index 584213d..0000000
--- a/types/src/numbers/secret_sharing/mod.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-use thiserror::Error;
-
-pub mod shamir;
-
-pub trait SecretSharing: Copy + Default {
-    fn share(&mut self) -> Result<(), SecretSharingError>;
-}
-
-#[derive(Debug, Error)]
-pub enum SecretSharingError {
-    #[error("SecretSharingError: {0}")]
-    ShamirError(#[from] shamir::ShamirError),
-}
diff --git a/types/src/numbers/secret_sharing/shamir.rs b/types/src/numbers/secret_sharing/shamir.rs
deleted file mode 100644
index 4aebbda..0000000
--- a/types/src/numbers/secret_sharing/shamir.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-use super::{SecretSharing, SecretSharingError};
-use ark_ff::{Field, PrimeField};
-use num_bigint::BigUint;
-use std::ops::{Add, Mul};
-use thiserror::Error;
-
-/// A Shamir secret
-///
-/// This type is used to represent a secret-shared value using polynomials.
-/// It can be used as an inner representation of some integer value.
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Default)]
-pub struct Shamir<T: Field>(T);
-
-impl<T: PrimeField> Shamir<T> {
-    /// Create a new Shamir secret
-    ///
-    /// This implementation uses the BLS12-381 prime field.
-    pub fn new(integer: BigUint) -> Result<Shamir<T>, ShamirError> {
-        let field_element = T::from(integer);
-        Ok(Shamir(field_element))
-    }
-}
-
-impl<T: Field> From<T> for Shamir<T> {
-    fn from(element: T) -> Self {
-        Shamir(element)
-    }
-}
-
-impl<T: Field> Add for Shamir<T> {
-    type Output = Self;
-
-    fn add(self, rhs: Self) -> Self::Output {
-        Shamir(self.0 + rhs.0)
-    }
-}
-
-impl<T: Field> Mul for Shamir<T> {
-    type Output = Self;
-
-    fn mul(self, rhs: Self) -> Self::Output {
-        Shamir(self.0 * rhs.0)
-    }
-}
-
-impl<T: PrimeField> std::fmt::Display for Shamir<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", &self.0.into_repr())
-    }
-}
-
-impl<T: PrimeField> SecretSharing for Shamir<T> {
-    fn share(&mut self) -> Result<(), SecretSharingError> {
-        todo!()
-    }
-}
-
-#[derive(Debug, Error)]
-pub enum ShamirError {
-    #[error("Unable to convert element into prime field")]
-    PrimeFieldConvert,
-    #[error("Unable to create sharing")]
-    CreateSharing,
-    #[error("Not enough evaluation points to reconstruct secret")]
-    Underdetermined,
-}
-
-#[cfg(test)]
-mod tests {
-    use ark_bls12_381::Fr;
-
-    use super::*;
-
-    #[test]
-    fn shamir_new() {
-        let _shamir_1 = Shamir::<Fr>::new(0_u64.into()).unwrap();
-        let _shamir_2 = Shamir::<Fr>::new(2310498322_u64.into()).unwrap();
-    }
-
-    #[test]
-    fn shamir_add() {
-        let shamir_1 = Shamir::<Fr>::new(5_u64.into()).unwrap();
-        let shamir_2 = Shamir::<Fr>::new(3_u64.into()).unwrap();
-
-        assert_eq!(
-            shamir_1 + shamir_2,
-            Shamir::<Fr>::new(8_u64.into()).unwrap()
-        );
-    }
-
-    #[test]
-    fn shamir_multiply() {
-        let shamir_1 = Shamir::<Fr>::new(42_u64.into()).unwrap();
-        let shamir_2 = Shamir::<Fr>::new(5_u64.into()).unwrap();
-
-        assert_eq!(
-            shamir_1 * shamir_2,
-            Shamir::<Fr>::new(210_u64.into()).unwrap()
-        );
-    }
-
-    #[test]
-    fn shamir_display() {
-        let shamir_1 = Shamir::<Fr>::new(42_u64.into()).unwrap();
-        assert_eq!(
-            shamir_1.to_string(),
-            "000000000000000000000000000000000000000000000000000000000000002A"
-        );
-    }
-}
diff --git a/vm/Cargo.toml b/vm/Cargo.toml
index a8be430..fe7e762 100644
--- a/vm/Cargo.toml
+++ b/vm/Cargo.toml
@@ -7,3 +7,9 @@ edition = "2021"
 
 [dependencies]
 types = {path = "../types"}
+
+futures = { version = "0.3" }
+tokio = {version = "0.2", features = ["full"] }
+ark-ff = "0.3"
+ark-poly = "0.3"
+ark-ec = "0.3"
diff --git a/vm/src/instructions/arithmetic.rs b/vm/src/instructions/arithmetic.rs
new file mode 100644
index 0000000..149e0ee
--- /dev/null
+++ b/vm/src/instructions/arithmetic.rs
@@ -0,0 +1,827 @@
+use crate::processors::arithmetic::ArithmeticProcessor;
+use types::numbers::{Number, SecretSharing};
+
+// Assign immediate value to clear register
+pub fn ldi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Assign immeidate value to secret register
+pub fn ldsi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Assign clear register to clear memory value(s) by immediate address
+pub fn stmc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Assign secret register to secret memory value(s) by immediate address
+pub fn stms<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Assign clear memory value(s) to clear register by register address
+pub fn ldmci<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Assign secret memory value(s) to secret register by register address
+pub fn ldmsi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Assign clear register to clear memory value(s) by register address
+pub fn stmci<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Assign secret register to secret memory value(s) by register address
+pub fn stmsi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Copy clear register
+pub fn movc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Copy secret register
+pub fn movs<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store number of current thread in clear integer register
+pub fn ldtn<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Require on computation modulus
+// @dev: Do we need to keep this?
+pub fn reqbl<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Custom preprocessed data usage
+pub fn use_prep<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Matrix multiplication usage
+pub fn use_matmul<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Clear addition
+pub fn addc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Secret addition
+pub fn adds<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Mixed addition
+pub fn addm<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Addition of clear register and immediate value
+pub fn addci<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Addition of secret register and immediate value
+pub fn addsi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Clear subtraction
+pub fn subc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Secret subtraction
+pub fn subs<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Subtract clear from secret value
+pub fn subml<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Subtract secret from clear value
+pub fn submr<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Subtraction immediate value from clear register
+pub fn subci<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Subtraction immediate value from secret register
+pub fn subsi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Subtraction of clear register from immediate value
+pub fn subcfi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Subtraction of secret register from immediate value
+pub fn subsfi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Clear multiplcation
+pub fn mulc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Multiply secret and clear value
+pub fn mulm<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Multipleication of clear register and immediate value
+pub fn mulci<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Multiplication of secret register and immediate value
+pub fn mulsi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Clear division
+pub fn divc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Division of secret register and immediate value
+pub fn divci<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Clear modular reduction
+pub fn modc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Modular reduction of clear register and immediate value
+pub fn modci<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Clear legendre symbol computation over prime p
+pub fn legendrec<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Clear truncated hash computation
+pub fn digestc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Inverse of power of two modulo prime
+pub fn inv2m<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Clear integer floor division
+pub fn floordivc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store fresh random triples in secret register
+pub fn triple<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store fresh random bits in secret register
+pub fn bit<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store fresh random squares in secret register
+pub fn square<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store fresh random inverses in secret register
+pub fn inv<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store custom preprocessed data in secret register
+pub fn prep<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store fresh length-restricted random shares in secret register
+pub fn randoms<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store fresh random input maskes in secret register and clear regiser of the relevant player
+pub fn inputmaskreg<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store shares of a fresh secret random element in secret register
+pub fn randomfulls<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Read a variable number of clear values in internal representation from socket for a specified
+// client id and store them in clear registers
+pub fn readsocketc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Read a variable number of secret values in internal representation from socket for a specified
+// client id and store them in secret registers
+pub fn readsockets<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Write a variable number of secret shares from registers into a socket for a specified client id
+pub fn writesockets<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Read a variable number of 32-bit integers from socket for a specified client id and store them in clear integer registers
+pub fn writesocketshare<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Open a server socket on a party-specific port number and listen for client connections
+// @dev: Does this need to be an opcode?
+pub fn listen<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Wait for a connection at the given port and write socket handle to clear integer register
+// @dev: Does this need to be an opcode?
+pub fn acceptclientconnection<
+    T: Number + SecretSharing,
+    U: Number,
+    const M: usize,
+    const N: usize,
+>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Close connection to client
+// @dev: Does this need to be an opcode?
+pub fn closeclientconnection<
+    T: Number + SecretSharing,
+    U: Number,
+    const M: usize,
+    const N: usize,
+>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Logical AND of clear registers
+pub fn andc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Logical XOR of clear registers
+pub fn xorc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Logical OR of clear registers
+pub fn orc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Logical AND of clear registers and immediate value
+pub fn andci<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Logical XOR of clear register and immediate value
+pub fn xorci<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Logical OR of clear register and immediate value
+pub fn orci<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Clear logical NOT of a constant number of bits of clear register
+pub fn notc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Bitwise left shift of clear register
+pub fn shlc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Bitwise right shift of clear register
+pub fn shrc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Bitwise left shift of clear by immediate value
+pub fn shlci<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Bitwise right shift of clear register by immediate value
+pub fn shrci<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Bitwise right shift of secret register by immediate value
+pub fn shrsi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Reveat secret registers to clear registers
+pub fn open<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Element-wise mupleication of secret registers
+pub fn muls<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Constant-vector mutiplication of secret registers
+pub fn mulrs<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Dot product of secret register
+pub fn dotprods<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Probabilistic truncation if supported by protocol
+pub fn trunc_pr<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Secret matrix multiplication from registers
+pub fn matmuls<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Secret matrix multiplication reading directly from memory
+pub fn matmulsm<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Secret 2D convolution
+pub fn conv2ds<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Force MAC check in current thread and all idle thread if current thread is the main thread
+pub fn check<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Debugging output of clear register
+// @dev: Should we keep this?
+pub fn printreg<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store insecure random value of specified length in clear integer register
+pub fn rand<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Output clear register
+pub fn printregplain<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store publc input in clear register
+pub fn pubinput<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Output floating-number from clear registers
+pub fn printfloatplain<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Write shares to Persistence/Transactions-P<playerno>.data
+pub fn writefileshare<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Read shares from Persistence/Transactions-P<playerno>.data
+pub fn readfileshare<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Conditionally output four bytes
+pub fn condprintstr<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Convert clear integer register to clear register
+pub fn convint<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Convert clear integer register to clear register
+pub fn convmodp<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Create incremental clear integer
+pub fn incint<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Randomly shuffles clear integer vector with public randomness
+pub fn shuffle<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Conditionally output clear register
+pub fn condprintplain<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// edaBit usage
+pub fn use_edabit<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Binary integer output
+pub fn intoutput<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Binary floating-point output
+pub fn floatoutput<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store private input in secret registers
+pub fn inputmixed<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store private input in secret registers
+pub fn inputmixedreg<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store private input in secret registers
+pub fn rawinput<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Private input from cint
+pub fn inputpersonal<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Bitwise XOR of single secret and clear bit registers
+pub fn xorm<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Copy clear bit register vector to clear regiser by bit
+pub fn convbitvec<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Copy secret bit register
+pub fn mov<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Copy clear bit memory cell with run-time address to clear bit register
+pub fn ldmcbi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Copy clear bit register to clear bit memory cell with run-time address
+pub fn stmcbi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn gldsi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn gstms<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn gldmsi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn gstmsi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn gmovs<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn gadds<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn gaddm<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn gaddsi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn gsubs<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn gsubsi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn gsubsfi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn gsubml<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn gsubmr<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn gmulm<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn gmulsi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn gtriple<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn gbit<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn gconvint<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    ap: &mut ArithmeticProcessor<T, U, M, N>,
+) {
+    todo!();
+}
diff --git a/vm/src/instructions/boolean.rs b/vm/src/instructions/boolean.rs
new file mode 100644
index 0000000..4107469
--- /dev/null
+++ b/vm/src/instructions/boolean.rs
@@ -0,0 +1,340 @@
+use crate::stoffel_vm::StoffelVM;
+use types::numbers::{Number, SecretSharing};
+
+// Copy private input to secret bit register vectors
+pub fn inputb<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Copy private input secret bit registers bit by bit
+pub fn inputbvec<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn ldmsd<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn stmsd<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn ldmsdi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn stmsdi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn stmsdci<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Bitwise XOR of secret bit register
+pub fn xors<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Bitwise XOR of two single clear bit registers
+pub fn xorcb<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Bitwise XOR of single clear bit register and immediate
+pub fn xorcbi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Bitwise NOT of secret register vector
+pub fn nots<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Bitwise NOT of secret register vector
+pub fn notcb<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Constant-vector AND of secret bit registeers
+pub fn andrs<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Bitwise AND of secret bit register vector
+pub fn ands<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Integer addition two single clear bit registers
+pub fn addcb<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Integer addition single clear bit register and immediate
+pub fn addcbi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Integer multiplication single clear bit register and immediate
+pub fn mulcbi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Secret bit register decomposition
+pub fn bitdecs<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Secret bit register decomposition
+pub fn bitcoms<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Secret bit register decomposition
+pub fn bitdecc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Right shift of clear bit register by immediate
+pub fn shrcbi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Left shift of clear bit register by immediate
+pub fn shlcbi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store immediate in secret bit register
+pub fn ldbits<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Copy secret bit memory cell with compile-time address to secret bit register
+pub fn ldmsb<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Copy secret bit register to secret bit memory cell with compile-time address
+pub fn stmsb<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Copy secret bit memory cell with run-time address to secret bit register
+pub fn ldmsbi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Copy secret bit register to secret bit memory cell with run-time address
+pub fn stmsbi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Copy clear bit memory cell with compile-time address to clear bit register
+pub fn ldmcb<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Copy clear bit register to cleare bit memory cell with compile-time address
+pub fn stmcb<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn movsb<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Secret bit register vector transpose
+pub fn trans<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Copy fresh secret random bit to secret bit register
+pub fn bitb<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Reveal secret bit register vectors and copy result to clear bit register vectors
+pub fn reveal<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Signed output of clear bit register
+pub fn printregsigned<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Debug output of clear bit register
+pub fn printregb<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Output clear bit register
+pub fn printregplainb<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Output floating-number from clear bit registers
+pub fn printfloatplainb<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Conditionally output four bytes
+pub fn condprintstrb<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Bitwise AND of single secret and clear bit registers
+pub fn andm<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Copy clear integer register to secret bit register
+pub fn convsint<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Copy clear integer register to clear bit register
+pub fn convcint<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Copy clear register vector by bit to clear bit register vectors
+pub fn convcintvec<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Copy clear bit register to clear integer register
+pub fn convcbit<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn convcbitvec<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Copy clear bit register vector to secret bit register vector
+pub fn convcbit2s<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store fresh random daBits in secret register
+// @dev: Do we need to keep this?
+pub fn dabit<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store frehs random loose edaBits in secret register
+// @dev: Do we need to keep this?
+pub fn edabit<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store fresh random strict edaBits in secret register
+pub fn sedabit<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Local share conversion
+pub fn split<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
diff --git a/vm/src/instructions/common.rs b/vm/src/instructions/common.rs
new file mode 100644
index 0000000..c440661
--- /dev/null
+++ b/vm/src/instructions/common.rs
@@ -0,0 +1,307 @@
+// VM<T, U, M, N> Instructions that are common to both GC and Arithmetic circuits
+
+use types::numbers::{Number, SecretSharing};
+
+use crate::stoffel_vm::StoffelVM;
+
+// Output a single byte
+pub fn printchr<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Output four bytes
+pub fn printstr<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Set number of digits after decimal point for PRINTFLOATPLAIN
+// @dev: Do we need this?
+pub fn printfloatprec<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store immediate value in clear integer register
+pub fn ldint<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Clear integer register addition
+pub fn addint<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Clera integer register subtraction
+pub fn subint<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Clear integer register multiplication
+pub fn mulint<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Clear integer register division with floor rounding
+pub fn divint<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Unconditional relative jump in the bytecode
+pub fn jmp<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Conditional relative jump in the bytecode
+// NZ = Not Zero
+pub fn jmpnz<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Conditional relative jump in the bytecode
+pub fn jmpeqz<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Clear integer zero test
+pub fn eqzc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Clear integer less than zero test
+pub fn ltzc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Clear integer less than comparison
+pub fn ltc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Clear integer greater than comparison
+pub fn gtc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Clear integer equality test
+pub fn eqc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Unconditional relative jump in the bytecode
+pub fn jmpi<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Assign clear integer memory value(s) to clear integer register by immediate address
+pub fn ldmint<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Assign clear integer memory value(s) to clear integer register by immeiate address
+pub fn stmint<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Assign clear integer memory value(s) to clear integer register by register address
+pub fn ldminti<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Assign clear integer to clear integer memory value(s) by register address
+pub fn stminti<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Pushes clear integer register to the thread-local stack
+pub fn pushint<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Pops from the thread-local stack to clear integer
+pub fn popint<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Copy clear integer register
+pub fn movint<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Clear integer bit decomposition
+pub fn bitdecint<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store the argument passed to the current thread in clear integer register
+pub fn ldarg<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Copy clear integer register to the thread argument
+pub fn starg<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Output time since start of computation
+pub fn time<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Start timer
+pub fn start<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Stop timer
+pub fn stop<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn gldms<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Assign clear memory value(s) to clear register by immediate address
+pub fn ldmc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Assign secret memory value(s) to secret register by immediate address
+pub fn ldms<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Output clear integer register
+// @dev: Should we keep this?
+pub fn printint<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+pub fn gldmc<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Start tape/bytecode file in another thread
+pub fn run_tape<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Join thread
+pub fn join_tape<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Crash runtime if the register's value is > 0
+pub fn crash<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Offline data usage
+pub fn use_off<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Input usage
+pub fn use_inp<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store number of players in clear integer register
+pub fn nplayers<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store maximal number of corrupt players in clear integer register
+pub fn threshold<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
+
+// Store current player number in clear integer register
+pub fn playerid<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>(
+    vm: &mut StoffelVM<T, U, M, N>,
+) {
+    todo!();
+}
diff --git a/vm/src/instructions/mod.rs b/vm/src/instructions/mod.rs
new file mode 100644
index 0000000..11dd217
--- /dev/null
+++ b/vm/src/instructions/mod.rs
@@ -0,0 +1,5 @@
+pub mod arithmetic;
+pub mod boolean;
+pub mod common;
+pub mod opcodes;
+
diff --git a/vm/src/instructions.rs b/vm/src/instructions/opcodes.rs
similarity index 98%
rename from vm/src/instructions.rs
rename to vm/src/instructions/opcodes.rs
index 7e8f8fe..89e7625 100644
--- a/vm/src/instructions.rs
+++ b/vm/src/instructions/opcodes.rs
@@ -2,7 +2,8 @@
 /// These are the instructions for the StoffelMPC VM. These instructions are taken from the MP-SPDZ's VM instructions
 /// These instructions may be reduced or added to at a later time.
 
-pub enum Instructions {
+#[derive(Debug, Clone, Copy)]
+pub enum Opcodes {
     /// Emulation
     CISC = 0x00,
     /// Load/store
@@ -188,4 +189,3 @@ pub enum Instructions {
     INITSECURESOCKET = 0x1BA,
     RESPSECURESOCKET = 0x1BB,
 }
-
diff --git a/vm/src/lib.rs b/vm/src/lib.rs
new file mode 100644
index 0000000..3b4dada
--- /dev/null
+++ b/vm/src/lib.rs
@@ -0,0 +1,9 @@
+#![feature(derive_default_enum)]
+
+mod instructions;
+mod processors;
+mod program;
+mod state;
+pub mod stoffel_vm;
+
+pub use stoffel_vm::StoffelVM;
diff --git a/vm/src/main.rs b/vm/src/main.rs
index 40845b5..f328e4d 100644
--- a/vm/src/main.rs
+++ b/vm/src/main.rs
@@ -1,27 +1 @@
-mod instructions;
-
 fn main() {}
-
-pub struct StoffelVM {
-    stack: Vec<u8>,
-    memory: Vec<u8>,
-    code: Vec<u8>,
-    sp: u32,
-    fp: u32,
-    ip: u32,
-    log_level: (),
-}
-
-impl StoffelVM {
-    pub fn new() -> Self {
-        todo!()
-    }
-
-    pub fn run(&mut self) {
-        loop {
-            todo!()
-        }
-    }
-
-    fn load_code(&mut self) {}
-}
diff --git a/vm/src/processors/arithmetic.rs b/vm/src/processors/arithmetic.rs
new file mode 100644
index 0000000..1170a0b
--- /dev/null
+++ b/vm/src/processors/arithmetic.rs
@@ -0,0 +1,70 @@
+use types::numbers::{Number, SecretSharing};
+
+use super::Processor;
+use crate::state::{GlobalMemory, Registers, StackRegisters};
+
+#[derive(Debug, Clone, Default)]
+pub struct ArithmeticProcessor<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>
+{
+    pub stack: StackRegisters<T, U, N>,
+    pub registers: Registers<T, U, M, N>,
+}
+
+impl<T: Number + SecretSharing, U: Number, const M: usize, const N: usize> Processor
+    for ArithmeticProcessor<T, U, M, N>
+{
+    type Memory = GlobalMemory<T, U, N>;
+
+    fn clear_registers(&mut self) {
+        todo!()
+    }
+
+    fn get_program_counter(&self) -> usize {
+        todo!()
+    }
+
+    fn get_program_size(&self) -> usize {
+        todo!()
+    }
+
+    fn execute(&mut self) {
+        todo!()
+    }
+
+    fn jump(&mut self) {
+        todo!()
+    }
+
+    fn relative_jump(&mut self) {
+        todo!()
+    }
+
+    fn increment_program_counter(&mut self) {
+        todo!()
+    }
+
+    fn read_tape(&self) {
+        todo!()
+    }
+
+    fn receive_tape(&self) {
+        todo!()
+    }
+
+    fn receive_private_input(&self, to_store_in_memory: bool) {
+        todo!()
+    }
+
+    fn give_private_output(&self, to_store_in_memory: bool) {
+        todo!()
+    }
+
+    fn memory(&self) -> Self::Memory {
+        todo!()
+    }
+}
+
+impl<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>
+    ArithmeticProcessor<T, U, M, N>
+{
+}
diff --git a/vm/src/processors/boolean.rs b/vm/src/processors/boolean.rs
new file mode 100644
index 0000000..6848f4d
--- /dev/null
+++ b/vm/src/processors/boolean.rs
@@ -0,0 +1,69 @@
+use crate::state::{GlobalMemory, Registers, StackRegisters};
+use types::numbers::{Number, SecretSharing};
+
+use super::Processor;
+
+#[derive(Debug, Clone, Default)]
+pub struct BooleanProcessor<T: Number + SecretSharing, U: Number, const M: usize, const N: usize> {
+    pub stack: StackRegisters<T, U, M>,
+    pub registers: Registers<T, U, M, N>,
+}
+
+impl<T: Number + SecretSharing, U: Number, const M: usize, const N: usize> Processor
+    for BooleanProcessor<T, U, M, N>
+{
+    type Memory = GlobalMemory<T, U, N>;
+
+    fn clear_registers(&mut self) {
+        todo!()
+    }
+
+    fn get_program_counter(&self) -> usize {
+        todo!()
+    }
+
+    fn get_program_size(&self) -> usize {
+        todo!()
+    }
+
+    fn execute(&mut self) {
+        todo!()
+    }
+
+    fn jump(&mut self) {
+        todo!()
+    }
+
+    fn relative_jump(&mut self) {
+        todo!()
+    }
+
+    fn increment_program_counter(&mut self) {
+        todo!()
+    }
+
+    fn read_tape(&self) {
+        todo!()
+    }
+
+    fn receive_tape(&self) {
+        todo!()
+    }
+
+    fn receive_private_input(&self, to_store_in_memory: bool) {
+        todo!()
+    }
+
+    fn give_private_output(&self, to_store_in_memory: bool) {
+        todo!()
+    }
+
+    fn memory(&self) -> Self::Memory {
+        todo!()
+    }
+}
+
+impl<T: Number + SecretSharing, U: Number, const M: usize, const N: usize>
+    BooleanProcessor<T, U, M, N>
+{
+}
diff --git a/vm/src/processors/mod.rs b/vm/src/processors/mod.rs
new file mode 100644
index 0000000..ac9b145
--- /dev/null
+++ b/vm/src/processors/mod.rs
@@ -0,0 +1,23 @@
+/// A Processor is component of the MPC VM that handles the core processing within the MPC VM
+pub mod arithmetic;
+pub mod boolean;
+
+pub use arithmetic::ArithmeticProcessor;
+pub use boolean::BooleanProcessor;
+
+pub trait Processor: std::fmt::Debug {
+    type Memory;
+
+    fn clear_registers(&mut self);
+    fn get_program_counter(&self) -> usize;
+    fn get_program_size(&self) -> usize;
+    fn execute(&mut self);
+    fn jump(&mut self);
+    fn relative_jump(&mut self);
+    fn increment_program_counter(&mut self);
+    fn read_tape(&self);
+    fn receive_tape(&self);
+    fn receive_private_input(&self, to_store_in_memory: bool);
+    fn give_private_output(&self, to_store_in_memory: bool);
+    fn memory(&self) -> Self::Memory;
+}
diff --git a/vm/src/program.rs b/vm/src/program.rs
new file mode 100644
index 0000000..6970d43
--- /dev/null
+++ b/vm/src/program.rs
@@ -0,0 +1,18 @@
+use super::instructions::opcodes::Opcodes;
+
+#[derive(Debug)]
+pub struct Program(Vec<Opcodes>);
+
+impl Program {
+    pub fn new() -> Self {
+        Program(vec![])
+    }
+
+    pub fn parse_bytes(&mut self, bytes: impl AsRef<[u8]>) {
+        todo!();
+    }
+
+    fn execute() {
+        todo!();
+    }
+}
diff --git a/vm/src/state.rs b/vm/src/state.rs
new file mode 100644
index 0000000..75f4435
--- /dev/null
+++ b/vm/src/state.rs
@@ -0,0 +1,134 @@
+use types::numbers::{
+    bit::{PubBit, SecBit},
+    fixed::{PubFixed, SecFixed},
+    float::{PubFloat, SecFloat},
+    gf2::{PubGf2, SecGf2},
+    int::{PubInt, SecInt},
+    Number, SecretSharing,
+};
+
+#[derive(Clone, Debug, Default)]
+pub struct StackRegisters<T: Number + SecretSharing, U: Number, const N: usize> {
+    secret_int_memory: StackRegister<SecInt<T>>,
+    pub_int_memory: StackRegister<PubInt<U>>,
+
+    secret_fixed_memory: StackRegister<SecFixed<T>>,
+    pub_fixed_memory: StackRegister<PubFixed<U>>,
+
+    secret_float_memory: StackRegister<SecFloat<T>>,
+    pub_float_memory: StackRegister<PubFloat<U>>,
+
+    secret_bit_memory: StackRegister<SecBit<T>>,
+    pub_bit_memory: StackRegister<PubBit<U>>,
+
+    secret_gf2_memory: StackRegister<SecGf2<T>>,
+    public_gf2_memory: StackRegister<PubGf2<U, N>>,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct Registers<T: Number + SecretSharing, U: Number, const M: usize, const N: usize> {
+    secret_int_memory: Register<SecInt<T>, N>,
+    pub_int_memory: Register<PubInt<U>, N>,
+
+    secret_fixed_memory: Register<SecFixed<T>, N>,
+    pub_fixed_memory: Register<PubFixed<U>, N>,
+
+    secret_float_memory: Register<SecFloat<T>, N>,
+    pub_float_memory: Register<PubFloat<U>, N>,
+
+    secret_bit_memory: Register<SecBit<T>, N>,
+    pub_bit_memory: Register<PubBit<U>, N>,
+
+    secret_gf2_memory: Register<SecGf2<T>, N>,
+    public_gf2_memory: Register<PubGf2<U, M>, N>,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct GlobalMemory<T: Number + SecretSharing, U: Number, const N: usize> {
+    secret_int_memory: Memory<SecInt<T>>,
+    pub_int_memory: Memory<PubInt<U>>,
+
+    secret_fixed_memory: Memory<SecFixed<T>>,
+    pub_fixed_memory: Memory<PubFixed<U>>,
+
+    secret_float_memory: Memory<SecFloat<T>>,
+    pub_float_memory: Memory<PubFloat<U>>,
+
+    secret_bit_memory: Memory<SecBit<T>>,
+    pub_bit_memory: Memory<PubBit<U>>,
+
+    secret_gf2_memory: Memory<SecGf2<T>>,
+    public_gf2_memory: Memory<PubGf2<U, N>>,
+}
+
+#[derive(Clone, Debug)]
+struct Register<T: Number, const N: usize>([T; N]);
+
+impl<T: Number, const N: usize> Default for Register<T, N> {
+    fn default() -> Self {
+        Self([T::default(); N])
+    }
+}
+
+impl<T: Number, const N: usize> Register<T, N> {
+    fn read(&self, i: usize) -> T {
+        self.0[i]
+    }
+
+    fn write(&mut self, i: usize, element: T) {
+        self.0[i] = element;
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+struct StackRegister<T: Number>(Vec<T>);
+
+impl<T: Number> StackRegister<T> {
+    fn push(&mut self, element: T) {
+        self.0.push(element);
+    }
+
+    fn pop(&mut self) -> T {
+        self.0.pop().unwrap()
+    }
+
+    fn peek(&self, location: usize) -> Option<&T> {
+        self.0.get(location)
+    }
+
+    fn poke(&mut self, location: usize, element: T) {
+        if location > self.0.len() {
+            panic!("location is out of range");
+        }
+        self.0[location] = element;
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+struct Memory<T: Number>(Vec<T>);
+
+impl<T: Number> Memory<T> {
+    fn new() -> Self {
+        todo!();
+    }
+
+    fn read() -> T {
+        todo!();
+    }
+
+    fn write() {
+        todo!();
+    }
+
+    fn allocate() {
+        todo!();
+    }
+
+    fn deallocate() {
+        todo!();
+    }
+
+    fn resize() {
+        todo!();
+    }
+}
diff --git a/vm/src/stoffel_vm.rs b/vm/src/stoffel_vm.rs
new file mode 100644
index 0000000..9c2bcac
--- /dev/null
+++ b/vm/src/stoffel_vm.rs
@@ -0,0 +1,65 @@
+use super::processors::{ArithmeticProcessor, BooleanProcessor, Processor};
+use super::program::Program;
+use super::state::GlobalMemory;
+use std::sync::{Arc, Mutex};
+use types::numbers::{Number, SecretSharing};
+
+#[derive(Debug, Clone, Copy, Default)]
+pub enum VMMode {
+    #[default]
+    Normal,
+    Debug,
+    Optimized,
+}
+
+#[derive(Debug)]
+pub struct StoffelVM<T: SecretSharing + Number, U: Number, const M: usize, const N: usize> {
+    processors: Vec<Box<dyn Processor<Memory = GlobalMemory<T, U, N>>>>,
+    program_counter: usize,
+    global_memory: Arc<Mutex<GlobalMemory<T, U, N>>>,
+    mode: VMMode,
+    code: Program,
+}
+
+impl<T: SecretSharing + Number, U: Number, const M: usize, const N: usize> StoffelVM<T, U, M, N> {
+    pub fn new() -> Self {
+        Self {
+            processors: vec![
+                Box::new(ArithmeticProcessor::<T, U, M, N>::default()),
+                Box::new(BooleanProcessor::<T, U, M, N>::default()),
+            ],
+            program_counter: 0,
+            global_memory: Arc::new(Mutex::new(GlobalMemory::<T, U, N>::default())),
+            mode: VMMode::default(),
+            code: Program::new(),
+        }
+    }
+
+    pub fn load_byte_code(&mut self, bytes: impl AsRef<[u8]>) {
+        self.code.parse_bytes(bytes.as_ref())
+    }
+
+    pub fn execute(&mut self) -> i32 {
+        todo!();
+    }
+
+    pub fn load_schedule() {
+        todo!();
+    }
+
+    pub fn set_mode(&mut self, mode: VMMode) {
+        todo!();
+    }
+
+    pub fn start_timer() {
+        todo!();
+    }
+
+    pub fn stop_timer() {
+        todo!();
+    }
+
+    pub fn get_current_program_counter(&self) -> usize {
+        self.program_counter
+    }
+}