diff --git a/cli/src/main.rs b/cli/src/main.rs
index 18df73567d..efc0f1fe1e 100644
--- a/cli/src/main.rs
+++ b/cli/src/main.rs
@@ -25,6 +25,53 @@ use std::process::ExitCode;
 use crate::cli::{Command, Options};
 
 fn main() -> ExitCode {
+    // Show the size of the Term structure
+    println!(
+        "Size of Term: {}",
+        std::mem::size_of::<nickel_lang_core::term::Term>()
+    );
+    println!(
+        "Size of Label: {}",
+        std::mem::size_of::<nickel_lang_core::label::Label>()
+    );
+    println!(
+        "Size of Label: {}",
+        std::mem::size_of::<nickel_lang_core::label::Label>()
+    );
+    println!(
+        "Size of RecordData: {}",
+        std::mem::size_of::<nickel_lang_core::term::record::RecordData>()
+    );
+
+    println!(
+        "Size of UnaryOp: {}",
+        std::mem::size_of::<nickel_lang_core::term::UnaryOp>()
+    );
+    println!(
+        "Size of BinaryOp: {}",
+        std::mem::size_of::<nickel_lang_core::term::BinaryOp>()
+    );
+    println!(
+        "Size of NAryOp: {}",
+        std::mem::size_of::<nickel_lang_core::term::NAryOp>()
+    );
+    println!(
+        "Size of TypeAnnotation: {}",
+        std::mem::size_of::<nickel_lang_core::term::TypeAnnotation>()
+    );
+    println!(
+        "Size of Type: {}",
+        std::mem::size_of::<nickel_lang_core::typ::Type>()
+    );
+    println!(
+        "Size of ParseError: {}",
+        std::mem::size_of::<nickel_lang_core::error::ParseError>()
+    );
+    println!(
+        "Size of EvalError: {}",
+        std::mem::size_of::<nickel_lang_core::error::EvalError>()
+    );
+
     #[cfg(feature = "metrics")]
     let metrics = metrics::Recorder::install();
 
diff --git a/core/src/cache.rs b/core/src/cache.rs
index e5f962f3ea..30dd1684a7 100644
--- a/core/src/cache.rs
+++ b/core/src/cache.rs
@@ -10,7 +10,7 @@ use crate::position::TermPos;
 use crate::program::FieldPath;
 use crate::stdlib::{self as nickel_stdlib, StdlibModule};
 use crate::term::array::Array;
-use crate::term::record::{Field, RecordData};
+use crate::term::record::Field;
 use crate::term::{RichTerm, SharedTerm, Term};
 use crate::transform::import_resolution;
 use crate::typ::UnboundTypeVariableError;
@@ -697,7 +697,8 @@ impl Cache {
 
                 if state < EntryState::Transforming {
                     match SharedTerm::make_mut(&mut term.term) {
-                        Term::Record(RecordData { ref mut fields, .. }) => {
+                        Term::Record(ref mut data) => {
+                            let fields = &mut data.fields;
                             let map_res: Result<_, UnboundTypeVariableError> =
                                 std::mem::take(fields)
                                     .into_iter()
diff --git a/core/src/eval/fixpoint.rs b/core/src/eval/fixpoint.rs
index f4a80900e2..8c429c59c9 100644
--- a/core/src/eval/fixpoint.rs
+++ b/core/src/eval/fixpoint.rs
@@ -93,7 +93,7 @@ pub fn rec_env<'a, I: Iterator<Item = (&'a LocIdent, &'a Field)>, C: Cache>(
                 };
 
                 let closure = Closure {
-                    body: RichTerm::from(Term::RuntimeError(error)),
+                    body: RichTerm::from(Term::RuntimeError(Box::new(error))),
                     env: Environment::new(),
                 };
 
@@ -164,5 +164,5 @@ pub fn revert<C: Cache>(cache: &mut C, record_data: RecordData) -> Term {
 
     // At run-time, we don't care about `RecordDeps`, because this information is already stored in
     // the cache (thunks in call-by-need mode). We set it to `None`.
-    Term::RecRecord(record_data, Vec::new(), None)
+    Term::RecRecord(Box::new(record_data), Vec::new(), None)
 }
diff --git a/core/src/eval/merge.rs b/core/src/eval/merge.rs
index 2ffd4abdd8..4bc7f8a7ac 100644
--- a/core/src/eval/merge.rs
+++ b/core/src/eval/merge.rs
@@ -245,7 +245,11 @@ pub fn merge<C: Cache>(
             // exactly the same, but can't be shadowed.
             let eq_contract = mk_app!(stdlib::internals::stdlib_contract_equal(), t1);
             let result = mk_app!(
-                mk_term::op2(BinaryOp::ContractApply, eq_contract, Term::Lbl(label)),
+                mk_term::op2(
+                    BinaryOp::ContractApply,
+                    eq_contract,
+                    Term::Lbl(Box::new(label))
+                ),
                 t2
             )
             .with_pos(pos_op);
@@ -289,7 +293,7 @@ pub fn merge<C: Cache>(
                     // of raising a blame error as for a delayed contract error, which can't be
                     // caught in user-code, we return an `'Error {..}` value instead.
                     return Ok(Closure::atomic_closure(
-                        mk_term::enum_variant("Error", Term::Record(RecordData::with_field_values([
+                        mk_term::enum_variant("Error", Term::Record(Box::new(RecordData::with_field_values([
                             ("message".into(), mk_term::string(format!("extra field{plural} {fields_list}"))),
                             ("notes".into(), Term::Array([
                                 mk_term::string("Have you misspelled a field?"),
@@ -300,7 +304,7 @@ pub fn merge<C: Cache>(
                                     `{some_field | SomeContract, ..}`, to make it accept extra fields."
                                 ),
                             ].into_iter().collect(), Default::default()).into())
-                        ])))));
+                        ]))))));
                 }
                 _ => (),
             };
@@ -359,7 +363,7 @@ pub fn merge<C: Cache>(
                     // of program transformations. At this point, the interpreter doesn't care
                     // about them anymore, and dependencies are stored at the level of revertible
                     // cache elements directly.
-                    Term::RecRecord(RecordData::new(m, attrs, None), Vec::new(), None),
+                    Term::RecRecord(Box::new(RecordData::new(m, attrs, None)), Vec::new(), None),
                     final_pos,
                 ),
                 env: Environment::new(),
diff --git a/core/src/eval/mod.rs b/core/src/eval/mod.rs
index 93c0da0441..cbb438d6b0 100644
--- a/core/src/eval/mod.rs
+++ b/core/src/eval/mod.rs
@@ -73,6 +73,7 @@
 //! probably suboptimal for a functional language and is unable to collect cyclic data, which may
 //! appear inside recursive records. A dedicated garbage collector is probably something to
 //! consider at some point.
+use crate::term::RecordInsertData;
 use crate::{
     cache::{Cache as ImportCache, Envs, ImportResolver},
     closurize::{closurize_rec_record, Closurize},
@@ -446,25 +447,37 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
         // a definition, we complete the error with the additional information of where
         // it was accessed:
         let Closure { body, env } = self.cache.get(idx);
-        let body = match_sharedterm!(match (body.term) {
-            Term::RuntimeError(EvalError::MissingFieldDef {
-                id,
-                metadata,
-                pos_record,
-                pos_access: TermPos::None,
-            }) => RichTerm::new(
-                Term::RuntimeError(EvalError::MissingFieldDef {
+
+        let body = match body.term.as_ref() {
+            Term::RuntimeError(error) if matches!(**error, EvalError::MissingFieldDef { .. }) => {
+                let term = body.term.into_owned();
+                // unreachable(): we checked in the pattern that we are precisely in this case
+                let Term::RuntimeError(error) = term else {
+                    unreachable!();
+                };
+                // unreachable(): we checked in the pattern that we are precisely in this case
+                let EvalError::MissingFieldDef {
                     id,
                     metadata,
                     pos_record,
-                    pos_access: pos,
-                }),
-                pos,
-            ),
-            _ => {
-                body
+                    pos_access: TermPos::None,
+                } = *error
+                else {
+                    unreachable!()
+                };
+
+                RichTerm::new(
+                    Term::RuntimeError(Box::new(EvalError::MissingFieldDef {
+                        id,
+                        metadata,
+                        pos_record,
+                        pos_access: pos,
+                    })),
+                    pos,
+                )
             }
-        });
+            _ => body,
+        };
 
         Ok(Closure { body, env })
     }
@@ -541,7 +554,7 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                             // This operation should not be allowed to evaluate a sealed term
                             return Err(EvalError::BlameError {
                                 evaluated_arg: label.get_evaluated_arg(&self.cache),
-                                label,
+                                label: *label,
                                 call_stack: self.call_stack.clone(),
                             });
                         }
@@ -688,7 +701,7 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                 Term::Record(data) if !data.attrs.closurized => {
                     Closure {
                         body: RichTerm::new(
-                            Term::Record(data.closurize(&mut self.cache, env)),
+                            Term::Record(Box::new(data.closurize(&mut self.cache, env))),
                             pos,
                         ),
                         env: Environment::new(),
@@ -704,9 +717,15 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                     // type, once we have a different representation for runtime evaluation,
                     // instead of relying on invariants. But for now, we have to live with it.
                     let (mut static_part, dyn_fields) = if !data.attrs.closurized {
-                        closurize_rec_record(&mut self.cache, data, dyn_fields, deps, env)
+                        closurize_rec_record(
+                            &mut self.cache,
+                            *data,
+                            dyn_fields,
+                            deps.map(|deps| *deps),
+                            env,
+                        )
                     } else {
-                        (data, dyn_fields)
+                        (*data, dyn_fields)
                     };
 
                     let rec_env =
@@ -733,7 +752,7 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                     // recursive environment only contains the static fields, and not the dynamic
                     // fields.
                     let extended = dyn_fields.into_iter().fold(
-                        RichTerm::new(Term::Record(static_part), pos),
+                        RichTerm::new(Term::Record(Box::new(static_part)), pos),
                         |acc, (name_as_term, mut field)| {
                             let pos = field
                                 .value
@@ -751,12 +770,12 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                             } = field;
 
                             let extend = mk_term::op2(
-                                BinaryOp::RecordInsert {
+                                BinaryOp::RecordInsert(Box::new(RecordInsertData {
                                     metadata,
                                     pending_contracts,
                                     ext_kind,
                                     op_kind: RecordOpKind::ConsiderAllFields,
-                                },
+                                })),
                                 name_as_term,
                                 acc,
                             );
@@ -828,10 +847,10 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                     }
                 }
                 Term::ParseError(parse_error) => {
-                    return Err(EvalError::ParseError(parse_error));
+                    return Err(EvalError::ParseError(*parse_error));
                 }
                 Term::RuntimeError(error) => {
-                    return Err(error);
+                    return Err(*error);
                 }
                 // For now, we simply erase annotations at runtime. They aren't accessible anyway
                 // (as opposed to field metadata) and don't change the operational semantics, as
@@ -1226,8 +1245,8 @@ pub fn subst<C: Cache>(
             let t = subst(cache, t, initial_env, env);
             RichTerm::new(Term::Sealed(i, t, lbl), pos)
         }
-        Term::Record(record) => {
-            let mut record = record
+        Term::Record(mut record) => {
+            *record = record
                 .map_defined_values(|_, value| subst(cache, value, initial_env, env));
 
             // [^subst-closurized-false]: After substitution, there's no closure in here anymore.
@@ -1239,8 +1258,8 @@ pub fn subst<C: Cache>(
 
             RichTerm::new(Term::Record(record), pos)
         }
-        Term::RecRecord(record, dyn_fields, deps) => {
-            let mut record = record
+        Term::RecRecord(mut record, dyn_fields, deps) => {
+            *record = record
                 .map_defined_values(|_, value| subst(cache, value, initial_env, env));
 
             // see [^subst-closurized-false]
diff --git a/core/src/eval/operation.rs b/core/src/eval/operation.rs
index d6a0fa1168..252c48d7b5 100644
--- a/core/src/eval/operation.rs
+++ b/core/src/eval/operation.rs
@@ -309,7 +309,7 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
             UnaryOp::Blame => match_sharedterm!(match (t) {
                 Term::Lbl(label) => Err(EvalError::BlameError {
                     evaluated_arg: label.get_evaluated_arg(&self.cache),
-                    label,
+                    label: *label,
                     call_stack: std::mem::take(&mut self.call_stack),
                 }),
                 _ => mk_type_error!("Label"),
@@ -648,7 +648,7 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
 
                         Ok(Closure {
                             body: RichTerm::new(
-                                Term::Record(RecordData { fields, ..record }),
+                                Term::Record(Box::new(RecordData { fields, ..*record })),
                                 pos_op_inh,
                             ),
                             env: Environment::new(),
@@ -1085,7 +1085,7 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                         });
 
                         let cont = RichTerm::new(
-                            Term::Record(RecordData { fields, ..record }),
+                            Term::Record(Box::new(RecordData { fields, ..*record })),
                             pos.into_inherited(),
                         );
 
@@ -1165,7 +1165,7 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                     let mut empty = RecordData::empty();
                     empty.sealed_tail = r.sealed_tail;
                     Ok(Closure {
-                        body: RichTerm::new(Term::Record(empty), pos_op.into_inherited()),
+                        body: RichTerm::new(Term::Record(Box::new(empty)), pos_op.into_inherited()),
                         env,
                     })
                 }
@@ -1941,7 +1941,7 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                         .and_then(|field| field.value)
                         .map(|v| v.term.into_owned())
                     {
-                        label = label.with_diagnostic_message(msg.into_inner());
+                        *label = label.with_diagnostic_message(msg.into_inner());
                     }
 
                     if let Some(notes_term) = record_data
@@ -1968,7 +1968,7 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                                 })
                                 .collect::<Result<Vec<_>, _>>()?;
 
-                            label = label.with_diagnostic_notes(notes);
+                            *label = label.with_diagnostic_notes(notes);
                         }
                     }
 
@@ -2180,12 +2180,14 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                     _ => mk_type_error!("String", 1, t1, pos1),
                 })
             }
-            BinaryOp::RecordInsert {
-                metadata,
-                pending_contracts,
-                ext_kind,
-                op_kind,
-            } => {
+            BinaryOp::RecordInsert(data) => {
+                let RecordInsertData {
+                    metadata,
+                    pending_contracts,
+                    ext_kind,
+                    op_kind,
+                } = *data;
+
                 if let Term::Str(id) = &*t1 {
                     match_sharedterm!(match (t2) {
                         Term::Record(record) => {
@@ -2229,7 +2231,8 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                                     ))
                                 }
                                 _ => Ok(Closure {
-                                    body: Term::Record(RecordData { fields, ..record }).into(),
+                                    body: Term::Record(Box::new(RecordData { fields, ..*record }))
+                                        .into(),
                                     env: env2,
                                 }),
                             }
@@ -2272,7 +2275,7 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                                 _ => {
                                     // We reconstruct the record's data to have access to
                                     // `data.field_names()`
-                                    let record = RecordData { fields, ..record };
+                                    let record = RecordData { fields, ..*record };
 
                                     Err(EvalError::FieldMissing {
                                         id: id.into(),
@@ -2286,7 +2289,7 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                         } else {
                             Ok(Closure {
                                 body: RichTerm::new(
-                                    Term::Record(RecordData { fields, ..record }),
+                                    Term::Record(Box::new(RecordData { fields, ..*record })),
                                     pos_op_inh,
                                 ),
                                 env: env2,
@@ -2683,7 +2686,7 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                         RuntimeContract::push_dedup(
                             &mut attrs.pending_contracts,
                             &final_env,
-                            RuntimeContract::new(contract, lbl),
+                            RuntimeContract::new(contract, *lbl),
                             &final_env,
                         );
 
@@ -2734,7 +2737,7 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                         for (id, field) in record_data.fields.iter_mut() {
                             let runtime_ctr = RuntimeContract {
                                 contract: contract_at_field(*id),
-                                label: label.clone(),
+                                label: (*label).clone(),
                             };
 
                             RuntimeContract::push_dedup(
@@ -2753,7 +2756,7 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                         // We want recursive occurrences of fields to pick this new value as
                         // well: hence, we need to recompute the fixpoint, which is done by
                         // `fixpoint::revert`.
-                        let reverted = super::fixpoint::revert(&mut self.cache, record_data);
+                        let reverted = super::fixpoint::revert(&mut self.cache, *record_data);
 
                         Ok(Closure {
                             body: RichTerm::new(reverted, pos2),
@@ -2771,12 +2774,13 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                     return mk_type_error!("String", 1, t1.into(), pos1);
                 };
 
-                let Term::Lbl(label) = t2 else {
+                let Term::Lbl(mut label) = t2 else {
                     return mk_type_error!("String", 2, t2.into(), pos2);
                 };
 
+                *label = label.with_diagnostic_message(message.into_inner());
                 Ok(Closure::atomic_closure(RichTerm::new(
-                    Term::Lbl(label.with_diagnostic_message(message.into_inner())),
+                    Term::Lbl(label),
                     pos_op_inh,
                 )))
             }
@@ -2814,12 +2818,14 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                     })
                     .collect::<Result<Vec<_>, _>>()?;
 
-                let Term::Lbl(label) = t2 else {
+                let Term::Lbl(mut label) = t2 else {
                     return mk_type_error!("Label", 2, t2.into(), pos2);
                 };
 
+                *label = label.with_diagnostic_notes(notes);
+
                 Ok(Closure::atomic_closure(RichTerm::new(
-                    Term::Lbl(label.with_diagnostic_notes(notes)),
+                    Term::Lbl(label),
                     pos_op_inh,
                 )))
             }
@@ -2831,12 +2837,13 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                     return mk_type_error!("String", 1, t1.into(), pos1);
                 };
 
-                let Term::Lbl(label) = t2 else {
+                let Term::Lbl(mut label) = t2 else {
                     return mk_type_error!("Label", 2, t2.into(), pos2);
                 };
 
+                *label = label.append_diagnostic_note(note.into_inner());
                 Ok(Closure::atomic_closure(RichTerm::new(
-                    Term::Lbl(label.append_diagnostic_note(note.into_inner())),
+                    Term::Lbl(label),
                     pos2.into_inherited(),
                 )))
             }
@@ -2875,17 +2882,17 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                     right,
                 } = split::split(record1.fields, record2.fields);
 
-                let left_only = Term::Record(RecordData {
+                let left_only = Term::Record(Box::new(RecordData {
                     fields: left,
                     sealed_tail: record1.sealed_tail,
                     attrs: record1.attrs,
-                });
+                }));
 
-                let right_only = Term::Record(RecordData {
+                let right_only = Term::Record(Box::new(RecordData {
                     fields: right,
                     sealed_tail: record2.sealed_tail,
                     attrs: record2.attrs,
-                });
+                }));
 
                 let (center1, center2): (IndexMap<LocIdent, Field>, IndexMap<LocIdent, Field>) =
                     center
@@ -2893,20 +2900,20 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                         .map(|(id, (left, right))| ((id, left), (id, right)))
                         .unzip();
 
-                let left_center = Term::Record(RecordData {
+                let left_center = Term::Record(Box::new(RecordData {
                     fields: center1,
                     sealed_tail: None,
                     attrs: RecordAttrs::default().closurized(),
-                });
+                }));
 
-                let right_center = Term::Record(RecordData {
+                let right_center = Term::Record(Box::new(RecordData {
                     fields: center2,
                     sealed_tail: None,
                     attrs: RecordAttrs::default().closurized(),
-                });
+                }));
 
                 Ok(Closure::atomic_closure(RichTerm::new(
-                    Term::Record(RecordData {
+                    Term::Record(Box::new(RecordData {
                         fields: IndexMap::from([
                             (
                                 LocIdent::from("left_only"),
@@ -2927,7 +2934,7 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                         ]),
                         attrs: RecordAttrs::default().closurized(),
                         sealed_tail: None,
-                    }),
+                    })),
                     pos_op_inh,
                 )))
             }
@@ -2973,11 +2980,11 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                 record1.attrs.open = record1.attrs.open || record2.attrs.open;
 
                 Ok(Closure::atomic_closure(RichTerm::new(
-                    Term::Record(RecordData {
+                    Term::Record(Box::new(RecordData {
                         fields: record1.fields,
                         attrs: record1.attrs,
                         sealed_tail,
-                    }),
+                    })),
                     pos_op_inh,
                 )))
             }
@@ -3122,7 +3129,7 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                             },
                             env3,
                             pos_op,
-                            MergeMode::Contract(lbl),
+                            MergeMode::Contract(*lbl),
                             &mut self.call_stack,
                         )
                     }
@@ -3199,7 +3206,7 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                         let fields = tail.fields.keys().map(|s| s.ident()).collect();
                         r.sealed_tail = Some(record::SealedTail::new(
                             *s,
-                            label.clone(),
+                            (**label).clone(),
                             tail_closurized,
                             fields,
                         ));
@@ -3255,13 +3262,13 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                 debug_assert!(args.next().is_none());
 
                 match (&*a1, &*a2, &*a3) {
-                    (Term::SealingKey(s), Term::Lbl(l), Term::Record(r)) => r
+                    (Term::SealingKey(key), Term::Lbl(label), Term::Record(record)) => record
                         .clone()
                         .sealed_tail
-                        .and_then(|t| t.unseal(s).cloned())
+                        .and_then(|t| t.unseal(key).cloned())
                         .ok_or_else(|| EvalError::BlameError {
-                            evaluated_arg: l.get_evaluated_arg(&self.cache),
-                            label: l.clone(),
+                            evaluated_arg: label.get_evaluated_arg(&self.cache),
+                            label: (**label).clone(),
                             call_stack: std::mem::take(&mut self.call_stack),
                         })
                         .map(|t| Closure { body: t, env: env3 }),
@@ -3522,7 +3529,7 @@ impl RecPriority {
                             cache.map_at_index(idx, |cache, inner| match inner.body.as_ref() {
                                 Term::Record(record_data) => self.propagate_in_record(
                                     cache,
-                                    record_data.clone(),
+                                    (**record_data).clone(),
                                     &inner.env,
                                     pos,
                                 ),
@@ -3550,7 +3557,7 @@ impl RecPriority {
             .collect();
 
         Closure {
-            body: RichTerm::new(Term::Record(record), pos),
+            body: RichTerm::new(Term::Record(Box::new(record)), pos),
             env: new_env,
         }
     }
@@ -3564,7 +3571,7 @@ impl RecPriority {
         pos: TermPos,
     ) -> Closure {
         match st.into_owned() {
-            Term::Record(record_data) => self.propagate_in_record(cache, record_data, &env, pos),
+            Term::Record(record_data) => self.propagate_in_record(cache, *record_data, &env, pos),
             t => Closure {
                 body: RichTerm::new(t, pos),
                 env,
diff --git a/core/src/parser/utils.rs b/core/src/parser/utils.rs
index 57d71e2ea3..394314fe7f 100644
--- a/core/src/parser/utils.rs
+++ b/core/src/parser/utils.rs
@@ -157,10 +157,10 @@ impl FieldDef {
                         let mut fields = IndexMap::new();
                         fields.insert(id, acc);
                         Field::from(RichTerm::new(
-                            Term::Record(RecordData {
+                            Term::Record(Box::new(RecordData {
                                 fields,
                                 ..Default::default()
-                            }),
+                            })),
                             pos,
                         ))
                     }
@@ -172,10 +172,10 @@ impl FieldDef {
                             let mut fields = IndexMap::new();
                             fields.insert(id, acc);
                             Field::from(RichTerm::new(
-                                Term::Record(RecordData {
+                                Term::Record(Box::new(RecordData {
                                     fields,
                                     ..Default::default()
-                                }),
+                                })),
                                 pos,
                             ))
                         } else {
@@ -184,7 +184,11 @@ impl FieldDef {
                             // `RecRecord` to handle dynamic fields at evaluation time rather than
                             // right here
                             Field::from(RichTerm::new(
-                                Term::RecRecord(RecordData::empty(), vec![(exp, acc)], None),
+                                Term::RecRecord(
+                                    Box::new(RecordData::empty()),
+                                    vec![(exp, acc)],
+                                    None,
+                                ),
                                 pos,
                             ))
                         }
@@ -359,7 +363,7 @@ impl AttachTerm<RichTerm> for TypeAnnotation {
         }
 
         let pos = rt.pos;
-        RichTerm::new(Term::Annotated(self, rt), pos)
+        RichTerm::new(Term::Annotated(Box::new(self), rt), pos)
     }
 }
 
@@ -497,7 +501,7 @@ where
     });
 
     Term::RecRecord(
-        RecordData::new(static_fields, attrs, None),
+        Box::new(RecordData::new(static_fields, attrs, None)),
         dynamic_fields,
         None,
     )
@@ -536,11 +540,11 @@ fn merge_fields(id_span: RawSpan, field1: Field, field2: Field) -> Field {
                 for (id, (field1, field2)) in center.into_iter() {
                     fields.insert(id, merge_fields(id_span, field1, field2));
                 }
-                Term::Record(RecordData::new(
+                Term::Record(Box::new(RecordData::new(
                     fields,
                     RecordAttrs::combine(rd1.attrs, rd2.attrs),
                     None,
-                ))
+                )))
                 .into()
             }
             (t1, t2) => mk_term::op2(
@@ -643,7 +647,7 @@ pub fn mk_let(
 pub fn mk_fun(pat: Pattern, body: RichTerm) -> Term {
     match pat.data {
         PatternData::Any(id) => Term::Fun(id, body),
-        _ => Term::FunPattern(pat, body),
+        _ => Term::FunPattern(Box::new(pat), body),
     }
 }
 
diff --git a/core/src/pretty.rs b/core/src/pretty.rs
index 67d7820f03..67ff7a12a0 100644
--- a/core/src/pretty.rs
+++ b/core/src/pretty.rs
@@ -863,7 +863,7 @@ where
             LetPattern(pattern, rt, body) => docs![
                 allocator,
                 "let ",
-                pattern,
+                &**pattern,
                 if let Annotated(annot, _) = rt.as_ref() {
                     annot.pretty(allocator)
                 } else {
diff --git a/core/src/term/make/builder.rs b/core/src/term/make/builder.rs
index 4326f54c5d..03f6e59c53 100644
--- a/core/src/term/make/builder.rs
+++ b/core/src/term/make/builder.rs
@@ -223,10 +223,10 @@ where
     let fst = it.next().unwrap();
 
     let content = it.rev().fold(content, |acc, id| {
-        record::Field::from(RichTerm::from(Term::Record(RecordData {
+        record::Field::from(RichTerm::from(Term::Record(Box::new(RecordData {
             fields: [(LocIdent::from(id), acc)].into(),
             ..Default::default()
-        })))
+        }))))
     });
 
     (fst.into(), content)
@@ -262,7 +262,7 @@ where
             }
         }
     }
-    Term::Record(RecordData::new(static_fields, attrs, None))
+    Term::Record(Box::new(RecordData::new(static_fields, attrs, None)))
 }
 
 impl Record {
diff --git a/core/src/term/mod.rs b/core/src/term/mod.rs
index 3e50f8fbb7..9e6f798ffb 100644
--- a/core/src/term/mod.rs
+++ b/core/src/term/mod.rs
@@ -101,11 +101,13 @@ pub enum Term {
 
     /// A destructuring function.
     #[serde(skip)]
-    FunPattern(Pattern, RichTerm),
+    FunPattern(Box<Pattern>, RichTerm),
 
     /// A blame label.
+    ///
+    /// Label are boxed to minimize the overall size of term.
     #[serde(skip)]
-    Lbl(Label),
+    Lbl(Box<Label>),
 
     /// A let binding.
     #[serde(skip)]
@@ -113,7 +115,7 @@ pub enum Term {
 
     /// A destructuring let-binding.
     #[serde(skip)]
-    LetPattern(Pattern, RichTerm, RichTerm),
+    LetPattern(Box<Pattern>, RichTerm, RichTerm),
 
     /// An application.
     #[serde(skip)]
@@ -139,14 +141,14 @@ pub enum Term {
     /// A record, mapping identifiers to terms.
     #[serde(serialize_with = "crate::serialize::serialize_record")]
     #[serde(deserialize_with = "crate::serialize::deserialize_record")]
-    Record(RecordData),
+    Record(Box<RecordData>),
 
     /// A recursive record, where the fields can reference each others.
     #[serde(skip)]
     RecRecord(
-        RecordData,
+        Box<RecordData>,
         Vec<(RichTerm, Field)>, /* field whose name is defined by interpolation */
-        Option<RecordDeps>, /* dependency tracking between fields. None before the free var pass */
+        Option<Box<RecordDeps>>, /* dependency tracking between fields. None before the free var pass */
     ),
 
     /// A match expression. Corresponds only to the cases: this expression is still to be applied
@@ -197,12 +199,12 @@ pub enum Term {
     /// type variable. In our example, the last cast to `a` finds `Sealed(2, "a")`, while it
     /// expected `Sealed(1, _)`, hence it raises a positive blame.
     #[serde(skip)]
-    Sealed(SealingKey, RichTerm, Label),
+    Sealed(SealingKey, RichTerm, Box<Label>),
 
     /// A term with a type and/or contract annotation.
     #[serde(serialize_with = "crate::serialize::serialize_annotated_value")]
     #[serde(skip_deserializing)]
-    Annotated(TypeAnnotation, RichTerm),
+    Annotated(Box<TypeAnnotation>, RichTerm),
 
     /// An unresolved import.
     #[serde(skip)]
@@ -218,7 +220,7 @@ pub enum Term {
     #[serde(skip)]
     Type {
         /// The static type.
-        typ: Type,
+        typ: Box<Type>,
         /// The conversion of this type to a contract, that is, `typ.contract()?`. This field
         /// serves as a caching mechanism so we only run the contract generation code once per type
         /// written by the user.
@@ -273,7 +275,7 @@ pub enum Term {
     /// A term that couldn't be parsed properly. Used by the LSP to handle partially valid
     /// programs.
     #[serde(skip)]
-    ParseError(ParseError),
+    ParseError(Box<ParseError>),
 
     /// A delayed runtime error. Usually, errors are raised and abort the execution right away,
     /// without the need to store them in the AST. However, some cases require a term which aborts
@@ -299,7 +301,7 @@ pub enum Term {
     /// evaluated, will raise a proper missing field definition error. This is precisely the
     /// behavior of `RuntimeError` behaves.
     #[serde(skip)]
-    RuntimeError(EvalError),
+    RuntimeError(Box<EvalError>),
 
     #[serde(skip)]
     /// A "pointer" (cache index, which can see as a kind of generic pointer to the memory managed
@@ -469,7 +471,7 @@ impl RuntimeContract {
             make::op2(
                 BinaryOp::ContractApply,
                 self.contract,
-                Term::Lbl(self.label)
+                Term::Lbl(Box::new(self.label))
             )
             .with_pos(pos),
             rt
@@ -1682,6 +1684,14 @@ pub enum RecordOpKind {
     ConsiderAllFields,
 }
 
+#[derive(Clone, Debug)]
+pub struct RecordInsertData {
+    pub metadata: FieldMetadata,
+    pub pending_contracts: Vec<RuntimeContract>,
+    pub ext_kind: RecordExtKind,
+    pub op_kind: RecordOpKind,
+}
+
 /// Primitive binary operators
 #[derive(Clone, Debug, PartialEq)]
 pub enum BinaryOp {
@@ -1780,12 +1790,7 @@ pub enum BinaryOp {
     /// aren't first class values, at least at the time of writing), so for now we attach it
     /// directly to the extend primop. This isn't ideal, and in the future we may want to have a
     /// more principled primop.
-    RecordInsert {
-        metadata: FieldMetadata,
-        pending_contracts: Vec<RuntimeContract>,
-        ext_kind: RecordExtKind,
-        op_kind: RecordOpKind,
-    },
+    RecordInsert(Box<RecordInsertData>),
 
     /// Remove a field from a record. The field name is given as an argument.
     RecordRemove(RecordOpKind),
@@ -1912,14 +1917,16 @@ impl fmt::Display for BinaryOp {
             LabelWithErrorData => write!(f, "label/with_error_data"),
             Unseal => write!(f, "unseal"),
             LabelGoField => write!(f, "label/go_field"),
-            RecordInsert {
-                op_kind: RecordOpKind::IgnoreEmptyOpt,
-                ..
-            } => write!(f, "record/insert"),
-            RecordInsert {
-                op_kind: RecordOpKind::ConsiderAllFields,
-                ..
-            } => write!(f, "record/insert_with_opts"),
+            RecordInsert(data) => match **data {
+                RecordInsertData {
+                    op_kind: RecordOpKind::IgnoreEmptyOpt,
+                    ..
+                } => write!(f, "record/insert"),
+                RecordInsertData {
+                    op_kind: RecordOpKind::ConsiderAllFields,
+                    ..
+                } => write!(f, "record/insert_with_opts"),
+            },
             RecordRemove(RecordOpKind::IgnoreEmptyOpt) => write!(f, "record/remove"),
             RecordRemove(RecordOpKind::ConsiderAllFields) => write!(f, "record/remove_with_opts"),
             RecordGet => write!(f, "record/get"),
@@ -2275,11 +2282,11 @@ impl Traverse<RichTerm> for RichTerm {
                     .map(|(id, field)| Ok((id, field.traverse(f, order)?)))
                     .collect();
                 RichTerm::new(
-                    Term::Record(RecordData::new(
+                    Term::Record(Box::new(RecordData::new(
                         fields_res?,
                         record.attrs,
                         record.sealed_tail,
-                    )),
+                    ))),
                     pos,
                 )
             }
@@ -2303,7 +2310,11 @@ impl Traverse<RichTerm> for RichTerm {
                     .collect();
                 RichTerm::new(
                     Term::RecRecord(
-                        RecordData::new(static_fields_res?, record.attrs, record.sealed_tail),
+                        Box::new(RecordData::new(
+                            static_fields_res?,
+                            record.attrs,
+                            record.sealed_tail,
+                        )),
                         dyn_fields_res?,
                         deps,
                     ),
@@ -2335,13 +2346,19 @@ impl Traverse<RichTerm> for RichTerm {
             Term::Annotated(annot, term) => {
                 let annot = annot.traverse(f, order)?;
                 let term = term.traverse(f, order)?;
-                RichTerm::new(Term::Annotated(annot, term), pos)
+                RichTerm::new(Term::Annotated(Box::new(annot), term), pos)
             }
             Term::Type { typ, contract } => {
                 let typ = typ.traverse(f, order)?;
                 let contract = contract.traverse(f, order)?;
 
-                RichTerm::new(Term::Type { typ, contract }, pos)
+                RichTerm::new(
+                    Term::Type {
+                        typ: Box::new(typ),
+                        contract,
+                    },
+                    pos,
+                )
             }
             _ => rt,
         });
@@ -2453,7 +2470,13 @@ impl Traverse<Type> for RichTerm {
                 match_sharedterm!(match (rt.term) {
                     Term::Type { typ, contract } => {
                         let typ = typ.traverse(f, order)?;
-                        Ok(RichTerm::new(Term::Type { typ, contract }, rt.pos))
+                        Ok(RichTerm::new(
+                            Term::Type {
+                                typ: Box::new(typ),
+                                contract,
+                            },
+                            rt.pos,
+                        ))
                     }
                     _ => Ok(rt),
                 })
@@ -2668,7 +2691,7 @@ pub mod make {
                 )*
                 $crate::term::RichTerm::from(
                     $crate::term::Term::Record(
-                        $crate::term::record::RecordData::with_field_values(fields)
+                        Box::new($crate::term::record::RecordData::with_field_values(fields))
                     )
                 )
             }
@@ -2743,7 +2766,7 @@ pub mod make {
         T2: Into<RichTerm>,
         D: Into<Pattern>,
     {
-        Term::LetPattern(pat.into(), t1.into(), t2.into()).into()
+        Term::LetPattern(Box::new(pat.into()), t1.into(), t2.into()).into()
     }
 
     pub fn if_then_else<T1, T2, T3>(cond: T1, t1: T2, t2: T3) -> RichTerm
@@ -2790,7 +2813,11 @@ pub mod make {
         T: Into<RichTerm>,
     {
         Ok(mk_app!(
-            op2(BinaryOp::ContractApply, typ.contract()?, Term::Lbl(l)),
+            op2(
+                BinaryOp::ContractApply,
+                typ.contract()?,
+                Term::Lbl(Box::new(l))
+            ),
             t.into()
         ))
     }
diff --git a/core/src/term/pattern/compile.rs b/core/src/term/pattern/compile.rs
index bb4b645a23..0fc3646c83 100644
--- a/core/src/term/pattern/compile.rs
+++ b/core/src/term/pattern/compile.rs
@@ -28,19 +28,19 @@ use crate::{
     mk_app,
     term::{
         make, record::FieldMetadata, BinaryOp, MatchBranch, MatchData, NAryOp, RecordExtKind,
-        RecordOpKind, RichTerm, Term, UnaryOp,
+        RecordInsertData, RecordOpKind, RichTerm, Term, UnaryOp,
     },
 };
 
 /// Generate a standard `%record/insert%` primop as generated by the parser.
 fn record_insert() -> BinaryOp {
-    BinaryOp::RecordInsert {
+    BinaryOp::RecordInsert(Box::new(RecordInsertData {
         ext_kind: RecordExtKind::WithValue,
         metadata: Default::default(),
         pending_contracts: Default::default(),
         // We don't really care for optional fields here and we don't need to filter them out
         op_kind: RecordOpKind::ConsiderAllFields,
-    }
+    }))
 }
 
 /// Generate a record update
@@ -164,10 +164,10 @@ fn update_with_merge(record_id: LocIdent, id: LocIdent, field: Field) -> RichTer
     let annot = field.metadata.annotation.clone();
     let pos_value = field.value.as_ref().and_then(|value| value.pos.into_opt());
 
-    let singleton = Term::Record(RecordData {
+    let singleton = Term::Record(Box::new(RecordData {
         fields: IndexMap::from([(id, field)]),
         ..Default::default()
-    });
+    }));
     // Right now, patterns are compiled on-the-fly during evaluation. We thus need to
     // perform the gen_pending_contract transformation manually, or the contracts will
     // just be ignored. One step suffices, as we create a singleton record that doesn't
@@ -570,7 +570,7 @@ impl CompilePart for RecordPattern {
                             UnaryOp::RecordAccess(rest_field),
                             Term::Var(final_bindings_id),
                         ),
-                        Term::Record(RecordData::empty()),
+                        Term::Record(Box::new(RecordData::empty())),
                     ),
                 ),
                 Term::Null,
@@ -938,10 +938,10 @@ impl Compile for MatchData {
         }
 
         let error_case = RichTerm::new(
-            Term::RuntimeError(EvalError::NonExhaustiveMatch {
+            Term::RuntimeError(Box::new(EvalError::NonExhaustiveMatch {
                 value: value.clone(),
                 pos,
-            }),
+            })),
             pos,
         );
 
@@ -1013,7 +1013,7 @@ impl Compile for MatchData {
                 // <inner>
                 make::let_in(
                     init_bindings_id,
-                    Term::Record(RecordData::empty()),
+                    Term::Record(Box::new(RecordData::empty())),
                     make::let_in(
                         bindings_id,
                         branch.pattern.compile_part(value_id, init_bindings_id),
@@ -1048,7 +1048,9 @@ impl Compile for TagsOnlyMatch {
                 value
             )
             .with_pos(pos),
-            Term::Record(RecordData::with_field_values(self.branches.into_iter()))
+            Term::Record(Box::new(RecordData::with_field_values(
+                self.branches.into_iter()
+            )))
         );
 
         let match_op = if let Some(default) = self.default {
diff --git a/core/src/transform/desugar_destructuring.rs b/core/src/transform/desugar_destructuring.rs
index 69639b2152..459e6d5f4e 100644
--- a/core/src/transform/desugar_destructuring.rs
+++ b/core/src/transform/desugar_destructuring.rs
@@ -20,7 +20,7 @@ use crate::{
 /// destructuring patterns to be desugared in children nodes.
 pub fn transform_one(rt: RichTerm) -> RichTerm {
     match_sharedterm!(match (rt.term) {
-        Term::LetPattern(pat, bound, body) => RichTerm::new(desugar_let(pat, bound, body), rt.pos),
+        Term::LetPattern(pat, bound, body) => RichTerm::new(desugar_let(*pat, bound, body), rt.pos),
         Term::FunPattern(pat, body) => RichTerm::new(desugar_fun(pat, body), rt.pos),
         _ => rt,
     })
@@ -31,7 +31,7 @@ pub fn transform_one(rt: RichTerm) -> RichTerm {
 /// A function `fun <pat> => body` is desugared to `fun x => let <pat> = x in body`. The inner
 /// destructuring let isn't desugared further, as the general program transformation machinery will
 /// take care of transforming the body of the function in a second step.
-pub fn desugar_fun(mut pat: Pattern, body: RichTerm) -> Term {
+pub fn desugar_fun(mut pat: Box<Pattern>, body: RichTerm) -> Term {
     let id = pat.alias.take().unwrap_or_else(LocIdent::fresh);
     let pos_body = body.pos;
 
diff --git a/core/src/transform/free_vars.rs b/core/src/transform/free_vars.rs
index e4ab64d3fc..562cd65eae 100644
--- a/core/src/transform/free_vars.rs
+++ b/core/src/transform/free_vars.rs
@@ -159,7 +159,7 @@ impl CollectFreeVars for RichTerm {
                 // variables anyway for the nodes higher up, because deps alone is not sufficient to
                 // reconstruct the full set of free variables. At this point, we override it in any
                 // case.
-                *deps = Some(new_deps);
+                *deps = Some(Box::new(new_deps));
             }
             Term::Array(ts, _) => {
                 for t in ts.make_mut().iter_mut() {
diff --git a/core/src/transform/gen_pending_contracts.rs b/core/src/transform/gen_pending_contracts.rs
index c03479aa25..39f1fc55ca 100644
--- a/core/src/transform/gen_pending_contracts.rs
+++ b/core/src/transform/gen_pending_contracts.rs
@@ -63,7 +63,7 @@ pub fn transform_one(rt: RichTerm) -> Result<RichTerm, UnboundTypeVariableError>
                 fields,
                 attrs,
                 sealed_tail,
-            } = record_data;
+            } = *record_data;
 
             let fields = attach_to_fields(fields)?;
             let dyn_fields = dyn_fields
@@ -73,11 +73,11 @@ pub fn transform_one(rt: RichTerm) -> Result<RichTerm, UnboundTypeVariableError>
 
             RichTerm::new(
                 Term::RecRecord(
-                    RecordData {
+                    Box::new(RecordData {
                         fields,
                         attrs,
                         sealed_tail,
-                    },
+                    }),
                     dyn_fields,
                     deps,
                 ),
@@ -89,16 +89,16 @@ pub fn transform_one(rt: RichTerm) -> Result<RichTerm, UnboundTypeVariableError>
                 fields,
                 attrs,
                 sealed_tail,
-            } = record_data;
+            } = *record_data;
 
             let fields = attach_to_fields(fields)?;
 
             RichTerm::new(
-                Term::Record(RecordData {
+                Term::Record(Box::new(RecordData {
                     fields,
                     attrs,
                     sealed_tail,
-                }),
+                })),
                 pos,
             )
         }
diff --git a/core/src/transform/substitute_wildcards.rs b/core/src/transform/substitute_wildcards.rs
index 36dc273e0f..0b4f67bb70 100644
--- a/core/src/transform/substitute_wildcards.rs
+++ b/core/src/transform/substitute_wildcards.rs
@@ -22,11 +22,15 @@ use crate::{
 pub fn transform_one(rt: RichTerm, wildcards: &Wildcards) -> RichTerm {
     let pos = rt.pos;
     match_sharedterm!(match (rt.term) {
-        Term::Annotated(annot @ TypeAnnotation { typ: Some(_), .. }, inner) => {
-            RichTerm::new(
-                Term::Annotated(annot.subst_wildcards(wildcards), inner),
-                pos,
-            )
+        Term::Annotated(annot, inner) => {
+            if let TypeAnnotation { typ: Some(_), .. } = annot {
+                RichTerm::new(
+                    Term::Annotated(annot.subst_wildcards(wildcards), inner),
+                    pos,
+                )
+            } else {
+                RichTerm::new(Term::Annotated(annot, inner), pos)
+            }
         }
         Term::RecRecord(record_data, dyn_fields, deps) => {
             let record_data = record_data.subst_wildcards(wildcards);
@@ -35,10 +39,16 @@ pub fn transform_one(rt: RichTerm, wildcards: &Wildcards) -> RichTerm {
                 .map(|(id_t, field)| (id_t, field.subst_wildcards(wildcards)))
                 .collect();
 
-            RichTerm::new(Term::RecRecord(record_data, dyn_fields, deps), pos)
+            RichTerm::new(
+                Term::RecRecord(Box::new(record_data), dyn_fields, deps),
+                pos,
+            )
         }
         Term::Record(record_data) => {
-            RichTerm::new(Term::Record(record_data.subst_wildcards(wildcards)), pos)
+            RichTerm::new(
+                Term::Record(Box::new(record_data.subst_wildcards(wildcards))),
+                pos,
+            )
         }
         _ => rt,
     })
diff --git a/core/src/typ.rs b/core/src/typ.rs
index 1370272fc6..4378727989 100644
--- a/core/src/typ.rs
+++ b/core/src/typ.rs
@@ -1175,7 +1175,7 @@ impl Subcontract for RecordRows {
             RecordRowsF::Extend { .. } => unreachable!(),
         };
 
-        let rec = RichTerm::from(Term::Record(RecordData::with_field_values(fcs)));
+        let rec = RichTerm::from(Term::Record(Box::new(RecordData::with_field_values(fcs))));
 
         Ok(mk_app!(
             internals::record_type(),