diff --git a/Cargo.lock b/Cargo.lock
index db6d8317dfe9e1..221f5eca704281 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11991,6 +11991,7 @@ version = "0.1.0"
 dependencies = [
  "ambassador",
  "bcs 0.1.4",
+ "better_any",
  "bytes",
  "claims",
  "crossbeam",
diff --git a/api/types/src/convert.rs b/api/types/src/convert.rs
index 7a9d699c20e12a..61b9e0f97af223 100644
--- a/api/types/src/convert.rs
+++ b/api/types/src/convert.rs
@@ -892,6 +892,11 @@ impl<'a, S: StateView> MoveConverter<'a, S> {
             MoveTypeLayout::Struct(struct_layout) => {
                 self.try_into_vm_value_struct(struct_layout, val)?
             },
+            MoveTypeLayout::Function(..) => {
+                // TODO(#15664): do we actually need this? It appears the code here is dead and
+                //   nowhere used
+                bail!("unexpected move type {:?} for value {:?}", layout, val)
+            },
 
             // Some values, e.g., signer or ones with custom serialization
             // (native), are not stored to storage and so we do not expect
diff --git a/api/types/src/move_types.rs b/api/types/src/move_types.rs
index 22342761857e0a..b8c995c92fc460 100644
--- a/api/types/src/move_types.rs
+++ b/api/types/src/move_types.rs
@@ -681,6 +681,10 @@ impl From<TypeTag> for MoveType {
                 items: Box::new(MoveType::from(*v)),
             },
             TypeTag::Struct(v) => MoveType::Struct((*v).into()),
+            TypeTag::Function(..) => {
+                // TODO(#15664): determine whether functions and closures need to be supported
+                panic!("functions not supported by API types")
+            },
         }
     }
 }
@@ -701,6 +705,10 @@ impl From<&TypeTag> for MoveType {
                 items: Box::new(MoveType::from(v.as_ref())),
             },
             TypeTag::Struct(v) => MoveType::Struct((&**v).into()),
+            TypeTag::Function(..) => {
+                // TODO(#15664): determine whether functions and closures need to be supported
+                panic!("functions not supported by API types")
+            },
         }
     }
 }
diff --git a/aptos-move/aptos-gas-schedule/src/gas_schedule/misc.rs b/aptos-move/aptos-gas-schedule/src/gas_schedule/misc.rs
index b9f4a8615c02e0..755458b36c24ae 100644
--- a/aptos-move/aptos-gas-schedule/src/gas_schedule/misc.rs
+++ b/aptos-move/aptos-gas-schedule/src/gas_schedule/misc.rs
@@ -125,6 +125,11 @@ where
         self.offset = 1;
         true
     }
+
+    #[inline]
+    fn visit_closure(&mut self, depth: usize, len: usize) -> bool {
+        self.inner.visit_closure(depth, len)
+    }
 }
 
 struct AbstractValueSizeVisitor<'a> {
@@ -200,6 +205,13 @@ impl<'a> ValueVisitor for AbstractValueSizeVisitor<'a> {
         true
     }
 
+    #[inline]
+    fn visit_closure(&mut self, _depth: usize, _len: usize) -> bool {
+        // TODO(#15664): introduce a dedicated gas parameter?
+        self.size += self.params.struct_;
+        true
+    }
+
     #[inline]
     fn visit_vec(&mut self, _depth: usize, _len: usize) -> bool {
         self.size += self.params.vector;
@@ -366,6 +378,13 @@ impl AbstractValueSizeGasParameters {
                 false
             }
 
+            #[inline]
+            fn visit_closure(&mut self, _depth: usize, _len: usize) -> bool {
+                // TODO(#15664): independent gas parameter for closures?
+                self.res = Some(self.params.struct_);
+                false
+            }
+
             #[inline]
             fn visit_vec(&mut self, _depth: usize, _len: usize) -> bool {
                 self.res = Some(self.params.vector);
@@ -509,6 +528,13 @@ impl AbstractValueSizeGasParameters {
                 false
             }
 
+            #[inline]
+            fn visit_closure(&mut self, _depth: usize, _len: usize) -> bool {
+                // TODO(#15664): independent gas parameter
+                self.res = Some(self.params.struct_);
+                false
+            }
+
             #[inline]
             fn visit_vec(&mut self, _depth: usize, _len: usize) -> bool {
                 self.res = Some(self.params.vector);
diff --git a/aptos-move/aptos-sdk-builder/src/common.rs b/aptos-move/aptos-sdk-builder/src/common.rs
index 9914b5ea613cd5..1711ecaf3414d0 100644
--- a/aptos-move/aptos-sdk-builder/src/common.rs
+++ b/aptos-move/aptos-sdk-builder/src/common.rs
@@ -45,7 +45,7 @@ fn quote_type_as_format(type_tag: &TypeTag) -> Format {
             tag if &**tag == Lazy::force(&str_tag) => Format::Seq(Box::new(Format::U8)),
             _ => type_not_allowed(type_tag),
         },
-        Signer => type_not_allowed(type_tag),
+        Signer | Function(..) => type_not_allowed(type_tag),
     }
 }
 
@@ -122,7 +122,7 @@ pub(crate) fn mangle_type(type_tag: &TypeTag) -> String {
             tag if &**tag == Lazy::force(&str_tag) => "string".into(),
             _ => type_not_allowed(type_tag),
         },
-        Signer => type_not_allowed(type_tag),
+        Signer | Function(..) => type_not_allowed(type_tag),
     }
 }
 
diff --git a/aptos-move/aptos-sdk-builder/src/golang.rs b/aptos-move/aptos-sdk-builder/src/golang.rs
index dbbbc734d0661d..17a847c0a8cebe 100644
--- a/aptos-move/aptos-sdk-builder/src/golang.rs
+++ b/aptos-move/aptos-sdk-builder/src/golang.rs
@@ -672,7 +672,7 @@ func encode_{}_argument(arg {}) []byte {{
                 U8 => ("U8Vector", default_stmt),
                 _ => common::type_not_allowed(type_tag),
             },
-            Struct(_) | Signer => common::type_not_allowed(type_tag),
+            Struct(_) | Signer | Function(..) => common::type_not_allowed(type_tag),
         };
         writeln!(
             self.out,
@@ -793,7 +793,7 @@ func decode_{0}_argument(arg aptostypes.TransactionArgument) (value {1}, err err
                 tag if &**tag == Lazy::force(&str_tag) => "[]uint8".into(),
                 _ => common::type_not_allowed(type_tag),
             },
-            Signer => common::type_not_allowed(type_tag),
+            Signer | Function(..) => common::type_not_allowed(type_tag),
         }
     }
 
@@ -820,7 +820,7 @@ func decode_{0}_argument(arg aptostypes.TransactionArgument) (value {1}, err err
                 U8 => format!("(*aptostypes.TransactionArgument__U8Vector)(&{})", name),
                 _ => common::type_not_allowed(type_tag),
             },
-            Struct(_) | Signer => common::type_not_allowed(type_tag),
+            Struct(_) | Signer | Function(..) => common::type_not_allowed(type_tag),
         }
     }
 
@@ -854,7 +854,7 @@ func decode_{0}_argument(arg aptostypes.TransactionArgument) (value {1}, err err
                 tag if &**tag == Lazy::force(&str_tag) => Some("Bytes"),
                 _ => common::type_not_allowed(type_tag),
             },
-            Signer => common::type_not_allowed(type_tag),
+            Signer | Function(..) => common::type_not_allowed(type_tag),
         }
     }
 }
diff --git a/aptos-move/aptos-sdk-builder/src/rust.rs b/aptos-move/aptos-sdk-builder/src/rust.rs
index cc01736cb3748f..70980cd5d0a5e4 100644
--- a/aptos-move/aptos-sdk-builder/src/rust.rs
+++ b/aptos-move/aptos-sdk-builder/src/rust.rs
@@ -737,7 +737,7 @@ static SCRIPT_FUNCTION_DECODER_MAP: once_cell::sync::Lazy<EntryFunctionDecoderMa
                 U8 => ("U8Vector", "Some(value)".to_string()),
                 _ => common::type_not_allowed(type_tag),
             },
-            Struct(_) | Signer => common::type_not_allowed(type_tag),
+            Struct(_) | Signer | Function(..) => common::type_not_allowed(type_tag),
         };
         writeln!(
             self.out,
@@ -880,7 +880,7 @@ fn decode_{}_argument(arg: TransactionArgument) -> Option<{}> {{
                 tag if &**tag == Lazy::force(&str_tag) => "Vec<u8>".into(),
                 _ => common::type_not_allowed(type_tag),
             },
-            Signer => common::type_not_allowed(type_tag),
+            Signer | Function(..) => common::type_not_allowed(type_tag),
         }
     }
 
@@ -909,7 +909,7 @@ fn decode_{}_argument(arg: TransactionArgument) -> Option<{}> {{
                 _ => common::type_not_allowed(type_tag),
             },
 
-            Struct(_) | Signer => common::type_not_allowed(type_tag),
+            Struct(_) | Signer | Function(..) => common::type_not_allowed(type_tag),
         }
     }
 }
diff --git a/aptos-move/aptos-vm/src/move_vm_ext/session/mod.rs b/aptos-move/aptos-vm/src/move_vm_ext/session/mod.rs
index 736e2327f953d6..0095ff286731db 100644
--- a/aptos-move/aptos-vm/src/move_vm_ext/session/mod.rs
+++ b/aptos-move/aptos-vm/src/move_vm_ext/session/mod.rs
@@ -127,6 +127,7 @@ impl<'r, 'l> SessionExt<'r, 'l> {
         module_storage: &impl ModuleStorage,
     ) -> VMResult<(VMChangeSet, ModuleWriteSet)> {
         let move_vm = self.inner.get_move_vm();
+
         let function_extension = module_storage.as_function_value_extension();
 
         let resource_converter = |value: Value,
diff --git a/aptos-move/aptos-vm/src/verifier/transaction_arg_validation.rs b/aptos-move/aptos-vm/src/verifier/transaction_arg_validation.rs
index 153f26da17ecf3..0e9c3e21fd56d4 100644
--- a/aptos-move/aptos-vm/src/verifier/transaction_arg_validation.rs
+++ b/aptos-move/aptos-vm/src/verifier/transaction_arg_validation.rs
@@ -212,7 +212,7 @@ pub(crate) fn is_valid_txn_arg(
                 let full_name = format!("{}::{}", st.module.short_str_lossless(), st.name);
                 allowed_structs.contains_key(&full_name)
             }),
-        Signer | Reference(_) | MutableReference(_) | TyParam(_) => false,
+        Signer | Reference(_) | MutableReference(_) | TyParam(_) | Function { .. } => false,
     }
 }
 
@@ -304,7 +304,9 @@ fn construct_arg(
                 Err(invalid_signature())
             }
         },
-        Reference(_) | MutableReference(_) | TyParam(_) => Err(invalid_signature()),
+        Reference(_) | MutableReference(_) | TyParam(_) | Function { .. } => {
+            Err(invalid_signature())
+        },
     }
 }
 
@@ -373,7 +375,9 @@ pub(crate) fn recursively_construct_arg(
         U64 => read_n_bytes(8, cursor, arg)?,
         U128 => read_n_bytes(16, cursor, arg)?,
         U256 | Address => read_n_bytes(32, cursor, arg)?,
-        Signer | Reference(_) | MutableReference(_) | TyParam(_) => return Err(invalid_signature()),
+        Signer | Reference(_) | MutableReference(_) | TyParam(_) | Function { .. } => {
+            return Err(invalid_signature())
+        },
     };
     Ok(())
 }
