🧠 OCaml Memory Model Visualizer

Understand how OCaml represents values in memory — boxed vs unboxed, stack vs heap, and garbage collection

Value Representations

Interactive Sandbox

GC Simulator

Cheat Sheet

How OCaml Stores Values

OCaml uses a uniform representation: every value is either an unboxed immediate (fits in a machine word) or a boxed pointer to a heap-allocated block.

Integers Unboxed

let x = 42

Stack: ┌──────────────────┐ │ x = 85 (42<<1|1) │ ← tagged: n*2+1 └──────────────────┘ No heap allocation! Tag bit 0 = 1 → immediate

Booleans Unboxed

let b = true (* = 1 *) let b = false (* = 0 *)

Stack: ┌──────────┐ │ true = 3 │ ← 1<<1|1 │ false = 1 │ ← 0<<1|1 └──────────┘

Unit & Chars Unboxed

let u = () (* = 0 *) let c = 'A' (* = 65 *)

Stack: ┌──────────────────┐ │ () = 1 (0<<1|1) │ │ 'A' = 131 (65<<1|1)│ └──────────────────┘

Floats Boxed Heap

let f = 3.14

Stack: Heap: ┌─────────┐ ┌─────────────────┐ │ f = ptr ─┼───→│ hdr: Double_tag │ └─────────┘ │ 3.14 (64-bit) │ └─────────────────┘

Strings Boxed Heap

let s = "hello"

Stack: Heap: ┌─────────┐ ┌──────────────────┐ │ s = ptr ─┼───→│ hdr: String_tag │ └─────────┘ │ size: 5 │ │ 'h''e''l''l''o' │ │ padding + last=3 │ └──────────────────┘

Tuples Boxed Heap

let t = (1, "hi", 3.0)

Stack: Heap: ┌─────────┐ ┌──────────────────┐ │ t = ptr ─┼───→│ hdr: tag=0 sz=3 │ └─────────┘ │ field0: 3 (int 1)│ │ field1: ptr→"hi" │ │ field2: ptr→3.0 │ └──────────────────┘

Lists Boxed Heap

let l = [1; 2; 3]

┌────────┐ ┌────────┐ ┌────────┐ │tag=0 │ │tag=0 │ │tag=0 │ │hd: 3 ├→ │hd: 5 ├→ │hd: 7 ├→ 0 (nil) │tl: ptr │ │tl: ptr │ │tl: ptr │ └────────┘ └────────┘ └────────┘ [] = immediate 0 (no allocation)

Variants Unboxed/Boxed

type t = A | B of int | C of int * string

A → immediate 0 (no payload) B 5 → heap block tag=0, field=11 C (1,"x") → heap block tag=1 field0=3, field1=ptr→"x" Constant ctors: numbered 0,1,2... Non-const ctors: tagged 0,1,2...

Records Boxed Heap

type point = { x: int; y: int } let p = { x = 10; y = 20 }

Stack: Heap: ┌─────────┐ ┌──────────────────┐ │ p = ptr ─┼───→│ hdr: tag=0 sz=2 │ └─────────┘ │ field0: 21 (x=10)│ │ field1: 41 (y=20)│ └──────────────────┘ Same layout as a tuple!

Arrays Boxed Heap

let a = [| 10; 20; 30 |] let fa = [| 1.0; 2.0 |]

Int array → tag=0, unboxed ints Float array → Double_array_tag stores raw 64-bit floats (no per-element boxing!) This is a key optimization.

Closures Boxed Heap

let add x = fun y -> x + y let add5 = add 5

Stack: Heap: ┌────────────┐ ┌─────────────────┐ │ add5 = ptr ─┼───→│ hdr: Closure_tag│ └────────────┘ │ code_ptr → λy │ │ env: x = 11 │ └─────────────────┘ Captured variables stored in closure

Refs (Mutable) Boxed Heap

let r = ref 42 r := 99

Stack: Heap: ┌─────────┐ ┌──────────────────┐ │ r = ptr ─┼───→│ hdr: tag=0 sz=1 │ └─────────┘ │ field0: 85→199 │ └──────────────────┘ ref is just a 1-field mutable record {mutable contents: 'a}

Memory Layout Explorer

Type an OCaml expression and see its memory representation.

Enter an expression above and click Visualize...

Presets

Garbage Collection Simulator

OCaml uses a generational GC with a minor heap (copying) and major heap (mark-sweep-compact). Watch it in action!

Minor Heap (nursery)

Major Heap

Free Minor (young) Major (old) Root Garbage Promoted

Allocations: 0 | Minor GCs: 0 | Major GCs: 0 | Live objects: 0 | Promoted: 0

GC Simulator ready. Click "Allocate" to create objects.

OCaml Memory Cheat Sheet

Value Representation Rules

Type	Representation	Size (words)	Notes
`int`	Immediate (tagged)	0 (in-register)	63-bit on 64-bit systems, tag bit stolen
`bool`	Immediate	0	false=0, true=1 (tagged)
`char`	Immediate	0	Code point as tagged int
`unit`	Immediate	0	Represented as 0
`float`	Boxed (Double_tag)	1 header + 1 data	64-bit IEEE 754
`string`	Boxed (String_tag)	1 header + ⌈len/8⌉	Includes padding byte
`'a * 'b`	Boxed block (tag 0)	1 header + n fields	Same as records
`'a list`	Cons cells (tag 0)	1 header + 2 per cons	[] is immediate 0
`'a option`	None=immediate 0	Some: 1 header + 1	None costs nothing
`'a array`	Boxed block (tag 0)	1 header + n elems	Mutable, bounds-checked
`float array`	Flat (Double_array)	1 header + n×1	Unboxed floats! Fast
`'a ref`	1-field mutable block	1 header + 1	`{mutable contents: 'a}`
`closure`	Closure_tag	1 hdr + 1 code + env	Env = captured vars
Constant variant	Immediate	0	Numbered 0,1,2...
Non-const variant	Boxed block	1 header + n fields	Tag = constructor index

GC Quick Facts

Property	Minor Heap	Major Heap
Strategy	Copying (semi-space)	Mark-sweep-compact
Default size	256 KB	Grows as needed
Speed	Very fast (µs)	Slower (ms)
When triggered	Minor heap full	Major heap grows past threshold
Objects survive	Promoted to major	Stay until unreachable
Allocation	Bump pointer (fast!)	Free-list based

Performance Tips

Tip	Why
Use `int` over `float` when possible	Unboxed = no allocation
Use `float array` for numeric work	Flat layout, no per-element boxing
Prefer `Array` over `List` for random access	Contiguous memory, O(1) access
Avoid excessive `ref` usage	Each ref = heap allocation
Use `[@unboxed]` for single-field records	Eliminates wrapper allocation
Reuse buffers with `Buffer.t`	Avoids repeated string allocations
Profile with `Gc.stat()`	Shows allocation rates and GC frequency