diff --git a/engine/Cargo.toml b/engine/Cargo.toml
index e5a9ad6..c370b3c 100644
--- a/engine/Cargo.toml
+++ b/engine/Cargo.toml
@@ -20,6 +20,7 @@ regex = "1.11.1"
 rustyline = { version = "15.0.0", features = ["derive", "rustyline-derive"] }
 tokio = { version = "1.42.0", features = ["macros", "parking_lot", "rt", "rt-multi-thread"] }
 
+
 [profile.dev]
 debug-assertions = true
 
diff --git a/engine/src/core/repl/Re-exports.rs b/engine/src/core/repl/Re-exports.rs
new file mode 100644
index 0000000..8d7f394
--- /dev/null
+++ b/engine/src/core/repl/Re-exports.rs
@@ -0,0 +1,9 @@
+pub use renderer::*;
+pub use window::*;
+pub use crate::core::*;
+pub use material::*;
+pub use effect::*;
+pub use light::*;
+pub use geometry::*;
+pub use object::*;
+pub use control::*;
\ No newline at end of file
diff --git a/engine/src/core/repl/zlua.rs b/engine/src/core/repl/zlua.rs
index ff911fa..90203c5 100644
--- a/engine/src/core/repl/zlua.rs
+++ b/engine/src/core/repl/zlua.rs
@@ -1,4 +1,4 @@
-use mlua::{Lua, MultiValue, Number};
+use mlua::{Function, Lua, LuaOptions, MultiValue, Number, Value::Nil};
 use rustyline::{error::ReadlineError, DefaultEditor};
 use crate::core::repl::handler::Command;
 
@@ -9,27 +9,39 @@ impl Command for ZLua {
     fn execute(&self, _args: Option<Vec<String>>) -> Result<(), anyhow::Error> {
         let time = chrono::Local::now().format("%H:%M:%S.%3f").to_string();
         let prompt = format!("[{}/{}] {}", time, "ZLUA", ">>\t");
-        let lua = Lua::new();
+        let lua = Lua::new_with(
+            mlua::StdLib::ALL_SAFE, 
+            LuaOptions::default()
+        )?;
         let globals = lua.globals();
+        //This just adds 2 numbers together
         let add = lua.create_function(|_, (number1,number2):(i32,i32)|{
             let result = number1 + number2;
             println!("{result}");
             Ok(())
         })?;
+        globals.set("add", add)?;
+
         let is_equal = lua.create_function(|_, (list1, list2): (i32, i32)| {
-            // This function just checks whether two string lists are equal, and in an inefficient way.
-            // Lua callbacks return `mlua::Result`, an Ok value is a normal return, and an Err return
-            // turns into a Lua 'error'. Again, any type that is convertible to Lua may be returned.
+            if list1 == 0 || list2 == 0 {
+                return Err(mlua::Error::RuntimeError("Zero values not allowed".to_string()));
+            }
             Ok(list1 == list2)
         })?;
-        globals.set("isequal", is_equal)?;
+        globals.set("isEqual", is_equal)?;
+
         let log = lua.create_function(|_, (msg,): (String,)| {
-            println!("{}", msg);
-            Ok(())
+        println!("{}", msg);
+        Ok(())
         })?;
         globals.set("log", log)?;
+
+        let fail_safe = lua.create_function(|_,()|{
+            println!("Failed");
+            Ok(())
+        })?;
+        globals.set("failSafe",fail_safe)?;
         let mut editor = DefaultEditor::new().expect("Failed to create editor");
-        globals.set("add", add)?;
 
         loop {
             let mut prompt = &prompt;
@@ -47,6 +59,15 @@ impl Command for ZLua {
 
                 match lua.load(&line).eval::<MultiValue>() {
                     Ok(values) => {
+                        for value in &values {
+                            match value {
+                                mlua::Value::Nil => println!("Got nil value"),
+                                mlua::Value::Number(n) => println!("Got number: {}", n),
+                                mlua::Value::String(s) => println!("Got string: {}", s.to_str()?),
+                                mlua::Value::Boolean(b) => println!("Got boolean: {}", b),
+                                _ => eprintln!("Got unexpected type: {:#?}", value)
+                            }
+                        }
                         editor.add_history_entry(line).unwrap();
                         println!(
                             "{}",
@@ -68,9 +89,11 @@ impl Command for ZLua {
                     }
 
                     Err(e) => {
-                        eprintln!("error: {}", e);
+                        eprintln!("Error: {} at line {}", e, line.lines().count());
+                        eprintln!("Input that caused error: {}", line);
                         break;
                     }
+        
                 }
             }
         }