diff --git a/aptos-move/framework/move-stdlib/src/natives/bcs.rs b/aptos-move/framework/move-stdlib/src/natives/bcs.rs
index d7cd0e9d258c43..e64504743bc013 100644
--- a/aptos-move/framework/move-stdlib/src/natives/bcs.rs
+++ b/aptos-move/framework/move-stdlib/src/natives/bcs.rs
@@ -191,10 +191,11 @@ fn constant_serialized_size(ty_layout: &MoveTypeLayout) -> (u64, PartialVMResult
         MoveTypeLayout::Signer => Ok(None),
         // vectors have no constant size
         MoveTypeLayout::Vector(_) => Ok(None),
-        // enums have no constant size
+        // enums and functions have no constant size
         MoveTypeLayout::Struct(
             MoveStructLayout::RuntimeVariants(_) | MoveStructLayout::WithVariants(_),
-        ) => Ok(None),
+        )
+        | MoveTypeLayout::Function(..) => Ok(None),
         MoveTypeLayout::Struct(MoveStructLayout::Runtime(fields)) => {
             let mut total = Some(0);
             for field in fields {
diff --git a/aptos-move/framework/src/natives/string_utils.rs b/aptos-move/framework/src/natives/string_utils.rs
index 0a4c7c71583f89..b23eb4a6d1db38 100644
--- a/aptos-move/framework/src/natives/string_utils.rs
+++ b/aptos-move/framework/src/natives/string_utils.rs
@@ -18,7 +18,7 @@ use move_core_types::{
 use move_vm_runtime::native_functions::NativeFunction;
 use move_vm_types::{
     loaded_data::runtime_types::Type,
-    values::{Reference, Struct, Value, Vector, VectorRef},
+    values::{Closure, Reference, Struct, Value, Vector, VectorRef},
 };
 use smallvec::{smallvec, SmallVec};
 use std::{collections::VecDeque, fmt::Write, ops::Deref};
@@ -347,6 +347,23 @@ fn native_format_impl(
             )?;
             out.push('}');
         },
+        MoveTypeLayout::Function(_) => {
+            let (fun, mask, args) = val.value_as::<Closure>()?.unpack();
+            let (mid, fid, flayout) = context
+                .context
+                .function_value_extension()
+                .get_serialization_data(fun.as_ref())?;
+            out.push_str(&format!("{}::{}", mid, fid));
+            format_vector(
+                context,
+                mask.extract(&flayout.0, true).into_iter(),
+                args.collect(),
+                depth,
+                !context.single_line,
+                out,
+            )?;
+            out.push(')');
+        },
 
         // This is unreachable because we check layout at the start. Still, return
         // an error to be safe.
diff --git a/aptos-move/script-composer/src/helpers.rs b/aptos-move/script-composer/src/helpers.rs
index 2bbab803fcfdc5..adb27fe8bea597 100644
--- a/aptos-move/script-composer/src/helpers.rs
+++ b/aptos-move/script-composer/src/helpers.rs
@@ -29,6 +29,11 @@ pub(crate) fn import_type_tag(
     type_tag: &TypeTag,
     module_resolver: &BTreeMap<ModuleId, CompiledModule>,
 ) -> PartialVMResult<SignatureToken> {
+    let to_list = |script_builder: &mut CompiledScriptBuilder, ts: &[TypeTag]| {
+        ts.iter()
+            .map(|t| import_type_tag(script_builder, t, module_resolver))
+            .collect::<PartialVMResult<Vec<_>>>()
+    };
     Ok(match type_tag {
         TypeTag::Address => SignatureToken::Address,
         TypeTag::U8 => SignatureToken::U8,
@@ -53,13 +58,15 @@ pub(crate) fn import_type_tag(
             } else {
                 SignatureToken::StructInstantiation(
                     struct_idx,
-                    s.type_args
-                        .iter()
-                        .map(|ty| import_type_tag(script_builder, ty, module_resolver))
-                        .collect::<PartialVMResult<Vec<_>>>()?,
+                    to_list(script_builder, &s.type_args)?,
                 )
             }
         },
+        TypeTag::Function(f) => SignatureToken::Function(
+            to_list(script_builder, &f.args)?,
+            to_list(script_builder, &f.results)?,
+            f.abilities,
+        ),
     })
 }
 
diff --git a/testsuite/fuzzer/fuzz/fuzz_targets/move/utils/helpers.rs b/testsuite/fuzzer/fuzz/fuzz_targets/move/utils/helpers.rs
index 15960f5f920aab..52c3973dec322e 100644
--- a/testsuite/fuzzer/fuzz/fuzz_targets/move/utils/helpers.rs
+++ b/testsuite/fuzzer/fuzz/fuzz_targets/move/utils/helpers.rs
@@ -6,7 +6,10 @@
 use aptos_language_e2e_tests::{account::Account, executor::FakeExecutor};
 use arbitrary::Arbitrary;
 use move_binary_format::file_format::CompiledModule;
-use move_core_types::value::{MoveStructLayout, MoveTypeLayout};
+use move_core_types::{
+    function::MoveFunctionLayout,
+    value::{MoveStructLayout, MoveTypeLayout},
+};
 
 #[macro_export]
 macro_rules! tdbg {
@@ -82,6 +85,9 @@ pub(crate) fn is_valid_layout(layout: &MoveTypeLayout) -> bool {
             }
             fields.iter().all(is_valid_layout)
         },
+        L::Function(MoveFunctionLayout(args, results, _)) => {
+            args.iter().chain(results).all(is_valid_layout)
+        },
         L::Struct(_) => {
             // decorated layouts not supported
             false
diff --git a/third_party/move/move-binary-format/src/constant.rs b/third_party/move/move-binary-format/src/constant.rs
index 6fa8b21fa11fbd..65f362f8102dd5 100644
--- a/third_party/move/move-binary-format/src/constant.rs
+++ b/third_party/move/move-binary-format/src/constant.rs
@@ -43,6 +43,7 @@ fn construct_ty_for_constant(layout: &MoveTypeLayout) -> Option<SignatureToken>
             construct_ty_for_constant(l.as_ref())?,
         ))),
         MoveTypeLayout::Struct(_) => None,
+        MoveTypeLayout::Function(_) => None,
         MoveTypeLayout::Bool => Some(SignatureToken::Bool),
 
         // It is not possible to have native layout for constant values.
diff --git a/third_party/move/move-binary-format/src/normalized.rs b/third_party/move/move-binary-format/src/normalized.rs
index d938f8fbcebfe7..037f6f472f8643 100644
--- a/third_party/move/move-binary-format/src/normalized.rs
+++ b/third_party/move/move-binary-format/src/normalized.rs
@@ -398,6 +398,7 @@ impl From<TypeTag> for Type {
                 name: s.name,
                 type_arguments: s.type_args.into_iter().map(|ty| ty.into()).collect(),
             },
+            TypeTag::Function(_) => panic!("function types not supported in normalized types"),
         }
     }
 }
diff --git a/third_party/move/move-compiler/src/cfgir/ast.rs b/third_party/move/move-compiler/src/cfgir/ast.rs
index 12788db3550656..e7e2de089dd855 100644
--- a/third_party/move/move-compiler/src/cfgir/ast.rs
+++ b/third_party/move/move-compiler/src/cfgir/ast.rs
@@ -323,6 +323,7 @@ impl AstDebug for MoveValue {
             },
             V::Struct(_) => panic!("ICE struct constants not supported"),
             V::Signer(_) => panic!("ICE signer constants not supported"),
+            V::Closure(_) => panic!("ICE closures not supported"),
         }
     }
 }
diff --git a/third_party/move/move-core/types/src/function.rs b/third_party/move/move-core/types/src/function.rs
index aba217289b5c73..509c5570a49588 100644
--- a/third_party/move/move-core/types/src/function.rs
+++ b/third_party/move/move-core/types/src/function.rs
@@ -1,7 +1,13 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use serde::{Deserialize, Serialize};
+use crate::{
+    ability::AbilitySet,
+    identifier::Identifier,
+    language_storage::{FunctionTag, ModuleId, TypeTag},
+    value::{MoveTypeLayout, MoveValue},
+};
+use serde::{de::Error, ser::SerializeSeq, Deserialize, Serialize};
 use std::fmt;
 
 /// A `ClosureMask` is a value which determines how to distinguish those function arguments
@@ -105,3 +111,161 @@ impl ClosureMask {
         self.compose(captured, provided)
     }
 }
+
+/// Function type layout, with arguments and result types.
+#[derive(Debug, Clone, Hash, Serialize, Deserialize, PartialEq, Eq)]
+#[cfg_attr(
+    any(test, feature = "fuzzing"),
+    derive(arbitrary::Arbitrary, dearbitrary::Dearbitrary)
+)]
+pub struct MoveFunctionLayout(
+    pub Vec<MoveTypeLayout>,
+    pub Vec<MoveTypeLayout>,
+    pub AbilitySet,
+);
+
+/// A closure (function value)
+#[derive(Debug, PartialEq, Eq, Clone)]
+#[cfg_attr(
+    any(test, feature = "fuzzing"),
+    derive(arbitrary::Arbitrary, dearbitrary::Dearbitrary)
+)]
+pub struct MoveClosure {
+    pub module_id: ModuleId,
+    pub fun_id: Identifier,
+    pub fun_type: MoveFunctionLayout,
+    pub mask: ClosureMask,
+    pub captured: Vec<MoveValue>,
+}
+
+#[allow(unused)] // Currently, we do not use the expected function layout
+pub(crate) struct ClosureVisitor<'a>(pub(crate) &'a MoveFunctionLayout);
+
+impl<'d, 'a> serde::de::Visitor<'d> for ClosureVisitor<'a> {
+    type Value = MoveClosure;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("Closure")
+    }
+
+    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::SeqAccess<'d>,
+    {
+        let module_id = read_required_value::<_, ModuleId>(&mut seq)?;
+        let fun_id = read_required_value::<_, Identifier>(&mut seq)?;
+        let fun_type = read_required_value::<_, MoveFunctionLayout>(&mut seq)?;
+        let mask = read_required_value::<_, ClosureMask>(&mut seq)?;
+        let mut captured = vec![];
+        for arg_layout in mask.extract(&fun_type.0, true /*captured*/) {
+            match seq.next_element_seed(arg_layout)? {
+                Some(v) => captured.push(v),
+                None => return Err(A::Error::invalid_length(captured.len(), &self)),
+            }
+        }
+        // If the sequence length is known, check whether there are no extra values
+        if matches!(seq.size_hint(), Some(remaining) if remaining != 0) {
+            return Err(A::Error::invalid_length(captured.len(), &self));
+        }
+        Ok(MoveClosure {
+            module_id,
+            fun_id,
+            fun_type,
+            mask,
+            captured,
+        })
+    }
+}
+
+fn read_required_value<'a, A, T>(seq: &mut A) -> Result<T, A::Error>
+where
+    A: serde::de::SeqAccess<'a>,
+    T: serde::de::Deserialize<'a>,
+{
+    match seq.next_element::<T>()? {
+        Some(x) => Ok(x),
+        None => Err(A::Error::custom("expected more elements")),
+    }
+}
+
+impl serde::Serialize for MoveClosure {
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let MoveClosure {
+            module_id,
+            fun_id,
+            fun_type,
+            mask,
+            captured,
+        } = self;
+        let mut s = serializer.serialize_seq(Some(4 + captured.len()))?;
+        s.serialize_element(module_id)?;
+        s.serialize_element(fun_id)?;
+        s.serialize_element(fun_type)?;
+        s.serialize_element(mask)?;
+        for v in captured {
+            s.serialize_element(v)?;
+        }
+        s.end()
+    }
+}
+
+impl fmt::Display for MoveFunctionLayout {
+    fn fmt(&self, f: &mut fmt::Formatter) -> std::fmt::Result {
+        let fmt_list = |l: &[MoveTypeLayout]| {
+            l.iter()
+                .map(|t| t.to_string())
+                .collect::<Vec<_>>()
+                .join(", ")
+        };
+        let MoveFunctionLayout(args, results, abilities) = self;
+        write!(
+            f,
+            "|{}|{}{}",
+            fmt_list(args),
+            fmt_list(results),
+            abilities.display_postfix()
+        )
+    }
+}
+
+impl TryInto<FunctionTag> for &MoveFunctionLayout {
+    type Error = anyhow::Error;
+
+    fn try_into(self) -> Result<FunctionTag, Self::Error> {
+        let into_list = |ts: &[MoveTypeLayout]| {
+            ts.iter()
+                .map(|t| t.try_into())
+                .collect::<Result<Vec<TypeTag>, _>>()
+        };
+        Ok(FunctionTag {
+            args: into_list(&self.0)?,
+            results: into_list(&self.1)?,
+            abilities: self.2,
+        })
+    }
+}
+
+impl fmt::Display for MoveClosure {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let MoveClosure {
+            module_id,
+            fun_id,
+            fun_type,
+            mask,
+            captured,
+        } = self;
+        let captured_str = mask
+            .merge_placeholder_strings(
+                fun_type.0.len(),
+                captured.iter().map(|v| v.to_string()).collect(),
+            )
+            .unwrap_or_else(|| vec!["*invalid*".to_string()])
+            .join(",");
+        write!(
+            f,
+            // this will print `a::m::f|T|R(a1,_,a2,_)`
+            "{}::{}{}({})",
+            module_id, fun_id, fun_type, captured_str
+        )
+    }
+}
diff --git a/third_party/move/move-core/types/src/language_storage.rs b/third_party/move/move-core/types/src/language_storage.rs
index 821b2e22c43d03..53613c7cc87c2b 100644
--- a/third_party/move/move-core/types/src/language_storage.rs
+++ b/third_party/move/move-core/types/src/language_storage.rs
@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{
+    ability::AbilitySet,
     account_address::AccountAddress,
     identifier::{IdentStr, Identifier},
     parser::{parse_module_id, parse_struct_tag, parse_type_tag},
@@ -67,6 +68,15 @@ pub enum TypeTag {
     U32,
     #[serde(rename = "u256", alias = "U256")]
     U256,
+
+    // NOTE: added in bytecode version v8
+    Function(
+        #[serde(
+            serialize_with = "safe_serialize::type_tag_recursive_serialize",
+            deserialize_with = "safe_serialize::type_tag_recursive_deserialize"
+        )]
+        Box<FunctionTag>,
+    ),
 }
 
 impl TypeTag {
@@ -82,6 +92,7 @@ impl TypeTag {
     /// to change and should not be used inside stable code.
     pub fn to_canonical_string(&self) -> String {
         use TypeTag::*;
+
         match self {
             Bool => "bool".to_owned(),
             U8 => "u8".to_owned(),
@@ -94,6 +105,25 @@ impl TypeTag {
             Signer => "signer".to_owned(),
             Vector(t) => format!("vector<{}>", t.to_canonical_string()),
             Struct(s) => s.to_canonical_string(),
+            Function(f) => {
+                let fmt_list = |l: &[TypeTag]| -> String {
+                    l.iter()
+                        .map(|t| t.to_canonical_string())
+                        .collect::<Vec<_>>()
+                        .join(",")
+                };
+                let FunctionTag {
+                    args,
+                    results,
+                    abilities,
+                } = f.as_ref();
+                format!(
+                    "|{}|{}{}",
+                    fmt_list(args),
+                    fmt_list(results),
+                    abilities.display_postfix()
+                )
+            },
         }
     }
 }
@@ -193,6 +223,19 @@ impl FromStr for StructTag {
     }
 }
 
+#[derive(Serialize, Deserialize, Debug, PartialEq, Hash, Eq, Clone, PartialOrd, Ord)]
+#[cfg_attr(
+    feature = "fuzzing",
+    derive(arbitrary::Arbitrary, dearbitrary::Dearbitrary)
+)]
+#[cfg_attr(any(test, feature = "fuzzing"), derive(Arbitrary))]
+#[cfg_attr(any(test, feature = "fuzzing"), proptest(no_params))]
+pub struct FunctionTag {
+    pub args: Vec<TypeTag>,
+    pub results: Vec<TypeTag>,
+    pub abilities: AbilitySet,
+}
+
 /// Represents the initial key into global storage where we first index by the address, and then
 /// the struct tag
 #[derive(Serialize, Deserialize, Debug, PartialEq, Hash, Eq, Clone, PartialOrd, Ord)]
