diff --git a/rust/kcl-lib/src/engine/conn.rs b/rust/kcl-lib/src/engine/conn.rs
index 9013e9123..a8a18f6b3 100644
--- a/rust/kcl-lib/src/engine/conn.rs
+++ b/rust/kcl-lib/src/engine/conn.rs
@@ -18,7 +18,7 @@ use tokio::sync::{mpsc, oneshot, RwLock};
 use tokio_tungstenite::tungstenite::Message as WsMsg;
 use uuid::Uuid;
 
-use super::ExecutionKind;
+use super::{EngineStats, ExecutionKind};
 use crate::{
     engine::EngineManager,
     errors::{KclError, KclErrorDetails},
@@ -52,6 +52,7 @@ pub struct EngineConnection {
     session_data: Arc<RwLock<Option<ModelingSessionData>>>,
 
     execution_kind: Arc<RwLock<ExecutionKind>>,
+    stats: EngineStats,
 }
 
 pub struct TcpRead {
@@ -344,6 +345,7 @@ impl EngineConnection {
             default_planes: Default::default(),
             session_data,
             execution_kind: Default::default(),
+            stats: Default::default(),
         })
     }
 }
@@ -378,6 +380,10 @@ impl EngineManager for EngineConnection {
         original
     }
 
+    fn stats(&self) -> &EngineStats {
+        &self.stats
+    }
+
     fn get_default_planes(&self) -> Arc<RwLock<Option<DefaultPlanes>>> {
         self.default_planes.clone()
     }
diff --git a/rust/kcl-lib/src/engine/conn_mock.rs b/rust/kcl-lib/src/engine/conn_mock.rs
index ec9f28678..19d1d10b1 100644
--- a/rust/kcl-lib/src/engine/conn_mock.rs
+++ b/rust/kcl-lib/src/engine/conn_mock.rs
@@ -16,7 +16,7 @@ use kittycad_modeling_cmds::{self as kcmc};
 use tokio::sync::RwLock;
 use uuid::Uuid;
 
-use super::ExecutionKind;
+use super::{EngineStats, ExecutionKind};
 use crate::{
     errors::KclError,
     exec::DefaultPlanes,
@@ -32,6 +32,7 @@ pub struct EngineConnection {
     execution_kind: Arc<RwLock<ExecutionKind>>,
     /// The default planes for the scene.
     default_planes: Arc<RwLock<Option<DefaultPlanes>>>,
+    stats: EngineStats,
 }
 
 impl EngineConnection {
@@ -42,6 +43,7 @@ impl EngineConnection {
             artifact_commands: Arc::new(RwLock::new(Vec::new())),
             execution_kind: Default::default(),
             default_planes: Default::default(),
+            stats: Default::default(),
         })
     }
 }
@@ -60,6 +62,10 @@ impl crate::engine::EngineManager for EngineConnection {
         Arc::new(RwLock::new(IndexMap::new()))
     }
 
+    fn stats(&self) -> &EngineStats {
+        &self.stats
+    }
+
     fn artifact_commands(&self) -> Arc<RwLock<Vec<ArtifactCommand>>> {
         self.artifact_commands.clone()
     }
diff --git a/rust/kcl-lib/src/engine/conn_wasm.rs b/rust/kcl-lib/src/engine/conn_wasm.rs
index e7abb5b78..e46846d66 100644
--- a/rust/kcl-lib/src/engine/conn_wasm.rs
+++ b/rust/kcl-lib/src/engine/conn_wasm.rs
@@ -11,7 +11,7 @@ use uuid::Uuid;
 use wasm_bindgen::prelude::*;
 
 use crate::{
-    engine::ExecutionKind,
+    engine::{EngineStats, ExecutionKind},
     errors::{KclError, KclErrorDetails},
     execution::{ArtifactCommand, DefaultPlanes, IdGenerator},
     SourceRange,
@@ -45,6 +45,7 @@ pub struct EngineConnection {
     execution_kind: Arc<RwLock<ExecutionKind>>,
     /// The default planes for the scene.
     default_planes: Arc<RwLock<Option<DefaultPlanes>>>,
+    stats: EngineStats,
 }
 
 // Safety: WebAssembly will only ever run in a single-threaded context.
@@ -62,6 +63,7 @@ impl EngineConnection {
             artifact_commands: Arc::new(RwLock::new(Vec::new())),
             execution_kind: Default::default(),
             default_planes: Default::default(),
+            stats: Default::default(),
         })
     }
 
@@ -141,6 +143,10 @@ impl crate::engine::EngineManager for EngineConnection {
         self.responses.clone()
     }
 
+    fn stats(&self) -> &EngineStats {
+        &self.stats
+    }
+
     fn artifact_commands(&self) -> Arc<RwLock<Vec<ArtifactCommand>>> {
         self.artifact_commands.clone()
     }
diff --git a/rust/kcl-lib/src/engine/mod.rs b/rust/kcl-lib/src/engine/mod.rs
index a10d44ce1..084d06149 100644
--- a/rust/kcl-lib/src/engine/mod.rs
+++ b/rust/kcl-lib/src/engine/mod.rs
@@ -8,7 +8,13 @@ pub mod conn_mock;
 #[cfg(feature = "engine")]
 pub mod conn_wasm;
 
-use std::{collections::HashMap, sync::Arc};
+use std::{
+    collections::HashMap,
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    },
+};
 
 use indexmap::IndexMap;
 use kcmc::{
@@ -58,6 +64,21 @@ impl ExecutionKind {
     }
 }
 
