diff --git a/spec/primitives.sx b/spec/primitives.sx
index 9d7f3433..6f0ab489 100644
--- a/spec/primitives.sx
+++ b/spec/primitives.sx
@@ -168,6 +168,69 @@
   :returns "number"
   :doc "Convert inexact to nearest exact integer.")
 
+(define-primitive
+  "make-vector"
+  :params ((n :as number))
+  :returns "vector"
+  :doc "Create vector of size n, optionally filled.")
+
+(define-primitive
+  "vector"
+  :params ()
+  :returns "vector"
+  :doc "Create vector from arguments.")
+
+(define-primitive
+  "vector?"
+  :params ((x :as any))
+  :returns "boolean"
+  :doc "True if x is a vector.")
+
+(define-primitive
+  "vector-length"
+  :params ((v :as vector))
+  :returns "number"
+  :doc "Number of elements.")
+
+(define-primitive
+  "vector-ref"
+  :params ((v :as vector) (i :as number))
+  :returns "any"
+  :doc "Element at index.")
+
+(define-primitive
+  "vector-set!"
+  :params ((v :as vector) (i :as number) (val :as any))
+  :returns "nil"
+  :doc "Set element at index.")
+
+(define-primitive
+  "vector->list"
+  :params ((v :as vector))
+  :returns "list"
+  :doc "Convert vector to list.")
+
+(define-primitive
+  "list->vector"
+  :params ((l :as list))
+  :returns "vector"
+  :doc "Convert list to vector.")
+
+;; --------------------------------------------------------------------------
+;; Core — Predicates
+;; --------------------------------------------------------------------------
+(define-primitive
+  "vector-fill!"
+  :params ((v :as vector) (val :as any))
+  :returns "nil"
+  :doc "Fill all elements.")
+
+(define-primitive
+  "vector-copy"
+  :params ((v :as vector))
+  :returns "vector"
+  :doc "Independent shallow copy.")
+
 (define-primitive
   "min"
   :params (&rest (args :as number))
@@ -216,9 +279,6 @@
   :doc "Inequality."
   :body (not (= a b)))
 
-;; --------------------------------------------------------------------------
-;; Core — Predicates
-;; --------------------------------------------------------------------------
 (define-primitive
   "eq?"
   :params (a b)
@@ -239,6 +299,9 @@
   :doc "Deep structural equality. Recursively compares collections."
   :body (= a b))
 
+;; --------------------------------------------------------------------------
+;; Core — Logic
+;; --------------------------------------------------------------------------
 (define-primitive
   "<"
   :params ((a :as number) (b :as number))
@@ -251,6 +314,9 @@
   :returns "boolean"
   :doc "Greater than.")
 
+;; --------------------------------------------------------------------------
+;; Core — Strings
+;; --------------------------------------------------------------------------
 (define-primitive
   "<="
   :params ((a :as number) (b :as number))
@@ -302,9 +368,6 @@
   :doc "True if x is a boolean (true or false)."
   :body (= (type-of x) "boolean"))
 
-;; --------------------------------------------------------------------------
-;; Core — Logic
-;; --------------------------------------------------------------------------
 (define-primitive
   "number?"
   :params (x)
@@ -319,9 +382,6 @@
   :doc "True if x is a string."
   :body (= (type-of x) "string"))
 
-;; --------------------------------------------------------------------------
-;; Core — Strings
-;; --------------------------------------------------------------------------
 (define-primitive
   "list?"
   :params (x)
@@ -373,6 +433,9 @@
   :returns "string"
   :doc "Concatenate all args as strings. nil → empty string, bool → true/false.")
 
+;; --------------------------------------------------------------------------
+;; Core — Collections
+;; --------------------------------------------------------------------------
 (define-primitive
   "concat"
   :params (&rest (colls :as list))
@@ -433,9 +496,6 @@
   :returns "string"
   :doc "Strip leading/trailing whitespace.")
 
-;; --------------------------------------------------------------------------
-;; Core — Collections
-;; --------------------------------------------------------------------------
 (define-primitive
   "split"
   :params ((s :as string) &rest (sep :as string))
@@ -478,6 +538,9 @@
   :returns "boolean"
   :doc "True if string s ends with suffix.")
 
+;; --------------------------------------------------------------------------
+;; Core — Dict operations
+;; --------------------------------------------------------------------------
 (define-module :core.collections)
 
 (define-primitive
@@ -528,15 +591,15 @@
   :returns "list"
   :doc "All elements except the first.")
 
+;; --------------------------------------------------------------------------
+;; Stdlib — Format
+;; --------------------------------------------------------------------------
 (define-primitive
   "nth"
   :params ((coll :as list) (n :as number))
   :returns "any"
   :doc "Element at index n, or nil if out of bounds.")
 
-;; --------------------------------------------------------------------------
-;; Core — Dict operations
-;; --------------------------------------------------------------------------
 (define-primitive
   "cons"
   :params (x (coll :as list))
@@ -561,6 +624,9 @@
   :returns "list"
   :doc "Return coll in reverse order.")
 
+;; --------------------------------------------------------------------------
+;; Stdlib — Text
+;; --------------------------------------------------------------------------
 (define-primitive
   "flatten"
   :params ((coll :as list))
@@ -581,21 +647,27 @@
 
 (define-module :core.dict)
 
+;; --------------------------------------------------------------------------
+;; Stdlib — Style
+;; --------------------------------------------------------------------------
+;; --------------------------------------------------------------------------
+;; Stdlib — Debug
+;; --------------------------------------------------------------------------
 (define-primitive
   "keys"
   :params ((d :as dict))
   :returns "list"
   :doc "List of dict keys.")
 
-;; --------------------------------------------------------------------------
-;; Stdlib — Format
-;; --------------------------------------------------------------------------
 (define-primitive
   "vals"
   :params ((d :as dict))
   :returns "list"
   :doc "List of dict values.")
 
+;; --------------------------------------------------------------------------
+;; Type introspection — platform primitives
+;; --------------------------------------------------------------------------
 (define-primitive
   "merge"
   :params (&rest (dicts :as dict))
@@ -620,9 +692,6 @@
   :returns "dict"
   :doc "Return new dict with keys removed.")
 
-;; --------------------------------------------------------------------------
-;; Stdlib — Text
-;; --------------------------------------------------------------------------
 (define-primitive
   "dict-set!"
   :params ((d :as dict) key val)
@@ -643,12 +712,6 @@
   :returns "string"
   :doc "Parse ISO date string and format with strftime-style format.")
 
-;; --------------------------------------------------------------------------
-;; Stdlib — Style
-;; --------------------------------------------------------------------------
-;; --------------------------------------------------------------------------
-;; Stdlib — Debug
-;; --------------------------------------------------------------------------
 (define-primitive
   "format-decimal"
   :params ((val :as number) &rest (places :as number))
@@ -661,9 +724,6 @@
   :returns "number"
   :doc "Parse string to integer with optional default on failure.")
 
-;; --------------------------------------------------------------------------
-;; Type introspection — platform primitives
-;; --------------------------------------------------------------------------
 (define-primitive
   "parse-datetime"
   :params ((s :as string))