@@ -320,6 +363,7 @@ impl Display for TypeTag {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         match self {
             TypeTag::Struct(s) => write!(f, "{}", s),
+            TypeTag::Function(_) => write!(f, "{}", self.to_canonical_string()),
             TypeTag::Vector(ty) => write!(f, "vector<{}>", ty),
             TypeTag::U8 => write!(f, "u8"),
             TypeTag::U16 => write!(f, "u16"),
diff --git a/third_party/move/move-core/types/src/safe_serialize.rs b/third_party/move/move-core/types/src/safe_serialize.rs
index 42ab4b4a897089..351e8e42ddfd9f 100644
--- a/third_party/move/move-core/types/src/safe_serialize.rs
+++ b/third_party/move/move-core/types/src/safe_serialize.rs
@@ -4,9 +4,6 @@
 
 //! Custom serializers which track recursion nesting with a thread local,
 //! and otherwise delegate to the derived serializers.
-//!
-//! This is currently only implemented for type tags, but can be easily
-//! generalized, as the only type-tag specific thing is the allowed nesting.
 
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::cell::RefCell;
diff --git a/third_party/move/move-core/types/src/transaction_argument.rs b/third_party/move/move-core/types/src/transaction_argument.rs
index 701fbce112f484..da85bc7ccabe57 100644
--- a/third_party/move/move-core/types/src/transaction_argument.rs
+++ b/third_party/move/move-core/types/src/transaction_argument.rs
@@ -82,7 +82,7 @@ impl TryFrom<MoveValue> for TransactionArgument {
                     })
                     .collect::<Result<Vec<u8>>>()?,
             ),