+#[derive(Default, Debug)]
+pub struct EngineStats {
+    pub commands_batched: AtomicUsize,
+    pub batches_sent: AtomicUsize,
+}
+
+impl Clone for EngineStats {
+    fn clone(&self) -> Self {
+        Self {
+            commands_batched: AtomicUsize::new(self.commands_batched.load(Ordering::Relaxed)),
+            batches_sent: AtomicUsize::new(self.batches_sent.load(Ordering::Relaxed)),
+        }
+    }
+}
+
 #[async_trait::async_trait]
 pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
     /// Get the batch of commands to be sent to the engine.
@@ -97,6 +118,8 @@ pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
     /// Get the default planes.
     fn get_default_planes(&self) -> Arc<RwLock<Option<DefaultPlanes>>>;
 
+    fn stats(&self) -> &EngineStats;
+
     /// Get the default planes, creating them if they don't exist.
     async fn default_planes(
         &self,
@@ -254,6 +277,7 @@ pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
 
         // Add cmd to the batch.
         self.batch().write().await.push((req, source_range));
+        self.stats().commands_batched.fetch_add(1, Ordering::Relaxed);
 
         Ok(())
     }
@@ -277,6 +301,9 @@ pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
         for cmd in cmds {
             extended_cmds.push((WebSocketRequest::ModelingCmdReq(cmd.clone()), source_range));
         }
+        self.stats()
+            .commands_batched
+            .fetch_add(extended_cmds.len(), Ordering::Relaxed);
         self.batch().write().await.extend(extended_cmds);
 
         Ok(())
@@ -303,6 +330,7 @@ pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
 
         // Add cmd to the batch end.
         self.batch_end().write().await.insert(id, (req, source_range));
+        self.stats().commands_batched.fetch_add(1, Ordering::Relaxed);
         Ok(())
     }
 
@@ -405,6 +433,7 @@ pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
         if batch_end {
             self.batch_end().write().await.clear();
         }
+        self.stats().batches_sent.fetch_add(1, Ordering::Relaxed);
 
         // We pop off the responses to cleanup our mappings.
         match final_req {
diff --git a/rust/kcl-lib/src/execution/mod.rs b/rust/kcl-lib/src/execution/mod.rs
index 3372317ee..ef50f27d9 100644
--- a/rust/kcl-lib/src/execution/mod.rs
+++ b/rust/kcl-lib/src/execution/mod.rs
@@ -750,6 +750,7 @@ impl ExecutorContext {
             "Post interpretation KCL memory stats: {:#?}",
             exec_state.stack().memory.stats
         ));
+        crate::log::log(format!("Engine stats: {:?}", self.engine.stats()));
 
         if !self.is_mock() {
             let mut mem = exec_state.stack().deep_clone();
diff --git a/rust/kcl-lib/src/lib.rs b/rust/kcl-lib/src/lib.rs
index ef15040be..536f9ba71 100644
--- a/rust/kcl-lib/src/lib.rs
+++ b/rust/kcl-lib/src/lib.rs
@@ -81,7 +81,7 @@ mod walk;
 mod wasm;
 
 pub use coredump::CoreDump;
-pub use engine::{EngineManager, ExecutionKind};
+pub use engine::{EngineManager, EngineStats, ExecutionKind};
 pub use errors::{
     CompilationError, ConnectionError, ExecError, KclError, KclErrorWithOutputs, Report, ReportWithOutputs,
 };
diff --git a/rust/kcl-lib/src/main.rs b/rust/kcl-lib/src/main.rs
index e4427d411..95e544ad1 100644
--- a/rust/kcl-lib/src/main.rs
+++ b/rust/kcl-lib/src/main.rs
@@ -11,7 +11,13 @@ use kcl_lib::{ExecState, ExecutorContext, ExecutorSettings, Program};
 async fn main() {
     let mut args = env::args();
     args.next();
-    let filename = args.next().unwrap_or_else(|| "main.kcl".to_owned());
+    let mut filename = args.next().unwrap_or_else(|| "main.kcl".to_owned());
+    if !filename.ends_with(".kcl") {
+        if !filename.ends_with('/') && !filename.ends_with('\\') {
+            filename += "/";
+        }
+        filename += "main.kcl";
+    }
 
     let mut f = File::open(&filename).unwrap();
     let mut text = String::new();
diff --git a/rust/kcl-to-core/src/conn_mock_core.rs b/rust/kcl-to-core/src/conn_mock_core.rs
index adba6fd4c..9309c52fa 100644
--- a/rust/kcl-to-core/src/conn_mock_core.rs
+++ b/rust/kcl-to-core/src/conn_mock_core.rs
@@ -4,7 +4,7 @@ use anyhow::Result;
 use indexmap::IndexMap;
 use kcl_lib::{
     exec::{ArtifactCommand, DefaultPlanes, IdGenerator},
-    ExecutionKind, KclError,
+    EngineStats, ExecutionKind, KclError,
 };
 use kittycad_modeling_cmds::{
     self as kcmc,
@@ -26,6 +26,7 @@ pub struct EngineConnection {
     execution_kind: Arc<RwLock<ExecutionKind>>,
     /// The default planes for the scene.
     default_planes: Arc<RwLock<Option<DefaultPlanes>>>,
+    stats: EngineStats,
 }
 
 impl EngineConnection {
@@ -38,6 +39,7 @@ impl EngineConnection {
             core_test: result,
             execution_kind: Default::default(),
             default_planes: Default::default(),
+            stats: Default::default(),
         })
     }
 
@@ -369,6 +371,10 @@ impl kcl_lib::EngineManager for EngineConnection {
         Arc::new(RwLock::new(IndexMap::new()))
     }
 
+    fn stats(&self) -> &EngineStats {
+        &self.stats
+    }
+
     fn artifact_commands(&self) -> Arc<RwLock<Vec<ArtifactCommand>>> {
         Arc::new(RwLock::new(Vec::new()))
     }