diff --git a/crates/memtrack/src/ebpf/c/allocator.h b/crates/memtrack/src/ebpf/c/allocator.h
index 994d44ab5..92678f75f 100644
--- a/crates/memtrack/src/ebpf/c/allocator.h
+++ b/crates/memtrack/src/ebpf/c/allocator.h
@@ -27,6 +27,8 @@
         submit_block;                                \
     }
 
+/* free() carries no stack: the flamegraph only attributes allocations, so a
+ * copy here would double the capture cost for nothing. */
 #define UPROBE_RET(name, arg_expr, submit_block) \
     SEC(UPROBE_SEC)                              \
     int uprobe_##name(struct pt_regs* ctx) {     \
@@ -34,7 +36,6 @@
         if (arg0 == 0) {                         \
             return 0;                            \
         }                                        \
-        __u64 stack_hash = capture_stack(ctx);   \
         submit_block;                            \
     }
 
@@ -86,7 +87,7 @@
 UPROBE_ARG_RET(malloc, PT_REGS_PARM1(ctx),
                { return submit_alloc_event(arg0, ret_val, stack_hash); })
 
-UPROBE_RET(free, PT_REGS_PARM1(ctx), { return submit_free_event(arg0, stack_hash); })
+UPROBE_RET(free, PT_REGS_PARM1(ctx), { return submit_free_event(arg0); })
 
 UPROBE_ARG_RET(calloc, PT_REGS_PARM1(ctx) * PT_REGS_PARM2(ctx),
                { return submit_calloc_event(arg0, ret_val, stack_hash); })
diff --git a/crates/memtrack/src/ebpf/c/event.h b/crates/memtrack/src/ebpf/c/event.h
index b18af8745..ee50a1c45 100644
--- a/crates/memtrack/src/ebpf/c/event.h
+++ b/crates/memtrack/src/ebpf/c/event.h
@@ -74,8 +74,7 @@ struct event {
 
         /* Deallocation event (free) */
         struct {
-            uint64_t addr;       /* address to free */
-            uint64_t stack_hash; /* caller stack identity; 0 = not captured */
+            uint64_t addr; /* address to free */
         } free;
 
         /* Reallocation event - includes both old and new addresses */
diff --git a/crates/memtrack/src/ebpf/c/utils/event_helpers.h b/crates/memtrack/src/ebpf/c/utils/event_helpers.h
index 10dab1368..3dd056644 100644
--- a/crates/memtrack/src/ebpf/c/utils/event_helpers.h
+++ b/crates/memtrack/src/ebpf/c/utils/event_helpers.h
@@ -113,11 +113,8 @@ static __always_inline int submit_calloc_event(__u64 size, __u64 addr, __u64 sta
     });
 }
 