-            MoveValue::Signer(_) | MoveValue::Struct(_) => {
+            MoveValue::Signer(_) | MoveValue::Struct(_) | MoveValue::Closure(_) => {
                 return Err(anyhow!("invalid transaction argument: {:?}", val))
             },
             MoveValue::U16(i) => TransactionArgument::U16(i),
diff --git a/third_party/move/move-core/types/src/value.rs b/third_party/move/move-core/types/src/value.rs
index 0bf4cbcdf8f886..767be547b5a8ca 100644
--- a/third_party/move/move-core/types/src/value.rs
+++ b/third_party/move/move-core/types/src/value.rs
@@ -9,6 +9,7 @@
 
 use crate::{
     account_address::AccountAddress,
+    function::{ClosureVisitor, MoveClosure, MoveFunctionLayout},
     ident_str,
     identifier::Identifier,
     language_storage::{ModuleId, StructTag, TypeTag},
@@ -120,6 +121,8 @@ pub enum MoveValue {
     U16(u16),
     U32(u32),
     U256(u256::U256),
+    // Added in bytecode version v8
+    Closure(Box<MoveClosure>),
 }
 
 /// A layout associated with a named field
@@ -248,6 +251,10 @@ pub enum MoveTypeLayout {
     // TODO[agg_v2](?): Do we need a layout here if we have custom serde
     //                  implementations available?
     Native(IdentifierMappingKind, Box<MoveTypeLayout>),
+
+    // Added in bytecode version v8
+    #[serde(rename(serialize = "fun", deserialize = "fun"))]
+    Function(MoveFunctionLayout),
 }
 
 impl MoveValue {
@@ -259,6 +266,10 @@ impl MoveValue {
         bcs::to_bytes(self).ok()
     }
 
+    pub fn closure(c: MoveClosure) -> MoveValue {
+        Self::Closure(Box::new(c))
+    }
+
     pub fn vector_u8(v: Vec<u8>) -> Self {
         MoveValue::Vector(v.into_iter().map(MoveValue::U8).collect())
     }
@@ -536,6 +547,9 @@ impl<'d> serde::de::DeserializeSeed<'d> for &MoveTypeLayout {
                 AccountAddress::deserialize(deserializer).map(MoveValue::Signer)
             },
             MoveTypeLayout::Struct(ty) => Ok(MoveValue::Struct(ty.deserialize(deserializer)?)),
+            MoveTypeLayout::Function(fun) => Ok(MoveValue::Closure(Box::new(
+                deserializer.deserialize_seq(ClosureVisitor(fun))?,
+            ))),
             MoveTypeLayout::Vector(layout) => Ok(MoveValue::Vector(
                 deserializer.deserialize_seq(VectorElementVisitor(layout))?,
             )),
@@ -730,6 +744,7 @@ impl serde::Serialize for MoveValue {
     fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         match self {
             MoveValue::Struct(s) => s.serialize(serializer),
+            MoveValue::Closure(c) => c.serialize(serializer),
             MoveValue::Bool(b) => serializer.serialize_bool(*b),
             MoveValue::U8(i) => serializer.serialize_u8(*i),
             MoveValue::U16(i) => serializer.serialize_u16(*i),
@@ -849,6 +864,7 @@ impl fmt::Display for MoveTypeLayout {
             Address => write!(f, "address"),
             Vector(typ) => write!(f, "vector<{}>", typ),
             Struct(s) => fmt::Display::fmt(s, f),
+            Function(fun) => fmt::Display::fmt(fun, f),
             Signer => write!(f, "signer"),
             // TODO[agg_v2](cleanup): consider printing the tag as well.
             Native(_, typ) => write!(f, "native<{}>", typ),
@@ -916,6 +932,7 @@ impl TryInto<TypeTag> for &MoveTypeLayout {
             MoveTypeLayout::Signer => TypeTag::Signer,
             MoveTypeLayout::Vector(v) => TypeTag::Vector(Box::new(v.as_ref().try_into()?)),
             MoveTypeLayout::Struct(v) => TypeTag::Struct(Box::new(v.try_into()?)),
+            MoveTypeLayout::Function(f) => TypeTag::Function(Box::new(f.try_into()?)),
 
             // Native layout variant is only used by MoveVM, and is irrelevant
             // for type tags which are used to key resources in the global state.
@@ -953,6 +970,7 @@ impl fmt::Display for MoveValue {
             MoveValue::Signer(a) => write!(f, "signer({})", a.to_hex_literal()),
             MoveValue::Vector(v) => fmt_list(f, "vector[", v, "]"),
             MoveValue::Struct(s) => fmt::Display::fmt(s, f),
+            MoveValue::Closure(c) => fmt::Display::fmt(c, f),
         }
     }
 }
diff --git a/third_party/move/move-ir/types/src/ast.rs b/third_party/move/move-ir/types/src/ast.rs
index 40fa5695baf430..4718cf90841705 100644
--- a/third_party/move/move-ir/types/src/ast.rs
+++ b/third_party/move/move-ir/types/src/ast.rs
@@ -1807,7 +1807,7 @@ fn format_move_value(v: &MoveValue) -> String {
                 .join(", ");
             format!("vector[{}]", items)
         },
-        MoveValue::Struct(_) | MoveValue::Signer(_) => {
+        MoveValue::Struct(_) | MoveValue::Signer(_) | MoveValue::Closure(_) => {
             panic!("Should be inexpressible as a constant")
         },
         MoveValue::U16(u) => format!("{}u16", u),
diff --git a/third_party/move/move-model/src/builder/exp_builder.rs b/third_party/move/move-model/src/builder/exp_builder.rs
index b515e254d08994..3cf66a1ca2f1e7 100644
--- a/third_party/move/move-model/src/builder/exp_builder.rs
+++ b/third_party/move/move-model/src/builder/exp_builder.rs
@@ -5484,30 +5484,10 @@ impl<'env, 'translator, 'module_translator> ExpTranslator<'env, 'translator, 'mo
                     Value::Vector(b)
                 },
             },
-            (Type::Primitive(_), MoveValue::Vector(_))
-            | (Type::Primitive(_), MoveValue::Struct(_))
-            | (Type::Tuple(_), MoveValue::Vector(_))
-            | (Type::Tuple(_), MoveValue::Struct(_))
-            | (Type::Vector(_), MoveValue::Struct(_))
-            | (Type::Struct(_, _, _), MoveValue::Vector(_))
-            | (Type::Struct(_, _, _), MoveValue::Struct(_))
-            | (Type::TypeParameter(_), MoveValue::Vector(_))
-            | (Type::TypeParameter(_), MoveValue::Struct(_))
-            | (Type::Reference(_, _), MoveValue::Vector(_))
-            | (Type::Reference(_, _), MoveValue::Struct(_))
-            | (Type::Fun(..), MoveValue::Vector(_))
-            | (Type::Fun(..), MoveValue::Struct(_))
-            | (Type::TypeDomain(_), MoveValue::Vector(_))
-            | (Type::TypeDomain(_), MoveValue::Struct(_))
-            | (Type::ResourceDomain(_, _, _), MoveValue::Vector(_))
-            | (Type::ResourceDomain(_, _, _), MoveValue::Struct(_))
-            | (Type::Error, MoveValue::Vector(_))
-            | (Type::Error, MoveValue::Struct(_))
-            | (Type::Var(_), MoveValue::Vector(_))
-            | (Type::Var(_), MoveValue::Struct(_)) => {
+            _ => {
                 self.error(
                     loc,
-                    &format!("Not yet supported constant value: {:?}", value),
+                    &format!("Not supported constant value/type combination: {}", value),
                 );
                 Value::Bool(false)
             },
diff --git a/third_party/move/move-model/src/ty.rs b/third_party/move/move-model/src/ty.rs
index 08079025c9cb1c..8ef2891701167a 100644
--- a/third_party/move/move-model/src/ty.rs
+++ b/third_party/move/move-model/src/ty.rs
@@ -24,7 +24,7 @@ use move_binary_format::{
 };
 use move_core_types::{
     ability::{Ability, AbilitySet},
-    language_storage::{StructTag, TypeTag},
+    language_storage::{FunctionTag, StructTag, TypeTag},
     u256::U256,
 };
 use num::BigInt;
@@ -1333,6 +1333,21 @@ impl Type {
                 Struct(qid.module_id, qid.id, type_args)
             },
             TypeTag::Vector(type_param) => Vector(Box::new(Self::from_type_tag(type_param, env))),
+            TypeTag::Function(fun) => {
+                let FunctionTag {
+                    args,
+                    results,
+                    abilities,
+                } = fun.as_ref();
+                let from_vec = |ts: &[TypeTag]| {
+                    Type::tuple(ts.iter().map(|t| Type::from_type_tag(t, env)).collect_vec())
+                };
+                Fun(
+                    Box::new(from_vec(args)),
+                    Box::new(from_vec(results)),
+                    *abilities,
+                )
+            },
         }
     }
 
diff --git a/third_party/move/move-stdlib/src/natives/debug.rs b/third_party/move/move-stdlib/src/natives/debug.rs
index 38876b7685fdb6..408b5a084e8994 100644
--- a/third_party/move/move-stdlib/src/natives/debug.rs
+++ b/third_party/move/move-stdlib/src/natives/debug.rs
@@ -460,6 +460,9 @@ mod testing {
                     )?;
                 }
             },
+            MoveValue::Closure(clos) => {
+                write!(out, "{}", clos).map_err(fmt_error_to_partial_vm_error)?;
+            },
             MoveValue::Struct(move_struct) => match move_struct {
                 MoveStruct::WithTypes {
                     _type_: type_,
diff --git a/third_party/move/move-vm/runtime/Cargo.toml b/third_party/move/move-vm/runtime/Cargo.toml
index 4b20b934b638ca..6c17403a3acff8 100644
--- a/third_party/move/move-vm/runtime/Cargo.toml
+++ b/third_party/move/move-vm/runtime/Cargo.toml
@@ -12,6 +12,7 @@ edition = "2021"
 
 [dependencies]
 ambassador = { workspace = true }
+anyhow = { workspace = true }
 better_any = { workspace = true }
 bytes = { workspace = true }
 claims = { workspace = true }
@@ -37,7 +38,7 @@ hex = { workspace = true }
 move-binary-format = { workspace = true, features = ["fuzzing"] }
 move-compiler = { workspace = true }
 move-ir-compiler = { workspace = true }
-move-vm-test-utils ={ workspace = true }
+move-vm-test-utils = { workspace = true }
 proptest = { workspace = true }
 
 [features]
diff --git a/third_party/move/move-vm/runtime/src/interpreter.rs b/third_party/move/move-vm/runtime/src/interpreter.rs
index 33802b688be337..dc3636c028d29c 100644
--- a/third_party/move/move-vm/runtime/src/interpreter.rs
+++ b/third_party/move/move-vm/runtime/src/interpreter.rs
@@ -1420,6 +1420,18 @@ fn check_depth_of_type_impl(
             )?;
             check_depth!(formula.solve(&ty_arg_depths))
         },
+        Type::Function { args, results, .. } => {
+            let mut ty_max = depth;
+            for ty in args.iter().chain(results.iter()).map(|rc| rc.as_ref()) {
+                ty_max = ty_max.max(check_depth_of_type_impl(
+                    resolver,
+                    ty,
+                    max_depth,
+                    check_depth!(1),
+                )?);
+            }
+            ty_max
+        },
         Type::TyParam(_) => {
             return Err(
                 PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR)
@@ -1537,7 +1549,7 @@ impl Frame {
                 )?;
 
                 match instruction {
-                    // TODO: implement closures
+                    // TODO(#15664): implement closures
                     Bytecode::PackClosure(..)
                     | Bytecode::PackClosureGeneric(..)
                     | Bytecode::CallClosure(..) => {
diff --git a/third_party/move/move-vm/runtime/src/loader/function.rs b/third_party/move/move-vm/runtime/src/loader/function.rs
index d4dc9a7b18b7dd..804a7e0beead5f 100644
--- a/third_party/move/move-vm/runtime/src/loader/function.rs
+++ b/third_party/move/move-vm/runtime/src/loader/function.rs
@@ -10,6 +10,7 @@ use crate::{
     native_functions::{NativeFunction, NativeFunctions, UnboxedNativeFunction},
     ModuleStorage,
 };
+use better_any::{Tid, TidAble, TidExt};
 use move_binary_format::{
     access::ModuleAccess,
     binary_views::BinaryIndexedView,
@@ -17,13 +18,20 @@ use move_binary_format::{
     file_format::{Bytecode, CompiledModule, FunctionDefinitionIndex, Visibility},
 };
 use move_core_types::{
-    ability::AbilitySet, identifier::Identifier, language_storage::ModuleId, vm_status::StatusCode,
+    ability::{Ability, AbilitySet},
+    function::MoveFunctionLayout,
+    identifier::{IdentStr, Identifier},
+    language_storage::{FunctionTag, ModuleId, TypeTag},
+    vm_status::StatusCode,
 };
-use move_vm_types::loaded_data::{
-    runtime_access_specifier::AccessSpecifier,
-    runtime_types::{StructIdentifier, Type},
+use move_vm_types::{
+    loaded_data::{
+        runtime_access_specifier::AccessSpecifier,
+        runtime_types::{StructIdentifier, Type},
+    },
+    values::AbstractFunction,
 };
-use std::{fmt::Debug, sync::Arc};
+use std::{cell::RefCell, cmp::Ordering, collections::BTreeMap, fmt::Debug, sync::Arc};
 
 /// A runtime function definition representation.
 pub struct Function {
@@ -45,12 +53,14 @@ pub struct Function {
 }
 
 /// For loaded function representation, specifies the owner: a script or a module.
+#[derive(Clone)]
 pub(crate) enum LoadedFunctionOwner {
     Script(Arc<Script>),
     Module(Arc<Module>),
 }
 
 /// A loaded runtime function representation along with type arguments used to instantiate it.
+#[derive(Clone)]
 pub struct LoadedFunction {
     pub(crate) owner: LoadedFunctionOwner,
     // A set of verified type arguments provided for this definition. If
@@ -60,16 +70,243 @@ pub struct LoadedFunction {
     pub(crate) function: Arc<Function>,
 }
 
+/// A lazy loaded function, which can either be unresolved (as resulting
+/// from deserialization) or resolved, and then forwarding to a
+/// `LoadedFunction`.
+#[derive(Clone, Tid)]
+pub(crate) struct LazyLoadedFunction(pub(crate) RefCell<LazyLoadedFunctionState>);
+
+#[derive(Clone)]
+pub(crate) enum LazyLoadedFunctionState {
+    Unresolved {
+        module_id: ModuleId,
+        fun_id: Identifier,
+        fun_layout: MoveFunctionLayout,
+        // If the function was already attempted to be resolved but
+        // couldn't, the associated VMError
+        resolution_error: Option<PartialVMError>,
+    },
+    Resolved {
+        fun: LoadedFunction,
+        // In order to be able to implement `AbstractFunction::cmp_dyn` independent
+        // of resolution state, we need to store the function tag of the fully
+        // instantiated function. The `fun_layout` in the unresolved state can
+        // be converted to a function tag, however, the runtime type representation
+        // inside `fun` cannot be converted into this because of missing loader
+        // context during VMImpl comparison. In the VM2 design, we should just be able
+        // to access all core interfaces from everywhere (starting with moving the ValueImpl
+        // stuff into this crate).
+        fun_tag: FunctionTag,
+    },
+}
+
+impl LazyLoadedFunction {
+    pub(crate) fn new_unresolved(
+        module_id: ModuleId,
+        fun_id: Identifier,
+        fun_layout: MoveFunctionLayout,
+    ) -> Self {
+        Self(RefCell::new(LazyLoadedFunctionState::Unresolved {
+            module_id,
+            fun_id,
+            fun_layout,
+            resolution_error: None,
+        }))
+    }
+
+    #[allow(unused)]
+    pub(crate) fn new_resolved(
+        loader: &Loader,
+        module_storage: &dyn ModuleStorage,
+        fun: LoadedFunction,
+    ) -> PartialVMResult<Self> {
+        let fun_tag =
+            loader.type_to_type_tag(&fun.function.create_function_type(), module_storage)?;
+        if let TypeTag::Function(fun_tag) = fun_tag {
+            Ok(Self(RefCell::new(LazyLoadedFunctionState::Resolved {
+                fun,
+                fun_tag: *fun_tag,
+            })))
+        } else {
+            Err(
+                PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR)
+                    .with_message("function type conversion assertion failure".to_string()),
+            )
+        }
+    }
+
+    pub(crate) fn expect_this_impl(
+        fun: &dyn AbstractFunction,
+    ) -> PartialVMResult<&LazyLoadedFunction> {
+        fun.downcast_ref::<LazyLoadedFunction>().ok_or_else(|| {
+            PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR)
+                .with_message("unexpected abstract function implementation".to_string())
+        })
+    }
+
+    /// Access name components independent of resolution state. Since RefCell is in the play,
+    /// the accessor is passed in as a function.
+    pub(crate) fn with_name<T>(&self, action: impl FnOnce(Option<&ModuleId>, &IdentStr) -> T) -> T {
+        match &*self.0.borrow() {
+            LazyLoadedFunctionState::Unresolved {
+                module_id, fun_id, ..
+            } => action(Some(module_id), fun_id),
+            LazyLoadedFunctionState::Resolved { fun, .. } => action(fun.module_id(), fun.name_id()),
+        }
+    }
+
+    /// Get the function type tag independent of resolution state. In the unresolved state,
+    /// we need to convert from the layout, so a copy is returned.
+    pub(crate) fn get_type_tag(&self) -> PartialVMResult<FunctionTag> {
+        match &*self.0.borrow() {
+            LazyLoadedFunctionState::Unresolved { fun_layout, .. } => {
+                fun_layout.try_into().map_err(|e: anyhow::Error| {
+                    PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR)
+                        .with_message(e.to_string())
+                })
+            },
+            LazyLoadedFunctionState::Resolved { fun_tag, .. } => Ok(fun_tag.clone()),
+        }
+    }
+
+    /// Executed an action with the resolved loaded function. If the function hasn't been
+    /// loaded yet, it will be loaded now.
+    #[allow(unused)]
+    pub(crate) fn with_resolved_function<T>(
+        &self,
+        storage: &dyn ModuleStorage,
+        action: impl FnOnce(&LoadedFunction) -> PartialVMResult<T>,
+    ) -> PartialVMResult<T> {
+        let mut state = self.0.borrow_mut();
+        match &mut *state {
+            LazyLoadedFunctionState::Resolved { fun, .. } => action(fun),
+            LazyLoadedFunctionState::Unresolved {
+                resolution_error: Some(e),
+                ..
+            } => Err(e.clone()),
+            LazyLoadedFunctionState::Unresolved {
+                module_id,
+                fun_id,
+                fun_layout,
+                resolution_error,
+            } => match Self::resolve(storage, module_id, fun_id, fun_layout) {
+                Ok((fun, fun_tag)) => {
+                    let result = action(&fun);
+                    *state = LazyLoadedFunctionState::Resolved { fun, fun_tag };
+                    result
+                },
+                Err(e) => {
+                    *resolution_error = Some(e.clone());
+                    Err(e)
+                },
+            },
+        }
+    }
+
+    /// Resolves a function into a loaded function. This verifies existence of the named
+    /// function as well as whether it has the type as specified by the layout. The
+    /// layout is the fully instantiated type, and by unifying it with the potential
+    /// generic function type, the instantiation of the loaded function is derived.
+    fn resolve(
+        module_storage: &dyn ModuleStorage,
+        module_id: &ModuleId,
+        fun_id: &IdentStr,
+        layout: &MoveFunctionLayout,
+    ) -> PartialVMResult<(LoadedFunction, FunctionTag)> {
+        let (module, function) = module_storage
+            .fetch_function_definition(module_id.address(), module_id.name(), fun_id)
+            .map_err(|err| err.to_partial())?;
+        let fun_tag: FunctionTag = layout.try_into().map_err(|e: anyhow::Error| {
+            PartialVMError::new(StatusCode::FUNCTION_RESOLUTION_FAILURE).with_message(e.to_string())
+        })?;
+        // Verify type compatibility and compute the type instantiation
+        let fully_inst_fun_ty =
+            module_storage.fetch_ty(&TypeTag::Function(Box::new(fun_tag.clone())))?;
+        let declared_fun_ty = function.create_function_type();
+        let expected_ty_args = function.ty_param_abilities().len();
+        let mut subs: BTreeMap<u16, Type> = BTreeMap::new();
+        if !declared_fun_ty.unify(&fully_inst_fun_ty, &mut subs)
+            // we need to have all type params in the substitution
+            || subs.len() != expected_ty_args
+            // they need to be indexed 0..n
+            || subs.keys().max().map(|m| *m as usize >= expected_ty_args).unwrap_or(false)
+        {
+            Err(
+                PartialVMError::new(StatusCode::FUNCTION_RESOLUTION_FAILURE).with_message(format!(
+                    "Function {}::{} has type {} which does not match expected type {}",
+                    module_id, fun_id, declared_fun_ty, fully_inst_fun_ty
+                )),
+            )
+        } else {
+            let ty_args = subs.into_values().collect::<Vec<_>>();
+            Ok((
+                LoadedFunction {
+                    owner: LoadedFunctionOwner::Module(module),
+                    ty_args,
+                    function,
+                },
+                fun_tag,
+            ))
+        }
+    }
+}
+
+impl AbstractFunction for LazyLoadedFunction {
+    /// The comparison implementation need to ensure that the result is deterministic,
+    /// independent of whether the function is resolved or not.
+    fn cmp_dyn(&self, other: &dyn AbstractFunction) -> PartialVMResult<Ordering> {
+        let other = LazyLoadedFunction::expect_this_impl(other)?;
+        self.with_name(|mid1, fid1| {
+            other.with_name(|mid2, fid2| {
+                let r = mid1.cmp(&mid2).then_with(|| fid1.cmp(fid2));
+                if r != Ordering::Equal {
+                    Ok(r)
+                } else {
+                    let tag1 = self.get_type_tag()?;
+                    let tag2 = other.get_type_tag()?;
+                    Ok(tag1.cmp(&tag2))
+                }
+            })
+        })
+    }
+
+    fn clone_dyn(&self) -> PartialVMResult<Box<dyn AbstractFunction>> {
+        Ok(Box::new(LazyLoadedFunction(RefCell::new(
+            self.0.borrow().clone(),
+        ))))
+    }
+
+    fn to_stable_string(&self) -> String {
+        self.with_name(|module_id, fun_id| {
+            let prefix = if let Some(m) = module_id {
+                format!("0x{}::{}::", m.address(), m.name())
+            } else {
+                "".to_string()
+            };
+            if let Ok(t) = self.get_type_tag() {
+                let t = TypeTag::Function(Box::new(t)); // only TypeTag has display
+                format!("{}::{}:{}", prefix, fun_id, t)
+            } else {
+                format!("{}::{}", prefix, fun_id)
+            }
+        })
+    }
+}
+
 impl LoadedFunction {
     /// Returns type arguments used to instantiate the loaded function.
     pub fn ty_args(&self) -> &[Type] {
         &self.ty_args
     }
 
+    pub fn abilities(&self) -> AbilitySet {
+        self.function.abilities()
+    }
+
     /// Returns the corresponding module id of this function, i.e., its address and module name.
     pub fn module_id(&self) -> Option<&ModuleId> {
         match &self.owner {
-            LoadedFunctionOwner::Module(m) => Some(m.self_id()),
+            LoadedFunctionOwner::Module(m) => Some(Module::self_id(m)),
             LoadedFunctionOwner::Script(_) => None,
         }
     }
@@ -79,6 +316,11 @@ impl LoadedFunction {
         self.function.name()
     }
 
+    /// Returns the id of this function's name.
+    pub fn name_id(&self) -> &IdentStr {
+        self.function.name_id()
+    }
+
     /// Returns true if the loaded function has friend or private visibility.
     pub fn is_friend_or_private(&self) -> bool {
         self.function.is_friend_or_private()
@@ -250,6 +492,10 @@ impl Function {
         self.name.as_str()
     }
 
+    pub(crate) fn name_id(&self) -> &IdentStr {
+        &self.name
+    }
+
     pub fn ty_param_abilities(&self) -> &[AbilitySet] {
         &self.ty_param_abilities
     }
@@ -266,6 +512,36 @@ impl Function {
         &self.param_tys
     }
 
+    /// Creates the function type instance for this function. This requires cloning
+    /// the parameter and result types.
+    pub fn create_function_type(&self) -> Type {
+        Type::Function {
+            args: self
+                .param_tys
+                .iter()
+                .map(|t| triomphe::Arc::new(t.clone()))
+                .collect(),
+            results: self
+                .return_tys
+                .iter()
+                .map(|t| triomphe::Arc::new(t.clone()))
+                .collect(),
+            abilities: self.abilities(),
+        }
+    }
+
+    /// Returns the abilities associated with this function, without consideration of any captured
+    /// closure arguments. By default, this is copy and drop, and if the function is
+    /// immutable (public), also store.
+    pub fn abilities(&self) -> AbilitySet {
+        let result = AbilitySet::singleton(Ability::Copy).add(Ability::Drop);
+        if !self.is_friend_or_private {
+            result.add(Ability::Store)
+        } else {
+            result
+        }
+    }
+
     pub fn is_native(&self) -> bool {
         self.is_native
     }
diff --git a/third_party/move/move-vm/runtime/src/loader/mod.rs b/third_party/move/move-vm/runtime/src/loader/mod.rs
index 5c7494591f0f2b..919a07fa894554 100644
--- a/third_party/move/move-vm/runtime/src/loader/mod.rs
+++ b/third_party/move/move-vm/runtime/src/loader/mod.rs
@@ -59,17 +59,22 @@ use crate::{
     },
 };
 pub use function::{Function, LoadedFunction};
-pub(crate) use function::{FunctionHandle, FunctionInstantiation, LoadedFunctionOwner};
+pub(crate) use function::{
+    FunctionHandle, FunctionInstantiation, LazyLoadedFunction, LazyLoadedFunctionState,
+    LoadedFunctionOwner,
+};
 pub use modules::Module;
 pub(crate) use modules::{LegacyModuleCache, LegacyModuleStorage, LegacyModuleStorageAdapter};
 use move_binary_format::file_format::{
     StructVariantHandleIndex, StructVariantInstantiationIndex, VariantFieldHandleIndex,
     VariantFieldInstantiationIndex, VariantIndex,
 };
+use move_core_types::{function::MoveFunctionLayout, identifier::Identifier};
 use move_vm_metrics::{Timer, VM_TIMER};
 use move_vm_types::{
     loaded_data::runtime_types::{StructLayout, TypeBuilder},
     value_serde::FunctionValueExtension,
+    values::AbstractFunction,
 };
 pub use script::Script;
 pub(crate) use script::ScriptCache;
@@ -1662,6 +1667,28 @@ impl<'a> FunctionValueExtension for Resolver<'a> {
         };
         function_value_extension.get_function_arg_tys(module_id, function_name, ty_arg_tags)
     }
+
+    fn create_from_serialization_data(
+        &self,
+        module_id: ModuleId,
+        fun_id: Identifier,
+        fun_layout: MoveFunctionLayout,
+    ) -> PartialVMResult<Box<dyn AbstractFunction>> {
+        let function_value_extension = FunctionValueExtensionAdapter {
+            module_storage: self.module_storage,
+        };
+        function_value_extension.create_from_serialization_data(module_id, fun_id, fun_layout)
+    }
+
+    fn get_serialization_data(
+        &self,
+        fun: &dyn AbstractFunction,
+    ) -> PartialVMResult<(ModuleId, Identifier, MoveFunctionLayout)> {
+        let function_value_extension = FunctionValueExtensionAdapter {
+            module_storage: self.module_storage,
+        };
+        function_value_extension.get_serialization_data(fun)
+    }
 }
 
 /// Maximal depth of a value in terms of type depth.
@@ -1783,6 +1810,18 @@ impl Loader {
                 subst_struct_formula.scale(1);
                 subst_struct_formula
             },
+            Type::Function {
+                args,
+                results,
+                abilities: _,
+            } => DepthFormula::normalize(
+                args.iter()
+                    .chain(results)
+                    .map(|rc| {
+                        self.calculate_depth_of_type(rc.as_ref(), module_store, module_storage)
+                    })
+                    .collect::<PartialVMResult<Vec<_>>>()?,
+            ),
         })
     }
 
@@ -1865,6 +1904,8 @@ impl Loader {
 // Matches the actual returned type to the expected type, binding any type args to the
 // necessary type as stored in the map. The expected type must be a concrete type (no TyParam).
 // Returns true if a successful match is made.
+// TODO: is this really needed in presence of paranoid mode? This does a deep structural
+//   comparison and is expensive.
 fn match_return_type<'a>(
     returned: &Type,
     expected: &'a Type,
@@ -1887,6 +1928,30 @@ fn match_return_type<'a>(
         (Type::Vector(ret_inner), Type::Vector(expected_inner)) => {
             match_return_type(ret_inner, expected_inner, map)
         },
+        // Function types, the expected abilities need to be a subset of the provided ones,
+        // and recursively argument and result types need to match.
+        (
+            Type::Function {
+                args,
+                results,
+                abilities,
+            },
+            Type::Function {
+                args: exp_args,
+                results: exp_results,
+                abilities: exp_abilities,
+            },
+        ) => {
+            exp_abilities.is_subset(*abilities)
+                && args
+                    .iter()
+                    .zip(exp_args)
+                    .all(|(t, e)| match_return_type(t, e, map))
+                && results
+                    .iter()
+                    .zip(exp_results)
+                    .all(|(t, e)| match_return_type(t, e, map))
+        },
         // Abilities should not contribute to the equality check as they just serve for caching computations.
         // For structs the both need to be the same struct.
         (
@@ -1939,6 +2004,7 @@ fn match_return_type<'a>(
         | (Type::Signer, _)
         | (Type::Struct { .. }, _)
         | (Type::StructInstantiation { .. }, _)
+        | (Type::Function { .. }, _)
         | (Type::Vector(_), _)
         | (Type::MutableReference(_), _)
         | (Type::Reference(_), _) => false,
diff --git a/third_party/move/move-vm/runtime/src/storage/module_storage.rs b/third_party/move/move-vm/runtime/src/storage/module_storage.rs
index c96571b046cd1c..2bdc9df4bab9b6 100644
--- a/third_party/move/move-vm/runtime/src/storage/module_storage.rs
+++ b/third_party/move/move-vm/runtime/src/storage/module_storage.rs
@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{
-    loader::{Function, Module},
+    loader::{Function, LazyLoadedFunction, LazyLoadedFunctionState, Module},
     logging::expect_no_verification_errors,
-    WithRuntimeEnvironment,
+    ModuleStorageTypeConverter, TypeConverter, WithRuntimeEnvironment,
 };
 use ambassador::delegatable_trait;
 use bytes::Bytes;
@@ -15,9 +15,11 @@ use move_binary_format::{
 };
 use move_core_types::{
     account_address::AccountAddress,
-    identifier::IdentStr,
+    function::MoveFunctionLayout,
+    identifier::{IdentStr, Identifier},
     language_storage::{ModuleId, TypeTag},
     metadata::Metadata,
+    value::MoveTypeLayout,
     vm_status::StatusCode,
 };
 use move_vm_metrics::{Timer, VM_TIMER};
@@ -26,6 +28,7 @@ use move_vm_types::{
     loaded_data::runtime_types::{StructType, Type},
     module_cyclic_dependency_error, module_linker_error,
     value_serde::FunctionValueExtension,
+    values::AbstractFunction,
 };
 use std::sync::Arc;
 
@@ -448,4 +451,66 @@ impl<'a> FunctionValueExtension for FunctionValueExtensionAdapter<'a> {
             })
             .collect::<PartialVMResult<Vec<_>>>()
     }
+
+    fn create_from_serialization_data(
+        &self,
+        module_id: ModuleId,
+        fun_id: Identifier,
+        fun_layout: MoveFunctionLayout,
+    ) -> PartialVMResult<Box<dyn AbstractFunction>> {
+        Ok(Box::new(LazyLoadedFunction::new_unresolved(
+            module_id, fun_id, fun_layout,
+        )))
+    }
+
+    fn get_serialization_data(
+        &self,
+        fun: &dyn AbstractFunction,
+    ) -> PartialVMResult<(ModuleId, Identifier, MoveFunctionLayout)> {
+        match &*LazyLoadedFunction::expect_this_impl(fun)?.0.borrow() {
+            LazyLoadedFunctionState::Unresolved {
+                module_id,
+                fun_id,
+                fun_layout,
+                ..
+            } => Ok((module_id.clone(), fun_id.clone(), fun_layout.clone())),
+            LazyLoadedFunctionState::Resolved { fun: f, .. } => {
+                let ty_converter = ModuleStorageTypeConverter::new(self.module_storage);
+                let ty_builder = &self
+                    .module_storage
+                    .runtime_environment()
+                    .vm_config()
+                    .ty_builder;
+                let mk_layout = |ty: &Type| -> PartialVMResult<MoveTypeLayout> {
+                    if f.ty_args.is_empty() {
+                        ty_converter.type_to_type_layout(ty)
+                    } else {
+                        ty_converter
+                            .type_to_type_layout(&ty_builder.create_ty_with_subst(ty, &f.ty_args)?)
+                    }
+                };
+                let arg_layouts = f
+                    .param_tys()
+                    .iter()
+                    .map(mk_layout)
+                    .collect::<PartialVMResult<Vec<_>>>()?;
+                let result_layouts = f
+                    .return_tys()
+                    .iter()
+                    .map(mk_layout)
+                    .collect::<PartialVMResult<Vec<_>>>()?;
+                let module_id = f.module_id().ok_or_else(|| {
+                    PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR).with_message(
+                        "invalid attempt to serialize a closure without associated module"
+                            .to_string(),
+                    )
+                })?;
+                Ok((
+                    module_id.clone(),
+                    f.name_id().to_owned(),
+                    MoveFunctionLayout(arg_layouts, result_layouts, f.abilities()),
+                ))
+            },
+        }
+    }
 }
