diff --git a/ristretto_classloader/src/value.rs b/ristretto_classloader/src/value.rs
index da715aad..85436aa7 100644
--- a/ristretto_classloader/src/value.rs
+++ b/ristretto_classloader/src/value.rs
@@ -1100,8 +1100,8 @@ mod tests {
     #[tokio::test]
     async fn test_from_class_vec() -> Result<()> {
         let original_class = load_class("[Ljava/lang/Object;").await?;
-        let original_value = vec![None];
-        let value = Value::from((original_class.clone(), original_value.clone()));
+        let original_value = vec![Value::Object(None)];
+        let value = Value::try_from((original_class.clone(), original_value.clone()))?;
         assert!(matches!(value, Value::Object(Some(Reference::Array(_)))));
         Ok(())
     }
diff --git a/ristretto_vm/src/instruction/array.rs b/ristretto_vm/src/instruction/array.rs
index 69b3cad4..789c1e51 100644
--- a/ristretto_vm/src/instruction/array.rs
+++ b/ristretto_vm/src/instruction/array.rs
@@ -7,7 +7,7 @@ use crate::operand_stack::OperandStack;
 use crate::thread::Thread;
 use ristretto_classfile::BaseType;
 use ristretto_classfile::attributes::ArrayType;
-use ristretto_classloader::Reference;
+use ristretto_classloader::{Reference, Value};
 
 /// See: <https://docs.oracle.com/javase/specs/jvms/se24/html/jvms-6.html#jvms-6.5.newarray>
 #[inline]
@@ -18,15 +18,15 @@ pub(crate) fn newarray(
     let count = stack.pop_int()?;
     let count = usize::try_from(count)?;
     let array = match array_type {
-        ArrayType::Char => Reference::from(vec![0 as char; count]),
-        ArrayType::Float => Reference::from(vec![0.0f32; count]),
-        ArrayType::Double => Reference::from(vec![0.0f64; count]),
-        ArrayType::Boolean | ArrayType::Byte => Reference::from(vec![0i8; count]),
-        ArrayType::Short => Reference::from(vec![0i16; count]),
-        ArrayType::Int => Reference::from(vec![0i32; count]),
-        ArrayType::Long => Reference::from(vec![0i64; count]),
+        ArrayType::Char => Value::from(vec![0 as char; count]),
+        ArrayType::Float => Value::from(vec![0.0f32; count]),
+        ArrayType::Double => Value::from(vec![0.0f64; count]),
+        ArrayType::Boolean | ArrayType::Byte => Value::from(vec![0i8; count]),
+        ArrayType::Short => Value::from(vec![0i16; count]),
+        ArrayType::Int => Value::from(vec![0i32; count]),
+        ArrayType::Long => Value::from(vec![0i64; count]),
     };
-    stack.push_object(Some(array))?;
+    stack.push(array)?;
     Ok(Continue)
 }
 
@@ -44,8 +44,8 @@ pub(crate) async fn anewarray(
     let class = thread.class(array_class_name.as_str()).await?;
     let count = stack.pop_int()?;
     let count = usize::try_from(count)?;
-    let array = Reference::from((class, vec![None; count]));
-    stack.push_object(Some(array))?;
+    let array = Value::from((class, vec![None; count]));
+    stack.push(array)?;
     Ok(Continue)
 }
 
diff --git a/ristretto_vm/src/instruction/branch.rs b/ristretto_vm/src/instruction/branch.rs
index a9e7be56..07ace85e 100644
--- a/ristretto_vm/src/instruction/branch.rs
+++ b/ristretto_vm/src/instruction/branch.rs
@@ -274,7 +274,7 @@ pub(crate) fn ifnonnull(stack: &mut OperandStack, address: u16) -> Result<Execut
 mod test {
     use super::*;
     use crate::java_object::JavaObject;
-    use ristretto_classloader::Reference;
+    use ristretto_classloader::Value;
 
     #[test]
     fn test_ifeq_equal() -> Result<()> {
@@ -565,9 +565,9 @@ mod test {
     #[test]
     fn test_if_acmpeq_equal() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let object = Reference::from(vec![42i8]);
-        stack.push_object(Some(object.clone()))?;
-        stack.push_object(Some(object.clone()))?;
+        let object = Value::from(vec![42i8]);
+        stack.push(object.clone())?;
+        stack.push(object.clone())?;
         let result = if_acmpeq(stack, 3)?;
         assert_eq!(ContinueAtPosition(3), result);
         Ok(())
@@ -576,13 +576,13 @@ mod test {
     #[test]
     fn test_if_acmpeq_not_equal() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let object = Reference::from(vec![42i8]);
+        let object = Value::from(vec![42i8]);
         stack.push_object(None)?;
-        stack.push_object(Some(object.clone()))?;
+        stack.push(object.clone())?;
         let result = if_acmpeq(stack, 3)?;
         assert_eq!(Continue, result);
-        stack.push_object(Some(object.clone()))?;
-        stack.push_object(Some(object.clone()))?;
+        stack.push(object.clone())?;
+        stack.push(object.clone())?;
         let result = if_acmpeq(stack, 3)?;
         assert_eq!(ContinueAtPosition(3), result);
         Ok(())
@@ -632,9 +632,9 @@ mod test {
     #[test]
     fn test_if_acmpne_equal() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let object = Reference::from(vec![42i8]);
-        stack.push_object(Some(object.clone()))?;
-        stack.push_object(Some(object.clone()))?;
+        let object = Value::from(vec![42i8]);
+        stack.push(object.clone())?;
+        stack.push(object.clone())?;
         let result = if_acmpne(stack, 3)?;
         assert_eq!(Continue, result);
         Ok(())
@@ -643,9 +643,9 @@ mod test {
     #[test]
     fn test_if_acmpne_not_equal() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let object = Reference::from(vec![42i8]);
+        let object = Value::from(vec![42i8]);
         stack.push_object(None)?;
-        stack.push_object(Some(object.clone()))?;
+        stack.push(object.clone())?;
         let result = if_acmpne(stack, 3)?;
         assert_eq!(ContinueAtPosition(3), result);
         Ok(())
@@ -802,8 +802,8 @@ mod test {
     #[test]
     fn test_ifnull_not_null() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(1);
-        let object = Reference::from(vec![42i8]);
-        stack.push_object(Some(object))?;
+        let object = Value::from(vec![42i8]);
+        stack.push(object)?;
         let result = ifnull(stack, 3)?;
         assert_eq!(Continue, result);
         Ok(())
@@ -821,8 +821,8 @@ mod test {
     #[test]
     fn test_ifnonnull_not_null() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(1);
-        let object = Reference::from(vec![42i8]);
-        stack.push_object(Some(object))?;
+        let object = Value::from(vec![42i8]);
+        stack.push(object)?;
         let result = ifnonnull(stack, 3)?;
         assert_eq!(ContinueAtPosition(3), result);
         Ok(())
diff --git a/ristretto_vm/src/instruction/byte.rs b/ristretto_vm/src/instruction/byte.rs
index 61e08f6f..2ea788d0 100644
--- a/ristretto_vm/src/instruction/byte.rs
+++ b/ristretto_vm/src/instruction/byte.rs
@@ -71,12 +71,13 @@ pub(crate) fn bastore(stack: &mut OperandStack) -> Result<ExecutionResult> {
 mod test {
     use super::*;
     use crate::Error::JavaError;
+    use ristretto_classloader::Value;
 
     #[test]
     fn test_baload() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let array = Reference::from(vec![42i8]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![42i8]);
+        stack.push(array)?;
         stack.push_int(0)?;
         let result = baload(stack)?;
         assert_eq!(Continue, result);
@@ -87,8 +88,8 @@ mod test {
     #[test]
     fn test_baload_invalid_value() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let object = Reference::from(vec![42i32]);
-        stack.push_object(Some(object))?;
+        let object = Value::from(vec![42i32]);
+        stack.push(object)?;
         stack.push_int(2)?;
         let result = baload(stack);
         assert!(matches!(
@@ -104,8 +105,8 @@ mod test {
     #[test]
     fn test_baload_invalid_index_negative() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let array = Reference::from(vec![42i8]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![42i8]);
+        stack.push(array)?;
         stack.push_int(-1)?;
         let result = baload(stack);
         assert!(matches!(
@@ -119,8 +120,8 @@ mod test {
     #[test]
     fn test_baload_invalid_index() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let array = Reference::from(vec![42i8]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![42i8]);
+        stack.push(array)?;
         stack.push_int(2)?;
         let result = baload(stack);
         assert!(matches!(
@@ -144,8 +145,8 @@ mod test {
     #[test]
     fn test_bastore() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let array = Reference::from(vec![3i8]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![3i8]);
+        stack.push(array)?;
         stack.push_int(0)?;
         stack.push_int(42)?;
         let result = bastore(stack)?;
@@ -156,8 +157,8 @@ mod test {
     #[test]
     fn test_bastore_invalid_value() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let object = Reference::from(vec![42i32]);
-        stack.push_object(Some(object))?;
+        let object = Value::from(vec![42i32]);
+        stack.push(object)?;
         stack.push_int(2)?;
         stack.push_int(42)?;
         let result = bastore(stack);
@@ -174,8 +175,8 @@ mod test {
     #[test]
     fn test_bastore_invalid_index_negative() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let array = Reference::from(vec![3i8]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![3i8]);
+        stack.push(array)?;
         stack.push_int(-1)?;
         stack.push_int(42)?;
         let result = bastore(stack);
@@ -190,8 +191,8 @@ mod test {
     #[test]
     fn test_bastore_invalid_index() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let array = Reference::from(vec![3i8]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![3i8]);
+        stack.push(array)?;
         stack.push_int(2)?;
         stack.push_int(42)?;
         let result = bastore(stack);
diff --git a/ristretto_vm/src/instruction/char.rs b/ristretto_vm/src/instruction/char.rs
index f21f3eca..f591c769 100644
--- a/ristretto_vm/src/instruction/char.rs
+++ b/ristretto_vm/src/instruction/char.rs
@@ -71,12 +71,13 @@ pub(crate) fn castore(stack: &mut OperandStack) -> Result<ExecutionResult> {
 mod test {
     use super::*;
     use crate::Error::JavaError;
+    use ristretto_classloader::Value;
 
     #[test]
     fn test_caload() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let array = Reference::from(vec![42 as char]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![42 as char]);
+        stack.push(array)?;
         stack.push_int(0)?;
         let result = caload(stack)?;
         assert_eq!(Continue, result);
@@ -87,8 +88,8 @@ mod test {
     #[test]
     fn test_caload_invalid_value() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let object = Reference::from(vec![42i32]);
-        stack.push_object(Some(object))?;
+        let object = Value::from(vec![42i32]);
+        stack.push(object)?;
         stack.push_int(2)?;
         let result = caload(stack);
         assert!(matches!(
@@ -104,8 +105,8 @@ mod test {
     #[test]
     fn test_caload_invalid_index_negative() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let array = Reference::from(vec![42 as char]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![42 as char]);
+        stack.push(array)?;
         stack.push_int(-1)?;
         let result = caload(stack);
         assert!(matches!(
@@ -119,8 +120,8 @@ mod test {
     #[test]
     fn test_caload_invalid_index() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let array = Reference::from(vec![42 as char]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![42 as char]);
+        stack.push(array)?;
         stack.push_int(2)?;
         let result = caload(stack);
         assert!(matches!(
@@ -144,8 +145,8 @@ mod test {
     #[test]
     fn test_castore() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let array = Reference::from(vec![3 as char]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![3 as char]);
+        stack.push(array)?;
         stack.push_int(0)?;
         stack.push_int(42)?;
         let result = castore(stack)?;
@@ -156,8 +157,8 @@ mod test {
     #[test]
     fn test_castore_invalid_value() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let object = Reference::from(vec![42i32]);
-        stack.push_object(Some(object))?;
+        let object = Value::from(vec![42i32]);
+        stack.push(object)?;
         stack.push_int(2)?;
         stack.push_int(42)?;
         let result = castore(stack);
@@ -174,8 +175,8 @@ mod test {
     #[test]
     fn test_castore_invalid_index_negative() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let array = Reference::from(vec![3 as char]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![3 as char]);
+        stack.push(array)?;
         stack.push_int(-1)?;
         stack.push_int(42)?;
         let result = castore(stack);
@@ -190,8 +191,8 @@ mod test {
     #[test]
     fn test_castore_invalid_index() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let array = Reference::from(vec![3 as char]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![3 as char]);
+        stack.push(array)?;
         stack.push_int(2)?;
         stack.push_int(42)?;
         let result = castore(stack);
diff --git a/ristretto_vm/src/instruction/double.rs b/ristretto_vm/src/instruction/double.rs
index b0805d04..7db57fdf 100644
--- a/ristretto_vm/src/instruction/double.rs
+++ b/ristretto_vm/src/instruction/double.rs
@@ -486,8 +486,8 @@ mod tests {
     #[test]
     fn test_daload() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let array = Reference::from(vec![42f64]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![42f64]);
+        stack.push(array)?;
         stack.push_int(0)?;
         let result = daload(stack)?;
         assert_eq!(Continue, result);
@@ -499,8 +499,8 @@ mod tests {
     #[test]
     fn test_daload_invalid_value() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let object = Reference::from(vec![42i32]);
-        stack.push_object(Some(object))?;
+        let object = Value::from(vec![42i32]);
+        stack.push(object)?;
         stack.push_int(2)?;
         let result = daload(stack);
         assert!(matches!(
@@ -516,8 +516,8 @@ mod tests {
     #[test]
     fn test_daload_invalid_index_negative() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let array = Reference::from(vec![42f64]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![42f64]);
+        stack.push(array)?;
         stack.push_int(-1)?;
         let result = daload(stack);
         assert!(matches!(
@@ -531,8 +531,8 @@ mod tests {
     #[test]
     fn test_daload_invalid_index() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let array = Reference::from(vec![42f64]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![42f64]);
+        stack.push(array)?;
         stack.push_int(2)?;
         let result = daload(stack);
         assert!(matches!(
@@ -556,8 +556,8 @@ mod tests {
     #[test]
     fn test_dastore() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let array = Reference::from(vec![3f64]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![3f64]);
+        stack.push(array)?;
         stack.push_int(0)?;
         stack.push_double(42f64)?;
         let result = dastore(stack)?;
@@ -568,8 +568,8 @@ mod tests {
     #[test]
     fn test_dastore_invalid_value() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let object = Reference::from(vec![42i32]);
-        stack.push_object(Some(object))?;
+        let object = Value::from(vec![42i32]);
+        stack.push(object)?;
         stack.push_int(2)?;
         stack.push_double(42f64)?;
         let result = dastore(stack);
@@ -586,8 +586,8 @@ mod tests {
     #[test]
     fn test_dastore_invalid_index_negative() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let array = Reference::from(vec![3f64]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![3f64]);
+        stack.push(array)?;
         stack.push_int(-1)?;
         stack.push_double(42f64)?;
         let result = dastore(stack);
@@ -602,8 +602,8 @@ mod tests {
     #[test]
     fn test_dastore_invalid_index() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let array = Reference::from(vec![3f64]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![3f64]);
+        stack.push(array)?;
         stack.push_int(2)?;
         stack.push_double(42f64)?;
         let result = dastore(stack);
diff --git a/ristretto_vm/src/instruction/exception.rs b/ristretto_vm/src/instruction/exception.rs
index 0a60124c..6d91f943 100644
--- a/ristretto_vm/src/instruction/exception.rs
+++ b/ristretto_vm/src/instruction/exception.rs
@@ -3,7 +3,7 @@ use crate::assignable::Assignable;
 use crate::frame::{ExecutionResult, Frame};
 use crate::operand_stack::OperandStack;
 use crate::{Error, Result, VM};
-use ristretto_classloader::{Object, Reference};
+use ristretto_classloader::{Object, Reference, Value};
 use std::sync::Arc;
 
 /// See: <https://docs.oracle.com/javase/specs/jvms/se24/html/jvms-6.html#jvms-6.5.athrow>
@@ -56,7 +56,7 @@ pub(crate) async fn process_throwable(
 
         if matching_exception_handler {
             let handler_program_counter = usize::from(exception_table_entry.handler_pc);
-            stack.push_object(Some(Reference::from(throwable)))?;
+            stack.push(Value::from(throwable))?;
             return Ok(handler_program_counter);
         }
     }
diff --git a/ristretto_vm/src/instruction/float.rs b/ristretto_vm/src/instruction/float.rs
index b2116d9c..3784d087 100644
--- a/ristretto_vm/src/instruction/float.rs
+++ b/ristretto_vm/src/instruction/float.rs
@@ -503,8 +503,8 @@ mod tests {
     #[test]
     fn test_faload() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let array = Reference::from(vec![42f32]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![42f32]);
+        stack.push(array)?;
         stack.push_int(0)?;
         let result = faload(stack)?;
         assert_eq!(Continue, result);
@@ -516,8 +516,8 @@ mod tests {
     #[test]
     fn test_faload_invalid_value() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let object = Reference::from(vec![42i32]);
-        stack.push_object(Some(object))?;
+        let object = Value::from(vec![42i32]);
+        stack.push(object)?;
         stack.push_int(2)?;
         let result = faload(stack);
         assert!(matches!(
@@ -533,8 +533,8 @@ mod tests {
     #[test]
     fn test_faload_invalid_index_negative() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let array = Reference::from(vec![42f32]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![42f32]);
+        stack.push(array)?;
         stack.push_int(-1)?;
         let result = faload(stack);
         assert!(matches!(
@@ -548,8 +548,8 @@ mod tests {
     #[test]
     fn test_faload_invalid_index() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let array = Reference::from(vec![42f32]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![42f32]);
+        stack.push(array)?;
         stack.push_int(2)?;
         let result = faload(stack);
         assert!(matches!(
@@ -573,8 +573,8 @@ mod tests {
     #[test]
     fn test_fastore() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let array = Reference::from(vec![3f32]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![3f32]);
+        stack.push(array)?;
         stack.push_int(0)?;
         stack.push_float(42f32)?;
         let result = fastore(stack)?;
@@ -585,8 +585,8 @@ mod tests {
     #[test]
     fn test_fastore_invalid_value() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let object = Reference::from(vec![42i32]);
-        stack.push_object(Some(object))?;
+        let object = Value::from(vec![42i32]);
+        stack.push(object)?;
         stack.push_int(2)?;
         stack.push_float(42f32)?;
         let result = fastore(stack);
@@ -603,8 +603,8 @@ mod tests {
     #[test]
     fn test_fastore_invalid_index_negative() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let array = Reference::from(vec![3f32]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![3f32]);
+        stack.push(array)?;
         stack.push_int(-1)?;
         stack.push_float(42f32)?;
         let result = fastore(stack);
@@ -619,8 +619,8 @@ mod tests {
     #[test]
     fn test_fastore_invalid_index() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let array = Reference::from(vec![3f32]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![3f32]);
+        stack.push(array)?;
         stack.push_int(2)?;
         stack.push_float(42f32)?;
         let result = fastore(stack);
diff --git a/ristretto_vm/src/instruction/integer.rs b/ristretto_vm/src/instruction/integer.rs
index 43922318..69790abe 100644
--- a/ristretto_vm/src/instruction/integer.rs
+++ b/ristretto_vm/src/instruction/integer.rs
@@ -621,8 +621,8 @@ mod tests {
     #[test]
     fn test_iaload() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let array = Reference::from(vec![42i32]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![42i32]);
+        stack.push(array)?;
         stack.push_int(0)?;
         let result = iaload(stack)?;
         assert_eq!(Continue, result);
@@ -633,8 +633,8 @@ mod tests {
     #[test]
     fn test_iaload_invalid_value() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let object = Reference::from(vec![42i8]);
-        stack.push_object(Some(object))?;
+        let object = Value::from(vec![42i8]);
+        stack.push(object)?;
         stack.push_int(2)?;
         let result = iaload(stack);
         assert!(matches!(
@@ -650,8 +650,8 @@ mod tests {
     #[test]
     fn test_iaload_invalid_index_negative() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let array = Reference::from(vec![42i32]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![42i32]);
+        stack.push(array)?;
         stack.push_int(-1)?;
         let result = iaload(stack);
         assert!(matches!(
@@ -665,8 +665,8 @@ mod tests {
     #[test]
     fn test_iaload_invalid_index() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let array = Reference::from(vec![42i32]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![42i32]);
+        stack.push(array)?;
         stack.push_int(2)?;
         let result = iaload(stack);
         assert!(matches!(
@@ -690,8 +690,8 @@ mod tests {
     #[test]
     fn test_iastore() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let array = Reference::from(vec![3i32]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![3i32]);
+        stack.push(array)?;
         stack.push_int(0)?;
         stack.push_int(42)?;
         let result = iastore(stack)?;
@@ -702,8 +702,8 @@ mod tests {
     #[test]
     fn test_iastore_invalid_value() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let object = Reference::from(vec![42i8]);
-        stack.push_object(Some(object))?;
+        let object = Value::from(vec![42i8]);
+        stack.push(object)?;
         stack.push_int(2)?;
         stack.push_int(42)?;
         let result = iastore(stack);
@@ -720,8 +720,8 @@ mod tests {
     #[test]
     fn test_iastore_invalid_index_negative() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let array = Reference::from(vec![3i32]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![3i32]);
+        stack.push(array)?;
         stack.push_int(-1)?;
         stack.push_int(42)?;
         let result = iastore(stack);
@@ -736,8 +736,8 @@ mod tests {
     #[test]
     fn test_iastore_invalid_index() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let array = Reference::from(vec![3i32]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![3i32]);
+        stack.push(array)?;
         stack.push_int(2)?;
         stack.push_int(42)?;
         let result = iastore(stack);
diff --git a/ristretto_vm/src/instruction/long.rs b/ristretto_vm/src/instruction/long.rs
index 58764b96..48651b90 100644
--- a/ristretto_vm/src/instruction/long.rs
+++ b/ristretto_vm/src/instruction/long.rs
@@ -524,8 +524,8 @@ mod tests {
     #[test]
     fn test_laload() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let array = Reference::from(vec![42i64]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![42i64]);
+        stack.push(array)?;
         stack.push_int(0)?;
         let result = laload(stack)?;
         assert_eq!(Continue, result);
@@ -536,8 +536,8 @@ mod tests {
     #[test]
     fn test_laload_invalid_value() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let object = Reference::from(vec![42i32]);
-        stack.push_object(Some(object))?;
+        let object = Value::from(vec![42i32]);
+        stack.push(object)?;
         stack.push_int(2)?;
         let result = laload(stack);
         assert!(matches!(
@@ -553,8 +553,8 @@ mod tests {
     #[test]
     fn test_laload_invalid_index_negative() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let array = Reference::from(vec![42i64]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![42i64]);
+        stack.push(array)?;
         stack.push_int(-1)?;
         let result = laload(stack);
         assert!(matches!(
@@ -568,8 +568,8 @@ mod tests {
     #[test]
     fn test_laload_invalid_index() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let array = Reference::from(vec![42i64]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![42i64]);
+        stack.push(array)?;
         stack.push_int(2)?;
         let result = laload(stack);
         assert!(matches!(
@@ -593,8 +593,8 @@ mod tests {
     #[test]
     fn test_lastore() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let array = Reference::from(vec![3i64]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![3i64]);
+        stack.push(array)?;
         stack.push_int(0)?;
         stack.push_long(42)?;
         let result = lastore(stack)?;
@@ -605,8 +605,8 @@ mod tests {
     #[test]
     fn test_lastore_invalid_value() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let object = Reference::from(vec![42i32]);
-        stack.push_object(Some(object))?;
+        let object = Value::from(vec![42i32]);
+        stack.push(object)?;
         stack.push_int(2)?;
         stack.push_long(42)?;
         let result = lastore(stack);
@@ -623,8 +623,8 @@ mod tests {
     #[test]
     fn test_lastore_invalid_index_negative() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let array = Reference::from(vec![3i64]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![3i64]);
+        stack.push(array)?;
         stack.push_int(-1)?;
         stack.push_long(42)?;
         let result = lastore(stack);
@@ -639,8 +639,8 @@ mod tests {
     #[test]
     fn test_lastore_invalid_index() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let array = Reference::from(vec![3i64]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![3i64]);
+        stack.push(array)?;
         stack.push_int(2)?;
         stack.push_long(42)?;
         let result = lastore(stack);
diff --git a/ristretto_vm/src/instruction/object.rs b/ristretto_vm/src/instruction/object.rs
index 291d042a..7338ea6d 100644
--- a/ristretto_vm/src/instruction/object.rs
+++ b/ristretto_vm/src/instruction/object.rs
@@ -237,8 +237,8 @@ pub(crate) async fn new(
     let class_name = constant_pool.try_get_class(index)?;
     let class = thread.class(class_name).await?;
     let object = Object::new(class)?;
-    let reference = Reference::from(object);
-    stack.push_object(Some(reference))?;
+    let reference = Value::from(object);
+    stack.push(reference)?;
     Ok(Continue)
 }
 
@@ -326,7 +326,6 @@ mod tests {
     use crate::Error::{InvalidOperand, JavaError};
     use crate::JavaError::NullPointerException;
     use crate::java_object::JavaObject;
-    use ristretto_classloader::ConcurrentVec;
     use std::sync::Arc;
 
     #[test]
@@ -475,21 +474,21 @@ mod tests {
         let (_vm, thread, _frame) = crate::test::frame().await?;
         let stack = &mut OperandStack::with_max_size(2);
         let class = thread.class("java/lang/Object").await?;
-        let object = Reference::from(vec![42i32]);
-        let array = Reference::from((class, vec![Some(object.clone())]));
-        stack.push_object(Some(array))?;
+        let object = Value::from(vec![42i32]);
+        let array = Value::try_from((class, vec![object.clone()]))?;
+        stack.push(array)?;
         stack.push_int(0)?;
         let result = aaload(stack)?;
         assert_eq!(Continue, result);
-        assert_eq!(Some(object), stack.pop_object()?);
+        assert_eq!(object, stack.pop()?);
         Ok(())
     }
 
     #[test]
     fn test_aaload_invalid_value() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let object = Reference::from(vec![42i32]);
-        stack.push_object(Some(object))?;
+        let object = Value::from(vec![42i32]);
+        stack.push(object)?;
         stack.push_int(2)?;
         let result = aaload(stack);
         assert!(matches!(
@@ -507,9 +506,9 @@ mod tests {
         let (_vm, thread, _frame) = crate::test::frame().await?;
         let stack = &mut OperandStack::with_max_size(2);
         let class = thread.class("java/lang/Object").await?;
-        let object = Reference::from(vec![42i32]);
-        let array = Reference::from((class, vec![Some(object.clone())]));
-        stack.push_object(Some(array))?;
+        let object = Value::from(vec![42i32]);
+        let array = Value::try_from((class, vec![object.clone()]))?;
+        stack.push(array)?;
         stack.push_int(-1)?;
         let result = aaload(stack);
         assert!(matches!(
@@ -525,9 +524,9 @@ mod tests {
         let (_vm, thread, _frame) = crate::test::frame().await?;
         let stack = &mut OperandStack::with_max_size(2);
         let class = thread.class("java/lang/Object").await?;
-        let object = Reference::from(vec![42i32]);
-        let array = Reference::from((class, vec![Some(object.clone())]));
-        stack.push_object(Some(array))?;
+        let object = Value::from(vec![42i32]);
+        let array = Value::try_from((class, vec![object.clone()]))?;
+        stack.push(array)?;
         stack.push_int(2)?;
         let result = aaload(stack);
         assert!(matches!(
@@ -553,11 +552,11 @@ mod tests {
         let (_vm, thread, _frame) = crate::test::frame().await?;
         let stack = &mut OperandStack::with_max_size(3);
         let class = thread.class("java/lang/Object").await?;
-        let object = Reference::from(vec![3i32]);
-        let array = Reference::from((class, vec![Some(object)]));
-        stack.push_object(Some(array))?;
+        let object = Value::from(vec![3i32]);
+        let array = Value::try_from((class, vec![object]))?;
+        stack.push(array)?;
         stack.push_int(0)?;
-        stack.push_object(Some(Reference::from(vec![3i32])))?;
+        stack.push(Value::from(vec![3i32]))?;
         let result = aastore(stack)?;
         assert_eq!(Continue, result);
         Ok(())
@@ -566,10 +565,10 @@ mod tests {
     #[test]
     fn test_aastore_invalid_value() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let object = Reference::from(vec![42i32]);
-        stack.push_object(Some(object.clone()))?;
+        let object = Value::from(vec![42i32]);
+        stack.push(object.clone())?;
         stack.push_int(0)?;
-        stack.push_object(Some(object))?;
+        stack.push(object)?;
         let result = aastore(stack);
         assert!(matches!(
             result,
@@ -586,11 +585,11 @@ mod tests {
         let (_vm, thread, _frame) = crate::test::frame().await?;
         let stack = &mut OperandStack::with_max_size(3);
         let class = thread.class("java/lang/Object").await?;
-        let object = Reference::from(vec![3i32]);
-        let array = Reference::from((class, vec![Some(object.clone())]));
-        stack.push_object(Some(array))?;
+        let object = Value::from(vec![3i32]);
+        let array = Value::try_from((class, vec![object.clone()]))?;
+        stack.push(array)?;
         stack.push_int(-1)?;
-        stack.push_object(Some(object))?;
+        stack.push(object)?;
         let result = aastore(stack);
         assert!(matches!(
             result,
@@ -605,11 +604,11 @@ mod tests {
         let (_vm, thread, _frame) = crate::test::frame().await?;
         let stack = &mut OperandStack::with_max_size(3);
         let class = thread.class("java/lang/Object").await?;
-        let object = Reference::from(vec![3i32]);
-        let array = Reference::from((class, vec![Some(object.clone())]));
-        stack.push_object(Some(array))?;
+        let object = Value::from(vec![3i32]);
+        let array = Value::try_from((class, vec![object.clone()]))?;
+        stack.push(array)?;
         stack.push_int(2)?;
-        stack.push_object(Some(object))?;
+        stack.push(object)?;
         let result = aastore(stack);
         assert!(matches!(
             result,
@@ -622,10 +621,10 @@ mod tests {
     #[test]
     fn test_aastore_null_pointer() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let object = Reference::from(vec![3i32]);
+        let object = Value::from(vec![3i32]);
         stack.push_object(None)?;
         stack.push_int(0)?;
-        stack.push_object(Some(object))?;
+        stack.push(object)?;
         let result = aastore(stack);
         assert!(matches!(result, Err(JavaError(NullPointerException(_)))));
         Ok(())
@@ -634,8 +633,8 @@ mod tests {
     #[test]
     fn test_areturn_object() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(1);
-        let object = Reference::from(vec![42i8]);
-        stack.push_object(Some(object))?;
+        let object = Value::from(vec![42i8]);
+        stack.push(object)?;
         let result = areturn(stack)?;
         assert!(matches!(result, Return(Some(Value::Object(_)))));
         Ok(())
@@ -715,7 +714,7 @@ mod tests {
         let stack = &mut OperandStack::with_max_size(1);
         let object_class = thread.class("java/lang/Object").await?;
         let object = Object::new(object_class)?;
-        stack.push_object(Some(Reference::from(object)))?;
+        stack.push(Value::from(object))?;
         let class_index = get_class_index(&mut frame, "java/lang/String")?;
         let result = checkcast(&frame, stack, class_index).await;
         assert!(matches!(
@@ -731,8 +730,8 @@ mod tests {
         let (_vm, thread, mut frame) = crate::test::frame().await?;
         let stack = &mut OperandStack::with_max_size(1);
         let string_class = thread.class("[Ljava/lang/String;").await?;
-        let string_array = Reference::from((string_class, Vec::new()));
-        stack.push_object(Some(string_array))?;
+        let string_array = Value::from((string_class, Vec::new()));
+        stack.push(string_array)?;
         let class_index = get_class_index(&mut frame, "[Ljava/lang/Object;")?;
         let result = checkcast(&frame, stack, class_index).await?;
         assert_eq!(Continue, result);
@@ -770,7 +769,7 @@ mod tests {
         let stack = &mut OperandStack::with_max_size(1);
         let object_class = thread.class("java/lang/Object").await?;
         let object = Object::new(object_class)?;
-        stack.push_object(Some(Reference::from(object)))?;
+        stack.push(Value::from(object))?;
         let class_index = get_class_index(&mut frame, "java/lang/String")?;
         let result = instanceof(&frame, stack, class_index).await?;
         assert_eq!(Continue, result);
@@ -783,8 +782,8 @@ mod tests {
         let (_vm, thread, mut frame) = crate::test::frame().await?;
         let stack = &mut OperandStack::with_max_size(1);
         let string_class = thread.class("[Ljava/lang/String;").await?;
-        let string_array = Reference::from((string_class, Vec::new()));
-        stack.push_object(Some(string_array))?;
+        let string_array = Value::try_from((string_class, Vec::<Value>::new()))?;
+        stack.push(string_array)?;
         let class_index = get_class_index(&mut frame, "java/lang/Object")?;
         let result = instanceof(&frame, stack, class_index).await?;
         assert_eq!(Continue, result);
@@ -797,8 +796,8 @@ mod tests {
         let (_vm, thread, mut frame) = crate::test::frame().await?;
         let stack = &mut OperandStack::with_max_size(1);
         let object_class = thread.class("[Ljava/lang/Object;").await?;
-        let object_array = Reference::from((object_class, Vec::new()));
-        stack.push_object(Some(object_array))?;
+        let object_array = Value::try_from((object_class, Vec::<Value>::new()))?;
+        stack.push(object_array)?;
         let class_index = get_class_index(&mut frame, "java/lang/String")?;
         let result = instanceof(&frame, stack, class_index).await?;
         assert_eq!(Continue, result);
@@ -810,8 +809,8 @@ mod tests {
     async fn test_instanceof_int_array_to_int_array() -> Result<()> {
         let (_vm, _thread, mut frame) = crate::test::frame().await?;
         let stack = &mut OperandStack::with_max_size(1);
-        let int_array = Reference::from(vec![0i32; 0]);
-        stack.push_object(Some(int_array))?;
+        let int_array = Value::from(vec![0i32; 0]);
+        stack.push(int_array)?;
         let class_index = get_class_index(&mut frame, "[I")?;
         let result = instanceof(&frame, stack, class_index).await?;
         assert_eq!(Continue, result);
@@ -823,8 +822,8 @@ mod tests {
     async fn test_instanceof_long_array_to_int_array() -> Result<()> {
         let (_vm, _thread, mut frame) = crate::test::frame().await?;
         let stack = &mut OperandStack::with_max_size(1);
-        let long_array = Reference::LongArray(ConcurrentVec::default());
-        stack.push_object(Some(long_array))?;
+        let long_array = Value::from(Vec::<i64>::new());
+        stack.push(long_array)?;
         let class_index = get_class_index(&mut frame, "[I")?;
         let result = instanceof(&frame, stack, class_index).await?;
         assert_eq!(Continue, result);
diff --git a/ristretto_vm/src/instruction/short.rs b/ristretto_vm/src/instruction/short.rs
index dbc77da8..9bd686f2 100644
--- a/ristretto_vm/src/instruction/short.rs
+++ b/ristretto_vm/src/instruction/short.rs
@@ -71,12 +71,13 @@ pub(crate) fn sastore(stack: &mut OperandStack) -> Result<ExecutionResult> {
 mod test {
     use super::*;
     use crate::Error::JavaError;
+    use ristretto_classloader::Value;
 
     #[test]
     fn test_saload() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let array = Reference::from(vec![42i16]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![42i16]);
+        stack.push(array)?;
         stack.push_int(0)?;
         let result = saload(stack)?;
         assert_eq!(Continue, result);
@@ -87,8 +88,8 @@ mod test {
     #[test]
     fn test_saload_invalid_value() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let object = Reference::from(vec![42i32]);
-        stack.push_object(Some(object))?;
+        let object = Value::from(vec![42i32]);
+        stack.push(object)?;
         stack.push_int(2)?;
         let result = saload(stack);
         assert!(matches!(
@@ -104,8 +105,8 @@ mod test {
     #[test]
     fn test_saload_invalid_index_negative() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let array = Reference::from(vec![42i16]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![42i16]);
+        stack.push(array)?;
         stack.push_int(-1)?;
         let result = saload(stack);
         assert!(matches!(
@@ -119,8 +120,8 @@ mod test {
     #[test]
     fn test_saload_invalid_index() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(2);
-        let array = Reference::from(vec![42i16]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![42i16]);
+        stack.push(array)?;
         stack.push_int(2)?;
         let result = saload(stack);
         assert!(matches!(
@@ -144,8 +145,8 @@ mod test {
     #[test]
     fn test_sastore() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let array = Reference::from(vec![3i16]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![3i16]);
+        stack.push(array)?;
         stack.push_int(0)?;
         stack.push_int(42)?;
         let result = sastore(stack)?;
@@ -156,8 +157,8 @@ mod test {
     #[test]
     fn test_sastore_invalid_value() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let object = Reference::from(vec![42i32]);
-        stack.push_object(Some(object))?;
+        let object = Value::from(vec![42i32]);
+        stack.push(object)?;
         stack.push_int(2)?;
         stack.push_int(42)?;
         let result = sastore(stack);
@@ -174,8 +175,8 @@ mod test {
     #[test]
     fn test_sastore_invalid_index_negative() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let array = Reference::from(vec![3i16]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![3i16]);
+        stack.push(array)?;
         stack.push_int(-1)?;
         stack.push_int(42)?;
         let result = sastore(stack);
@@ -190,8 +191,8 @@ mod test {
     #[test]
     fn test_sastore_invalid_index() -> Result<()> {
         let stack = &mut OperandStack::with_max_size(3);
-        let array = Reference::from(vec![3i16]);
-        stack.push_object(Some(array))?;
+        let array = Value::from(vec![3i16]);
+        stack.push(array)?;
         stack.push_int(2)?;
         stack.push_int(42)?;
         let result = sastore(stack);
diff --git a/ristretto_vm/src/intrinsic_methods/java/io/objectinputstream.rs b/ristretto_vm/src/intrinsic_methods/java/io/objectinputstream.rs
index 6b242b0c..e60404fe 100644
--- a/ristretto_vm/src/intrinsic_methods/java/io/objectinputstream.rs
+++ b/ristretto_vm/src/intrinsic_methods/java/io/objectinputstream.rs
@@ -93,18 +93,17 @@ pub(crate) async fn bytes_to_floats(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use ristretto_classloader::Reference;
 
     #[tokio::test]
     async fn test_bytes_to_doubles() -> Result<()> {
         let (_vm, thread) = crate::test::thread().await.expect("thread");
         let mut parameters = Parameters::default();
         let bytes: Vec<i8> = vec![64, 8, 0, 0, 0, 0, 0, 0, 64, 69, 0, 0, 0, 0, 0, 0];
-        let source = Reference::from(bytes);
-        let destination = Reference::from(vec![0f64; 2]);
-        parameters.push_reference(Some(source));
+        let source = Value::from(bytes);
+        let destination = Value::from(vec![0f64; 2]);
+        parameters.push(source);
         parameters.push_int(0); // source position
-        parameters.push_reference(Some(destination.clone()));
+        parameters.push(destination.clone());
         parameters.push_int(0); // destination position
         parameters.push_int(2); // number of doubles
 
@@ -119,11 +118,11 @@ mod tests {
         let (_vm, thread) = crate::test::thread().await.expect("thread");
         let mut parameters = Parameters::default();
         let bytes: Vec<i8> = vec![64, 64, 0, 0, 66, 40, 0, 0];
-        let source = Reference::from(bytes);
-        let destination = Reference::from(vec![0f32; 2]);
-        parameters.push_reference(Some(source));
+        let source = Value::from(bytes);
+        let destination = Value::from(vec![0f32; 2]);
+        parameters.push(source);
         parameters.push_int(0); // source position
-        parameters.push_reference(Some(destination.clone()));
+        parameters.push(destination.clone());
         parameters.push_int(0); // destination position
         parameters.push_int(2); // number of floats
 
diff --git a/ristretto_vm/src/intrinsic_methods/java/io/objectoutputstream.rs b/ristretto_vm/src/intrinsic_methods/java/io/objectoutputstream.rs
index da82b454..ce0ed843 100644
--- a/ristretto_vm/src/intrinsic_methods/java/io/objectoutputstream.rs
+++ b/ristretto_vm/src/intrinsic_methods/java/io/objectoutputstream.rs
@@ -89,17 +89,16 @@ pub(crate) async fn floats_to_bytes(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use ristretto_classloader::Reference;
 
     #[tokio::test]
     async fn test_doubles_to_bytes() -> Result<()> {
         let (_vm, thread) = crate::test::thread().await.expect("thread");
         let mut parameters = Parameters::default();
-        let source = Reference::from(vec![3.0f64, 42.0f64]);
-        let destination = Reference::from(vec![0i8; 16]); // 2 doubles * 8 bytes each
-        parameters.push_reference(Some(source));
+        let source = Value::from(vec![3.0f64, 42.0f64]);
+        let destination = Value::from(vec![0i8; 16]); // 2 doubles * 8 bytes each
+        parameters.push(source);
         parameters.push_int(0); // source position
-        parameters.push_reference(Some(destination.clone()));
+        parameters.push(destination.clone());
         parameters.push_int(0); // destination position
         parameters.push_int(2); // number of doubles
 
@@ -116,11 +115,11 @@ mod tests {
     async fn test_floats_to_bytes() -> Result<()> {
         let (_vm, thread) = crate::test::thread().await.expect("thread");
         let mut parameters = Parameters::default();
-        let source = Reference::from(vec![3.0f32, 42.0f32]);
-        let destination = Reference::from(vec![0i8; 8]); // 2 floats * 4 bytes each
-        parameters.push_reference(Some(source));
+        let source = Value::from(vec![3.0f32, 42.0f32]);
+        let destination = Value::from(vec![0i8; 8]); // 2 floats * 4 bytes each
+        parameters.push(source);
         parameters.push_int(0); // source position
-        parameters.push_reference(Some(destination.clone()));
+        parameters.push(destination.clone());
         parameters.push_int(0); // destination position
         parameters.push_int(2); // number of floats
 
diff --git a/ristretto_vm/src/intrinsic_methods/java/lang/class.rs b/ristretto_vm/src/intrinsic_methods/java/lang/class.rs
index 35e8ce66..b54c3439 100644
--- a/ristretto_vm/src/intrinsic_methods/java/lang/class.rs
+++ b/ristretto_vm/src/intrinsic_methods/java/lang/class.rs
@@ -582,8 +582,8 @@ pub(crate) async fn get_enclosing_method_0(
             let object_array_class = thread.class("[Ljava/lang/Object;").await?;
             let enclosing_information = vec![class, method_name, method_descriptor];
             let enclosing_information_array =
-                Reference::try_from((object_array_class, enclosing_information))?;
-            return Ok(Some(Value::from(enclosing_information_array)));
+                Value::try_from((object_array_class, enclosing_information))?;
+            return Ok(Some(enclosing_information_array));
         }
     }
 
diff --git a/ristretto_vm/src/intrinsic_methods/java/lang/invoke/methodhandlenatives.rs b/ristretto_vm/src/intrinsic_methods/java/lang/invoke/methodhandlenatives.rs
index 38a20a7e..843f0874 100644
--- a/ristretto_vm/src/intrinsic_methods/java/lang/invoke/methodhandlenatives.rs
+++ b/ristretto_vm/src/intrinsic_methods/java/lang/invoke/methodhandlenatives.rs
@@ -555,7 +555,6 @@ pub(crate) async fn static_field_offset(
 mod tests {
     use super::*;
     use crate::JavaObject;
-    use ristretto_classloader::Reference;
 
     #[tokio::test]
     #[should_panic(
@@ -635,11 +634,11 @@ mod tests {
         let member_name_class = thread.class("java.lang.invoke.MemberName").await?;
         let member_name = Object::new(member_name_class)?;
         let class_object = thread.class("java.lang.Integer").await?;
-        let class = Reference::from(Object::new(class_object)?);
-        member_name.set_value("clazz", Value::from(class))?;
+        let class = Value::from(Object::new(class_object)?);
+        member_name.set_value("clazz", class)?;
         let value_string = "value".to_object(&thread).await?;
         member_name.set_value("name", value_string)?;
-        parameters.push_reference(Some(Reference::from(member_name)));
+        parameters.push(Value::from(member_name));
         let result = object_field_offset(thread, parameters).await?;
         assert_eq!(Some(Value::Long(7)), result);
         Ok(())
@@ -658,11 +657,11 @@ mod tests {
         let (_vm, thread) = crate::test::thread().await.expect("thread");
         let mut parameters = Parameters::default();
         let method_handle_class = thread.class("java.lang.invoke.MethodHandle").await?;
-        let method_handle = Reference::from(Object::new(method_handle_class)?);
-        parameters.push_reference(Some(method_handle));
+        let method_handle = Value::from(Object::new(method_handle_class)?);
+        parameters.push(method_handle);
         let call_site_class = thread.class("java.lang.invoke.CallSite").await?;
-        let call_site = Reference::from(Object::new(call_site_class)?);
-        parameters.push_reference(Some(call_site));
+        let call_site = Value::from(Object::new(call_site_class)?);
+        parameters.push(call_site);
         let result = set_call_site_target_normal(thread, parameters).await?;
         assert_eq!(None, result);
         Ok(())
@@ -673,11 +672,11 @@ mod tests {
         let (_vm, thread) = crate::test::thread().await.expect("thread");
         let mut parameters = Parameters::default();
         let method_handle_class = thread.class("java.lang.invoke.MethodHandle").await?;
-        let method_handle = Reference::from(Object::new(method_handle_class)?);
-        parameters.push_reference(Some(method_handle));
+        let method_handle = Value::from(Object::new(method_handle_class)?);
+        parameters.push(method_handle);
         let call_site_class = thread.class("java.lang.invoke.CallSite").await?;
-        let call_site = Reference::from(Object::new(call_site_class)?);
-        parameters.push_reference(Some(call_site));
+        let call_site = Value::from(Object::new(call_site_class)?);
+        parameters.push(call_site);
         let result = set_call_site_target_volatile(thread, parameters).await?;
         assert_eq!(None, result);
         Ok(())
@@ -690,11 +689,11 @@ mod tests {
         let member_name_class = thread.class("java.lang.invoke.MemberName").await?;
         let member_name = Object::new(member_name_class)?;
         let class_object = thread.class("java.lang.Integer").await?;
-        let class = Reference::from(Object::new(class_object)?);
-        member_name.set_value("clazz", Value::from(class.clone()))?;
-        parameters.push_reference(Some(Reference::from(member_name)));
+        let class = Value::from(Object::new(class_object)?);
+        member_name.set_value("clazz", class.clone())?;
+        parameters.push(Value::from(member_name));
         let result = static_field_base(thread, parameters).await?;
-        assert_eq!(Some(Value::from(class)), result);
+        assert_eq!(Some(class), result);
         Ok(())
     }
 
@@ -705,11 +704,11 @@ mod tests {
         let member_name_class = thread.class("java.lang.invoke.MemberName").await?;
         let member_name = Object::new(member_name_class)?;
         let class_object = thread.class("java.lang.Integer").await?;
-        let class = Reference::from(Object::new(class_object)?);
-        member_name.set_value("clazz", Value::from(class))?;
+        let class = Value::from(Object::new(class_object)?);
+        member_name.set_value("clazz", class)?;
         let value_string = "MAX_VALUE".to_object(&thread).await?;
         member_name.set_value("name", value_string)?;
-        parameters.push_reference(Some(Reference::from(member_name)));
+        parameters.push(Value::from(member_name));
         let result = static_field_offset(thread, parameters).await?;
         assert_eq!(Some(Value::Long(2)), result);
         Ok(())
diff --git a/ristretto_vm/src/intrinsic_methods/java/lang/processenvironment.rs b/ristretto_vm/src/intrinsic_methods/java/lang/processenvironment.rs
index 0df551b8..01afaa65 100644
--- a/ristretto_vm/src/intrinsic_methods/java/lang/processenvironment.rs
+++ b/ristretto_vm/src/intrinsic_methods/java/lang/processenvironment.rs
@@ -4,7 +4,7 @@ use crate::thread::Thread;
 use async_recursion::async_recursion;
 use ristretto_classfile::VersionSpecification::Any;
 use ristretto_classfile::mutf8;
-use ristretto_classloader::{Reference, Value};
+use ristretto_classloader::Value;
 use ristretto_macros::intrinsic_method;
 use std::sync::Arc;
 
@@ -13,12 +13,12 @@ use std::sync::Arc;
 pub(crate) async fn environ(thread: Arc<Thread>, _parameters: Parameters) -> Result<Option<Value>> {
     let mut values = Vec::new();
     for (key, value) in std::env::vars() {
-        let key = Some(Reference::from(mutf8::to_bytes(key)?));
+        let key = Value::from(mutf8::to_bytes(key)?);
         values.push(key);
-        let value = Some(Reference::from(mutf8::to_bytes(value)?));
+        let value = Value::from(mutf8::to_bytes(value)?);
         values.push(value);
     }
     let class = thread.class("[[B").await?;
-    let result = Reference::from((class, values));
-    Ok(Some(Value::Object(Some(result))))
+    let value = Value::try_from((class, values))?;
+    Ok(Some(value))
 }
diff --git a/ristretto_vm/src/intrinsic_methods/java/lang/reflect/array.rs b/ristretto_vm/src/intrinsic_methods/java/lang/reflect/array.rs
index 2c1d2ca4..638b6995 100644
--- a/ristretto_vm/src/intrinsic_methods/java/lang/reflect/array.rs
+++ b/ristretto_vm/src/intrinsic_methods/java/lang/reflect/array.rs
@@ -417,22 +417,21 @@ pub(crate) async fn new_array(
     let class_name = get_class_name(parameters.pop()?)?;
 
     let array = match class_name.as_str() {
-        "boolean" | "byte" => Reference::from(vec![0i8; length]),
-        "char" => Reference::from(vec![0 as char; length]),
-        "float" => Reference::from(vec![0.0f32; length]),
-        "double" => Reference::from(vec![0.0f64; length]),
-        "int" => Reference::from(vec![0i32; length]),
-        "long" => Reference::from(vec![0i64; length]),
-        "short" => Reference::from(vec![0i16; length]),
+        "boolean" | "byte" => Value::from(vec![0i8; length]),
+        "char" => Value::from(vec![0 as char; length]),
+        "float" => Value::from(vec![0.0f32; length]),
+        "double" => Value::from(vec![0.0f64; length]),
+        "int" => Value::from(vec![0i32; length]),
+        "long" => Value::from(vec![0i64; length]),
+        "short" => Value::from(vec![0i16; length]),
         _ => {
             let class_name = format!("[L{class_name};");
             let class = thread.class(&class_name).await?;
-            Reference::from((class, vec![None; length]))
+            Value::from((class, vec![None; length]))
         }
     };
 
-    let value = Value::from(array);
-    Ok(Some(value))
+    Ok(Some(array))
 }
 
 #[intrinsic_method(
diff --git a/ristretto_vm/src/intrinsic_methods/java/lang/system.rs b/ristretto_vm/src/intrinsic_methods/java/lang/system.rs
index 68493b52..1eccb39d 100644
--- a/ristretto_vm/src/intrinsic_methods/java/lang/system.rs
+++ b/ristretto_vm/src/intrinsic_methods/java/lang/system.rs
@@ -360,8 +360,7 @@ pub(crate) async fn register_natives(
         "jdk/internal/access"
     };
     let java_lang_ref_access = java_lang_ref_access_class(&thread, package_name).await?;
-    let java_lang_ref_access =
-        Value::Object(Some(Reference::Object(Object::new(java_lang_ref_access)?)));
+    let java_lang_ref_access = Value::from(Object::new(java_lang_ref_access)?);
     let shared_secrets_class = format!("{package_name}/SharedSecrets");
     thread
         .invoke(
diff --git a/ristretto_vm/src/intrinsic_methods/jdk/internal/reflect/constantpool.rs b/ristretto_vm/src/intrinsic_methods/jdk/internal/reflect/constantpool.rs
index 2c1a462d..bbf5c61e 100644
--- a/ristretto_vm/src/intrinsic_methods/jdk/internal/reflect/constantpool.rs
+++ b/ristretto_vm/src/intrinsic_methods/jdk/internal/reflect/constantpool.rs
@@ -6,7 +6,7 @@ use crate::{JavaObject, Result};
 use async_recursion::async_recursion;
 use ristretto_classfile::VersionSpecification::GreaterThanOrEqual;
 use ristretto_classfile::{Constant, FieldType, JAVA_11};
-use ristretto_classloader::{Object, Reference, Value};
+use ristretto_classloader::{Object, Value};
 use ristretto_macros::intrinsic_method;
 use std::sync::Arc;
 
@@ -228,8 +228,8 @@ pub(crate) async fn get_member_ref_info_at_0(
     let descriptor = descriptor.to_object(&thread).await?.to_reference()?;
     let string_class = thread.class("java/lang/String").await?;
     let string_array = vec![class_name, name, descriptor];
-    let results = Reference::from((string_class, string_array));
-    Ok(Some(Value::from(results)))
+    let results = Value::from((string_class, string_array));
+    Ok(Some(results))
 }
 
 #[intrinsic_method(
@@ -390,8 +390,8 @@ pub(crate) async fn get_name_and_type_ref_info_at_0(
     let descriptor = descriptor.to_object(&thread).await?.to_reference()?;
     let string_class = thread.class("java/lang/String").await?;
     let string_array = vec![name, descriptor];
-    let results = Reference::from((string_class, string_array));
-    Ok(Some(Value::from(results)))
+    let results = Value::from((string_class, string_array));
+    Ok(Some(results))
 }
 
 #[intrinsic_method(
@@ -479,7 +479,7 @@ pub(crate) mod tests {
         BaseType, ClassAccessFlags, ClassFile, ConstantPool, FieldAccessFlags, FieldType,
         MethodAccessFlags,
     };
-    use ristretto_classloader::Class;
+    use ristretto_classloader::{Class, Reference};
 
     pub(crate) async fn test_object() -> Result<(Arc<VM>, Arc<Thread>, Value)> {
         let (vm, thread) = crate::test::thread().await.expect("thread");
diff --git a/ristretto_vm/src/intrinsic_methods/jdk/internal/util/systemprops_raw.rs b/ristretto_vm/src/intrinsic_methods/jdk/internal/util/systemprops_raw.rs
index e1012487..ebcfdfc9 100644
--- a/ristretto_vm/src/intrinsic_methods/jdk/internal/util/systemprops_raw.rs
+++ b/ristretto_vm/src/intrinsic_methods/jdk/internal/util/systemprops_raw.rs
@@ -7,7 +7,7 @@ use crate::thread::Thread;
 use async_recursion::async_recursion;
 use ristretto_classfile::VersionSpecification::GreaterThanOrEqual;
 use ristretto_classfile::{JAVA_17, JAVA_21};
-use ristretto_classloader::{Reference, Value};
+use ristretto_classloader::Value;
 use ristretto_macros::intrinsic_method;
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -27,7 +27,7 @@ pub(crate) async fn platform_properties(
     let java_version = vm.java_major_version();
 
     // VM properties must be returned in a specific order as they are accessed by array index.
-    let mut properties: Vec<Option<Reference>> = Vec::new();
+    let mut properties: Vec<Value> = Vec::new();
     push_property(system_properties, &mut properties, "user.country")?;
     push_property(system_properties, &mut properties, "user.language")?;
     push_property(system_properties, &mut properties, "user.script")?;
@@ -78,17 +78,16 @@ pub(crate) async fn platform_properties(
     push_property(system_properties, &mut properties, "user.home")?;
     push_property(system_properties, &mut properties, "user.name")?;
 
-    let properties = properties;
-    let result = Value::from((string_array_class, properties));
+    let result = Value::try_from((string_array_class, properties))?;
     Ok(Some(result))
 }
 
 fn push_property(
     system_properties: &mut HashMap<&str, Value>,
-    properties: &mut Vec<Option<Reference>>,
+    properties: &mut Vec<Value>,
     property_name: &str,
 ) -> Result<()> {
-    let Some(Value::Object(value)) = system_properties.remove(property_name) else {
+    let Some(value) = system_properties.remove(property_name) else {
         return Err(InternalError(format!(
             "Property not found: {property_name}"
         )));
@@ -127,23 +126,15 @@ pub(crate) async fn vm_properties(
     system_properties.insert("java.vm.version".to_string(), vm_version.to_string());
     system_properties.insert("java.vm.name".to_string(), vm_name);
 
-    let mut properties: Vec<Option<Reference>> = Vec::new();
+    let mut properties: Vec<Value> = Vec::new();
     for (key, value) in system_properties {
-        let Value::Object(key) = key.to_object(&thread).await? else {
-            return Err(InternalError(format!(
-                "Unable to convert key to string: {key}"
-            )));
-        };
+        let key = key.to_object(&thread).await?;
+        let value = value.to_object(&thread).await?;
         properties.push(key);
-        let Value::Object(value) = value.to_object(&thread).await? else {
-            return Err(InternalError(format!(
-                "Unable to convert value to string: {value}"
-            )));
-        };
         properties.push(value);
     }
 
     let string_array_class = thread.class("[Ljava/lang/String;").await?;
-    let result = Value::from((string_array_class, properties));
+    let result = Value::try_from((string_array_class, properties))?;
     Ok(Some(result))
 }
diff --git a/ristretto_vm/src/intrinsic_methods/sun/nio/fs/unixnativedispatcher.rs b/ristretto_vm/src/intrinsic_methods/sun/nio/fs/unixnativedispatcher.rs
index 60268bcb..844cb4c0 100644
--- a/ristretto_vm/src/intrinsic_methods/sun/nio/fs/unixnativedispatcher.rs
+++ b/ristretto_vm/src/intrinsic_methods/sun/nio/fs/unixnativedispatcher.rs
@@ -9,7 +9,7 @@ use ristretto_classfile::VersionSpecification::{
     Any, Between, Equal, GreaterThanOrEqual, LessThan, LessThanOrEqual,
 };
 use ristretto_classfile::{JAVA_8, JAVA_11, JAVA_17, JAVA_21, JAVA_24};
-use ristretto_classloader::{Reference, Value};
+use ristretto_classloader::Value;
 use ristretto_macros::intrinsic_method;
 use std::sync::Arc;
 
@@ -338,8 +338,8 @@ pub(crate) async fn getcwd(_thread: Arc<Thread>, _parameters: Parameters) -> Res
         .iter()
         .map(|&b| b as i8)
         .collect::<Vec<i8>>();
-    let current_dir_bytes = Reference::from(current_dir);
-    Ok(Some(Value::Object(Some(current_dir_bytes))))
+    let current_dir_bytes = Value::from(current_dir);
+    Ok(Some(current_dir_bytes))
 }
 
 #[intrinsic_method("sun/nio/fs/UnixNativeDispatcher.getgrgid(I)[B", Any)]
diff --git a/ristretto_vm/src/java_object.rs b/ristretto_vm/src/java_object.rs
index 423d1b7b..9366ddee 100644
--- a/ristretto_vm/src/java_object.rs
+++ b/ristretto_vm/src/java_object.rs
@@ -160,7 +160,7 @@ impl JavaObject for &str {
         let array = if java_class_file_version <= &JAVA_8 {
             // Java 8 and below: store as UTF-16 char array
             let chars = self.encode_utf16().collect::<Vec<u16>>();
-            Reference::CharArray(ConcurrentVec::from(chars))
+            Value::from(Reference::CharArray(ConcurrentVec::from(chars)))
         } else {
             if java_class_file_version >= &JAVA_17 {
                 object.set_value("hashIsZero", Value::Int(0))?;
@@ -184,10 +184,10 @@ impl JavaObject for &str {
             };
 
             object.set_value("coder", Value::Int(coder))?;
-            Reference::from(bytes)
+            Value::from(bytes)
         };
 
-        object.set_value("value", Value::Object(Some(array)))?;
+        object.set_value("value", array)?;
         object.set_value("hash", Value::Int(0))?;
 
         let value = Value::from(object);
diff --git a/ristretto_vm/src/local_variables.rs b/ristretto_vm/src/local_variables.rs
index 68e2fafe..c84eb34d 100644
--- a/ristretto_vm/src/local_variables.rs
+++ b/ristretto_vm/src/local_variables.rs
@@ -346,11 +346,11 @@ mod tests {
     #[test]
     fn test_get_object() -> Result<()> {
         let mut locals = LocalVariables::with_max_size(2);
-        let object = Reference::from(vec![42i8]);
+        let object = Value::from(vec![42i8]);
         locals.set_object(0, None)?;
-        locals.set_object(1, Some(object.clone()))?;
+        locals.set(1, object.clone())?;
         assert_eq!(locals.get_object(0)?, None);
-        assert_eq!(locals.get_object(1)?, Some(object));
+        assert_eq!(locals.get(1)?, object);
         Ok(())
     }