-static __always_inline int submit_free_event(__u64 addr, __u64 stack_hash) {
-    SUBMIT_GATED_EVENT(EVENT_TYPE_FREE, {
-        e->data.free.addr = addr;
-        e->data.free.stack_hash = stack_hash;
-    });
+static __always_inline int submit_free_event(__u64 addr) {
+    SUBMIT_GATED_EVENT(EVENT_TYPE_FREE, { e->data.free.addr = addr; });
 }
 
 static __always_inline int submit_realloc_event(__u64 old_addr, __u64 new_addr, __u64 size,
diff --git a/crates/memtrack/src/ebpf/events.rs b/crates/memtrack/src/ebpf/events.rs
index 271599843..753daa0e1 100644
--- a/crates/memtrack/src/ebpf/events.rs
+++ b/crates/memtrack/src/ebpf/events.rs
@@ -39,12 +39,7 @@ pub fn parse_event(data: &[u8]) -> Option<MemtrackEvent> {
                     stack_hash: event.data.alloc.stack_hash,
                 },
             ),
-            EVENT_TYPE_FREE => (
-                event.data.free.addr,
-                MemtrackEventKind::Free {
-                    stack_hash: event.data.free.stack_hash,
-                },
-            ),
+            EVENT_TYPE_FREE => (event.data.free.addr, MemtrackEventKind::Free),
             EVENT_TYPE_CALLOC => (
                 event.data.alloc.addr,
                 MemtrackEventKind::Calloc {
diff --git a/crates/memtrack/tests/c_tests.rs b/crates/memtrack/tests/c_tests.rs
index df728538b..a1e39d701 100644
--- a/crates/memtrack/tests/c_tests.rs
+++ b/crates/memtrack/tests/c_tests.rs
@@ -106,7 +106,7 @@ fn test_track_allocators_disabled_skips_allocations() -> Result<(), Box<dyn std:
             matches!(
                 e.kind,
                 MemtrackEventKind::Malloc { .. }
-                    | MemtrackEventKind::Free { .. }
+                    | MemtrackEventKind::Free
                     | MemtrackEventKind::Calloc { .. }
                     | MemtrackEventKind::Realloc { .. }
                     | MemtrackEventKind::AlignedAlloc { .. }
diff --git a/crates/memtrack/tests/dlopen_tests.rs b/crates/memtrack/tests/dlopen_tests.rs
index dfca50444..ec243ae26 100644
--- a/crates/memtrack/tests/dlopen_tests.rs
+++ b/crates/memtrack/tests/dlopen_tests.rs
@@ -78,8 +78,7 @@ fn test_dlopen_allocator() -> Result<(), Box<dyn std::error::Error>> {
             let free_count = events
                 .iter()
                 .filter(|e| {
-                    matches!(e.kind, MemtrackEventKind::Free { .. })
-                        && malloc_addrs.contains(&e.addr)
+                    matches!(e.kind, MemtrackEventKind::Free) && malloc_addrs.contains(&e.addr)
                 })
                 .count();
 
diff --git a/crates/memtrack/tests/shared.rs b/crates/memtrack/tests/shared.rs
index 1d01c8ec7..2e175f613 100644
--- a/crates/memtrack/tests/shared.rs
+++ b/crates/memtrack/tests/shared.rs
@@ -34,7 +34,7 @@ macro_rules! assert_events_snapshot {
                 matches!(
                     e.kind,
                     MemtrackEventKind::Malloc { .. }
-                        | MemtrackEventKind::Free { .. }
+                        | MemtrackEventKind::Free
                         | MemtrackEventKind::Calloc { .. }
                         | MemtrackEventKind::Realloc { .. }
                         | MemtrackEventKind::AlignedAlloc { .. }
@@ -97,7 +97,7 @@ macro_rules! assert_events_with_marker_for_each_variant {
 /// differ between runs of the same workload.
 pub fn describe_kind(kind: &MemtrackEventKind) -> String {
     match kind {
-        MemtrackEventKind::Free { .. } => "Free".to_string(),
+        MemtrackEventKind::Free => "Free".to_string(),
         MemtrackEventKind::Malloc { size, .. } => format!("Malloc {{ size: {size} }}"),
         MemtrackEventKind::Calloc { size, .. } => format!("Calloc {{ size: {size} }}"),
         MemtrackEventKind::AlignedAlloc { size, .. } => format!("AlignedAlloc {{ size: {size} }}"),
@@ -280,7 +280,7 @@ fn event_profile(events: &[Event]) -> EventProfile {
         // Only allocator events are comparable across variants: RSS and
         // lifecycle values (sizes, pids) are per-run.
         match event.kind {
-            MemtrackEventKind::Free { .. } => {
+            MemtrackEventKind::Free => {
                 if !live.remove(&event.addr) {
                     continue;
                 }
diff --git a/crates/memtrack/tests/snapshots/stack_tests__nested_doubling.snap b/crates/memtrack/tests/snapshots/stack_tests__nested_doubling.snap
index f1d65a997..ad8aa563d 100644
--- a/crates/memtrack/tests/snapshots/stack_tests__nested_doubling.snap
+++ b/crates/memtrack/tests/snapshots/stack_tests__nested_doubling.snap
@@ -6,7 +6,7 @@ expression: format_events(&events)
     "Malloc { size: 1024, has_stack: true }",
     "Malloc { size: 2048, has_stack: true }",
     "Malloc { size: 4096, has_stack: true }",
-    "Free { has_stack: true }",
-    "Free { has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
+    "Free",
+    "Free",
 ]
diff --git a/crates/memtrack/tests/snapshots/stack_tests__nested_doubling_shared_free.snap b/crates/memtrack/tests/snapshots/stack_tests__nested_doubling_shared_free.snap
index f1d65a997..ad8aa563d 100644
--- a/crates/memtrack/tests/snapshots/stack_tests__nested_doubling_shared_free.snap
+++ b/crates/memtrack/tests/snapshots/stack_tests__nested_doubling_shared_free.snap
@@ -6,7 +6,7 @@ expression: format_events(&events)
     "Malloc { size: 1024, has_stack: true }",
     "Malloc { size: 2048, has_stack: true }",
     "Malloc { size: 4096, has_stack: true }",
-    "Free { has_stack: true }",
-    "Free { has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
+    "Free",
+    "Free",
 ]
diff --git a/crates/memtrack/tests/snapshots/stack_tests__nested_doubling_shared_free_stack_capture_disabled.snap b/crates/memtrack/tests/snapshots/stack_tests__nested_doubling_shared_free_stack_capture_disabled.snap
index 2bd6a37ce..b1a57a50d 100644
--- a/crates/memtrack/tests/snapshots/stack_tests__nested_doubling_shared_free_stack_capture_disabled.snap
+++ b/crates/memtrack/tests/snapshots/stack_tests__nested_doubling_shared_free_stack_capture_disabled.snap
@@ -6,7 +6,7 @@ expression: format_events(&events)
     "Malloc { size: 1024, has_stack: false }",
     "Malloc { size: 2048, has_stack: false }",
     "Malloc { size: 4096, has_stack: false }",
-    "Free { has_stack: false }",
-    "Free { has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
+    "Free",
+    "Free",
 ]
diff --git a/crates/memtrack/tests/snapshots/stack_tests__nested_doubling_stack_capture_disabled.snap b/crates/memtrack/tests/snapshots/stack_tests__nested_doubling_stack_capture_disabled.snap
index 2bd6a37ce..b1a57a50d 100644
--- a/crates/memtrack/tests/snapshots/stack_tests__nested_doubling_stack_capture_disabled.snap
+++ b/crates/memtrack/tests/snapshots/stack_tests__nested_doubling_stack_capture_disabled.snap
@@ -6,7 +6,7 @@ expression: format_events(&events)
     "Malloc { size: 1024, has_stack: false }",
     "Malloc { size: 2048, has_stack: false }",
     "Malloc { size: 4096, has_stack: false }",
-    "Free { has_stack: false }",
-    "Free { has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
+    "Free",
+    "Free",
 ]
diff --git a/crates/memtrack/tests/snapshots/stack_tests__stack_paths.snap b/crates/memtrack/tests/snapshots/stack_tests__stack_paths.snap
index 7cb31d31e..05ef5ef02 100644
--- a/crates/memtrack/tests/snapshots/stack_tests__stack_paths.snap
+++ b/crates/memtrack/tests/snapshots/stack_tests__stack_paths.snap
@@ -4,203 +4,203 @@ expression: format_events(&events)
 ---
 [
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 64, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
     "Malloc { size: 192, has_stack: true }",
-    "Free { has_stack: true }",
+    "Free",
 ]
diff --git a/crates/memtrack/tests/snapshots/stack_tests__stack_paths_stack_capture_disabled.snap b/crates/memtrack/tests/snapshots/stack_tests__stack_paths_stack_capture_disabled.snap
index cf9fc935d..e1b825211 100644
--- a/crates/memtrack/tests/snapshots/stack_tests__stack_paths_stack_capture_disabled.snap
+++ b/crates/memtrack/tests/snapshots/stack_tests__stack_paths_stack_capture_disabled.snap
@@ -4,203 +4,203 @@ expression: format_events(&events)
 ---
 [
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 64, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
     "Malloc { size: 192, has_stack: false }",
-    "Free { has_stack: false }",
+    "Free",
 ]
diff --git a/crates/memtrack/tests/stack_tests.rs b/crates/memtrack/tests/stack_tests.rs
index bc6ee76b3..8b723ad74 100644
--- a/crates/memtrack/tests/stack_tests.rs
+++ b/crates/memtrack/tests/stack_tests.rs
@@ -30,9 +30,7 @@ fn describe_allocator_event(kind: &MemtrackEventKind) -> Option<String> {
                 *stack_hash != 0
             )
         }
-        MemtrackEventKind::Free { stack_hash } => {
-            format!("Free {{ has_stack: {} }}", *stack_hash != 0)
-        }
+        MemtrackEventKind::Free => "Free".to_string(),
         _ => return None,
     };
 
@@ -57,7 +55,7 @@ fn format_events(events: &[MemtrackEvent]) -> Vec<String> {
                 matches!(
                     e.kind,
                     MemtrackEventKind::Malloc { .. }
-                        | MemtrackEventKind::Free { .. }
+                        | MemtrackEventKind::Free
                         | MemtrackEventKind::Calloc { .. }
                         | MemtrackEventKind::Realloc { .. }
                         | MemtrackEventKind::AlignedAlloc { .. }
diff --git a/crates/runner-shared/benches/memtrack_writer.rs b/crates/runner-shared/benches/memtrack_writer.rs
index 10c329379..580424a1a 100644
--- a/crates/runner-shared/benches/memtrack_writer.rs
+++ b/crates/runner-shared/benches/memtrack_writer.rs
@@ -33,7 +33,7 @@ fn generate_events(n: usize) -> Vec<MemtrackEvent> {
                 size,
                 stack_hash: 0,
             },
-            1 => MemtrackEventKind::Free { stack_hash: 0 },
+            1 => MemtrackEventKind::Free,
             2 => MemtrackEventKind::Realloc {
                 old_addr: Some(rng.r#gen()),
                 size,
@@ -133,7 +133,7 @@ fn generate_realistic_events(n: usize) -> Vec<MemtrackEvent> {
             let idx = rng.gen_range(0..live_heap.len());
             let addr = live_heap.swap_remove(idx);
             free_list.push(addr);
-            (addr, MemtrackEventKind::Free { stack_hash: 0 })
+            (addr, MemtrackEventKind::Free)
         } else {
             let idx = rng.gen_range(0..live_heap.len());
             let old_addr = live_heap[idx];
diff --git a/crates/runner-shared/src/artifacts/memtrack/mod.rs b/crates/runner-shared/src/artifacts/memtrack/mod.rs
index 155b59f54..7560ec9c0 100644
--- a/crates/runner-shared/src/artifacts/memtrack/mod.rs
+++ b/crates/runner-shared/src/artifacts/memtrack/mod.rs
@@ -59,10 +59,7 @@ pub enum MemtrackEventKind {
         #[serde(default, skip_serializing_if = "is_zero")]
         stack_hash: u64,
     },
-    Free {
-        #[serde(default, skip_serializing_if = "is_zero")]
-        stack_hash: u64,
-    },
+    Free,
     Realloc {
         #[serde(default, skip_serializing_if = "Option::is_none")]
         old_addr: Option<u64>,
@@ -182,7 +179,7 @@ mod tests {
                 tid: 12,
                 timestamp: 200,
                 addr: 0x20,
-                kind: MemtrackEventKind::Free { stack_hash: 0 },
+                kind: MemtrackEventKind::Free,
             },
             MemtrackEvent {
                 pid: 1,
@@ -243,8 +240,7 @@ mod tests {
                 size: 7,
                 stack_hash: 0xCAFE_BABE,
             },
-            MemtrackEventKind::Free { stack_hash: 0 },
-            MemtrackEventKind::Free { stack_hash: 0xFEED },
+            MemtrackEventKind::Free,
             MemtrackEventKind::Realloc {
                 old_addr: Some(0x1000),
                 size: 42,
diff --git a/src/executor/memory/module_artifacts.rs b/src/executor/memory/module_artifacts.rs
index 8bd0596c1..ca28ed11e 100644
--- a/src/executor/memory/module_artifacts.rs
+++ b/src/executor/memory/module_artifacts.rs
@@ -449,7 +449,7 @@ mod tests {
                     tid: 1,
                     timestamp: 13,
                     addr: 0x2000,
-                    kind: MemtrackEventKind::Free { stack_hash: 0 },
+                    kind: MemtrackEventKind::Free,
                 },
             ],
         };