diff --git a/third_party/move/move-vm/runtime/src/storage/type_converter.rs b/third_party/move/move-vm/runtime/src/storage/type_converter.rs
index 7dc9e7323586aa..a6767f2501a463 100644
--- a/third_party/move/move-vm/runtime/src/storage/type_converter.rs
+++ b/third_party/move/move-vm/runtime/src/storage/type_converter.rs
@@ -12,7 +12,8 @@ use crate::{
 };
 use move_binary_format::errors::{PartialVMError, PartialVMResult};
 use move_core_types::{
-    language_storage::{StructTag, TypeTag},
+    function::MoveFunctionLayout,
+    language_storage::{FunctionTag, StructTag, TypeTag},
     value::{IdentifierMappingKind, MoveFieldLayout, MoveStructLayout, MoveTypeLayout},
     vm_status::StatusCode,
 };
@@ -23,7 +24,7 @@ use std::sync::Arc;
 #[allow(private_bounds)]
 pub trait TypeConverter: TypeConverterBase {
     /// Converts a runtime type to a type layout.
-    fn type_to_type_layout(&mut self, ty: &Type) -> PartialVMResult<MoveTypeLayout> {
+    fn type_to_type_layout(&self, ty: &Type) -> PartialVMResult<MoveTypeLayout> {
         let mut count = 0;
         self.type_to_type_layout_impl(ty, &mut count, 1)
             .map(|(l, _)| l)
@@ -142,6 +143,32 @@ pub(crate) trait TypeConverterBase {
                 *count += 1;
                 self.struct_name_to_type_layout(*idx, ty_args, count, depth + 1)?
             },
+            Type::Function {
+                args,
+                results,
+                abilities,
+            } => {
+                let mut identifier_mapping = false;
+                let mut to_list = |rcs: &[triomphe::Arc<Type>]| {
+                    rcs.iter()
+                        .map(|rc| {
+                            self.type_to_type_layout_impl(rc.as_ref(), count, depth + 1)
+                                .map(|(l, has)| {
+                                    identifier_mapping |= has;
+                                    l
+                                })
+                        })
+                        .collect::<PartialVMResult<Vec<_>>>()
+                };
+                (
+                    MoveTypeLayout::Function(MoveFunctionLayout(
+                        to_list(args)?,
+                        to_list(results)?,
+                        *abilities,
+                    )),
+                    identifier_mapping,
+                )
+            },
             Type::Reference(_) | Type::MutableReference(_) | Type::TyParam(_) => {
                 return Err(
                     PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR)
@@ -309,6 +336,24 @@ pub(crate) trait TypeConverterBase {
             Type::StructInstantiation { idx, ty_args, .. } => {
                 self.struct_name_to_fully_annotated_layout(*idx, ty_args, count, depth + 1)?
             },
+            Type::Function {
+                args,
+                results,
+                abilities,
+            } => {
+                let mut to_list = |rcs: &[triomphe::Arc<Type>]| {
+                    rcs.iter()
+                        .map(|rc| {
+                            self.type_to_fully_annotated_layout_impl(rc.as_ref(), count, depth + 1)
+                        })
+                        .collect::<PartialVMResult<Vec<_>>>()
+                };
+                MoveTypeLayout::Function(MoveFunctionLayout(
+                    to_list(args)?,
+                    to_list(results)?,
+                    *abilities,
+                ))
+            },
             Type::Reference(_) | Type::MutableReference(_) | Type::TyParam(_) => {
                 return Err(
                     PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR)
@@ -409,6 +454,22 @@ pub(crate) trait TypeConverterBase {
             Type::StructInstantiation { idx, ty_args, .. } => TypeTag::Struct(Box::new(
                 self.struct_name_to_type_tag(*idx, ty_args, gas_context)?,
             )),
+            Type::Function {
+                args,
+                results,
+                abilities,
+            } => {
+                let mut to_list = |rcs: &[triomphe::Arc<Type>]| {
+                    rcs.iter()
+                        .map(|rc| self.type_to_type_tag_impl(rc.as_ref(), gas_context))
+                        .collect::<PartialVMResult<Vec<_>>>()
+                };
+                TypeTag::Function(Box::new(FunctionTag {
+                    args: to_list(args)?,
+                    results: to_list(results)?,
+                    abilities: *abilities,
+                }))
+            },
             Type::Reference(_) | Type::MutableReference(_) | Type::TyParam(_) => {
                 return Err(
                     PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR)
diff --git a/third_party/move/move-vm/types/Cargo.toml b/third_party/move/move-vm/types/Cargo.toml
index 858a924fc16412..cab1e94eaa89f0 100644
--- a/third_party/move/move-vm/types/Cargo.toml
+++ b/third_party/move/move-vm/types/Cargo.toml
@@ -12,6 +12,7 @@ edition = "2021"
 [dependencies]
 ambassador = { workspace = true }
 bcs = { workspace = true }
+better_any = { workspace = true }
 bytes = { workspace = true }
 crossbeam = { workspace = true }
 dashmap = { workspace = true }
diff --git a/third_party/move/move-vm/types/src/loaded_data/runtime_types.rs b/third_party/move/move-vm/types/src/loaded_data/runtime_types.rs
index a2c077274fd1ed..20f3f7b535586a 100644
--- a/third_party/move/move-vm/types/src/loaded_data/runtime_types.rs
+++ b/third_party/move/move-vm/types/src/loaded_data/runtime_types.rs
@@ -17,7 +17,7 @@ use move_core_types::account_address::AccountAddress;
 use move_core_types::{
     ability::{Ability, AbilitySet},
     identifier::Identifier,
-    language_storage::{ModuleId, StructTag, TypeTag},
+    language_storage::{FunctionTag, ModuleId, StructTag, TypeTag},
     vm_status::{sub_status::unknown_invariant_violation::EPARANOID_FAILURE, StatusCode},
 };
 use serde::Serialize;
@@ -26,7 +26,7 @@ use smallvec::{smallvec, SmallVec};
 use std::{
     cell::RefCell,
     cmp::max,
-    collections::{btree_map, BTreeMap},
+    collections::{btree_map, BTreeMap, BTreeSet},
     fmt,
     fmt::Debug,
     sync::Arc,
@@ -287,6 +287,11 @@ pub enum Type {
         ty_args: TriompheArc<Vec<Type>>,
         ability: AbilityInfo,
     },
+    Function {
+        args: Vec<TriompheArc<Type>>,
+        results: Vec<TriompheArc<Type>>,
+        abilities: AbilitySet,
+    },
     Reference(Box<Type>),
     MutableReference(Box<Type>),
     TyParam(u16),
@@ -329,6 +334,11 @@ impl<'a> Iterator for TypePreorderTraversalIter<'a> {
                     },
 
                     StructInstantiation { ty_args, .. } => self.stack.extend(ty_args.iter().rev()),
+
+                    Function { args, results, .. } => {
+                        self.stack.extend(args.iter().map(|rc| rc.as_ref()));
+                        self.stack.extend(results.iter().map(|rc| rc.as_ref()))
+                    },
                 }
                 Some(ty)
             },
@@ -654,6 +664,7 @@ impl Type {
                         .with_message(e.to_string())
                 })
             },
+            Type::Function { abilities, .. } => Ok(*abilities),
         }
     }
 
@@ -720,13 +731,109 @@ impl Type {
                     | Struct { .. }
                     | Reference(..)
                     | MutableReference(..)
-                    | StructInstantiation { .. } => n += 1,
+                    | StructInstantiation { .. }
+                    | Function { .. } => n += 1,
                 }
             }
 
             Ok(n)
         })
     }
+
+    /// Term unification of two types where the type parameters are considered
+    /// as variables. Uses and extends as needed the passed type parameter
+    /// substitution. Returns true if unification succeeds.
+    pub fn unify(&self, other: &Type, subs: &mut BTreeMap<u16, Type>) -> bool {
+        self.unify_impl(other, subs, &mut BTreeSet::new()).is_some()
+    }
+
+    fn unify_impl(
+        &self,
+        other: &Type,
+        subs: &mut BTreeMap<u16, Type>,
+        visiting: &mut BTreeSet<u16>,
+    ) -> Option<()> {
+        use Type::*;
+        match (self, other) {
+            (TyParam(idx), ty) | (ty, TyParam(idx)) => {
+                if let Some(s) = subs.get(idx) {
+                    if !visiting.insert(*idx) {
+                        // Cyclic substitution
+                        None
+                    } else {
+                        s.clone().unify_impl(ty, subs, visiting)?;
+                        visiting.remove(idx);
+                        Some(())
+                    }
+                } else {
+                    subs.insert(*idx, ty.clone());
+                    Some(())
+                }
+            },
+            (Reference(ty1), Reference(ty2)) | (MutableReference(ty1), MutableReference(ty2)) => {
+                ty1.unify_impl(ty2.as_ref(), subs, visiting)
+            },
+            (
+                StructInstantiation { idx, ty_args, .. },
+                StructInstantiation {
+                    idx: idx2,
+                    ty_args: ty_args2,
+                    ..
+                },
+            ) if idx == idx2 && ty_args.len() == ty_args2.len() => {
+                for (ty1, ty2) in ty_args.iter().zip(ty_args2.as_ref()) {
+                    ty1.unify_impl(ty2, subs, visiting)?
+                }
+                Some(())
+            },
+            (Vector(ty1), Vector(ty2)) => ty1.unify_impl(ty2.as_ref(), subs, visiting),
+            (
+                Function {
+                    args,
+                    results,
+                    abilities,
+                },
+                Function {
+                    args: args2,
+                    results: results2,
+                    abilities: abilities2,
+                },
+            ) if abilities == abilities2
+                && args.len() == args2.len()
+                && results.len() == results2.len() =>
+            {
+                for (ty1, ty2) in args.iter().zip(args2).chain(results.iter().zip(results2)) {
+                    ty1.unify_impl(ty2.as_ref(), subs, visiting)?
+                }
+                Some(())
+            },
+            // The remaining combinations with recursive types can't match
+            (
+                Vector(..)
+                | StructInstantiation { .. }
+                | Function { .. }
+                | Reference(..)
+                | MutableReference(..),
+                _,
+            )
+            | (
+                _,
+                Vector(..)
+                | StructInstantiation { .. }
+                | Function { .. }
+                | Reference(..)
+                | MutableReference(..),
+            ) => None,
+            // Everything else matched by non-recursive term equality
+            (ty1, ty2) => {
+                if ty1 == ty2 {
+                    Some(())
+                } else {
+                    None
+                }
+            },
+        }
+    }
 }
 
 impl fmt::Display for StructIdentifier {
@@ -765,6 +872,17 @@ impl fmt::Display for Type {
                 idx.0,
                 ty_args.iter().map(|t| t.to_string()).join(",")
             ),
+            Function {
+                args,
+                results,
+                abilities,
+            } => write!(
+                f,
+                "|{}|{}{}",
+                args.iter().map(|t| t.to_string()).join(","),
+                results.iter().map(|t| t.to_string()).join(","),
+                abilities.display_postfix()
+            ),
             Reference(t) => write!(f, "&{}", t),
             MutableReference(t) => write!(f, "&mut {}", t),
             TyParam(no) => write!(f, "_{}", no),
@@ -1136,6 +1254,36 @@ impl TypeBuilder {
                     ability: ability.clone(),
                 }
             },
+            Function {
+                args,
+                results,
+                abilities,
+            } => {
+                let subs_elem = |count: &mut u64,
+                                 ty: &TriompheArc<Type>|
+                 -> PartialVMResult<TriompheArc<Type>> {
+                    Ok(TriompheArc::new(Self::apply_subst(
+                        ty.as_ref(),
+                        subst,
+                        count,
+                        depth + 1,
+                        check,
+                    )?))
+                };
+                let args = args
+                    .iter()
+                    .map(|ty| subs_elem(count, ty))
+                    .collect::<PartialVMResult<Vec<_>>>()?;
+                let results = results
+                    .iter()
+                    .map(|ty| subs_elem(count, ty))
+                    .collect::<PartialVMResult<Vec<_>>>()?;
+                Function {
+                    args,
+                    results,
+                    abilities: *abilities,
+                }
+            },
         })
     }
 
@@ -1195,6 +1343,26 @@ impl TypeBuilder {
                     }
                 }
             },
+            T::Function(fun) => {
+                let FunctionTag {
+                    args,
+                    results,
+                    abilities,
+                } = fun.as_ref();
+                let mut to_list = |ts: &[TypeTag]| {
+                    ts.iter()
+                        .map(|t| {
+                            self.create_ty_impl(t, resolver, count, depth + 1)
+                                .map(TriompheArc::new)
+                        })
+                        .collect::<VMResult<Vec<_>>>()
+                };
+                Function {
+                    args: to_list(args)?,
+                    results: to_list(results)?,
+                    abilities: *abilities,
+                }
+            },
         })
     }
 
diff --git a/third_party/move/move-vm/types/src/value_serde.rs b/third_party/move/move-vm/types/src/value_serde.rs
index c8f390096f9ac4..5eddc321dcca1b 100644
--- a/third_party/move/move-vm/types/src/value_serde.rs
+++ b/third_party/move/move-vm/types/src/value_serde.rs
@@ -4,18 +4,19 @@
 use crate::{
     delayed_values::delayed_field_id::DelayedFieldID,
     loaded_data::runtime_types::Type,
-    values::{DeserializationSeed, SerializationReadyValue, Value},
+    values::{AbstractFunction, DeserializationSeed, SerializationReadyValue, Value},
 };
 use move_binary_format::errors::{PartialVMError, PartialVMResult};
 use move_core_types::{
-    identifier::IdentStr,
+    function::MoveFunctionLayout,
+    identifier::{IdentStr, Identifier},
     language_storage::{ModuleId, TypeTag},
     value::{IdentifierMappingKind, MoveTypeLayout},
     vm_status::StatusCode,
 };
 use std::cell::RefCell;
 
-/// An extension to (de)serializer to lookup information about function values.
+/// An extension to (de)serialize information about function values.
 pub trait FunctionValueExtension {
     /// Given the module's id and the function name, returns the parameter types of the
     /// corresponding function, instantiated with the provided set of type tags.
@@ -25,6 +26,20 @@ pub trait FunctionValueExtension {
         function_name: &IdentStr,
         ty_arg_tags: Vec<TypeTag>,
     ) -> PartialVMResult<Vec<Type>>;
+
+    // TODO: document
+    fn create_from_serialization_data(
+        &self,
+        module_id: ModuleId,
+        fun_id: Identifier,
+        fun_type: MoveFunctionLayout,
+    ) -> PartialVMResult<Box<dyn AbstractFunction>>;
+
+    // TODO: document
+    fn get_serialization_data(
+        &self,
+        fun: &dyn AbstractFunction,
+    ) -> PartialVMResult<(ModuleId, Identifier, MoveFunctionLayout)>;
 }
 
 /// An extension to (de)serializer to lookup information about delayed fields.
@@ -84,6 +99,14 @@ impl<'a> ValueSerDeContext<'a> {
         self
     }
 
+    pub fn required_function_extension(&self) -> PartialVMResult<&dyn FunctionValueExtension> {
+        self.function_extension.ok_or_else(|| {
+            PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR).with_message(
+                "require function extension context for serialization of closures".to_string(),
+            )
+        })
+    }
+
     /// Returns the same extension but without allowing the delayed fields.
     pub(crate) fn clone_without_delayed_fields(&self) -> Self {
         Self {
diff --git a/third_party/move/move-vm/types/src/value_traversal.rs b/third_party/move/move-vm/types/src/value_traversal.rs
index 16a1669a6fe00a..a9b1774e6edbde 100644
--- a/third_party/move/move-vm/types/src/value_traversal.rs
+++ b/third_party/move/move-vm/types/src/value_traversal.rs
@@ -3,7 +3,7 @@
 
 use crate::{
     delayed_values::error::code_invariant_error,
-    values::{Container, Value, ValueImpl},
+    values::{Closure, Container, Value, ValueImpl},
 };
 use move_binary_format::errors::{PartialVMError, PartialVMResult};
 use move_core_types::vm_status::StatusCode;
@@ -56,6 +56,12 @@ fn find_identifiers_in_value_impl(
             },
         },
 
+        ValueImpl::ClosureValue(Closure(_, _, captured)) => {
+            for val in captured.iter() {
+                find_identifiers_in_value_impl(val, identifiers)?;
+            }
+        },
+
         ValueImpl::Invalid | ValueImpl::ContainerRef(_) | ValueImpl::IndexedRef(_) => {
             return Err(PartialVMError::new(
                 StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR,
diff --git a/third_party/move/move-vm/types/src/values/function_values_impl.rs b/third_party/move/move-vm/types/src/values/function_values_impl.rs
new file mode 100644
index 00000000000000..2b3c5d4cb810e4
--- /dev/null
+++ b/third_party/move/move-vm/types/src/values/function_values_impl.rs
@@ -0,0 +1,210 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::values::{DeserializationSeed, SerializationReadyValue, VMValueCast, Value, ValueImpl};
+use better_any::Tid;
+use move_binary_format::errors::{PartialVMError, PartialVMResult};
+use move_core_types::{
+    function::{ClosureMask, MoveFunctionLayout},
+    identifier::Identifier,
+    language_storage::ModuleId,
+    vm_status::StatusCode,
+};
+use serde::{
+    de::Error as DeError,
+    ser::{Error, SerializeSeq},
+};
+use std::{
+    cmp::Ordering,
+    fmt,
+    fmt::{Debug, Display, Formatter},
+};
+
+/// A trait describing a function which can be executed. If this is a generic
+/// function, the type instantiation is part of this.
+/// The value system is agnostic about how this is implemented in the runtime.
+/// The `FunctionValueExtension` trait describes how to construct and
+/// deconstruct instances for serialization.
+pub trait AbstractFunction: for<'a> Tid<'a> {
+    fn cmp_dyn(&self, other: &dyn AbstractFunction) -> PartialVMResult<Ordering>;
+    fn clone_dyn(&self) -> PartialVMResult<Box<dyn AbstractFunction>>;
+    fn to_stable_string(&self) -> String;
+}
+
+/// A closure, consisting of a function descriptor, a mask describing which arguments
+/// are captured, and the captured arguments.
+pub struct Closure(
+    pub(crate) Box<dyn AbstractFunction>,
+    pub(crate) ClosureMask,
+    pub(crate) Vec<ValueImpl>,
+);
+
+impl Closure {
+    pub fn pack(
+        fun: Box<dyn AbstractFunction>,
+        mask: ClosureMask,
+        captured: impl IntoIterator<Item = Value>,
+    ) -> Self {
+        Self(fun, mask, captured.into_iter().map(|v| v.0).collect())
+    }
+
+    pub fn unpack(
+        self,
+    ) -> (
+        Box<dyn AbstractFunction>,
+        ClosureMask,
+        impl Iterator<Item = Value>,
+    ) {
+        let Self(fun, mask, captured) = self;
+        (fun, mask, captured.into_iter().map(Value))
+    }
+
+    pub fn into_call_data(
+        self,
+        args: Vec<Value>,
+    ) -> PartialVMResult<(Box<dyn AbstractFunction>, Vec<Value>)> {
+        let (fun, mask, captured) = self.unpack();
+        if let Some(all_args) = mask.compose(captured, args) {
+            Ok((fun, all_args))
+        } else {
+            Err(
+                PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR)
+                    .with_message("invalid empty enum variant".to_string()),
+            )
+        }
+    }
+}
+
+impl Debug for Closure {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let Self(fun, mask, captured) = self;
+        write!(
+            f,
+            "Closure({}, {}, {:?})",
+            fun.to_stable_string(),
+            mask,
+            captured
+        )
+    }
+}
+
+impl Display for Closure {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let Self(fun, mask, captured) = self;
+        let captured = mask
+            .merge_placeholder_strings(
+                captured.len(),
+                captured.iter().map(|v| v.to_string()).collect(),
+            )
+            .unwrap_or_else(|| vec!["*invalid*".to_string()]);
+        write!(f, "{}({})", fun.to_stable_string(), captured.join(","))
+    }
+}
+
+impl VMValueCast<Closure> for Value {
+    fn cast(self) -> PartialVMResult<Closure> {
+        match self.0 {
+            ValueImpl::ClosureValue(c) => Ok(c),
+            v => Err(PartialVMError::new(StatusCode::INTERNAL_TYPE_ERROR)
+                .with_message(format!("cannot cast {:?} to closure", v))),
+        }
+    }
+}
+
+impl<'c, 'l, 'v> serde::Serialize
+    for SerializationReadyValue<'c, 'l, 'v, MoveFunctionLayout, Closure>
+{
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let Closure(fun, mask, captured) = self.value;
+        let fun_ext = self
+            .ctx
+            .required_function_extension()
+            .map_err(S::Error::custom)?;
+        let (module_id, fun_id, fun_layout) = fun_ext
+            .get_serialization_data(fun.as_ref())
+            .map_err(S::Error::custom)?;
+        let mut seq = serializer.serialize_seq(Some(4 + captured.len()))?;
+        // Serialize function name and type
+        seq.serialize_element(&module_id)?;
+        seq.serialize_element(&fun_id)?;
+        seq.serialize_element(&fun_layout)?;
+        // Serialize closure mask and captured arguments
+        seq.serialize_element(&mask)?;
+        let captured_layouts = mask.extract(&fun_layout.0, true /*collect_captured*/);
+        if captured_layouts.len() != captured.len() {
+            return Err(S::Error::custom(
+                PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR).with_message(
+                    format!(
+                        "closure mask has {} captured arguments but given were {}",
+                        captured_layouts.len(),
+                        captured.len()
+                    ),
+                ),
+            ));
+        }
+        for (layout, value) in captured_layouts.into_iter().zip(captured) {
+            seq.serialize_element(&SerializationReadyValue {
+                ctx: self.ctx,
+                layout,
+                value,
+            })?
+        }
+        seq.end()
+    }
+}
+
+pub(crate) struct ClosureVisitor<'c, 'l>(
+    pub(crate) DeserializationSeed<'c, &'l MoveFunctionLayout>,
+);
+
+impl<'d, 'c, 'l> serde::de::Visitor<'d> for ClosureVisitor<'c, 'l> {
+    type Value = Closure;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("Closure")
+    }
+
+    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+    where
+        A: serde::de::SeqAccess<'d>,
+    {
+        let fun_ext = self
+            .0
+            .ctx
+            .required_function_extension()
+            .map_err(A::Error::custom)?;
+        let module_id = read_required_value::<_, ModuleId>(&mut seq)?;
+        let fun_id = read_required_value::<_, Identifier>(&mut seq)?;
+        let fun_layout = read_required_value::<_, MoveFunctionLayout>(&mut seq)?;
+        let mask = read_required_value::<_, ClosureMask>(&mut seq)?;
+        let mut captured = vec![];
+        for layout in mask.extract(&fun_layout.0, true /*collect_captured*/) {
+            match seq.next_element_seed(DeserializationSeed {
+                ctx: self.0.ctx,
+                layout,
+            })? {
+                Some(v) => captured.push(v.0),
+                None => return Err(A::Error::invalid_length(captured.len(), &self)),
+            }
+        }
+        // If the sequence length is known, check whether there are no extra values
+        if matches!(seq.size_hint(), Some(remaining) if remaining != 0) {
+            return Err(A::Error::invalid_length(captured.len(), &self));
+        }
+        let fun = fun_ext
+            .create_from_serialization_data(module_id, fun_id, fun_layout)
+            .map_err(A::Error::custom)?;
+        Ok(Closure(fun, mask, captured))
+    }
+}
+
+fn read_required_value<'a, A, T>(seq: &mut A) -> Result<T, A::Error>
+where
+    A: serde::de::SeqAccess<'a>,
+    T: serde::de::Deserialize<'a>,
+{
+    match seq.next_element::<T>()? {
+        Some(x) => Ok(x),
+        None => Err(A::Error::custom("expected more elements")),
+    }
+}
diff --git a/third_party/move/move-vm/types/src/values/mod.rs b/third_party/move/move-vm/types/src/values/mod.rs
index 4796eb7fbd9472..31b773cffd3da9 100644
--- a/third_party/move/move-vm/types/src/values/mod.rs
+++ b/third_party/move/move-vm/types/src/values/mod.rs
@@ -2,6 +2,7 @@
 // Copyright (c) The Move Contributors
 // SPDX-License-Identifier: Apache-2.0
 
+pub mod function_values_impl;
 pub mod values_impl;
 
 #[cfg(test)]
@@ -12,4 +13,5 @@ mod serialization_tests;
 #[cfg(all(test, feature = "fuzzing"))]
 mod value_prop_tests;
 
+pub use function_values_impl::*;
 pub use values_impl::*;
diff --git a/third_party/move/move-vm/types/src/values/values_impl.rs b/third_party/move/move-vm/types/src/values/values_impl.rs
index 122c232dc6a818..c310288b21a543 100644
--- a/third_party/move/move-vm/types/src/values/values_impl.rs
+++ b/third_party/move/move-vm/types/src/values/values_impl.rs
@@ -8,6 +8,7 @@ use crate::{
     delayed_values::delayed_field_id::{DelayedFieldID, TryFromMoveValue, TryIntoMoveValue},
     loaded_data::runtime_types::Type,
     value_serde::ValueSerDeContext,
+    values::function_values_impl::{AbstractFunction, Closure, ClosureVisitor},
     views::{ValueView, ValueVisitor},
 };
 use itertools::Itertools;
@@ -18,6 +19,7 @@ use move_binary_format::{
 use move_core_types::{
     account_address::AccountAddress,
     effects::Op,
+    function::ClosureMask,
     gas_algebra::AbstractMemorySize,
     u256, value,
     value::{MoveStruct, MoveStructLayout, MoveTypeLayout, MoveValue},
@@ -89,6 +91,11 @@ pub(crate) enum ValueImpl {
     DelayedFieldID {
         id: DelayedFieldID,
     },
+
+    /// A closure, consisting of a function reference and captured arguments.
+    /// Notice that captured arguments cannot be referenced, hence a closure is
+    /// not a container.
+    ClosureValue(Closure),
 }
 
 /// A container is a collection of values. It is used to represent data structures like a
@@ -407,6 +414,14 @@ impl ValueImpl {
             // Native values can be copied because this is how read_ref operates,
             // and copying is an internal API.
             DelayedFieldID { id } => DelayedFieldID { id: *id },
+
+            ClosureValue(Closure(fun, mask, captured)) => {
+                let captured = captured
+                    .iter()
+                    .map(|v| v.copy_value())
+                    .collect::<PartialVMResult<_>>()?;
+                ClosureValue(Closure(fun.clone_dyn()?, *mask, captured))
+            },
         })
     }
 }
@@ -530,6 +545,25 @@ impl ValueImpl {
                     .with_message("cannot compare delayed values".to_string()))
             },
 
+            (
+                ClosureValue(Closure(fun1, mask1, captured1)),
+                ClosureValue(Closure(fun2, mask2, captured2)),
+            ) => {
+                if fun1.cmp_dyn(fun2.as_ref())? == Ordering::Equal
+                    && mask1 == mask2
+                    && captured1.len() == captured2.len()
+                {
+                    for (v1, v2) in captured1.iter().zip(captured2.iter()) {
+                        if !v1.equals(v2)? {
+                            return Ok(false);
+                        }
+                    }
+                    true
+                } else {
+                    false
+                }
+            },
+
             (Invalid, _)
             | (U8(_), _)
             | (U16(_), _)
@@ -542,6 +576,7 @@ impl ValueImpl {
             | (Container(_), _)
             | (ContainerRef(_), _)
             | (IndexedRef(_), _)
+            | (ClosureValue(_), _)
             | (DelayedFieldID { .. }, _) => {
                 return Err(
                     PartialVMError::new(StatusCode::INTERNAL_TYPE_ERROR).with_message(format!(
@@ -580,6 +615,24 @@ impl ValueImpl {
                     .with_message("cannot compare delayed values".to_string()))
             },
 
+            (
+                ClosureValue(Closure(fun1, mask1, captured1)),
+                ClosureValue(Closure(fun2, mask2, captured2)),
+            ) => {
+                let o = fun1.cmp_dyn(fun2.as_ref())?.then(mask1.cmp(mask2));
+                if o == Ordering::Equal {
+                    for (v1, v2) in captured1.iter().zip(captured2.iter()) {
+                        let o = v1.compare(v2)?;
+                        if o != Ordering::Equal {
+                            return Ok(o);
+                        }
+                    }
+                    captured1.len().cmp(&captured2.len())
+                } else {
+                    o
+                }
+            },
+
             (Invalid, _)
             | (U8(_), _)
             | (U16(_), _)
@@ -592,6 +645,7 @@ impl ValueImpl {
             | (Container(_), _)
             | (ContainerRef(_), _)
             | (IndexedRef(_), _)
+            | (ClosureValue(_), _)
             | (DelayedFieldID { .. }, _) => {
                 return Err(
                     PartialVMError::new(StatusCode::INTERNAL_TYPE_ERROR).with_message(format!(
@@ -1403,6 +1457,7 @@ impl ContainerRef {
                     | ValueImpl::U256(_)
                     | ValueImpl::Bool(_)
                     | ValueImpl::Address(_)
+                    | ValueImpl::ClosureValue(_)
                     | ValueImpl::DelayedFieldID { .. } => ValueImpl::IndexedRef(IndexedRef {
                         idx,
                         container_ref: self.copy_value(),
@@ -1497,6 +1552,7 @@ impl Locals {
             | ValueImpl::U256(_)
             | ValueImpl::Bool(_)
             | ValueImpl::Address(_)
+            | ValueImpl::ClosureValue(_)
             | ValueImpl::DelayedFieldID { .. } => Ok(Value(ValueImpl::IndexedRef(IndexedRef {
                 idx,
                 container_ref: ContainerRef::Local(Container::Locals(Rc::clone(&self.0))),
@@ -1556,8 +1612,8 @@ impl Locals {
                             return Err(PartialVMError::new(
                                 StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR,
                             )
-                            .with_message("moving container with dangling references".to_string())
-                            .with_sub_status(move_core_types::vm_status::sub_status::unknown_invariant_violation::EREFERENCE_COUNTING_FAILURE));
+                                .with_message("moving container with dangling references".to_string())
+                                .with_sub_status(move_core_types::vm_status::sub_status::unknown_invariant_violation::EREFERENCE_COUNTING_FAILURE));
                         }
                     }
                 }
@@ -1743,6 +1799,14 @@ impl Value {
             it.into_iter().map(|v| v.0).collect(),
         )))))
     }
+
+    pub fn closure(
+        fun: Box<dyn AbstractFunction>,
+        mask: ClosureMask,
+        captured: impl IntoIterator<Item = Value>,
+    ) -> Self {
+        Self(ValueImpl::ClosureValue(Closure::pack(fun, mask, captured)))
+    }
 }
 
 /***************************************************************************************
@@ -2491,6 +2555,8 @@ pub const INDEX_OUT_OF_BOUNDS: u64 = NFE_VECTOR_ERROR_BASE + 1;
 pub const POP_EMPTY_VEC: u64 = NFE_VECTOR_ERROR_BASE + 2;
 pub const VEC_UNPACK_PARITY_MISMATCH: u64 = NFE_VECTOR_ERROR_BASE + 3;
 
+// TODO: this check seems to be obsolete if paranoid mode is on,
+//   and should either be removed or move over to runtime_type_checks?
 fn check_elem_layout(ty: &Type, v: &Container) -> PartialVMResult<()> {
     match (ty, v) {
         (Type::U8, Container::VecU8(_))
@@ -2507,7 +2573,8 @@ fn check_elem_layout(ty: &Type, v: &Container) -> PartialVMResult<()> {
 
         (Type::Struct { .. }, Container::Vec(_))
         | (Type::Signer, Container::Vec(_))
-        | (Type::StructInstantiation { .. }, Container::Vec(_)) => Ok(()),
+        | (Type::StructInstantiation { .. }, Container::Vec(_))
+        | (Type::Function { .. }, Container::Vec(_)) => Ok(()),
 
         (Type::Reference(_), _) | (Type::MutableReference(_), _) | (Type::TyParam(_), _) => Err(
             PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR)
@@ -2525,7 +2592,8 @@ fn check_elem_layout(ty: &Type, v: &Container) -> PartialVMResult<()> {
         | (Type::Signer, _)
         | (Type::Vector(_), _)
         | (Type::Struct { .. }, _)
-        | (Type::StructInstantiation { .. }, _) => Err(PartialVMError::new(
+        | (Type::StructInstantiation { .. }, _)
+        | (Type::Function { .. }, _) => Err(PartialVMError::new(
             StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR,
         )
         .with_message(format!(
@@ -2814,11 +2882,10 @@ impl Vector {
             Type::Signer
             | Type::Vector(_)
             | Type::Struct { .. }
-            | Type::StructInstantiation {
-                idx: _, ty_args: _, ..
-            } => Value(ValueImpl::Container(Container::Vec(Rc::new(RefCell::new(
-                elements.into_iter().map(|v| v.0).collect(),
-            ))))),
+            | Type::StructInstantiation { .. }
+            | Type::Function { .. } => Value(ValueImpl::Container(Container::Vec(Rc::new(
+                RefCell::new(elements.into_iter().map(|v| v.0).collect()),
+            )))),
 
             Type::Reference(_) | Type::MutableReference(_) | Type::TyParam(_) => {
                 return Err(
@@ -2925,6 +2992,9 @@ pub(crate) const LEGACY_REFERENCE_SIZE: AbstractMemorySize = AbstractMemorySize:
 /// The size of a struct in bytes
 pub(crate) const LEGACY_STRUCT_SIZE: AbstractMemorySize = AbstractMemorySize::new(2);
 
+/// The size of a closure in bytes
+pub(crate) const LEGACY_CLOSURE_SIZE: AbstractMemorySize = AbstractMemorySize::new(6);
+
 impl Container {
     #[cfg(test)]
     fn legacy_size(&self) -> AbstractMemorySize {
@@ -2992,6 +3062,12 @@ impl ValueImpl {
             // Legacy size is only used by event native functions (which should not even
             // be part of move-stdlib), so we should never see any delayed values here.
             DelayedFieldID { .. } => unreachable!("Delayed values do not have legacy size!"),
+
+            ClosureValue(..) => {
+                // TODO(#15664): similarly as with delayed values, closures should not appear here,
+                //   but this needs to be verified
+                unreachable!("Closures do not have legacy size!")
+            },
         }
     }
 }
@@ -3295,6 +3371,8 @@ impl Debug for ValueImpl {
             Self::ContainerRef(r) => write!(f, "ContainerRef({:?})", r),
             Self::IndexedRef(r) => write!(f, "IndexedRef({:?})", r),
 
+            Self::ClosureValue(c) => write!(f, "Function({:?})", c),
+
             // Debug information must be deterministic, so we cannot print
             // inner fields.
             Self::DelayedFieldID { .. } => write!(f, "Delayed(?)"),
@@ -3330,6 +3408,8 @@ impl Display for ValueImpl {
             Self::ContainerRef(r) => write!(f, "{}", r),
             Self::IndexedRef(r) => write!(f, "{}", r),
 
+            Self::ClosureValue(c) => write!(f, "{}", c),
+
             // Display information must be deterministic, so we cannot print
             // inner fields.
             Self::DelayedFieldID { .. } => write!(f, "Delayed(?)"),
@@ -3488,6 +3568,10 @@ pub mod debug {
         debug_write!(buf, "{}", x.to_hex())
     }
 
+    fn print_closure<B: Write>(buf: &mut B, c: &Closure) -> PartialVMResult<()> {
+        debug_write!(buf, "{}", c)
+    }
+
     fn print_value_impl<B: Write>(buf: &mut B, val: &ValueImpl) -> PartialVMResult<()> {
         match val {
             ValueImpl::Invalid => print_invalid(buf),
@@ -3506,6 +3590,8 @@ pub mod debug {
             ValueImpl::ContainerRef(r) => print_container_ref(buf, r),
             ValueImpl::IndexedRef(r) => print_indexed_ref(buf, r),
 
+            ValueImpl::ClosureValue(c) => print_closure(buf, c),
+
             ValueImpl::DelayedFieldID { .. } => print_delayed_value(buf),
         }
     }
@@ -3676,6 +3762,14 @@ impl<'c, 'l, 'v> serde::Serialize
                 .serialize(serializer)
             },
 
+            // Functions.
+            (L::Function(fun_layout), ValueImpl::ClosureValue(clos)) => SerializationReadyValue {
+                ctx: self.ctx,
+                layout: fun_layout,
+                value: clos,
+            }
+            .serialize(serializer),
+
             // Vectors.
             (L::Vector(layout), ValueImpl::Container(c)) => {
                 let layout = layout.as_ref();
@@ -3906,6 +4000,16 @@ impl<'d, 'c> serde::de::DeserializeSeed<'d> for DeserializationSeed<'c, &MoveTyp
                 },
             }),
 
+            // Functions
+            L::Function(fun_layout) => {
+                let seed = DeserializationSeed {
+                    ctx: self.ctx,
+                    layout: fun_layout,
+                };
+                let closure = deserializer.deserialize_seq(ClosureVisitor(seed))?;
+                Ok(Value(ValueImpl::ClosureValue(closure)))
+            },
+
             // Delayed values should always use custom deserialization.
             L::Native(kind, layout) => {
                 match &self.ctx.delayed_fields_extension {
@@ -3928,9 +4032,9 @@ impl<'d, 'c> serde::de::DeserializeSeed<'d> for DeserializationSeed<'c, &MoveTyp
                                     DelayedFieldID::try_from_move_value(layout, value, &())
                                         .map_err(|_| {
                                             D::Error::custom(format!(
-                                            "Custom deserialization failed for {:?} with layout {}",
-                                            kind, layout
-                                        ))
+                                        "Custom deserialization failed for {:?} with layout {}",
+                                        kind, layout
+                                    ))
                                         })?;
                                 id
                             },
@@ -4238,6 +4342,17 @@ impl Container {
     }
 }
 
+impl Closure {
+    fn visit_impl(&self, visitor: &mut impl ValueVisitor, depth: usize) {
+        let Self(_, _, captured) = self;
+        if visitor.visit_closure(depth, captured.len()) {
+            for val in captured {
+                val.visit_impl(visitor, depth + 1);
+            }
+        }
+    }
+}
+
 impl ContainerRef {
     fn visit_impl(&self, visitor: &mut impl ValueVisitor, depth: usize) {
         use ContainerRef::*;
@@ -4289,6 +4404,8 @@ impl ValueImpl {
             ContainerRef(r) => r.visit_impl(visitor, depth),
             IndexedRef(r) => r.visit_impl(visitor, depth),
 
+            ClosureValue(c) => c.visit_impl(visitor, depth),
+
             DelayedFieldID { id } => visitor.visit_delayed(depth, *id),
         }
     }
@@ -4549,6 +4666,14 @@ pub mod prop {
                 .prop_map(move |vals| Value::struct_(Struct::pack(vals)))
                 .boxed(),
 
+            L::Function(_function_layout) => {
+                // TODO(#15664): not clear how to generate closure values, we'd need
+                //   some test functions for this, and generate `AbstractFunction` impls.
+                //   As we do not generate function layouts in the first place, we can bail
+                //   out here
+                unreachable!("unexpected function layout")
+            },
+
             // TODO[agg_v2](cleanup): double check what we should do here (i.e. if we should
             //  even skip these kinds of layouts, or if need to construct a delayed value)?
             L::Native(_, layout) => value_strategy_with_layout(layout.as_ref()),
diff --git a/third_party/move/move-vm/types/src/views.rs b/third_party/move/move-vm/types/src/views.rs
index 3c11766c55841a..120e712adc89fc 100644
--- a/third_party/move/move-vm/types/src/views.rs
+++ b/third_party/move/move-vm/types/src/views.rs
@@ -1,7 +1,7 @@
 // Copyright (c) The Move Contributors
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::delayed_values::delayed_field_id::DelayedFieldID;
+use crate::{delayed_values::delayed_field_id::DelayedFieldID, values::LEGACY_CLOSURE_SIZE};
 use move_core_types::{
     account_address::AccountAddress, gas_algebra::AbstractMemorySize, language_storage::TypeTag,
 };
@@ -79,6 +79,11 @@ pub trait ValueView {
                 true
             }
 
+            fn visit_closure(&mut self, _depth: usize, _len: usize) -> bool {
+                self.0 += LEGACY_CLOSURE_SIZE;
+                true
+            }
+
             fn visit_vec(&mut self, _depth: usize, _len: usize) -> bool {
                 self.0 += LEGACY_STRUCT_SIZE;
                 true
@@ -142,6 +147,7 @@ pub trait ValueVisitor {
     fn visit_address(&mut self, depth: usize, val: AccountAddress);
 
     fn visit_struct(&mut self, depth: usize, len: usize) -> bool;
+    fn visit_closure(&mut self, depth: usize, len: usize) -> bool;
     fn visit_vec(&mut self, depth: usize, len: usize) -> bool;
 
     fn visit_ref(&mut self, depth: usize, is_global: bool) -> bool;
diff --git a/third_party/move/tools/move-bytecode-utils/src/layout.rs b/third_party/move/tools/move-bytecode-utils/src/layout.rs
index 46863644cdc55b..00235b3b32b32a 100644
--- a/third_party/move/tools/move-bytecode-utils/src/layout.rs
+++ b/third_party/move/tools/move-bytecode-utils/src/layout.rs
@@ -14,6 +14,7 @@ use move_binary_format::{
 };
 use move_core_types::{
     account_address::AccountAddress,
+    function::MoveFunctionLayout,
     identifier::{IdentStr, Identifier},
     language_storage::{ModuleId, StructTag, TypeTag},
     value::{MoveFieldLayout, MoveStructLayout, MoveTypeLayout},
@@ -374,6 +375,18 @@ impl TypeLayoutBuilder {
                 compiled_module_view,
                 layout_type,
             )?),
+            Function(f) => {
+                let build_list = |ts: &[TypeTag]| {
+                    ts.iter()
+                        .map(|t| Self::build(t, compiled_module_view, layout_type))
+                        .collect::<anyhow::Result<Vec<_>>>()
+                };
+                MoveTypeLayout::Function(MoveFunctionLayout(
+                    build_list(&f.args)?,
+                    build_list(&f.results)?,
+                    f.abilities,
+                ))
+            },
         })
     }
 
diff --git a/third_party/move/tools/move-resource-viewer/src/fat_type.rs b/third_party/move/tools/move-resource-viewer/src/fat_type.rs
index d4f8097a4f1789..0d9f75889d44b1 100644
--- a/third_party/move/tools/move-resource-viewer/src/fat_type.rs
+++ b/third_party/move/tools/move-resource-viewer/src/fat_type.rs
@@ -275,6 +275,10 @@ impl From<&TypeTag> for FatType {
             TypeTag::Vector(inner) => Vector(Box::new(inner.as_ref().into())),
             TypeTag::Struct(inner) => Struct(Box::new(inner.as_ref().into())),
             TypeTag::U256 => U256,
+            TypeTag::Function(..) => {
+                // TODO(#15664): implement functions for fat types
+                todo!("functions not supported by fat types")
+            },
         }
     }
 }
diff --git a/third_party/move/tools/move-resource-viewer/src/lib.rs b/third_party/move/tools/move-resource-viewer/src/lib.rs
index 6dd335429d4008..92bad96842650d 100644
--- a/third_party/move/tools/move-resource-viewer/src/lib.rs
+++ b/third_party/move/tools/move-resource-viewer/src/lib.rs
@@ -441,6 +441,10 @@ impl<V: CompiledModuleView> MoveValueAnnotator<V> {
             TypeTag::U256 => FatType::U256,
             TypeTag::U128 => FatType::U128,
             TypeTag::Vector(ty) => FatType::Vector(Box::new(self.resolve_type_impl(ty, limit)?)),
+            TypeTag::Function(..) => {
+                // TODO(#15664) implement functions for fat types"
+                todo!("functions for fat types")
+            },
         })
     }
 
@@ -582,6 +586,10 @@ impl<V: CompiledModuleView> MoveValueAnnotator<V> {
             (MoveValue::Struct(s), FatType::Struct(ty)) => {
                 AnnotatedMoveValue::Struct(self.annotate_struct(s, ty.as_ref(), limit)?)
             },
+            (MoveValue::Closure(..), _) => {
+                // TODO(#15664) implement functions for annotated move values
+                todo!("functions not implemented")
+            },
             (MoveValue::U8(_), _)
             | (MoveValue::U64(_), _)
             | (MoveValue::U128(_), _)