diff --git a/.github/workflows/premerge.yml b/.github/workflows/premerge.yml
index 3a256729..2c2b46fc 100644
--- a/.github/workflows/premerge.yml
+++ b/.github/workflows/premerge.yml
@@ -49,6 +49,11 @@ jobs:
       with:
         create-symlink: true
 
+    - name: Upgrade CMake
+      run: |
+        sudo apt-get purge cmake
+        sudo snap install cmake --classic
+
     - name: Configure CMake
       run: cmake --preset ${{env.CMAKE_PRESET}}
 
diff --git a/CLAUDE.md b/CLAUDE.md
index 2a8a229f..26eb5c12 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -9,8 +9,9 @@ This is an experimental Python 3.9-compatible interpreter implementation in C++.
 ## Build System
 
 ### Prerequisites
-- CMake 3.25+
-- C++23 compiler
+- CMake 3.30+ (`CMAKE_EXPERIMENTAL_CXX_IMPORT_STD`, used for `import std`)
+- A C++26 compiler supporting C++20 named modules and `import std`
+  (built and tested with GCC 16)
 - LLVM 23+ with MLIR (required for MLIR backend)
 - GMP (GNU Multiple Precision library)
 - ICU (International Components for Unicode)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index cc8a01c3..6b6f7e74 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,15 +1,29 @@
-cmake_minimum_required(VERSION 3.25)
+cmake_minimum_required(VERSION 3.30)
 include(FetchContent)
 include(ExternalProject)
 include(CheckCXXSourceCompiles)
 
+set(CMAKE_EXPERIMENTAL_CXX_IMPORT_STD "f35a9ac6-8463-4d38-8eec-5d6008153e7d")
+
 project(python++)
 
 set(CMAKE_CXX_STANDARD 26)
+set(CMAKE_CXX_SCAN_FOR_MODULES OFF)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 include(cmake/CPM.cmake)
 
-CPMAddPackage("gh:gabime/spdlog@1.8.5")
+# spdlog 1.11+ can format through std::format instead of its bundled fmt.
+# SPDLOG_USE_STD_FORMAT keeps fmt out of the build entirely, which matters for
+# modules: spdlog/fmt/fmt.h drags 231 libstdc++ headers, and anything reaching a
+# module's global module fragment lands in its BMI and then collides with the
+# same headers #included by consumers.
+CPMAddPackage(
+  NAME spdlog
+  GITHUB_REPOSITORY gabime/spdlog
+  VERSION 1.15.3
+  OPTIONS "SPDLOG_USE_STD_FORMAT ON" "SPDLOG_BUILD_PIC ON"
+)
 CPMAddPackage("gh:google/googletest@1.18.0")
 CPMAddPackage("gh:jarro2783/cxxopts@3.3.1")
 CPMAddPackage("gh:Tessil/ordered-map@1.2.0")
diff --git a/cmake/PythonCppFlags.cmake b/cmake/PythonCppFlags.cmake
index 1a905b8f..05bbecf2 100644
--- a/cmake/PythonCppFlags.cmake
+++ b/cmake/PythonCppFlags.cmake
@@ -1,4 +1,5 @@
-# Helper for giving every first-party target the same compiler flags.
+# Helper for giving every first-party target the same compiler flags and the
+# same C++ module configuration.
 #
 # The flags come from the external `project_options` package (added with CPM in
 # the top-level CMakeLists.txt), which exposes them as two INTERFACE targets:
@@ -16,6 +17,19 @@
 # not the usage requirements of libraries linked afterwards. Linking the flags
 # to `<name>` alone would therefore silently compile nothing with them, so this
 # always covers the `obj.<name>` twin as well.
+#
+# The same `obj.<name>` split applies to C++ module settings, and there it is
+# easier to miss: `CXX_SCAN_FOR_MODULES` set on `<name>` does not reach the
+# object library that actually compiles the sources, so those sources are built
+# by CMake's "unscanned" rule with no `-fmodule-mapper`. A TU that imports
+# `py.runtime` then fails with either "'import' does not name a type" or, worse,
+# a fallback lookup in `gcm.cache/`. Setting the properties on both twins is
+# what makes `import py.runtime;` work inside the MLIR layer.
+#
+# Note: do NOT add `-fmodules` here. CMake supplies `-fmodules-ts` together with
+# `-fmodule-mapper=` on its scanned compile rules; adding the flag by hand also
+# applies it to unscanned targets, which turns a clear diagnostic into a
+# confusing module-not-found error.
 
 include_guard(GLOBAL)
 
@@ -28,8 +42,26 @@ function(python_cpp_link_project_options)
       get_target_property(type ${name} TYPE)
       if(type STREQUAL "INTERFACE_LIBRARY")
         target_link_libraries(${name} INTERFACE project_options project_warnings)
-      else()
-        target_link_libraries(${name} PRIVATE project_options project_warnings)
+        continue()
+      endif()
+
+      target_link_libraries(${name} PRIVATE project_options project_warnings)
+
+      # Everything first-party either provides or consumes `py.runtime`, so
+      # scan it all. Scanning costs ~0.16s per TU (a preprocess-only pass) and
+      # removes a whole class of "this target cannot see the module" failures.
+      set_target_properties(${name} PROPERTIES CXX_SCAN_FOR_MODULES ON
+                                               CXX_MODULE_STD ON)
+
+      # Module imports resolve through link dependencies, so every consumer
+      # needs a path to python-runtime - the sole provider of `py.runtime`.
+      # It is linked directly rather than via python-cpp because python-cpp and
+      # python-mlir are mutually dependent: a module provider reached only
+      # through a link cycle cannot be ordered before its consumers, and they
+      # compile with an empty module map. python-runtime itself sits below that
+      # cycle, so linking it here is always acyclic.
+      if(TARGET python-runtime AND NOT ${target} STREQUAL "python-runtime")
+        target_link_libraries(${name} PRIVATE python-runtime)
       endif()
     endforeach()
   endforeach()
diff --git a/integration/program.cpp b/integration/program.cpp
index 36517a06..74674348 100644
--- a/integration/program.cpp
+++ b/integration/program.cpp
@@ -1,19 +1,17 @@
-#include "executable/Program.hpp"
-#include "executable/bytecode/Bytecode.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "parser/Parser.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/PyNumber.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/types/builtin.hpp"
-#include "vm/VM.hpp"
+#include "core.hpp"
+#include "executable/common.hpp"
 
 #include "gtest/gtest.h"
+#include <gmpxx.h>
+#include <spdlog/spdlog.h>
+
+#include <cmath>
+
+import py.ast;
+import py.types;
+import py.lexer;
+import py.runtime;
+import std;
 
 using namespace py;
 
diff --git a/integration/tests/slots_uninitialised.py b/integration/tests/slots_uninitialised.py
new file mode 100644
index 00000000..4fa9c06e
--- /dev/null
+++ b/integration/tests/slots_uninitialised.py
@@ -0,0 +1,59 @@
+# An unset __slots__ entry must read as unset, however the slot storage was recycled.
+#
+# The storage lives in extra bytes past the object, and both the GC and the member
+# accessor test each entry against null. Slab memory is poisoned rather than zeroed,
+# so if the allocator does not clear those bytes an unset slot reads back as a
+# non-null garbage pointer: the accessor returns it instead of raising AttributeError,
+# and the GC dereferences it.
+
+
+class C:
+    __slots__ = ("a", "b", "c")
+
+
+def unset_raises(obj, name):
+    try:
+        getattr(obj, name)
+    except AttributeError:
+        return True
+    else:
+        return False
+
+
+c = C()
+c.a = 1
+assert c.a == 1
+assert unset_raises(c, "b"), "unset slot 'b' should raise AttributeError"
+assert unset_raises(c, "c"), "unset slot 'c' should raise AttributeError"
+
+# Churn so that later instances land on slots that were freed and poisoned.
+for i in range(2000):
+    x = C()
+    x.a = i
+    x.b = i
+    x.c = i
+
+for i in range(2000):
+    y = C()
+    y.a = i
+    assert y.a == i
+    assert unset_raises(y, "b"), "recycled slot 'b' should still read as unset"
+    assert unset_raises(y, "c"), "recycled slot 'c' should still read as unset"
+
+# Slots that are set must survive a collection with their values intact. The list is a
+# heap object reachable only through the slot, so the GC has to trace the slot correctly.
+kept = []
+for i in range(500):
+    z = C()
+    z.a = i
+    z.b = [i, i + 1]
+    kept.append(z)
+
+i = 0
+for z in kept:
+    assert z.a == i
+    assert z.b == [i, i + 1]
+    assert unset_raises(z, "c")
+    i += 1
+
+print("slots_uninitialised: ok")
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 7598e9ed..30a2f66e 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,12 +1,108 @@
 set(AST_SOURCE_FILES # cmake-format: sortable
-                     ast/AST.cpp ast/ASTArena.cpp)
+                     core.cpp memory/allocate.cpp)
 
 set(BYTECODE_SOURCE_FILES
     # cmake-format: sortable
-    executable/bytecode/Bytecode.cpp
+    executable/bytecode/Bytecode.cpp)
+
+set(EXECUTABLE_SOURCE_FILES # cmake-format: sortable
+                            executable/Program.cpp)
+
+set(LEXER_SOURCE_FILES "")
+
+set(LLVM_BACKEND_FILES # cmake-format: sortable
+                       executable/llvm/LLVMGenerator.cpp executable/llvm/LLVMProgram.cpp)
+
+set(INTERPRETER_SOURCE_FILES # cmake-format: sortable
+                             interpreter/Interpreter.cpp)
+
+set(MEMORY_SOURCE_FILES # cmake-format: sortable
+                        memory/GarbageCollector.cpp memory/Heap.cpp)
+
+set(PARSER_SOURCE_FILES "")
+
+# The Python standard library implemented in C++, plus the runtime types that are
+# not `py.runtime` partitions yet. These are ordinary consumers - they import the
+# module but define nothing belonging to it - so they build in python-cpp.
+set(STDLIB_SOURCE_FILES
+    # cmake-format: sortable
+    runtime/AssertionError.cpp
+    runtime/AttributeError.cpp
+    runtime/Exception.cpp
+    runtime/Import.cpp
+    runtime/ImportError.cpp
+    runtime/IndexError.cpp
+    runtime/KeyError.cpp
+    runtime/LookupError.cpp
+    runtime/MemoryError.cpp
+    runtime/ModuleNotFoundError.cpp
+    runtime/NameError.cpp
+    runtime/NotImplemented.cpp
+    runtime/NotImplementedError.cpp
+    runtime/OSError.cpp
+    runtime/PyBool.cpp
+    runtime/PyBoundMethod.cpp
+    runtime/PyBuiltInMethod.cpp
+    runtime/PyByteArray.cpp
+    runtime/PyBytes.cpp
+    runtime/PyClassMethod.cpp
+    runtime/PyClassMethodDescriptor.cpp
+    runtime/PyComplex.cpp
+    runtime/PyEllipsis.cpp
+    runtime/PyEnumerate.cpp
+    runtime/PyGenericAlias.cpp
+    runtime/PyGetSetDescriptor.cpp
+    runtime/PyIterator.cpp
+    runtime/PyLLVMFunction.cpp
+    runtime/PyMap.cpp
+    runtime/PyMappingProxy.cpp
+    runtime/PyMemberDescriptor.cpp
+    runtime/PyMemoryView.cpp
+    runtime/PyMethodDescriptor.cpp
+    runtime/PyModule.cpp
+    runtime/PyNamespace.cpp
+    runtime/PyProperty.cpp
+    runtime/PyRange.cpp
+    runtime/PyReversed.cpp
+    runtime/PySet.cpp
+    runtime/PySlice.cpp
+    runtime/PySlotWrapper.cpp
+    runtime/PyStaticMethod.cpp
+    runtime/PySuper.cpp
+    runtime/PyZip.cpp
+    runtime/RuntimeError.cpp
+    runtime/SourceManager.cpp
+    runtime/StopIteration.cpp
+    runtime/SyntaxError.cpp
+    runtime/TypeError.cpp
+    runtime/UnboundLocalError.cpp
+    runtime/ValueError.cpp
+    runtime/warnings/DeprecationWarning.cpp
+    runtime/warnings/ImportWarning.cpp
+    runtime/warnings/PendingDeprecationWarning.cpp
+    runtime/warnings/ResourceWarning.cpp)
+
+# Translation units belonging to the `py.runtime` module: the .cpp counterparts of
+# the interface partitions listed in python-runtime's FILE_SET. Each defines members
+# of a module-owned class, so it must be an implementation unit (`module py.runtime;`)
+# compiled in python-runtime - a definition has to share its declaration's module
+# attachment, and a plain TU elsewhere is rejected with
+# "redeclaring ... in global module conflicts with import".
+set(RUNTIME_SOURCE_FILES
+    # cmake-format: sortable
+    ast/AST.cpp
+    ast/ASTArena.cpp
+    executable/bytecode/instructions/Instructions.cpp
     executable/bytecode/BytecodeProgram.cpp
-    executable/bytecode/codegen/BytecodeGenerator.cpp
-    executable/bytecode/codegen/VariablesResolver.cpp
+    runtime/warnings/Warning.cpp
+    runtime/modules/BuiltinsModule.cpp
+    runtime/modules/CodecsModule.cpp
+    runtime/modules/GcModule.cpp
+    runtime/modules/IOModule.cpp
+    runtime/modules/ImpModule.cpp
+    runtime/modules/SysModule.cpp
+    executable/Mangler.cpp
+    parser/Parser.cpp
     executable/bytecode/instructions/BinaryOperation.cpp
     executable/bytecode/instructions/BinarySubscript.cpp
     executable/bytecode/instructions/BuildDict.cpp
@@ -36,7 +132,6 @@ set(BYTECODE_SOURCE_FILES
     executable/bytecode/instructions/GetIter.cpp
     executable/bytecode/instructions/GetYieldFromIter.cpp
     executable/bytecode/instructions/InplaceOp.cpp
-    executable/bytecode/instructions/Instructions.cpp
     executable/bytecode/instructions/ImportFrom.cpp
     executable/bytecode/instructions/ImportName.cpp
     executable/bytecode/instructions/ImportStar.cpp
@@ -89,39 +184,8 @@ set(BYTECODE_SOURCE_FILES
     executable/bytecode/instructions/YieldFrom.cpp
     executable/bytecode/instructions/YieldLoad.cpp
     executable/bytecode/instructions/YieldValue.cpp
-    executable/Mangler.cpp)
-
-set(EXECUTABLE_SOURCE_FILES # cmake-format: sortable
-                            executable/Program.cpp)
-
-set(LEXER_SOURCE_FILES # cmake-format: sortable
-                       lexer/Lexer.cpp)
-
-set(LLVM_BACKEND_FILES # cmake-format: sortable
-                       executable/llvm/LLVMGenerator.cpp executable/llvm/LLVMProgram.cpp)
-
-set(INTERPRETER_SOURCE_FILES
-    # cmake-format: sortable
-    interpreter/Interpreter.cpp interpreter/InterpreterSession.cpp)
-
-set(MEMORY_SOURCE_FILES # cmake-format: sortable
-                        memory/GarbageCollector.cpp memory/Heap.cpp)
-
-set(PARSER_SOURCE_FILES # cmake-format: sortable
-                        parser/Parser.cpp)
-
-set(RUNTIME_SOURCE_FILES
-    # cmake-format: sortable
-    runtime/CustomPyObject.cpp
-    runtime/modules/BuiltinsModule.cpp
-    runtime/modules/CodecsModule.cpp
-    runtime/modules/ImpModule.cpp
-    runtime/modules/IOModule.cpp
-    runtime/modules/collections/module.cpp
-    runtime/modules/collections/Deque.cpp
     runtime/modules/collections/DefaultDict.cpp
-    runtime/modules/errno/module.cpp
-    runtime/modules/itertools/module.cpp
+    runtime/modules/collections/Deque.cpp
     runtime/modules/itertools/Chain.cpp
     runtime/modules/itertools/Count.cpp
     runtime/modules/itertools/ISlice.cpp
@@ -129,102 +193,52 @@ set(RUNTIME_SOURCE_FILES
     runtime/modules/itertools/Product.cpp
     runtime/modules/itertools/Repeat.cpp
     runtime/modules/itertools/StarMap.cpp
-    runtime/modules/math/module.cpp
-    runtime/modules/signal/module.cpp
-    runtime/modules/thread/module.cpp
-    runtime/modules/time/module.cpp
-    runtime/modules/weakref/module.cpp
+    runtime/modules/sre/Match.cpp
+    runtime/modules/sre/Pattern.cpp
     runtime/modules/weakref/PyCallableProxyType.cpp
     runtime/modules/weakref/PyWeakProxy.cpp
     runtime/modules/weakref/PyWeakRef.cpp
     runtime/modules/MarshalModule.cpp
     runtime/modules/PosixModule.cpp
+    runtime/modules/WarningsModule.cpp
+    runtime/modules/collections/module.cpp
+    runtime/modules/errno/module.cpp
+    runtime/modules/itertools/module.cpp
+    runtime/modules/math/module.cpp
+    runtime/modules/signal/module.cpp
     runtime/modules/sre/module.cpp
-    runtime/modules/sre/Match.cpp
-    runtime/modules/sre/Pattern.cpp
     runtime/modules/struct/module.cpp
-    runtime/modules/SysModule.cpp
-    runtime/modules/WarningsModule.cpp
-    runtime/modules/GcModule.cpp
-    runtime/types/builtin.cpp
-    runtime/warnings/DeprecationWarning.cpp
-    runtime/warnings/ImportWarning.cpp
-    runtime/warnings/PendingDeprecationWarning.cpp
-    runtime/warnings/ResourceWarning.cpp
-    runtime/warnings/Warning.cpp
-    runtime/AssertionError.cpp
-    runtime/AttributeError.cpp
+    runtime/modules/thread/module.cpp
+    runtime/modules/time/module.cpp
+    runtime/modules/weakref/module.cpp
+    executable/bytecode/codegen/BytecodeGenerator.cpp
+    executable/bytecode/codegen/VariablesResolver.cpp
+    lexer/Lexer.cpp
+    interpreter/InterpreterSession.cpp
     runtime/BaseException.cpp
-    runtime/Exception.cpp
     runtime/GeneratorInterface.cpp
-    runtime/IndexError.cpp
-    runtime/Import.cpp
-    runtime/ImportError.cpp
-    runtime/KeyError.cpp
-    runtime/LookupError.cpp
-    runtime/MemoryError.cpp
-    runtime/ModuleNotFoundError.cpp
-    runtime/NameError.cpp
-    runtime/NotImplemented.cpp
-    runtime/NotImplementedError.cpp
-    runtime/OSError.cpp
     runtime/PyAsyncGenerator.cpp
-    runtime/PyBoundMethod.cpp
-    runtime/PyBool.cpp
-    runtime/PyBuiltInMethod.cpp
-    runtime/PyBytes.cpp
-    runtime/PyByteArray.cpp
     runtime/PyCell.cpp
-    runtime/PyClassMethod.cpp
-    runtime/PyClassMethodDescriptor.cpp
     runtime/PyCode.cpp
-    runtime/PyComplex.cpp
     runtime/PyCoroutine.cpp
     runtime/PyDict.cpp
-    runtime/PyEllipsis.cpp
-    runtime/PyEnumerate.cpp
     runtime/PyFloat.cpp
     runtime/PyFrame.cpp
     runtime/PyFrozenSet.cpp
     runtime/PyFunction.cpp
     runtime/PyGenerator.cpp
-    runtime/PyGenericAlias.cpp
-    runtime/PyGetSetDescriptor.cpp
     runtime/PyInteger.cpp
-    runtime/PyIterator.cpp
     runtime/PyList.cpp
-    runtime/PyLLVMFunction.cpp
-    runtime/PyMap.cpp
-    runtime/PyMappingProxy.cpp
-    runtime/PyMemberDescriptor.cpp
-    runtime/PyMemoryView.cpp
-    runtime/PyMethodDescriptor.cpp
-    runtime/PyModule.cpp
-    runtime/PyNamespace.cpp
     runtime/PyNone.cpp
     runtime/PyNumber.cpp
     runtime/PyObject.cpp
-    runtime/PyProperty.cpp
-    runtime/PyRange.cpp
-    runtime/PyReversed.cpp
-    runtime/PySet.cpp
-    runtime/PySlice.cpp
-    runtime/PySlotWrapper.cpp
     runtime/PyString.cpp
-    runtime/PySuper.cpp
-    runtime/PyStaticMethod.cpp
     runtime/PyTraceback.cpp
     runtime/PyTuple.cpp
     runtime/PyType.cpp
-    runtime/PyZip.cpp
-    runtime/RuntimeError.cpp
-    runtime/SourceManager.cpp
-    runtime/StopIteration.cpp
-    runtime/SyntaxError.cpp
-    runtime/TypeError.cpp
-    runtime/UnboundLocalError.cpp
     runtime/Value.cpp
-    runtime/ValueError.cpp)
+    runtime/types/builtin.cpp
+)
 
 set(VM_SOURCE_FILES # cmake-format: sortable
                     vm/VM.cpp)
@@ -245,6 +259,7 @@ set(UNITTEST_SOURCES
     runtime/PyString_tests.cpp
     runtime/PyType_tests.cpp
     runtime/SourceManager_tests.cpp
+    runtime/warnings/Warnings_tests.cpp
     testing/main.cpp)
 
 set(PYTHON_LIB_PATH ${cpython_SOURCE_DIR}/Lib)
@@ -252,22 +267,171 @@ set(PYTHON_INSTALL_PATH ${CMAKE_INSTALL_PREFIX})
 
 configure_file(runtime/modules/paths.hpp.in runtime/modules/paths.hpp)
 
-add_library(
-  python-cpp
-  ${AST_SOURCE_FILES}
-  ${BYTECODE_SOURCE_FILES}
-  ${EXECUTABLE_SOURCE_FILES}
-  ${LEXER_SOURCE_FILES}
-  ${INTERPRETER_SOURCE_FILES}
-  ${MEMORY_SOURCE_FILES}
-  ${PARSER_SOURCE_FILES}
-  ${RUNTIME_SOURCE_FILES}
-  ${VM_SOURCE_FILES})
+# ---------------------------------------------------------------------------
+# python-runtime: the sole provider of the `py.runtime` module.
+# ---------------------------------------------------------------------------
+add_library(python-runtime)
+set_target_properties(python-runtime PROPERTIES CXX_SCAN_FOR_MODULES ON CXX_MODULE_STD ON)
+
+target_sources(python-runtime
+  PUBLIC
+    FILE_SET CXX_MODULES
+    FILES
+      executable/Function.cppm
+      executable/FunctionBlock.cppm
+      executable/Program.cppm
+      executable/bytecode/Bytecode.cppm
+      executable/bytecode/BytecodeProgram.cppm
+      executable/bytecode/codegen/codegen.cppm
+      executable/bytecode/codegen/VariablesResolver.cppm
+      executable/bytecode/codegen/BytecodeGenerator.cppm
+      memory/memory.cppm
+      memory/GarbageCollector.cppm
+      memory/Heap.cppm
+      lexer/Lexer.cppm
+      ast/ASTArena.cppm
+      ast/AST.cppm
+      interpreter/Interpreter.cppm
+      interpreter/InterpreterSession.cppm
+      runtime/runtime.cppm
+      executable/bytecode/instructions/Instructions.cppm
+      runtime/Klass.cppm
+      runtime/AssertionError.cppm
+      runtime/AttributeError.cppm
+      runtime/ImportError.cppm
+      runtime/IndexError.cppm
+      runtime/LookupError.cppm
+      runtime/MemoryError.cppm
+      runtime/ModuleNotFoundError.cppm
+      runtime/NotImplemented.cppm
+      runtime/NotImplementedError.cppm
+      runtime/OSError.cppm
+      runtime/PyArgParser.cppm
+      runtime/PyBoundMethod.cppm
+      runtime/PyBuiltInMethod.cppm
+      runtime/PyByteArray.cppm
+      runtime/PyBytes.cppm
+      runtime/PyClassMethod.cppm
+      runtime/PyClassMethodDescriptor.cppm
+      runtime/PyComplex.cppm
+      runtime/PyEllipsis.cppm
+      runtime/PyEnumerate.cppm
+      runtime/PyGenericAlias.cppm
+      runtime/PyGetSetDescriptor.cppm
+      runtime/PyIterator.cppm
+      runtime/PyLLVMFunction.cppm
+      runtime/PyMap.cppm
+      runtime/PyMappingProxy.cppm
+      runtime/PyMemberDescriptor.cppm
+      runtime/PyMemoryView.cppm
+      runtime/PyMethodDescriptor.cppm
+      runtime/PyNamespace.cppm
+      runtime/PyProperty.cppm
+      runtime/PyRange.cppm
+      runtime/PyReversed.cppm
+      runtime/PySet.cppm
+      runtime/PySlice.cppm
+      runtime/PySlotWrapper.cppm
+      runtime/PyStaticMethod.cppm
+      runtime/PySuper.cppm
+      runtime/PyZip.cppm
+      runtime/RuntimeError.cppm
+      runtime/StopIteration.cppm
+      runtime/SyntaxError.cppm
+      runtime/TypeError.cppm
+      runtime/UnboundLocalError.cppm
+      runtime/ValueError.cppm
+      runtime/utilities.cppm
+      runtime/warnings/DeprecationWarning.cppm
+      runtime/warnings/ImportWarning.cppm
+      runtime/warnings/PendingDeprecationWarning.cppm
+      runtime/warnings/ResourceWarning.cppm
+      runtime/warnings/Warning.cppm
+      runtime/modules/Modules.cppm
+      runtime/BaseException.cppm
+      runtime/concepts.cppm
+      runtime/Exception.cppm
+      runtime/GeneratorInterface.cppm
+      runtime/Import.cppm
+      runtime/KeyError.cppm
+      runtime/NameError.cppm
+      runtime/PyAsyncGenerator.cppm
+      runtime/PyBool.cppm
+      runtime/PyCell.cppm
+      runtime/PyCode.cppm
+      runtime/PyCoroutine.cppm
+      runtime/PyDict.cppm
+      runtime/PyFloat.cppm
+      runtime/PyFrame.cppm
+      runtime/PyFrozenSet.cppm
+      runtime/PyFunction.cppm
+      runtime/PyGenerator.cppm
+      runtime/PyInteger.cppm
+      runtime/PyList.cppm
+      runtime/PyModule.cppm
+      runtime/PyNone.cppm
+      runtime/PyNumber.cppm
+      runtime/PyObject.cppm
+      runtime/PyString.cppm
+      runtime/PyTraceback.cppm
+      runtime/PyTuple.cppm
+      runtime/PyType.cppm
+      runtime/Value.cppm
+      vm/VM.cppm
+      executable/Mangler.cppm
+      parser/Parser.cppm
+      runtime/types/types.cppm
+      runtime/types/builtin.cppm
+      runtime/types/api.cppm
+  PRIVATE
+    ${EXECUTABLE_SOURCE_FILES}
+    ${INTERPRETER_SOURCE_FILES}
+    ${MEMORY_SOURCE_FILES}
+    ${RUNTIME_SOURCE_FILES}
+)
+
+target_include_directories(python-runtime
+  PUBLIC .
+  PRIVATE ${GMP_INCLUDES} ${CMAKE_CURRENT_BINARY_DIR}
+)
+
+# Value.cppm exposes mpz_class through py::Number, so GMP is a usage requirement
+# of the module interface rather than an implementation detail.
+target_link_libraries(python-runtime
+  PUBLIC spdlog m ${GMPXX_LIBRARIES} ${GMP_LIBRARIES}
+  PRIVATE ICU::uc ICU::data tsl::ordered_map
+)
+
+if(STL_SUPPORTS_BIT_CAST)
+  target_compile_definitions(python-runtime PUBLIC "STL_SUPPORTS_BIT_CAST")
+endif()
+
+python_cpp_link_project_options(python-runtime)
+
+# ---------------------------------------------------------------------------
+# python-cpp: everything that is not a `py.runtime` module unit. It consumes the
+# module, so it still needs scanning, but it provides no modules of its own.
+# ---------------------------------------------------------------------------
+add_library(python-cpp)
+set_target_properties(python-cpp PROPERTIES CXX_SCAN_FOR_MODULES ON CXX_MODULE_STD ON)
+
+target_sources(python-cpp
+  PRIVATE
+    ${AST_SOURCE_FILES}
+    ${BYTECODE_SOURCE_FILES}
+    ${LEXER_SOURCE_FILES}
+    ${PARSER_SOURCE_FILES}
+    ${STDLIB_SOURCE_FILES}
+    ${VM_SOURCE_FILES}
+)
 
 add_executable(unittests_ ${UNITTEST_SOURCES})
+set_target_properties(unittests_ PROPERTIES CXX_SCAN_FOR_MODULES ON CXX_MODULE_STD ON)
 
+# PUBLIC so that every consumer of python-cpp (unittests_, python, freeze, and
+# the MLIR libraries) inherits an acyclic path to the py.runtime BMIs.
 target_link_libraries(python-cpp
-  PUBLIC spdlog m
+  PUBLIC spdlog m python-runtime
   PRIVATE
     ICU::uc
     ICU::data
@@ -346,9 +510,11 @@ target_link_libraries(unittests_ PRIVATE python-cpp gtest gtest_main cxxopts tsl
 gtest_discover_tests(unittests_)
 
 add_executable(python repl/repl.cpp)
+set_target_properties(python PROPERTIES CXX_SCAN_FOR_MODULES ON CXX_MODULE_STD ON)
 target_link_libraries(python PRIVATE linenoise cxxopts python-cpp stdc++)
 
 add_executable(freeze utilities/freeze.cpp)
+set_target_properties(freeze PROPERTIES CXX_SCAN_FOR_MODULES ON CXX_MODULE_STD ON)
 target_link_libraries(freeze PRIVATE python-cpp cxxopts)
 target_include_directories(freeze SYSTEM PRIVATE ${MLIR_INCLUDE_DIRS})
 
diff --git a/src/ast/AST.cpp b/src/ast/AST.cpp
index 218e7bdd..ada22803 100644
--- a/src/ast/AST.cpp
+++ b/src/ast/AST.cpp
@@ -1,7 +1,11 @@
-#include "AST.hpp"
+module;
+#include "ast/ASTNodeTypes.hpp"
+#include "core.hpp"
+#include <gmpxx.h>
 
-#include "runtime/PyObject.hpp"
-#include "runtime/Value.hpp"
+
+module py.ast;
+import py.runtime;
 
 namespace ast {
 
@@ -786,245 +790,272 @@ std::vector<ASTNode *> NodeTransformVisitor::visit(SetComp * node)
 #endif
 
 Constant::Constant(double value, SourceLocation source_location)
-	: ASTNode(ASTNodeType::Constant, source_location),
-	  m_value(std::make_unique<py::Value>(py::Number{ value }))
+	: ASTNode(ASTNodeType::Constant, source_location), m_value(value)
 {}
 
-Constant::Constant(int64_t value, SourceLocation source_location)
-	: ASTNode(ASTNodeType::Constant, source_location),
-	  m_value(std::make_unique<py::Value>(py::Number{ value }))
+Constant::Constant(std::int64_t value, SourceLocation source_location)
+	: ASTNode(ASTNodeType::Constant, source_location), m_value(value)
 {}
 
 Constant::Constant(mpz_class value, SourceLocation source_location)
-	: ASTNode(ASTNodeType::Constant, source_location),
-	  m_value(std::make_unique<py::Value>(py::Number{ value }))
+	: ASTNode(ASTNodeType::Constant, source_location), m_value(value)
 {}
 
 Constant::Constant(bool value, SourceLocation source_location)
-	: ASTNode(ASTNodeType::Constant, source_location),
-	  m_value(std::make_unique<py::Value>(py::NameConstant{ value }))
+	: ASTNode(ASTNodeType::Constant, source_location), m_value(value)
 {}
 
 Constant::Constant(std::string value, SourceLocation source_location)
-	: ASTNode(ASTNodeType::Constant, source_location),
-	  m_value(std::make_unique<py::Value>(py::String{ std::move(value) }))
+	: ASTNode(ASTNodeType::Constant, source_location), m_value(std::move(value))
+{}
+
+Constant::Constant(Bytes value, SourceLocation source_location)
+	: ASTNode(ASTNodeType::Constant, source_location), m_value(std::move(value))
 {}
 
 Constant::Constant(const char *value, SourceLocation source_location)
-	: ASTNode(ASTNodeType::Constant, source_location),
-	  m_value(std::make_unique<py::Value>(py::String{ std::string(value) }))
+	: ASTNode(ASTNodeType::Constant, source_location), m_value(std::string(value))
 {}
 
-Constant::Constant(const py::Value &value, SourceLocation source_location)
-	: ASTNode(ASTNodeType::Constant, source_location), m_value(std::make_unique<py::Value>(value))
+Constant::Constant(const Literal &value, SourceLocation source_location)
+	: ASTNode(ASTNodeType::Constant, source_location), m_value(value)
 {}
 
 void Expression::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Expression", indent);
+	::detail::log_debug(std::format("{}Expression", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
 	m_value->print_node(new_indent);
 }
 
 void Constant::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Constant [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Constant [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
-	std::visit(overloaded{ [&indent](const py::String &value) {
-							  spdlog::debug("{}  - value: \"{}\"", indent, value.to_string());
-						  },
-				   [&indent](const auto &value) {
-					   spdlog::debug("{}  - value: {}", indent, value.to_string());
+		source_location().end.column + 1)
+			.c_str());
+	// Literal is a plain variant of C++ types now - the AST no longer stores a
+	// py::Value - so the alternatives are formatted directly.
+	std::visit(
+		overloaded{ [&indent](std::monostate) {
+					   ::detail::log_debug(std::format("{}  - value: <none>", indent).c_str());
 				   },
-				   [&indent](py::PyObject *const value) {
-					   spdlog::debug("{}  - value: {}", indent, value->to_string());
-				   } },
-		*m_value);
+			[&indent](const std::string &value) {
+				::detail::log_debug(std::format("{}  - value: \"{}\"", indent, value).c_str());
+			},
+			[&indent](EllipsisType) {
+				::detail::log_debug(std::format("{}  - value: ...", indent).c_str());
+			},
+			[&indent](const Bytes &value) {
+				::detail::log_debug(
+					std::format("{}  - value: <{} bytes>", indent, value.size()).c_str());
+			},
+			[&indent](const mpz_class &value) {
+				::detail::log_debug(
+					std::format("{}  - value: {}", indent, value.get_str()).c_str());
+			},
+			[&indent](const auto &value) {
+				::detail::log_debug(std::format("{}  - value: {}", indent, value).c_str());
+			} },
+		m_value);
 }
 
 void List::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}List [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}List [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
-	spdlog::debug("{}  context: {}", indent, static_cast<int>(m_ctx));
-	spdlog::debug("{}  elements:", indent);
+		source_location().end.column + 1)
+			.c_str());
+	::detail::log_debug(std::format("{}  context: {}", indent, static_cast<int>(m_ctx)).c_str());
+	::detail::log_debug(std::format("{}  elements:", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
 	for (const auto &el : m_elements) { el->print_node(new_indent); }
 }
 
 void Tuple::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Tuple [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Tuple [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
-	spdlog::debug("{}  context: {}", indent, static_cast<int>(m_ctx));
-	spdlog::debug("{}  elements:", indent);
+		source_location().end.column + 1)
+			.c_str());
+	::detail::log_debug(std::format("{}  context: {}", indent, static_cast<int>(m_ctx)).c_str());
+	::detail::log_debug(std::format("{}  elements:", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
 	for (const auto &el : m_elements) { el->print_node(new_indent); }
 }
 
 void Dict::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Dict [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Dict [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
-	spdlog::debug("{}  keys:", indent);
+		source_location().end.column + 1)
+			.c_str());
+	::detail::log_debug(std::format("{}  keys:", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
 	for (const auto &el : m_keys) {
 		if (!el) {
-			spdlog::debug("{}None", new_indent);
+			::detail::log_debug(std::format("{}None", new_indent).c_str());
 		} else {
 			el->print_node(new_indent);
 		}
 	}
-	spdlog::debug("{}  values:", indent);
+	::detail::log_debug(std::format("{}  values:", indent).c_str());
 	for (const auto &el : m_values) { el->print_node(new_indent); }
 }
 
 void Set::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Set [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Set [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
-	spdlog::debug("{}  context: {}", indent, static_cast<int>(m_ctx));
-	spdlog::debug("{}  elements:", indent);
+		source_location().end.column + 1)
+			.c_str());
+	::detail::log_debug(std::format("{}  context: {}", indent, static_cast<int>(m_ctx)).c_str());
+	::detail::log_debug(std::format("{}  elements:", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
 	for (const auto &el : m_elements) { el->print_node(new_indent); }
 }
 
 void Name::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Name [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Name [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
-	spdlog::debug("{}  - id: \"{}\"", indent, m_id[0]);
-	spdlog::debug("{}  - context_type: {}", indent, static_cast<int>(m_ctx));
+		source_location().end.column + 1)
+			.c_str());
+	::detail::log_debug(std::format("{}  - id: \"{}\"", indent, m_id[0]).c_str());
+	::detail::log_debug(
+		std::format("{}  - context_type: {}", indent, static_cast<int>(m_ctx)).c_str());
 }
 
 void Assign::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Assign [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Assign [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
-	spdlog::debug("{}  - targets:", indent);
+		source_location().end.column + 1)
+			.c_str());
+	::detail::log_debug(std::format("{}  - targets:", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
 	for (const auto &t : m_targets) { t->print_node(new_indent); }
-	spdlog::debug("{}  - value:", indent);
+	::detail::log_debug(std::format("{}  - value:", indent).c_str());
 	m_value->print_node(new_indent);
-	spdlog::debug("{}  - comment type: {}", indent, m_type_comment);
+	::detail::log_debug(std::format("{}  - comment type: {}", indent, m_type_comment).c_str());
 }
 
 void BinaryExpr::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}BinaryOp [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}BinaryOp [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
-	spdlog::debug("{}  - op_type: {}", indent, stringify_binary_op(m_op_type));
-	spdlog::debug("{}  - lhs:", indent);
+		source_location().end.column + 1)
+			.c_str());
+	::detail::log_debug(
+		std::format("{}  - op_type: {}", indent, stringify_binary_op(m_op_type)).c_str());
+	::detail::log_debug(std::format("{}  - lhs:", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
 	m_lhs->print_node(new_indent);
-	spdlog::debug("{}  - rhs:", indent);
+	::detail::log_debug(std::format("{}  - rhs:", indent).c_str());
 	m_rhs->print_node(new_indent);
 }
 
 void AugAssign::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}AugAssign [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}AugAssign [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - target:", indent);
+	::detail::log_debug(std::format("{}  - target:", indent).c_str());
 	m_target->print_node(new_indent);
-	spdlog::debug("{}  - op: {}", indent, stringify_binary_op(m_op));
-	spdlog::debug("{}  - value:", indent);
+	::detail::log_debug(std::format("{}  - op: {}", indent, stringify_binary_op(m_op)).c_str());
+	::detail::log_debug(std::format("{}  - value:", indent).c_str());
 	m_value->print_node(new_indent);
 }
 
 void Return::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Return [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Return [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
-	spdlog::debug("{}  - value: {}", indent, m_value ? "" : "null");
+		source_location().end.column + 1)
+			.c_str());
+	::detail::log_debug(std::format("{}  - value: {}", indent, m_value ? "" : "null").c_str());
 	std::string new_indent = indent + std::string(6, ' ');
 	if (m_value) { m_value->print_node(new_indent); }
 }
 
 void Yield::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Yield [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Yield [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
-	spdlog::debug("{}  - value:", indent);
+		source_location().end.column + 1)
+			.c_str());
+	::detail::log_debug(std::format("{}  - value:", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
 	m_value->print_node(new_indent);
 }
 
 void YieldFrom::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}YieldFrom [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}YieldFrom [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
-	spdlog::debug("{}  - value:", indent);
+		source_location().end.column + 1)
+			.c_str());
+	::detail::log_debug(std::format("{}  - value:", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
 	m_value->print_node(new_indent);
 }
 
 void Argument::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Argument [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Argument [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
-	spdlog::debug("{}  - arg: {}", indent, m_arg);
+		source_location().end.column + 1)
+			.c_str());
+	::detail::log_debug(std::format("{}  - arg: {}", indent, m_arg).c_str());
 	if (m_annotation) {
-		spdlog::debug("{}  - annotation:", indent);
+		::detail::log_debug(std::format("{}  - annotation:", indent).c_str());
 		std::string new_indent = indent + std::string(6, ' ');
 		m_annotation->print_node(new_indent);
 	} else {
-		spdlog::debug("{}  - annotation: None", indent);
+		::detail::log_debug(std::format("{}  - annotation: None", indent).c_str());
 	}
-	spdlog::debug("{}  - type_comment: {}", indent, m_type_comment);
+	::detail::log_debug(std::format("{}  - type_comment: {}", indent, m_type_comment).c_str());
 }
 
 std::vector<std::string> Arguments::argument_names() const
@@ -1045,244 +1076,256 @@ std::vector<std::string> Arguments::kw_only_argument_names() const
 
 void Arguments::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Arguments [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Arguments [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	std::string new_indent = indent + std::string(6, ' ');
 
-	spdlog::debug("{}  - posonlyarg:", indent);
+	::detail::log_debug(std::format("{}  - posonlyarg:", indent).c_str());
 	for (const auto &arg : m_posonlyargs) { arg->print_node(new_indent); }
-	spdlog::debug("{}  - args:", indent);
+	::detail::log_debug(std::format("{}  - args:", indent).c_str());
 	for (const auto &arg : m_args) { arg->print_node(new_indent); }
-	spdlog::debug("{}  - vararg:", indent);
+	::detail::log_debug(std::format("{}  - vararg:", indent).c_str());
 	if (m_vararg) { m_vararg->print_node(new_indent); }
-	spdlog::debug("{}  - kwonlyargs:", indent);
+	::detail::log_debug(std::format("{}  - kwonlyargs:", indent).c_str());
 	for (const auto &kwarg : m_kwonlyargs) { kwarg->print_node(new_indent); }
-	spdlog::debug("{}  - kw_defaults:", indent);
+	::detail::log_debug(std::format("{}  - kw_defaults:", indent).c_str());
 	for (const auto &arg : m_kw_defaults) {
 		if (arg)
 			arg->print_node(new_indent);
 		else
-			spdlog::debug("{}null", new_indent);
+			::detail::log_debug(std::format("{}null", new_indent).c_str());
 	}
-	spdlog::debug("{}  - kwarg:", indent);
+	::detail::log_debug(std::format("{}  - kwarg:", indent).c_str());
 	if (m_kwarg) { m_kwarg->print_node(new_indent); }
-	spdlog::debug("{}  - defaults:", indent);
+	::detail::log_debug(std::format("{}  - defaults:", indent).c_str());
 	for (const auto &arg : m_defaults) {
 		if (arg)
 			arg->print_node(new_indent);
 		else
-			spdlog::debug("{}null", new_indent);
+			::detail::log_debug(std::format("{}null", new_indent).c_str());
 	}
 }
 
 void FunctionDefinition::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}FunctionDefinition [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}FunctionDefinition [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
-	spdlog::debug("{}  - function_name: {}", indent, m_function_name);
+		source_location().end.column + 1)
+			.c_str());
+	::detail::log_debug(std::format("{}  - function_name: {}", indent, m_function_name).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - args:", indent);
+	::detail::log_debug(std::format("{}  - args:", indent).c_str());
 	m_args->print_node(new_indent);
-	spdlog::debug("{}  - body:", indent);
+	::detail::log_debug(std::format("{}  - body:", indent).c_str());
 	for (const auto &statement : m_body) { statement->print_node(new_indent); }
-	spdlog::debug("{}  - decorator_list:", indent);
+	::detail::log_debug(std::format("{}  - decorator_list:", indent).c_str());
 	for (const auto &decorator : m_decorator_list) { decorator->print_node(new_indent); }
-	spdlog::debug("{}  - returns:", indent);
+	::detail::log_debug(std::format("{}  - returns:", indent).c_str());
 	if (m_returns) m_returns->print_node(new_indent);
-	spdlog::debug("{}  - type_comment:{}", indent, m_type_comment);
+	::detail::log_debug(std::format("{}  - type_comment:{}", indent, m_type_comment).c_str());
 }
 
 void AsyncFunctionDefinition::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}AsyncFunctionDefinition [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}AsyncFunctionDefinition [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
-	spdlog::debug("{}  - function_name: {}", indent, m_function_name);
+		source_location().end.column + 1)
+			.c_str());
+	::detail::log_debug(std::format("{}  - function_name: {}", indent, m_function_name).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - args:", indent);
+	::detail::log_debug(std::format("{}  - args:", indent).c_str());
 	m_args->print_node(new_indent);
-	spdlog::debug("{}  - body:", indent);
+	::detail::log_debug(std::format("{}  - body:", indent).c_str());
 	for (const auto &statement : m_body) { statement->print_node(new_indent); }
-	spdlog::debug("{}  - decorator_list:", indent);
+	::detail::log_debug(std::format("{}  - decorator_list:", indent).c_str());
 	for (const auto &decorator : m_decorator_list) { decorator->print_node(new_indent); }
-	spdlog::debug("{}  - returns:", indent);
+	::detail::log_debug(std::format("{}  - returns:", indent).c_str());
 	if (m_returns) m_returns->print_node(new_indent);
-	spdlog::debug("{}  - type_comment:{}", indent, m_type_comment);
+	::detail::log_debug(std::format("{}  - type_comment:{}", indent, m_type_comment).c_str());
 }
 
 void Await::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Await [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Await [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
-	spdlog::debug("{}  - value:", indent);
+		source_location().end.column + 1)
+			.c_str());
+	::detail::log_debug(std::format("{}  - value:", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
 	m_value->print_node(new_indent);
 }
 
 void Lambda::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Lambda [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Lambda [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - args:", indent);
+	::detail::log_debug(std::format("{}  - args:", indent).c_str());
 	m_args->print_node(new_indent);
-	spdlog::debug("{}  - body:", indent);
+	::detail::log_debug(std::format("{}  - body:", indent).c_str());
 	m_body->print_node(new_indent);
 }
 
 void Keyword::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Keyword [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Keyword [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	if (m_arg.has_value()) {
-		spdlog::debug("{}  - arg: {}", indent, *m_arg);
+		::detail::log_debug(std::format("{}  - arg: {}", indent, *m_arg).c_str());
 	} else {
-		spdlog::debug("{}  - arg: null", indent);
+		::detail::log_debug(std::format("{}  - arg: null", indent).c_str());
 	}
-	spdlog::debug("{}  - value:", indent);
+	::detail::log_debug(std::format("{}  - value:", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
 	m_value->print_node(new_indent);
 }
 
 void ClassDefinition::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}ClassDefinition [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}ClassDefinition [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
-	spdlog::debug("{}  - function_name: {}", indent, m_class_name);
+		source_location().end.column + 1)
+			.c_str());
+	::detail::log_debug(std::format("{}  - function_name: {}", indent, m_class_name).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - bases:", indent);
+	::detail::log_debug(std::format("{}  - bases:", indent).c_str());
 	for (const auto &base : m_bases) { base->print_node(new_indent); }
-	spdlog::debug("{}  - keywords:", indent);
+	::detail::log_debug(std::format("{}  - keywords:", indent).c_str());
 	for (const auto &keyword : m_keywords) { keyword->print_node(new_indent); }
-	spdlog::debug("{}  - body:", indent);
+	::detail::log_debug(std::format("{}  - body:", indent).c_str());
 	for (const auto &statement : m_body) { statement->print_node(new_indent); }
-	spdlog::debug("{}  - decorator_list:", indent);
+	::detail::log_debug(std::format("{}  - decorator_list:", indent).c_str());
 	for (const auto &decorator : m_decorator_list) { decorator->print_node(new_indent); }
 }
 
 void Call::print_this_node(const std::string &indent) const
 {
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}Call [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Call [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
-	spdlog::debug("{}  - function:", indent);
+		source_location().end.column + 1)
+			.c_str());
+	::detail::log_debug(std::format("{}  - function:", indent).c_str());
 	m_function->print_node(new_indent);
-	spdlog::debug("{}  - args:", indent);
+	::detail::log_debug(std::format("{}  - args:", indent).c_str());
 	for (const auto &arg : m_args) { arg->print_node(new_indent); }
-	spdlog::debug("{}  - keywords:", indent);
+	::detail::log_debug(std::format("{}  - keywords:", indent).c_str());
 	for (const auto &keyword : m_keywords) { keyword->print_node(new_indent); }
 }
 
 void Module::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Module", indent);
-	spdlog::debug("{}  - body:", indent);
+	::detail::log_debug(std::format("{}Module", indent).c_str());
+	::detail::log_debug(std::format("{}  - body:", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
 	for (const auto &el : m_body) { el->print_node(new_indent); }
 }
 
 void If::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}If [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}If [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - test:", indent);
+	::detail::log_debug(std::format("{}  - test:", indent).c_str());
 	m_test->print_node(new_indent);
-	spdlog::debug("{}  - body:", indent);
+	::detail::log_debug(std::format("{}  - body:", indent).c_str());
 	for (const auto &el : m_body) { el->print_node(new_indent); }
-	spdlog::debug("{}  - orelse:", indent);
+	::detail::log_debug(std::format("{}  - orelse:", indent).c_str());
 	for (const auto &el : m_orelse) { el->print_node(new_indent); }
 }
 
 void For::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}For [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}For [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - target:", indent);
+	::detail::log_debug(std::format("{}  - target:", indent).c_str());
 	m_target->print_node(new_indent);
-	spdlog::debug("{}  - iter:", indent);
+	::detail::log_debug(std::format("{}  - iter:", indent).c_str());
 	m_iter->print_node(new_indent);
-	spdlog::debug("{}  - body:", indent);
+	::detail::log_debug(std::format("{}  - body:", indent).c_str());
 	for (const auto &el : m_body) { el->print_node(new_indent); }
-	spdlog::debug("{}  - orelse:", indent);
+	::detail::log_debug(std::format("{}  - orelse:", indent).c_str());
 	for (const auto &el : m_orelse) { el->print_node(new_indent); }
-	spdlog::debug("{}  - type_comment:", m_type_comment);
+	::detail::log_debug(std::format("{}  - type_comment:", m_type_comment).c_str());
 }
 
 void While::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}While [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}While [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - target:", indent);
+	::detail::log_debug(std::format("{}  - target:", indent).c_str());
 	m_test->print_node(new_indent);
-	spdlog::debug("{}  - body:", indent);
+	::detail::log_debug(std::format("{}  - body:", indent).c_str());
 	for (const auto &el : m_body) { el->print_node(new_indent); }
-	spdlog::debug("{}  - orelse:", indent);
+	::detail::log_debug(std::format("{}  - orelse:", indent).c_str());
 }
 
 void Compare::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Compare [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Compare [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - lhs:", indent);
+	::detail::log_debug(std::format("{}  - lhs:", indent).c_str());
 	m_lhs->print_node(new_indent);
-	spdlog::debug("{}  - op:", indent);
-	for (size_t i = 0; i < m_ops.size(); ++i) {
+	::detail::log_debug(std::format("{}  - op:", indent).c_str());
+	for (std::size_t i = 0; i < m_ops.size(); ++i) {
 		const auto op = op_type_to_string(m_ops[i]);
-		spdlog::debug("{}        - {}", indent, op);
+		::detail::log_debug(std::format("{}        - {}", indent, op).c_str());
 	}
-	spdlog::debug("{}  - comparators:", indent);
-	for (size_t i = 0; i < m_comparators.size(); ++i) {
+	::detail::log_debug(std::format("{}  - comparators:", indent).c_str());
+	for (std::size_t i = 0; i < m_comparators.size(); ++i) {
 		const auto &comparator = m_comparators[i];
 		comparator->print_node(new_indent);
 	}
@@ -1290,89 +1333,92 @@ void Compare::print_this_node(const std::string &indent) const
 
 void Attribute::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Attribute [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Attribute [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - value:", indent);
+	::detail::log_debug(std::format("{}  - value:", indent).c_str());
 	m_value->print_node(new_indent);
-	spdlog::debug("{}  - attr: \"{}\"", indent, m_attr);
-	spdlog::debug("{}  - ctx: {}", indent, static_cast<int>(m_ctx));
+	::detail::log_debug(std::format("{}  - attr: \"{}\"", indent, m_attr).c_str());
+	::detail::log_debug(std::format("{}  - ctx: {}", indent, static_cast<int>(m_ctx)).c_str());
 }
 
 void Import::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Import [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Import [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	for (const auto &name : m_names) {
-		spdlog::debug("{}  - alias:", indent);
-		spdlog::debug("{}        asname: {}", indent, name.asname);
-		spdlog::debug("{}        name: {}", indent, name.name);
+		::detail::log_debug(std::format("{}  - alias:", indent).c_str());
+		::detail::log_debug(std::format("{}        asname: {}", indent, name.asname).c_str());
+		::detail::log_debug(std::format("{}        name: {}", indent, name.name).c_str());
 	}
 }
 
 void ImportFrom::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}ImportFrom [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}ImportFrom [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
-	spdlog::debug("{}  - level: {}", indent, m_level);
-	spdlog::debug("{}  - module: {}", indent, m_module);
+		source_location().end.column + 1)
+			.c_str());
+	::detail::log_debug(std::format("{}  - level: {}", indent, m_level).c_str());
+	::detail::log_debug(std::format("{}  - module: {}", indent, m_module).c_str());
 	for (const auto &name : m_names) {
-		spdlog::debug("{}  - alias:", indent);
-		spdlog::debug("{}        asname: {}", indent, name.asname);
-		spdlog::debug("{}        name: {}", indent, name.name);
+		::detail::log_debug(std::format("{}  - alias:", indent).c_str());
+		::detail::log_debug(std::format("{}        asname: {}", indent, name.asname).c_str());
+		::detail::log_debug(std::format("{}        name: {}", indent, name.name).c_str());
 	}
 }
 
 void Subscript::Index::print(const std::string &indent) const
 {
-	spdlog::debug("{}Index", indent);
+	::detail::log_debug(std::format("{}Index", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - value:", indent);
+	::detail::log_debug(std::format("{}  - value:", indent).c_str());
 	value->print_node(new_indent);
 }
 
 void Subscript::Slice::print(const std::string &indent) const
 {
-	spdlog::debug("{}Slice", indent);
+	::detail::log_debug(std::format("{}Slice", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
 
 	if (lower) {
-		spdlog::debug("{}  - lower:", indent);
+		::detail::log_debug(std::format("{}  - lower:", indent).c_str());
 		lower->print_node(new_indent);
 	} else {
-		spdlog::debug("{}  - lower: null", indent);
+		::detail::log_debug(std::format("{}  - lower: null", indent).c_str());
 	}
 
 	if (upper) {
-		spdlog::debug("{}  - upper:", indent);
+		::detail::log_debug(std::format("{}  - upper:", indent).c_str());
 		upper->print_node(new_indent);
 	} else {
-		spdlog::debug("{}  - upper: null", indent);
+		::detail::log_debug(std::format("{}  - upper: null", indent).c_str());
 	}
 
 	if (step) {
-		spdlog::debug("{}  - step:", indent);
+		::detail::log_debug(std::format("{}  - step:", indent).c_str());
 		step->print_node(new_indent);
 	} else {
-		spdlog::debug("{}  - step: null", indent);
+		::detail::log_debug(std::format("{}  - step: null", indent).c_str());
 	}
 }
 
 void Subscript::ExtSlice::print(const std::string &indent) const
 {
-	spdlog::debug("{}ExtSlice", indent);
+	::detail::log_debug(std::format("{}ExtSlice", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
 	for (const auto &d : dims) {
 		std::visit([&new_indent](const auto &val) { val.print(new_indent); }, d);
@@ -1381,324 +1427,351 @@ void Subscript::ExtSlice::print(const std::string &indent) const
 
 void Subscript::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Subscript [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Subscript [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - value:", indent);
+	::detail::log_debug(std::format("{}  - value:", indent).c_str());
 	if (m_value) { m_value->print_node(new_indent); }
-	spdlog::debug("{}  - slice:", indent);
+	::detail::log_debug(std::format("{}  - slice:", indent).c_str());
 	if (m_slice) {
 		std::visit([&new_indent](const auto &val) { val.print(new_indent); }, *m_slice);
 	}
-	spdlog::debug("{}  - ctx: {}", indent, m_ctx);
+	::detail::log_debug(std::format("{}  - ctx: {}", indent, static_cast<int>(m_ctx)).c_str());
 }
 
 void Raise::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Raise [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Raise [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	std::string new_indent = indent + std::string(6, ' ');
 	if (m_exception) {
-		spdlog::debug("{}  - exception:", indent);
+		::detail::log_debug(std::format("{}  - exception:", indent).c_str());
 		m_exception->print_node(new_indent);
 	} else {
-		spdlog::debug("{}  - exception: null", indent);
+		::detail::log_debug(std::format("{}  - exception: null", indent).c_str());
 	}
 	if (m_cause) {
-		spdlog::debug("{}  - cause:", indent);
+		::detail::log_debug(std::format("{}  - cause:", indent).c_str());
 		m_cause->print_node(new_indent);
 	} else {
-		spdlog::debug("{}  - cause: null", indent);
+		::detail::log_debug(std::format("{}  - cause: null", indent).c_str());
 	}
 }
 
 void ExceptHandler::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}ExceptHandler [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}ExceptHandler [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	std::string new_indent = indent + std::string(6, ' ');
 	if (m_type) {
-		spdlog::debug("{}  - type:", indent);
+		::detail::log_debug(std::format("{}  - type:", indent).c_str());
 		m_type->print_node(new_indent);
 	} else {
-		spdlog::debug("{}  - type: null", indent);
+		::detail::log_debug(std::format("{}  - type: null", indent).c_str());
 	}
-	spdlog::debug("{}  - name: {}", indent, m_name);
-	spdlog::debug("{}  - body:", indent);
+	::detail::log_debug(std::format("{}  - name: {}", indent, m_name).c_str());
+	::detail::log_debug(std::format("{}  - body:", indent).c_str());
 	for (const auto &node : m_body) { node->print_node(new_indent); }
 }
 
 void Try::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Try [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Try [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - body:", indent);
+	::detail::log_debug(std::format("{}  - body:", indent).c_str());
 	for (const auto &node : m_body) { node->print_node(new_indent); }
-	spdlog::debug("{}  - handlers:", indent);
+	::detail::log_debug(std::format("{}  - handlers:", indent).c_str());
 	for (const auto &node : m_handlers) { node->print_node(new_indent); }
-	spdlog::debug("{}  - orelse:", indent);
+	::detail::log_debug(std::format("{}  - orelse:", indent).c_str());
 	for (const auto &node : m_orelse) { node->print_node(new_indent); }
-	spdlog::debug("{}  - finalbody:", indent);
+	::detail::log_debug(std::format("{}  - finalbody:", indent).c_str());
 	for (const auto &node : m_finalbody) { node->print_node(new_indent); }
 }
 
 void Assert::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Assert [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Assert [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - test:", indent);
+	::detail::log_debug(std::format("{}  - test:", indent).c_str());
 	m_test->print_node(new_indent);
 	if (m_msg) {
-		spdlog::debug("{}  - message:", indent);
+		::detail::log_debug(std::format("{}  - message:", indent).c_str());
 		m_msg->print_node(new_indent);
 	} else {
-		spdlog::debug("{}  - message: null", indent);
+		::detail::log_debug(std::format("{}  - message: null", indent).c_str());
 	}
 }
 
 void UnaryExpr::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}UnaryExpr [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}UnaryExpr [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - op_type: {}", indent, stringify_unary_op(m_op_type));
+	::detail::log_debug(
+		std::format("{}  - op_type: {}", indent, stringify_unary_op(m_op_type)).c_str());
 	m_operand->print_node(new_indent);
 }
 
 void BoolOp::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}BoolOp [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}BoolOp [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - op_type: {}", indent, op_type_to_string(m_op));
-	spdlog::debug("{}Values:", indent);
+	::detail::log_debug(std::format("{}  - op_type: {}", indent, op_type_to_string(m_op)).c_str());
+	::detail::log_debug(std::format("{}Values:", indent).c_str());
 	for (const auto &value : m_values) { value->print_node(new_indent); }
 }
 
-void Pass::print_this_node(const std::string &indent) const { spdlog::debug("{}Pass", indent); }
+void Pass::print_this_node(const std::string &indent) const
+{
+	::detail::log_debug(std::format("{}Pass", indent).c_str());
+}
 
 void Continue::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Continue", indent);
+	::detail::log_debug(std::format("{}Continue", indent).c_str());
 }
 
-void Break::print_this_node(const std::string &indent) const { spdlog::debug("{}Break", indent); }
+void Break::print_this_node(const std::string &indent) const
+{
+	::detail::log_debug(std::format("{}Break", indent).c_str());
+}
 
 void Global::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Global [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Global [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	for (const auto &name : m_names) { spdlog::debug("{} {}", new_indent, name); }
+	for (const auto &name : m_names) {
+		::detail::log_debug(std::format("{} {}", new_indent, name).c_str());
+	}
 }
 
 void NonLocal::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}NonLocal [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}NonLocal [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	for (const auto &name : m_names) { spdlog::debug("{} {}", new_indent, name); }
+	for (const auto &name : m_names) {
+		::detail::log_debug(std::format("{} {}", new_indent, name).c_str());
+	}
 }
 
 void Delete::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Delete [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Delete [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
-	spdlog::debug("{}  - targets", indent);
+		source_location().end.column + 1)
+			.c_str());
+	::detail::log_debug(std::format("{}  - targets", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
 	for (const auto &target : m_targets) { target->print_node(new_indent); }
 }
 
 void With::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}With [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}With [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
-	spdlog::debug("{}  - items", indent);
+		source_location().end.column + 1)
+			.c_str());
+	::detail::log_debug(std::format("{}  - items", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
 	for (const auto &item : m_items) { item->print_node(new_indent); }
-	spdlog::debug("{}  - body", indent);
+	::detail::log_debug(std::format("{}  - body", indent).c_str());
 	for (const auto &statement : m_body) { statement->print_node(new_indent); }
-	spdlog::debug("{}  - type_comment: ", indent, m_type_comment);
+	::detail::log_debug(std::format("{}  - type_comment: ", indent, m_type_comment).c_str());
 }
 
 void WithItem::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}WithItem [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}WithItem [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - context_expr", indent);
+	::detail::log_debug(std::format("{}  - context_expr", indent).c_str());
 	m_context_expr->print_node(new_indent);
-	spdlog::debug("{}  - optional_vars: ", indent);
+	::detail::log_debug(std::format("{}  - optional_vars: ", indent).c_str());
 	if (m_optional_vars) { m_optional_vars->print_node(new_indent); }
 }
 
 void IfExpr::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}IfExpr [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}IfExpr [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - test", indent);
+	::detail::log_debug(std::format("{}  - test", indent).c_str());
 	m_test->print_node(new_indent);
-	spdlog::debug("{}  - body", indent);
+	::detail::log_debug(std::format("{}  - body", indent).c_str());
 	m_body->print_node(new_indent);
-	spdlog::debug("{}  - orelse", indent);
+	::detail::log_debug(std::format("{}  - orelse", indent).c_str());
 	m_orelse->print_node(new_indent);
 }
 
 void Starred::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Starred [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}Starred [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - value", indent);
+	::detail::log_debug(std::format("{}  - value", indent).c_str());
 	m_value->print_node(new_indent);
-	spdlog::debug("{}  - context: ", indent, m_ctx);
+	::detail::log_debug(std::format("{}  - context: {}", indent, static_cast<int>(m_ctx)).c_str());
 }
 
 void NamedExpr::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}NamedExpr [{}:{}-{}:{}]",
+	::detail::log_debug(std::format("{}NamedExpr [{}:{}-{}:{}]",
 		indent,
 		source_location().start.row + 1,
 		source_location().start.column + 1,
 		source_location().end.row + 1,
-		source_location().end.column + 1);
+		source_location().end.column + 1)
+			.c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - target", indent);
+	::detail::log_debug(std::format("{}  - target", indent).c_str());
 	m_target->print_node(new_indent);
-	spdlog::debug("{}  - value: ", indent);
+	::detail::log_debug(std::format("{}  - value: ", indent).c_str());
 	m_value->print_node(new_indent);
 }
 
 void JoinedStr::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}JoinedStr", indent);
+	::detail::log_debug(std::format("{}JoinedStr", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - values: ", indent);
+	::detail::log_debug(std::format("{}  - values: ", indent).c_str());
 	for (const auto &v : m_values) { v->print_node(new_indent); }
 }
 
 void FormattedValue::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}FormattedValue", indent);
+	::detail::log_debug(std::format("{}FormattedValue", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - value: ", indent);
+	::detail::log_debug(std::format("{}  - value: ", indent).c_str());
 	m_value->print_node(new_indent);
-	spdlog::debug("{}  - conversion: ", indent, static_cast<int64_t>(m_conversion));
-	spdlog::debug("{}  - format_spec: ", indent);
+	::detail::log_debug(
+		std::format("{}  - conversion: ", indent, static_cast<std::int64_t>(m_conversion)).c_str());
+	::detail::log_debug(std::format("{}  - format_spec: ", indent).c_str());
 	if (m_format_spec) m_format_spec->print_node(new_indent);
 }
 
 void Comprehension::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}Comprehension", indent);
+	::detail::log_debug(std::format("{}Comprehension", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - target: ", indent);
+	::detail::log_debug(std::format("{}  - target: ", indent).c_str());
 	m_target->print_node(new_indent);
-	spdlog::debug("{}  - iter: ", indent);
+	::detail::log_debug(std::format("{}  - iter: ", indent).c_str());
 	m_iter->print_node(new_indent);
-	spdlog::debug("{}  - ifs: ", indent);
+	::detail::log_debug(std::format("{}  - ifs: ", indent).c_str());
 	for (const auto &if_ : m_ifs) { if_->print_node(new_indent); }
-	spdlog::debug("{}  - is_async: {}", indent, m_is_async);
+	::detail::log_debug(std::format("{}  - is_async: {}", indent, m_is_async).c_str());
 }
 
 void ListComp::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}ListComp", indent);
+	::detail::log_debug(std::format("{}ListComp", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - elt: ", indent);
+	::detail::log_debug(std::format("{}  - elt: ", indent).c_str());
 	m_elt->print_node(new_indent);
-	spdlog::debug("{}  - generators: ", indent);
+	::detail::log_debug(std::format("{}  - generators: ", indent).c_str());
 	for (const auto &generator : m_generators) { generator->print_node(new_indent); }
 }
 
 void DictComp::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}DictComp", indent);
+	::detail::log_debug(std::format("{}DictComp", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - key: ", indent);
+	::detail::log_debug(std::format("{}  - key: ", indent).c_str());
 	m_key->print_node(new_indent);
-	spdlog::debug("{}  - value: ", indent);
+	::detail::log_debug(std::format("{}  - value: ", indent).c_str());
 	m_value->print_node(new_indent);
-	spdlog::debug("{}  - generators: ", indent);
+	::detail::log_debug(std::format("{}  - generators: ", indent).c_str());
 	for (const auto &generator : m_generators) { generator->print_node(new_indent); }
 }
 
 void GeneratorExp::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}GeneratorExp", indent);
+	::detail::log_debug(std::format("{}GeneratorExp", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - elt: ", indent);
+	::detail::log_debug(std::format("{}  - elt: ", indent).c_str());
 	m_elt->print_node(new_indent);
-	spdlog::debug("{}  - generators: ", indent);
+	::detail::log_debug(std::format("{}  - generators: ", indent).c_str());
 	for (const auto &generator : m_generators) { generator->print_node(new_indent); }
 }
 
 void SetComp::print_this_node(const std::string &indent) const
 {
-	spdlog::debug("{}SetComp", indent);
+	::detail::log_debug(std::format("{}SetComp", indent).c_str());
 	std::string new_indent = indent + std::string(6, ' ');
-	spdlog::debug("{}  - elt: ", indent);
+	::detail::log_debug(std::format("{}  - elt: ", indent).c_str());
 	m_elt->print_node(new_indent);
-	spdlog::debug("{}  - generators: ", indent);
+	::detail::log_debug(std::format("{}  - generators: ", indent).c_str());
 	for (const auto &generator : m_generators) { generator->print_node(new_indent); }
 }
 }// namespace ast
diff --git a/src/ast/AST.hpp b/src/ast/AST.cppm
similarity index 93%
rename from src/ast/AST.hpp
rename to src/ast/AST.cppm
index 313ee0c7..eebf3aa4 100644
--- a/src/ast/AST.hpp
+++ b/src/ast/AST.cppm
@@ -1,23 +1,17 @@
-#pragma once
-
-#include <memory>
-#include <numeric>
-#include <optional>
-#include <stack>
-#include <string>
-#include <variant>
-#include <vector>
+module;
 
 #include <gmpxx.h>
 
-#include "ast/ASTArena.hpp"
-#include "forward.hpp"
-#include "lexer/Lexer.hpp"
-#include "utilities.hpp"
+#include "ast/ASTNodeTypes.hpp"
+#include "core.hpp"
+
+export module py.ast;
 
-#include "spdlog/spdlog.h"
+export import :arena;
+import py.lexer;
+import std;
 
-struct SourceLocation
+export struct SourceLocation
 {
 	Position start;
 	Position end;
@@ -29,75 +23,8 @@ struct SourceLocation
 	}
 };
 
-template<> struct fmt::formatter<SourceLocation>
-{
-	constexpr auto parse(format_parse_context &ctx) { return ctx.end(); }
-
-	template<typename FormatContext> auto format(const SourceLocation &sc, FormatContext &ctx)
-	{
-		return format_to(ctx.out(), "[{}-{}]", sc.start, sc.end);
-	}
-};
 
-
-namespace ast {
-
-#define AST_NODE_TYPES                       \
-	__AST_NODE_TYPE(Argument)                \
-	__AST_NODE_TYPE(Arguments)               \
-	__AST_NODE_TYPE(Attribute)               \
-	__AST_NODE_TYPE(Assign)                  \
-	__AST_NODE_TYPE(Assert)                  \
-	__AST_NODE_TYPE(AsyncFunctionDefinition) \
-	__AST_NODE_TYPE(Await)                   \
-	__AST_NODE_TYPE(AugAssign)               \
-	__AST_NODE_TYPE(Break)                   \
-	__AST_NODE_TYPE(BinaryExpr)              \
-	__AST_NODE_TYPE(BoolOp)                  \
-	__AST_NODE_TYPE(Call)                    \
-	__AST_NODE_TYPE(ClassDefinition)         \
-	__AST_NODE_TYPE(Continue)                \
-	__AST_NODE_TYPE(Compare)                 \
-	__AST_NODE_TYPE(Comprehension)           \
-	__AST_NODE_TYPE(Constant)                \
-	__AST_NODE_TYPE(Delete)                  \
-	__AST_NODE_TYPE(Dict)                    \
-	__AST_NODE_TYPE(DictComp)                \
-	__AST_NODE_TYPE(ExceptHandler)           \
-	__AST_NODE_TYPE(Expression)              \
-	__AST_NODE_TYPE(For)                     \
-	__AST_NODE_TYPE(FormattedValue)          \
-	__AST_NODE_TYPE(FunctionDefinition)      \
-	__AST_NODE_TYPE(GeneratorExp)            \
-	__AST_NODE_TYPE(Global)                  \
-	__AST_NODE_TYPE(If)                      \
-	__AST_NODE_TYPE(IfExpr)                  \
-	__AST_NODE_TYPE(Import)                  \
-	__AST_NODE_TYPE(ImportFrom)              \
-	__AST_NODE_TYPE(JoinedStr)               \
-	__AST_NODE_TYPE(Keyword)                 \
-	__AST_NODE_TYPE(Lambda)                  \
-	__AST_NODE_TYPE(List)                    \
-	__AST_NODE_TYPE(ListComp)                \
-	__AST_NODE_TYPE(Module)                  \
-	__AST_NODE_TYPE(NamedExpr)               \
-	__AST_NODE_TYPE(Name)                    \
-	__AST_NODE_TYPE(NonLocal)                \
-	__AST_NODE_TYPE(Pass)                    \
-	__AST_NODE_TYPE(Raise)                   \
-	__AST_NODE_TYPE(Return)                  \
-	__AST_NODE_TYPE(Set)                     \
-	__AST_NODE_TYPE(SetComp)                 \
-	__AST_NODE_TYPE(Starred)                 \
-	__AST_NODE_TYPE(Subscript)               \
-	__AST_NODE_TYPE(Try)                     \
-	__AST_NODE_TYPE(Tuple)                   \
-	__AST_NODE_TYPE(UnaryExpr)               \
-	__AST_NODE_TYPE(While)                   \
-	__AST_NODE_TYPE(With)                    \
-	__AST_NODE_TYPE(WithItem)                \
-	__AST_NODE_TYPE(Yield)                   \
-	__AST_NODE_TYPE(YieldFrom)
+export namespace ast {
 
 class Value
 {
@@ -135,24 +62,6 @@ enum class ContextType { LOAD = 0, STORE = 1, DELETE = 2, UNSET = 3 };
 
 struct CodeGenerator;
 
-class ASTContext
-{
-	std::stack<const Arguments *> m_local_args;
-	std::vector<const ASTNode *> m_parent_nodes;
-
-  public:
-	void push_local_args(const Arguments *args) { m_local_args.push(args); }
-	void pop_local_args() { m_local_args.pop(); }
-
-	bool has_local_args() const { return !m_local_args.empty(); }
-
-	void push_node(const ASTNode *node) { m_parent_nodes.push_back(node); }
-	void pop_node() { m_parent_nodes.pop_back(); }
-
-	const Arguments *local_args() const { return m_local_args.top(); }
-	const std::vector<const ASTNode *> &parent_nodes() const { return m_parent_nodes; }
-};
-
 class ASTNode
 {
 	const ASTNodeType m_node_type;
@@ -173,7 +82,25 @@ class ASTNode
 	const SourceLocation &source_location() const { return m_source_location; }
 
 	virtual Value *codegen(CodeGenerator *) const = 0;
-};// namespace ast
+};
+
+class ASTContext
+{
+	std::stack<const Arguments *> m_local_args;
+	std::vector<const ASTNode *> m_parent_nodes;
+
+  public:
+	void push_local_args(const Arguments *args) { m_local_args.push(args); }
+	void pop_local_args() { m_local_args.pop(); }
+
+	bool has_local_args() const { return !m_local_args.empty(); }
+
+	void push_node(const ASTNode *node) { m_parent_nodes.push_back(node); }
+	void pop_node() { m_parent_nodes.pop_back(); }
+
+	const Arguments *local_args() const { return m_local_args.top(); }
+	const std::vector<const ASTNode *> &parent_nodes() const { return m_parent_nodes; }
+};
 
 class Expression : public ASTNode
 {
@@ -191,23 +118,45 @@ class Expression : public ASTNode
 	void print_this_node(const std::string &indent) const override;
 };
 
+
+// std::vector<std::byte> rather than py::Bytes: the AST deliberately does not
+// depend on the runtime's value representation, so a bytes literal is carried
+// as raw bytes and converted in codegen.
+// Python's `...`. std::monostate already stands for None, so Ellipsis needs
+// its own alternative.
+struct EllipsisType
+{
+	bool operator==(const EllipsisType &) const = default;
+};
+
+using Bytes = std::vector<std::byte>;
+using Literal = std::variant<std::monostate,
+	bool,
+	std::int64_t,
+	mpz_class,
+	double,
+	std::string,
+	Bytes,
+	EllipsisType>;
+
 class Constant : public ASTNode
 {
-	std::unique_ptr<py::Value> m_value;
+	Literal m_value;
 
   private:
 	void print_this_node(const std::string &indent) const override;
 
   public:
 	Constant(double value, SourceLocation source_location);
-	Constant(int64_t value, SourceLocation source_location);
+	Constant(std::int64_t value, SourceLocation source_location);
 	Constant(mpz_class value, SourceLocation source_location);
 	Constant(bool value, SourceLocation source_location);
 	Constant(std::string value, SourceLocation source_location);
 	Constant(const char *value, SourceLocation source_location);
-	Constant(const py::Value &, SourceLocation source_location);
+	Constant(Bytes value, SourceLocation source_location);
+	Constant(const Literal &, SourceLocation source_location);
 
-	const py::Value *value() const { return m_value.get(); }
+	const Literal &value() const { return m_value; }
 
 	Value *codegen(CodeGenerator *) const override;
 };
@@ -1093,19 +1042,19 @@ class Import : public ImportBase
 class ImportFrom : public ImportBase
 {
 	std::string m_module;
-	size_t m_level{ 0 };
+	std::size_t m_level{ 0 };
 
   public:
 	ImportFrom(std::string module,
 		std::vector<alias> &&names,
-		size_t level,
+		std::size_t level,
 		SourceLocation source_location)
 		: ImportBase(ASTNodeType::ImportFrom, std::move(names), source_location),
 		  m_module(std::move(module)), m_level(level)
 	{}
 
 	const std::string &module() const { return m_module; }
-	size_t level() const { return m_level; }
+	std::size_t level() const { return m_level; }
 
 	Value *codegen(CodeGenerator *) const override;
 
diff --git a/src/ast/ASTArena.cpp b/src/ast/ASTArena.cpp
index 0a07a378..d56339dc 100644
--- a/src/ast/ASTArena.cpp
+++ b/src/ast/ASTArena.cpp
@@ -1,30 +1,25 @@
-#include "ast/ASTArena.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
 
-#include <algorithm>
-#include <cstdint>
+module py.ast;
 
 namespace ast {
-
 ASTArena::ASTArena() : m_next_slab_size(kInitialSlabSize) {}
-
 ASTArena::~ASTArena()
 {
 	for (auto it = m_destructors.rbegin(); it != m_destructors.rend(); ++it) { it->fn(it->object); }
 }
-
 void ASTArena::grow(std::size_t at_least)
 {
 	std::size_t size = std::max(m_next_slab_size, at_least);
 	m_slabs.push_back(Slab{ std::make_unique<std::byte[]>(size), size, 0 });
 	m_next_slab_size = size * 2;
 }
-
 void *ASTArena::allocate(std::size_t size, std::size_t alignment)
 {
 	ASSERT(alignment > 0 && (alignment & (alignment - 1)) == 0);
-
 	if (m_slabs.empty()) { grow(size + alignment); }
-
 	for (;;) {
 		Slab &slab = m_slabs.back();
 		auto base = reinterpret_cast<std::uintptr_t>(slab.data.get()) + slab.used;
@@ -37,12 +32,10 @@ void *ASTArena::allocate(std::size_t size, std::size_t alignment)
 		grow(size + alignment);
 	}
 }
-
 std::size_t ASTArena::bytes_allocated() const
 {
 	std::size_t total = 0;
 	for (const auto &slab : m_slabs) { total += slab.used; }
 	return total;
 }
-
-}// namespace ast
+}// namespace ast
\ No newline at end of file
diff --git a/src/ast/ASTArena.hpp b/src/ast/ASTArena.cppm
similarity index 88%
rename from src/ast/ASTArena.hpp
rename to src/ast/ASTArena.cppm
index 87f87d57..d5abbf0a 100644
--- a/src/ast/ASTArena.hpp
+++ b/src/ast/ASTArena.cppm
@@ -1,14 +1,11 @@
-#pragma once
+module;
 
-#include "utilities.hpp"
+#include "core.hpp"
 
-#include <cstddef>
-#include <memory>
-#include <type_traits>
-#include <utility>
-#include <vector>
+export module py.ast:arena;
+import std;
 
-namespace ast {
+export namespace ast {
 
 // Bump-pointer allocator with destructor tracking, owned by the Module.
 //
diff --git a/src/ast/ASTArena_tests.cpp b/src/ast/ASTArena_tests.cpp
index b7059c9c..c82c6337 100644
--- a/src/ast/ASTArena_tests.cpp
+++ b/src/ast/ASTArena_tests.cpp
@@ -1,10 +1,11 @@
-#include "ast/ASTArena.hpp"
 
 #include "gtest/gtest.h"
 
 #include <cstddef>
 #include <cstdint>
-#include <string>
+
+import py.ast;
+import std;
 
 namespace {
 
diff --git a/src/ast/ASTNodeTypes.hpp b/src/ast/ASTNodeTypes.hpp
new file mode 100644
index 00000000..5cbef7cc
--- /dev/null
+++ b/src/ast/ASTNodeTypes.hpp
@@ -0,0 +1,66 @@
+#pragma once
+
+// The AST node-type X-macro list.
+//
+// This lives in a plain header rather than in the py.ast module because macros
+// are never exported by a module: every consumer that expands AST_NODE_TYPES to
+// generate visitor declarations (MLIRGenerator.hpp, VariablesResolver.cppm,
+// AST.cpp, ...) has to #include it directly. py.ast includes it in its global
+// module fragment for the same reason.
+
+#define AST_NODE_TYPES                       \
+	__AST_NODE_TYPE(Argument)                \
+	__AST_NODE_TYPE(Arguments)               \
+	__AST_NODE_TYPE(Attribute)               \
+	__AST_NODE_TYPE(Assign)                  \
+	__AST_NODE_TYPE(Assert)                  \
+	__AST_NODE_TYPE(AsyncFunctionDefinition) \
+	__AST_NODE_TYPE(Await)                   \
+	__AST_NODE_TYPE(AugAssign)               \
+	__AST_NODE_TYPE(Break)                   \
+	__AST_NODE_TYPE(BinaryExpr)              \
+	__AST_NODE_TYPE(BoolOp)                  \
+	__AST_NODE_TYPE(Call)                    \
+	__AST_NODE_TYPE(ClassDefinition)         \
+	__AST_NODE_TYPE(Continue)                \
+	__AST_NODE_TYPE(Compare)                 \
+	__AST_NODE_TYPE(Comprehension)           \
+	__AST_NODE_TYPE(Constant)                \
+	__AST_NODE_TYPE(Delete)                  \
+	__AST_NODE_TYPE(Dict)                    \
+	__AST_NODE_TYPE(DictComp)                \
+	__AST_NODE_TYPE(ExceptHandler)           \
+	__AST_NODE_TYPE(Expression)              \
+	__AST_NODE_TYPE(For)                     \
+	__AST_NODE_TYPE(FormattedValue)          \
+	__AST_NODE_TYPE(FunctionDefinition)      \
+	__AST_NODE_TYPE(GeneratorExp)            \
+	__AST_NODE_TYPE(Global)                  \
+	__AST_NODE_TYPE(If)                      \
+	__AST_NODE_TYPE(IfExpr)                  \
+	__AST_NODE_TYPE(Import)                  \
+	__AST_NODE_TYPE(ImportFrom)              \
+	__AST_NODE_TYPE(JoinedStr)               \
+	__AST_NODE_TYPE(Keyword)                 \
+	__AST_NODE_TYPE(Lambda)                  \
+	__AST_NODE_TYPE(List)                    \
+	__AST_NODE_TYPE(ListComp)                \
+	__AST_NODE_TYPE(Module)                  \
+	__AST_NODE_TYPE(NamedExpr)               \
+	__AST_NODE_TYPE(Name)                    \
+	__AST_NODE_TYPE(NonLocal)                \
+	__AST_NODE_TYPE(Pass)                    \
+	__AST_NODE_TYPE(Raise)                   \
+	__AST_NODE_TYPE(Return)                  \
+	__AST_NODE_TYPE(Set)                     \
+	__AST_NODE_TYPE(SetComp)                 \
+	__AST_NODE_TYPE(Starred)                 \
+	__AST_NODE_TYPE(Subscript)               \
+	__AST_NODE_TYPE(Try)                     \
+	__AST_NODE_TYPE(Tuple)                   \
+	__AST_NODE_TYPE(UnaryExpr)               \
+	__AST_NODE_TYPE(While)                   \
+	__AST_NODE_TYPE(With)                    \
+	__AST_NODE_TYPE(WithItem)                \
+	__AST_NODE_TYPE(Yield)                   \
+	__AST_NODE_TYPE(YieldFrom)
diff --git a/src/ast/SourceLocationFormatter.hpp b/src/ast/SourceLocationFormatter.hpp
new file mode 100644
index 00000000..406a34a6
--- /dev/null
+++ b/src/ast/SourceLocationFormatter.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+// fmt formatting for ast::SourceLocation. Kept out of the py.ast module for the
+// same reason as PositionFormatter.hpp: spdlog/fmt/fmt.h drags 231 libstdc++
+// headers into the BMI, which then collide with consumers' own #includes.
+
+
+template<> struct std::formatter<SourceLocation>
+{
+	constexpr auto parse(std::format_parse_context &ctx) { return ctx.end(); }
+
+	template<typename FormatContext> auto format(const SourceLocation &sc, FormatContext &ctx) const
+	{
+		return std::format_to(ctx.out(), "[{}-{}]", sc.start, sc.end);
+	}
+};
diff --git a/src/ast/optimizers/ConstantFolding.cpp b/src/ast/optimizers/ConstantFolding.cpp
index f9a531b7..92bd8d70 100644
--- a/src/ast/optimizers/ConstantFolding.cpp
+++ b/src/ast/optimizers/ConstantFolding.cpp
@@ -1,5 +1,9 @@
-#include "ConstantFolding.hpp"
-#include "runtime/Value.hpp"
+module;
+#include "core.hpp"
+
+module py.codegen;
+import std;
+import py.ast;
 
 namespace ast {
 namespace optimizer {
diff --git a/src/ast/optimizers/ConstantFolding.hpp b/src/ast/optimizers/ConstantFolding.hpp
deleted file mode 100644
index 34edf279..00000000
--- a/src/ast/optimizers/ConstantFolding.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#pragma once
-
-#include "ast/AST.hpp"
-
-namespace ast {
-namespace optimizer {
-
-	std::shared_ptr<ASTNode> constant_folding(std::shared_ptr<ASTNode> node);
-
-}// namespace optimizer
-}// namespace ast
\ No newline at end of file
diff --git a/src/ast/optimizers/Optimizers_tests.cpp b/src/ast/optimizers/Optimizers_tests.cpp
index 824d1461..b580b41d 100644
--- a/src/ast/optimizers/Optimizers_tests.cpp
+++ b/src/ast/optimizers/Optimizers_tests.cpp
@@ -1,12 +1,9 @@
-#include "ConstantFolding.hpp"
-#include "ast/AST.hpp"
-#include "executable/Program.hpp"
-#include "parser/Parser.hpp"
-#include "runtime/Value.hpp"
-#include "utilities.hpp"
-
 #include "gtest/gtest.h"
 
+import py.lexer;
+import py.ast;
+import py.runtime;
+
 using namespace ast;
 using namespace py;
 
diff --git a/src/core.cpp b/src/core.cpp
new file mode 100644
index 00000000..c743f3e6
--- /dev/null
+++ b/src/core.cpp
@@ -0,0 +1,21 @@
+#include "core.hpp"
+
+#include "spdlog/spdlog.h"
+
+#include <cstdlib>
+
+namespace detail {
+void assertion_failed(const char *what, const char *file, int line)
+{
+	spdlog::error("{} {}:{}", what, file, line);
+	std::abort();
+}
+
+void log_debug(const char *message) { spdlog::debug("{}", message); }
+void log_trace(const char *message) { spdlog::trace("{}", message); }
+void log_error(const char *message) { spdlog::error("{}", message); }
+
+// Lets callers skip formatting entirely when debug logging is off - the
+// spdlog::debug("...", args) form did that for free.
+bool log_debug_enabled() { return spdlog::should_log(spdlog::level::debug); }
+}// namespace detail
diff --git a/src/core.hpp b/src/core.hpp
new file mode 100644
index 00000000..c1c95c89
--- /dev/null
+++ b/src/core.hpp
@@ -0,0 +1,63 @@
+#pragma once
+
+// Diagnostics macros and the two empty base classes, with no libstdc++ and no
+// spdlog behind them.
+//
+// This header exists to be safe inside a module's global module fragment.
+// Macros are never exported by a module, so any module unit that uses TODO() or
+// ASSERT() has to #include them textually - and utilities.hpp, which used to be
+// that include, drags in 272 libstdc++ headers through spdlog. Those headers
+// then land in the module's BMI and collide with the same headers #included by
+// its consumers ("redefinition of ...", "conflicting declaration of template
+// ...").  Routing the macros through an out-of-line failure function keeps the
+// formatting - and therefore spdlog - in core.cpp where it costs nothing.
+
+namespace detail {
+// Defined in core.cpp; reports through spdlog and aborts.
+[[noreturn]] void assertion_failed(const char *what, const char *file, int line);
+
+// Logging sinks. Module units cannot #include spdlog in their global module
+// fragment - its libstdc++ headers land in the BMI and collide with the
+// `import std;` the module interfaces use - so they format with std::format and
+// pass the finished string through here.
+void log_debug(const char *message);
+void log_trace(const char *message);
+void log_error(const char *message);
+bool log_debug_enabled();
+}// namespace detail
+
+#define TODO() ::detail::assertion_failed("Not implemented", __FILE__, __LINE__)
+
+#define ASSERT(condition)                                                                   \
+	do {                                                                                    \
+		if (!(condition)) {                                                                 \
+			::detail::assertion_failed("Assertion failed " #condition, __FILE__, __LINE__); \
+		}                                                                                   \
+	} while (0)
+
+#define ASSERT_NOT_REACHED() \
+	::detail::assertion_failed("Reached unexpected line", __FILE__, __LINE__)
+
+// Pure templates, no spdlog behind them - safe in a module GMF.
+template<class... Ts> struct overloaded : Ts...
+{
+	using Ts::operator()...;
+};
+// explicit deduction guide (not needed as of C++20)
+template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
+
+using Register = __UINT8_TYPE__;
+
+struct NonCopyable
+{
+	NonCopyable() = default;
+	NonCopyable(const NonCopyable &) = delete;
+	NonCopyable &operator=(const NonCopyable &) = delete;
+};
+
+struct NonMoveable
+{
+	NonMoveable() = default;
+	NonMoveable(NonMoveable &&) = delete;
+	NonMoveable &operator=(NonMoveable &&) = delete;
+};
diff --git a/src/executable/CodeFlags.hpp b/src/executable/CodeFlags.hpp
new file mode 100644
index 00000000..8794b0b5
--- /dev/null
+++ b/src/executable/CodeFlags.hpp
@@ -0,0 +1,46 @@
+#pragma once
+#include <bitset>
+#include <cstdint>
+
+
+class CodeFlags
+{
+  public:
+	enum class Flag {
+		OPTIMIZED = 0,
+		NEWLOCALS = 1,
+		VARARGS = 2,
+		VARKEYWORDS = 3,
+		NESTED = 4,
+		GENERATOR = 5,
+		COROUTINE = 6,
+		CLASS = 7,
+	};
+
+  private:
+	std::bitset<8> m_flags;
+
+	CodeFlags() = default;
+
+  public:
+	template<typename... Args>
+	// requires std::conjunction_v<std::is_same<Flag, Args>...>
+	static CodeFlags create(Args... args)
+	{
+		CodeFlags f;
+		(f.m_flags.set(static_cast<std::uint8_t>(args)), ...);
+		return f;
+	}
+
+	static CodeFlags from_byte(std::uint8_t b)
+	{
+		auto f = CodeFlags();
+		f.m_flags = std::bitset<8>(b);
+		return f;
+	}
+
+	void set(Flag f) { m_flags.set(static_cast<std::uint8_t>(f)); }
+	void reset(Flag f) { m_flags.reset(static_cast<std::uint8_t>(f)); }
+	bool is_set(Flag f) const { return m_flags[static_cast<std::uint8_t>(f)]; }
+	std::bitset<8> bits() const { return m_flags; }
+};
diff --git a/src/executable/Function.hpp b/src/executable/Function.cppm
similarity index 60%
rename from src/executable/Function.hpp
rename to src/executable/Function.cppm
index 89000db7..e9ac6789 100644
--- a/src/executable/Function.hpp
+++ b/src/executable/Function.cppm
@@ -1,23 +1,35 @@
-#pragma once
+module;
 
-#include "FunctionBlock.hpp"
+#include "core.hpp"
+#include <cstddef>
+#include <cstdint>
+
+export module py.runtime:executable_function;
+import :value;
+import std;
+
+export class Program;
+
+export class VirtualMachine;
 
 enum class FunctionExecutionBackend { BYTECODE = 0, LLVM = 1 };
 
+export class Interpreter;
+
 class Function : NonCopyable
 {
   protected:
-	size_t m_register_count;
-	size_t m_locals_count;
-	size_t m_stack_size;
+	std::size_t m_register_count;
+	std::size_t m_locals_count;
+	std::size_t m_stack_size;
 	std::string m_function_name;
 	FunctionExecutionBackend m_backend;
 	std::shared_ptr<Program> m_program;
 
   public:
-	Function(size_t register_count,
-		size_t locals_count,
-		size_t stack_size,
+	Function(std::size_t register_count,
+		std::size_t locals_count,
+		std::size_t stack_size,
 		std::string function_name,
 		FunctionExecutionBackend backend,
 		std::shared_ptr<Program> program)
@@ -26,9 +38,9 @@ class Function : NonCopyable
 	{}
 	virtual ~Function() = default;
 
-	size_t register_count() const { return m_register_count; }
-	size_t locals_count() const { return m_locals_count; }
-	size_t stack_size() const { return m_stack_size; }
+	std::size_t register_count() const { return m_register_count; }
+	std::size_t locals_count() const { return m_locals_count; }
+	std::size_t stack_size() const { return m_stack_size; }
 
 	FunctionExecutionBackend backend() const { return m_backend; }
 
@@ -36,10 +48,10 @@ class Function : NonCopyable
 
 	virtual std::string to_string() const = 0;
 
-	virtual std::vector<uint8_t> serialize() const = 0;
+	virtual std::vector<std::uint8_t> serialize() const = 0;
 
 	std::shared_ptr<Program> program() const { return m_program; }
 
 	virtual py::PyResult<py::Value> call(VirtualMachine &, Interpreter &) const = 0;
 	virtual py::PyResult<py::Value> call_without_setup(VirtualMachine &, Interpreter &) const = 0;
-};
\ No newline at end of file
+};
diff --git a/src/executable/FunctionBlock.cppm b/src/executable/FunctionBlock.cppm
new file mode 100644
index 00000000..62e79210
--- /dev/null
+++ b/src/executable/FunctionBlock.cppm
@@ -0,0 +1,54 @@
+module;
+
+#include "CodeFlags.hpp"
+
+export module py.runtime:executable_functionblock;
+import :value;
+import std;
+
+export class Instruction;
+
+
+export using InstructionVector = std::vector<std::unique_ptr<Instruction>>;
+
+export struct InstructionSourceLocation
+{
+	std::uint32_t instruction_index;
+	std::uint32_t line;
+	std::uint32_t column;
+};
+
+export struct FunctionMetaData
+{
+	std::string function_name;
+	std::size_t register_count{ 0 };
+	std::size_t stack_size{ 0 };
+	std::vector<std::string> cellvars;
+	std::vector<std::string> varnames;
+	std::vector<std::string> freevars;
+	std::vector<std::string> names;
+	std::string filename;
+	std::size_t first_line_number;
+	std::size_t arg_count;
+	std::size_t positional_arg_count;
+	std::size_t kwonly_arg_count;
+	std::size_t nlocals;
+	std::vector<std::size_t> cell2arg;
+	std::vector<py::Value> consts;
+	CodeFlags flags = CodeFlags::create();
+};
+
+export struct FunctionBlock
+{
+	FunctionMetaData metadata;
+	InstructionVector blocks;
+	std::vector<InstructionSourceLocation> instruction_locations;
+	std::string to_string() const;
+};
+
+export struct FunctionBlocks
+{
+	std::list<FunctionBlock> functions;
+
+	using FunctionType = decltype(functions)::value_type;
+};
diff --git a/src/executable/FunctionBlock.hpp b/src/executable/FunctionBlock.hpp
deleted file mode 100644
index 5e089960..00000000
--- a/src/executable/FunctionBlock.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#pragma once
-
-#include "Program.hpp"
-#include "forward.hpp"
-#include <cstdint>
-#include <list>
-#include <memory>
-#include <string>
-#include <vector>
-
-using InstructionVector = std::vector<std::unique_ptr<Instruction>>;
-
-struct InstructionSourceLocation
-{
-	uint32_t instruction_index;
-	uint32_t line;
-	uint32_t column;
-};
-
-struct FunctionMetaData
-{
-	std::string function_name;
-	size_t register_count{ 0 };
-	size_t stack_size{ 0 };
-	std::vector<std::string> cellvars;
-	std::vector<std::string> varnames;
-	std::vector<std::string> freevars;
-	std::vector<std::string> names;
-	std::string filename;
-	size_t first_line_number;
-	size_t arg_count;
-	size_t positional_arg_count;
-	size_t kwonly_arg_count;
-	size_t nlocals;
-	std::vector<size_t> cell2arg;
-	std::vector<py::Value> consts;
-	CodeFlags flags = CodeFlags::create();
-};
-
-struct FunctionBlock
-{
-	FunctionMetaData metadata;
-	InstructionVector blocks;
-	std::vector<InstructionSourceLocation> instruction_locations;
-	std::string to_string() const;
-};
-
-struct FunctionBlocks
-{
-	std::list<FunctionBlock> functions;
-
-	using FunctionType = decltype(functions)::value_type;
-};
diff --git a/src/executable/Label.hpp b/src/executable/Label.hpp
index ed1c6757..c1da2334 100644
--- a/src/executable/Label.hpp
+++ b/src/executable/Label.hpp
@@ -1,54 +1,51 @@
 #pragma once
-
-#include "utilities.hpp"
-
+#include <cstddef>
+#include <cstdint>
 #include <optional>
 #include <string>
 
-namespace codegen {
-class BytecodeGenerator;
-class PythonBytecodeEmitter;
-}// namespace codegen
+#include "core.hpp"
+
 
 class Label
 	: NonCopyable
 	, NonMoveable
 {
-	friend codegen::BytecodeGenerator;
-	friend codegen::PythonBytecodeEmitter;
-
 	std::string m_label_name;
-	size_t m_function_id;
-	mutable std::optional<int64_t> m_position;
+	std::size_t m_function_id;
+	mutable std::optional<std::int64_t> m_position;
 
-  protected:
-	void set_position(int64_t position) const
+  public:
+	// Public rather than protected + friend: the two users (BytecodeGenerator,
+	// PythonBytecodeEmitter) live in py.codegen, and naming them here would
+	// declare them in the global module.
+	void set_position(std::int64_t position) const
 	{
 		ASSERT(!m_position.has_value());
 		m_position = position;
 	}
 
   public:
-	Label(std::string name, size_t function_id)
+	Label(std::string name, std::size_t function_id)
 		: m_label_name(std::move(name)), m_function_id(function_id)
 	{}
 
-	Label(int64_t position) : m_position(position) {}
+	Label(std::int64_t position) : m_position(position) {}
 
-	int64_t position() const
+	std::int64_t position() const
 	{
 		ASSERT(m_position.has_value());
 		return *m_position;
 	}
 
-	size_t function_id() const { return m_function_id; }
+	std::size_t function_id() const { return m_function_id; }
 
 	const std::string &name() const { return m_label_name; }
 
-	size_t hash() const
+	std::size_t hash() const
 	{
-		size_t seed = std::hash<std::string>{}(m_label_name);
-		seed ^= std::hash<size_t>{}(m_function_id) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+		std::size_t seed = std::hash<std::string>{}(m_label_name);
+		seed ^= std::hash<std::size_t>{}(m_function_id) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
 		return seed;
 	}
 
diff --git a/src/executable/Mangler.cpp b/src/executable/Mangler.cpp
index b46b50b4..7ad7a6b6 100644
--- a/src/executable/Mangler.cpp
+++ b/src/executable/Mangler.cpp
@@ -1,8 +1,9 @@
-#include "Mangler.hpp"
+module;
+#include "core.hpp"
 
-#include "ast/AST.hpp"
-
-#include <string_view>
+module py.runtime;
+import std;
+import py.ast;
 
 class DefaultMangler : public Mangler
 {
@@ -11,7 +12,7 @@ class DefaultMangler : public Mangler
 		const std::string &function_name,
 		const SourceLocation &source_location) const override
 	{
-		return fmt::format("{}.{}.{}:{}",
+		return std::format("{}.{}.{}:{}",
 			module,
 			function_name,
 			source_location.start.row,
@@ -22,7 +23,7 @@ class DefaultMangler : public Mangler
 		const std::string &class_name,
 		const SourceLocation &source_location) const override
 	{
-		return fmt::format("{}.__class__{}__.{}:{}",
+		return std::format("{}.__class__{}__.{}:{}",
 			module,
 			class_name,
 			source_location.start.row,
diff --git a/src/executable/Mangler.hpp b/src/executable/Mangler.cppm
similarity index 86%
rename from src/executable/Mangler.hpp
rename to src/executable/Mangler.cppm
index 987b44bc..81c13628 100644
--- a/src/executable/Mangler.hpp
+++ b/src/executable/Mangler.cppm
@@ -1,10 +1,9 @@
-#pragma once
+export module py.runtime:mangler;
 
-#include <string>
+import std;
+import py.ast;
 
-struct SourceLocation;
-
-class Mangler
+export class Mangler
 {
   public:
 	virtual ~Mangler() = default;
@@ -22,4 +21,4 @@ class Mangler
 	virtual std::string class_demangle(const std::string &mangled_name) const = 0;
 
 	static Mangler &default_mangler();
-};
\ No newline at end of file
+};
diff --git a/src/executable/Program.cpp b/src/executable/Program.cpp
index 2e64f33c..6a92071c 100644
--- a/src/executable/Program.cpp
+++ b/src/executable/Program.cpp
@@ -1,10 +1,22 @@
-#include "Program.hpp"
-#include "executable/bytecode/codegen/BytecodeGenerator.hpp"
+module;
+#include <cstdint>
+
+#include "core.hpp"
+#include "executable/common.hpp"
+
+module py.runtime;
+import py.ast;
+import py.codegen;
+import std;
+
+// These name py:: types, so they belong in the purview where the implicit
+// import of py.runtime has already happened. Including LLVMGenerator.hpp
+// unconditionally would attach codegen::LLVMGenerator to py.runtime and pull
+// its virtual members into the vtable even though the backend is not built.
+#if defined(ENABLE_LLVM_BACKEND) && defined(LLVM_FOUND)
 #include "executable/llvm/LLVMGenerator.hpp"
-#include "executable/mlir/Dialect/Python/MLIRGenerator.hpp"
+#endif
 #include "mlir/compile.hpp"
-#include "utilities.hpp"
-
 
 Program::Program(std::string &&filename, std::vector<std::string> &&argv)
 	: m_filename(std::move(filename)), m_argv(std::move(argv))
@@ -34,4 +46,4 @@ std::shared_ptr<Program> compile(std::shared_ptr<ast::Module> node,
 	}
 	ASSERT_NOT_REACHED();
 }
-}// namespace compiler
\ No newline at end of file
+}// namespace compiler
diff --git a/src/executable/Program.cppm b/src/executable/Program.cppm
new file mode 100644
index 00000000..713c638f
--- /dev/null
+++ b/src/executable/Program.cppm
@@ -0,0 +1,59 @@
+module;
+
+#include "common.hpp"
+#include "core.hpp"
+#include "executable/CodeFlags.hpp"
+
+export module py.runtime:executable_program;
+import :object;
+import std;
+import py.ast;
+
+export namespace py {
+struct Number;
+class PyTuple;
+}// namespace py
+
+export class VirtualMachine;
+
+export class Program
+	: NonCopyable
+	, public std::enable_shared_from_this<Program>
+{
+	std::string m_filename;
+	std::vector<std::string> m_argv;
+
+  protected:
+	Program() {}
+
+  public:
+	Program(std::string &&filename, std::vector<std::string> &&argv);
+	virtual ~Program() {}
+
+	virtual int execute(VirtualMachine *) = 0;
+
+	const std::string &filename() const { return m_filename; }
+	const std::vector<std::string> &argv() const { return m_argv; }
+
+	void set_filename(std::string filename) { m_filename = std::move(filename); }
+
+	virtual std::string to_string() const = 0;
+
+	virtual py::PyObject *as_pyfunction(const std::string &function_name,
+		const std::vector<py::Value> &default_values,
+		const std::vector<py::Value> &kw_default_values,
+		py::PyTuple *closure) const = 0;
+
+	virtual py::PyObject *main_function() = 0;
+
+	virtual void visit_functions(Cell::Visitor &) const = 0;
+
+	virtual std::vector<std::uint8_t> serialize() const = 0;
+};
+
+export namespace compiler {
+std::shared_ptr<Program> compile(std::shared_ptr<ast::Module> node,
+	std::vector<std::string> argv,
+	Backend backend,
+	OptimizationLevel lvl);
+}
diff --git a/src/executable/Program.hpp b/src/executable/Program.hpp
deleted file mode 100644
index 7d721ae5..00000000
--- a/src/executable/Program.hpp
+++ /dev/null
@@ -1,97 +0,0 @@
-#pragma once
-
-#include "common.hpp"
-#include "forward.hpp"
-#include "memory/GarbageCollector.hpp"
-#include "runtime/forward.hpp"
-#include "utilities.hpp"
-
-#include <bitset>
-
-class Function;
-class VirtualMachine;
-
-
-class CodeFlags
-{
-  public:
-	enum class Flag {
-		OPTIMIZED = 0,
-		NEWLOCALS = 1,
-		VARARGS = 2,
-		VARKEYWORDS = 3,
-		NESTED = 4,
-		GENERATOR = 5,
-		COROUTINE = 6,
-		CLASS = 7,
-	};
-
-  private:
-	std::bitset<8> m_flags;
-
-	CodeFlags() = default;
-
-  public:
-	template<typename... Args>
-	// requires std::conjunction_v<std::is_same<Flag, Args>...>
-	static CodeFlags create(Args... args)
-	{
-		CodeFlags f;
-		(f.m_flags.set(static_cast<uint8_t>(args)), ...);
-		return f;
-	}
-
-	static CodeFlags from_byte(uint8_t b)
-	{
-		auto f = CodeFlags();
-		f.m_flags = std::bitset<8>(b);
-		return f;
-	}
-
-	void set(Flag f) { m_flags.set(static_cast<uint8_t>(f)); }
-	void reset(Flag f) { m_flags.reset(static_cast<uint8_t>(f)); }
-	bool is_set(Flag f) const { return m_flags[static_cast<uint8_t>(f)]; }
-	std::bitset<8> bits() const { return m_flags; }
-};
-
-class Program
-	: NonCopyable
-	, public std::enable_shared_from_this<Program>
-{
-	std::string m_filename;
-	std::vector<std::string> m_argv;
-
-  protected:
-	Program() {}
-
-  public:
-	Program(std::string &&filename, std::vector<std::string> &&argv);
-	virtual ~Program() {}
-
-	virtual int execute(VirtualMachine *) = 0;
-
-	const std::string &filename() const { return m_filename; }
-	const std::vector<std::string> &argv() const { return m_argv; }
-
-	void set_filename(std::string filename) { m_filename = std::move(filename); }
-
-	virtual std::string to_string() const = 0;
-
-	virtual py::PyObject *as_pyfunction(const std::string &function_name,
-		const std::vector<py::Value> &default_values,
-		const std::vector<py::Value> &kw_default_values,
-		py::PyTuple *closure) const = 0;
-
-	virtual py::PyObject *main_function() = 0;
-
-	virtual void visit_functions(Cell::Visitor &) const = 0;
-
-	virtual std::vector<uint8_t> serialize() const = 0;
-};
-
-namespace compiler {
-std::shared_ptr<Program> compile(std::shared_ptr<ast::Module> node,
-	std::vector<std::string> argv,
-	Backend backend,
-	OptimizationLevel lvl);
-}
\ No newline at end of file
diff --git a/src/executable/bytecode/Bytecode.cpp b/src/executable/bytecode/Bytecode.cpp
index 80246ae3..255f7ec8 100644
--- a/src/executable/bytecode/Bytecode.cpp
+++ b/src/executable/bytecode/Bytecode.cpp
@@ -1,23 +1,27 @@
-#include "Bytecode.hpp"
-#include "ast/AST.hpp"
-#include "executable/FunctionBlock.hpp"
-#include "instructions/Instructions.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/BaseException.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyModule.hpp"
-#include "runtime/PyTraceback.hpp"
+module;
+#include <cstddef>
+#include <cstdint>
+
+#include "core.hpp"
+
+module py.runtime;
+import py.ast;
+import std;
+
+// After the module declaration and its imports: these name module-owned types.
 #include "serialization/deserialize.hpp"
 #include "serialization/serialize.hpp"
 
-#include <algorithm>
-#include <optional>
+// Out of line so that ~unique_ptr<Instruction> instantiates here, where
+// Instructions.hpp is included, rather than in the module interface.
+Bytecode::~Bytecode() = default;
+
 
 using namespace py;
 
-Bytecode::Bytecode(size_t register_count,
-	size_t locals_count,
-	size_t stack_size,
+Bytecode::Bytecode(std::size_t register_count,
+	std::size_t locals_count,
+	std::size_t stack_size,
 	std::string function_name,
 	InstructionVector instructions,
 	std::vector<InstructionSourceLocation> instruction_locations,
@@ -32,14 +36,14 @@ Bytecode::Bytecode(size_t register_count,
 	  m_instruction_locations(std::move(instruction_locations))
 {}
 
-std::optional<InstructionSourceLocation> Bytecode::location_for(size_t instruction_index) const
+std::optional<InstructionSourceLocation> Bytecode::location_for(std::size_t instruction_index) const
 {
 	if (m_instruction_locations.empty()) { return std::nullopt; }
 	// Find the last entry whose instruction_index is <= the query.
 	const auto it = std::upper_bound(m_instruction_locations.begin(),
 		m_instruction_locations.end(),
 		instruction_index,
-		[](size_t idx, const InstructionSourceLocation &entry) {
+		[](std::size_t idx, const InstructionSourceLocation &entry) {
 			return idx < entry.instruction_index;
 		});
 	if (it == m_instruction_locations.begin()) { return std::nullopt; }
@@ -50,23 +54,23 @@ std::string Bytecode::to_string() const
 {
 	std::ostringstream os;
 	for (const auto &ins : m_instructions) {
-		os << fmt::format("    {} {}", (void *)ins.get(), ins->to_string()) << '\n';
+		os << std::format("    {} {}", (void *)ins.get(), ins->to_string()) << '\n';
 	}
 
 	return os.str();
 }
 
-std::vector<uint8_t> Bytecode::serialize() const
+std::vector<std::uint8_t> Bytecode::serialize() const
 {
-	std::vector<uint8_t> result;
+	std::vector<std::uint8_t> result;
 
 	py::serialize(m_register_count, result);
 	py::serialize(m_locals_count, result);
 	py::serialize(m_stack_size, result);
 	py::serialize(m_function_name, result);
-	py::serialize(static_cast<uint8_t>(m_backend), result);
+	py::serialize(static_cast<std::uint8_t>(m_backend), result);
 
-	const size_t instruction_count = m_instructions.size();
+	const std::size_t instruction_count = m_instructions.size();
 	py::serialize(instruction_count, result);
 
 	for (const auto &ins : m_instructions) {
@@ -77,20 +81,21 @@ std::vector<uint8_t> Bytecode::serialize() const
 	return result;
 }
 
-std::unique_ptr<Bytecode> Bytecode::deserialize(std::span<const uint8_t> &buffer,
+std::unique_ptr<Bytecode> Bytecode::deserialize(std::span<const std::uint8_t> &buffer,
 	std::shared_ptr<Program> program)
 {
-	const auto register_count = py::deserialize<size_t>(buffer);
-	const auto locals_count = py::deserialize<size_t>(buffer);
-	const auto stack_size = py::deserialize<size_t>(buffer);
+	const auto register_count = py::deserialize<std::size_t>(buffer);
+	const auto locals_count = py::deserialize<std::size_t>(buffer);
+	const auto stack_size = py::deserialize<std::size_t>(buffer);
 	const auto function_name = py::deserialize<std::string>(buffer);
-	const auto backend = static_cast<FunctionExecutionBackend>(py::deserialize<uint8_t>(buffer));
+	const auto backend =
+		static_cast<FunctionExecutionBackend>(py::deserialize<std::uint8_t>(buffer));
 	(void)backend;
 
 	InstructionVector instructions;
-	const auto instruction_count = py::deserialize<size_t>(buffer);
+	const auto instruction_count = py::deserialize<std::size_t>(buffer);
 
-	for (size_t i = 0; i < instruction_count; ++i) {
+	for (std::size_t i = 0; i < instruction_count; ++i) {
 		auto instruction = ::deserialize(buffer);
 		if (!instruction) {
 			for (const auto &ins : instructions) { std::cout << ins->to_string() << '\n'; }
@@ -154,8 +159,9 @@ py::PyResult<py::Value> Bytecode::eval_loop(VirtualMachine &vm, Interpreter &int
 		ASSERT((*vm.instruction_pointer()).get());
 		const auto &current_ip = vm.instruction_pointer();
 		const auto &instruction = *current_ip;
-		// spdlog::debug("{} {}", (void *)instruction.get(), instruction->to_string());
-		// std::cout << std::format("{} {}", (void *)instruction.get(), instruction->to_string())
+		// ::detail::log_debug(std::format("{} {}", (void *)instruction.get(),
+		// instruction->to_string()).c_str()); std::cout << std::format("{} {}", (void
+		// *)instruction.get(), instruction->to_string())
 		// 		  << std::endl;
 		auto result = instruction->execute(vm, vm.interpreter());
 		// we left the current stack frame in the previous instruction
@@ -166,8 +172,8 @@ py::PyResult<py::Value> Bytecode::eval_loop(VirtualMachine &vm, Interpreter &int
 		// vm.dump();
 		if (result.is_err()) {
 			auto *exception = result.unwrap_err();
-			const size_t tb_lasti = std::distance(initial_ip, current_ip);
-			const size_t tb_lineno =
+			const std::size_t tb_lasti = std::distance(initial_ip, current_ip);
+			const std::size_t tb_lineno =
 				location_for(tb_lasti).value_or(InstructionSourceLocation{ 0, 0, 0 }).line;
 			PyTraceback *tb_next = exception->traceback();
 			auto traceback =
diff --git a/src/executable/bytecode/Bytecode.hpp b/src/executable/bytecode/Bytecode.cppm
similarity index 56%
rename from src/executable/bytecode/Bytecode.hpp
rename to src/executable/bytecode/Bytecode.cppm
index 06c6f6db..9ac77f4e 100644
--- a/src/executable/bytecode/Bytecode.hpp
+++ b/src/executable/bytecode/Bytecode.cppm
@@ -1,41 +1,39 @@
-#pragma once
+export module py.runtime:bytecode;
+import :value;
+import :executable_function;
+import :executable_program;
+import :executable_functionblock;
+import std;
 
-#include "codegen/BytecodeGenerator.hpp"
-#include "executable/Function.hpp"
-#include "executable/FunctionBlock.hpp"
+export class VirtualMachine;
 
-#include "forward.hpp"
 
-#include <memory>
-#include <set>
-#include <span>
-#include <string>
-#include <vector>
-
-class Bytecode : public Function
+export class Bytecode : public Function
 {
 	const InstructionVector m_instructions;
 	const std::vector<InstructionSourceLocation> m_instruction_locations;
 
   public:
-	Bytecode(size_t register_count,
-		size_t locals_count,
-		size_t stack_size,
+	Bytecode(std::size_t register_count,
+		std::size_t locals_count,
+		std::size_t stack_size,
 		std::string function_name,
 		InstructionVector instructions,
 		std::vector<InstructionSourceLocation> instruction_locations,
 		std::shared_ptr<Program> program);
 
+	~Bytecode() override;
+
 	auto begin() const { return m_instructions.begin(); }
 	auto end() const { return m_instructions.end(); }
 
-	std::optional<InstructionSourceLocation> location_for(size_t instruction_index) const;
+	std::optional<InstructionSourceLocation> location_for(std::size_t instruction_index) const;
 
 	std::string to_string() const override;
 
-	std::vector<uint8_t> serialize() const override;
+	std::vector<std::uint8_t> serialize() const override;
 
-	static std::unique_ptr<Bytecode> deserialize(std::span<const uint8_t> &buffer,
+	static std::unique_ptr<Bytecode> deserialize(std::span<const std::uint8_t> &buffer,
 		std::shared_ptr<Program> program);
 
 	py::PyResult<py::Value> call(VirtualMachine &, Interpreter &) const override;
diff --git a/src/executable/bytecode/BytecodeProgram.cpp b/src/executable/bytecode/BytecodeProgram.cpp
index 29e54edd..b1a414db 100644
--- a/src/executable/bytecode/BytecodeProgram.cpp
+++ b/src/executable/bytecode/BytecodeProgram.cpp
@@ -1,15 +1,15 @@
-#include "BytecodeProgram.hpp"
-#include "Bytecode.hpp"
-#include "executable/Function.hpp"
-#include "executable/Mangler.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyCode.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyFunction.hpp"
-#include "runtime/PyTraceback.hpp"
-#include "runtime/PyTuple.hpp"
-
-#include <memory>
+module;
+#include "core.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+
+module py.runtime;
+import py.ast;
+import py.codegen;
+import std;
+
 
 using namespace py;
 
@@ -227,16 +227,18 @@ std::shared_ptr<BytecodeProgram> BytecodeProgram::deserialize(const std::vector<
 	auto deserialized_result = PyCode::deserialize(span, program);
 	ASSERT(deserialized_result.first.is_ok());
 	program->m_main_function = deserialized_result.first.unwrap();
-	spdlog::debug(
-		"Deserialized main function:\n{}\n\n", program->m_main_function->function()->to_string());
+	::detail::log_debug(std::format(
+		"Deserialized main function:\n{}\n\n", program->m_main_function->function()->to_string())
+			.c_str());
 
 	while (!span.empty()) {
 		deserialized_result = PyCode::deserialize(span, program);
 		ASSERT(deserialized_result.first.is_ok());
 		program->m_functions.push_back(deserialized_result.first.unwrap());
-		spdlog::debug("Deserialized function {}:\n{}\n\n",
+		::detail::log_debug(std::format("Deserialized function {}:\n{}\n\n",
 			program->m_functions.back()->function()->function_name(),
-			program->m_functions.back()->function()->to_string());
+			program->m_functions.back()->function()->to_string())
+				.c_str());
 	}
 
 	return program;
diff --git a/src/executable/bytecode/BytecodeProgram.hpp b/src/executable/bytecode/BytecodeProgram.cppm
similarity index 73%
rename from src/executable/bytecode/BytecodeProgram.hpp
rename to src/executable/bytecode/BytecodeProgram.cppm
index 30f15027..08944e05 100644
--- a/src/executable/bytecode/BytecodeProgram.hpp
+++ b/src/executable/bytecode/BytecodeProgram.cppm
@@ -1,14 +1,16 @@
-#pragma once
+export module py.runtime:bytecode_program;
+import :bytecode;
+import :code;
+import :object;
+import :tuple;
+import :value;
+import :executable_program;
+import std;
 
-#include "Bytecode.hpp"
-#include "executable/Function.hpp"
-#include "executable/FunctionBlock.hpp"
-#include "executable/Program.hpp"
-#include "runtime/Value.hpp"
-#include "runtime/forward.hpp"
-#include <memory>
+export class VirtualMachine;
 
-class BytecodeProgram : public Program
+
+export class BytecodeProgram : public Program
 {
 	std::vector<py::PyCode *> m_functions;
 	py::PyCode *m_main_function;
@@ -26,7 +28,7 @@ class BytecodeProgram : public Program
 
 	InstructionVector::const_iterator end() const;
 
-	size_t main_stack_size() const;
+	std::size_t main_stack_size() const;
 
 	py::PyObject *as_pyfunction(const std::string &function_name,
 		const std::vector<py::Value> &default_values,
@@ -45,7 +47,7 @@ class BytecodeProgram : public Program
 
 	void visit_functions(Cell::Visitor &) const override;
 
-	std::vector<uint8_t> serialize() const final;
+	std::vector<std::uint8_t> serialize() const final;
 
-	static std::shared_ptr<BytecodeProgram> deserialize(const std::vector<uint8_t> &);
-};
\ No newline at end of file
+	static std::shared_ptr<BytecodeProgram> deserialize(const std::vector<std::uint8_t> &);
+};
diff --git a/src/executable/bytecode/BytecodeProgram_tests.cpp b/src/executable/bytecode/BytecodeProgram_tests.cpp
index 64f93874..258c3f8a 100644
--- a/src/executable/bytecode/BytecodeProgram_tests.cpp
+++ b/src/executable/bytecode/BytecodeProgram_tests.cpp
@@ -1,12 +1,14 @@
-#include "BytecodeProgram.hpp"
-#include "codegen/BytecodeGenerator.hpp"
+#include "core.hpp"
 #include "executable/common.hpp"
-#include "lexer/Lexer.hpp"
-#include "parser/Parser.hpp"
-#include "vm/VM.hpp"
-
 #include "gtest/gtest.h"
 
+import py.lexer;
+import py.runtime;
+import py.codegen;
+import py.ast;
+
+// After the import: these name module-owned types.
+
 namespace {
 std::shared_ptr<BytecodeProgram> generate_bytecode(std::string_view program)
 {
diff --git a/src/executable/bytecode/Bytecode_tests.cpp b/src/executable/bytecode/Bytecode_tests.cpp
index 98b8b127..6b52ea64 100644
--- a/src/executable/bytecode/Bytecode_tests.cpp
+++ b/src/executable/bytecode/Bytecode_tests.cpp
@@ -1,11 +1,12 @@
-#include "Bytecode.hpp"
-#include "executable/bytecode/BytecodeProgram.hpp"
-#include "executable/bytecode/codegen/BytecodeGenerator.hpp"
+#include "core.hpp"
+#include "gtest/gtest.h"
 
-#include "lexer/Lexer.hpp"
-#include "parser/Parser.hpp"
+import py.lexer;
+import py.runtime;
+import py.codegen;
+import py.ast;
 
-#include "gtest/gtest.h"
+// After the import: these name module-owned types.
 
 namespace {
 Bytecode make_bytecode_with_locations(std::vector<InstructionSourceLocation> locations)
diff --git a/src/executable/bytecode/codegen/BytecodeGenerator.cpp b/src/executable/bytecode/codegen/BytecodeGenerator.cpp
index d1c40747..49b36c29 100644
--- a/src/executable/bytecode/codegen/BytecodeGenerator.cpp
+++ b/src/executable/bytecode/codegen/BytecodeGenerator.cpp
@@ -1,100 +1,94 @@
-#include "BytecodeGenerator.hpp"
-#include "ast/AST.hpp"
-#include "executable/bytecode/BytecodeProgram.hpp"
-#include "executable/bytecode/instructions/BinaryOperation.hpp"
-#include "executable/bytecode/instructions/BinarySubscript.hpp"
-#include "executable/bytecode/instructions/BuildDict.hpp"
-#include "executable/bytecode/instructions/BuildList.hpp"
-#include "executable/bytecode/instructions/BuildSet.hpp"
-#include "executable/bytecode/instructions/BuildSlice.hpp"
-#include "executable/bytecode/instructions/BuildString.hpp"
-#include "executable/bytecode/instructions/BuildTuple.hpp"
-#include "executable/bytecode/instructions/ClearExceptionState.hpp"
-#include "executable/bytecode/instructions/ClearTopCleanup.hpp"
-#include "executable/bytecode/instructions/CompareOperation.hpp"
-#include "executable/bytecode/instructions/DeleteFast.hpp"
-#include "executable/bytecode/instructions/DeleteGlobal.hpp"
-#include "executable/bytecode/instructions/DeleteName.hpp"
-#include "executable/bytecode/instructions/DeleteSubscript.hpp"
-#include "executable/bytecode/instructions/DictAdd.hpp"
-#include "executable/bytecode/instructions/DictMerge.hpp"
-#include "executable/bytecode/instructions/DictUpdate.hpp"
-#include "executable/bytecode/instructions/ForIter.hpp"
-#include "executable/bytecode/instructions/FormatValue.hpp"
-#include "executable/bytecode/instructions/FunctionCall.hpp"
-#include "executable/bytecode/instructions/FunctionCallEx.hpp"
-#include "executable/bytecode/instructions/FunctionCallWithKeywords.hpp"
-#include "executable/bytecode/instructions/GetAwaitable.hpp"
-#include "executable/bytecode/instructions/GetIter.hpp"
-#include "executable/bytecode/instructions/GetYieldFromIter.hpp"
-#include "executable/bytecode/instructions/ImportFrom.hpp"
-#include "executable/bytecode/instructions/ImportName.hpp"
-#include "executable/bytecode/instructions/ImportStar.hpp"
-#include "executable/bytecode/instructions/InplaceOp.hpp"
-#include "executable/bytecode/instructions/Instructions.hpp"
-#include "executable/bytecode/instructions/Jump.hpp"
-#include "executable/bytecode/instructions/JumpForward.hpp"
-#include "executable/bytecode/instructions/JumpIfExceptionMatch.hpp"
-#include "executable/bytecode/instructions/JumpIfFalse.hpp"
-#include "executable/bytecode/instructions/JumpIfFalseOrPop.hpp"
-#include "executable/bytecode/instructions/JumpIfNotExceptionMatch.hpp"
-#include "executable/bytecode/instructions/JumpIfTrue.hpp"
-#include "executable/bytecode/instructions/JumpIfTrueOrPop.hpp"
-#include "executable/bytecode/instructions/LeaveExceptionHandling.hpp"
-#include "executable/bytecode/instructions/ListAppend.hpp"
-#include "executable/bytecode/instructions/ListExtend.hpp"
-#include "executable/bytecode/instructions/ListToTuple.hpp"
-#include "executable/bytecode/instructions/LoadAssertionError.hpp"
-#include "executable/bytecode/instructions/LoadAttr.hpp"
-#include "executable/bytecode/instructions/LoadBuildClass.hpp"
-#include "executable/bytecode/instructions/LoadClosure.hpp"
-#include "executable/bytecode/instructions/LoadConst.hpp"
-#include "executable/bytecode/instructions/LoadDeref.hpp"
-#include "executable/bytecode/instructions/LoadFast.hpp"
-#include "executable/bytecode/instructions/LoadGlobal.hpp"
-#include "executable/bytecode/instructions/LoadMethod.hpp"
-#include "executable/bytecode/instructions/LoadName.hpp"
-#include "executable/bytecode/instructions/MakeFunction.hpp"
-#include "executable/bytecode/instructions/MethodCall.hpp"
-#include "executable/bytecode/instructions/Move.hpp"
-#include "executable/bytecode/instructions/Pop.hpp"
-#include "executable/bytecode/instructions/Push.hpp"
-#include "executable/bytecode/instructions/RaiseVarargs.hpp"
-#include "executable/bytecode/instructions/ReRaise.hpp"
-#include "executable/bytecode/instructions/ReturnValue.hpp"
-#include "executable/bytecode/instructions/SetAdd.hpp"
-#include "executable/bytecode/instructions/SetupExceptionHandling.hpp"
-#include "executable/bytecode/instructions/SetupWith.hpp"
-#include "executable/bytecode/instructions/StoreAttr.hpp"
-#include "executable/bytecode/instructions/StoreDeref.hpp"
-#include "executable/bytecode/instructions/StoreFast.hpp"
-#include "executable/bytecode/instructions/StoreGlobal.hpp"
-#include "executable/bytecode/instructions/StoreName.hpp"
-#include "executable/bytecode/instructions/StoreSubscript.hpp"
-#include "executable/bytecode/instructions/Unary.hpp"
-#include "executable/bytecode/instructions/UnpackSequence.hpp"
-#include "executable/bytecode/instructions/WithExceptStart.hpp"
-#include "executable/bytecode/instructions/YieldFrom.hpp"
-#include "executable/bytecode/instructions/YieldLoad.hpp"
-#include "executable/bytecode/instructions/YieldValue.hpp"
-
-#include "ast/optimizers/ConstantFolding.hpp"
-#include "executable/FunctionBlock.hpp"
-#include "executable/Mangler.hpp"
-#include "executable/Program.hpp"
-#include "executable/bytecode/instructions/Instructions.hpp"
-#include "runtime/Value.hpp"
-
-#include "VariablesResolver.hpp"
-
-#include <filesystem>
+module;
+#include "core.hpp"
+#include "executable/CodeFlags.hpp"
+#include "executable/Label.hpp"
+#include "executable/common.hpp"
+#include <cstddef>
+#include <cstdint>
+#include <gmpxx.h>
+
+module py.codegen;
+import py.ast;
+import py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+#include "memory/allocate.hpp"
+
+#include "ast/SourceLocationFormatter.hpp"
+
 
 namespace fs = std::filesystem;
 
 using namespace ast;
 
+// ast::Literal (a plain C++ variant, so the AST does not depend on the runtime's
+// value representation) -> py::Value, which is what the bytecode's static-value
+// table stores. Kept here in codegen because this is the layer that legitimately
+// knows both sides.
+py::Value to_runtime_value(const ast::Literal &literal)
+{
+	return std::visit(
+		overloaded{ [](std::monostate) -> py::Value { return py::NameConstant{ py::NoneType{} }; },
+			[](bool value) -> py::Value { return py::NameConstant{ value }; },
+			[](std::int64_t value) -> py::Value { return py::Number{ py::BigIntType{ value } }; },
+			[](const mpz_class &value) -> py::Value { return py::Number{ value }; },
+			[](double value) -> py::Value { return py::Number{ value }; },
+			[](const std::string &value) -> py::Value { return py::String{ value }; },
+			[](const ast::Bytes &value) -> py::Value { return py::Bytes{ value }; },
+			[](ast::EllipsisType) -> py::Value { return py::Ellipsis{}; } },
+		literal);
+}
+
+
 namespace codegen {
 
+std::shared_ptr<Label> BytecodeGenerator::make_label(const std::string &name,
+	std::size_t function_id)
+{
+	::detail::log_debug(
+		std::format("New label to be added: name={} function_id={}", name, function_id).c_str());
+	auto new_label = std::make_shared<Label>(name, function_id);
+
+	ASSERT(std::find(m_labels.begin(), m_labels.end(), new_label) == m_labels.end());
+
+	m_labels.emplace_back(new_label);
+
+	return new_label;
+}
+
+void BytecodeGenerator::bind(const std::shared_ptr<Label> &label)
+{
+	ASSERT(std::find(m_labels.begin(), m_labels.end(), label) != m_labels.end());
+	auto &instructions = function(label->function_id());
+	const auto instructions_size = instructions.size();
+	const std::size_t current_instruction_position = instructions_size;
+	label->set_position(current_instruction_position);
+	::detail::log_debug(std::format("bound label {}", label->name()).c_str());
+}
+
+Register BytecodeGenerator::allocate_register()
+{
+	::detail::log_debug(std::format("New register: {}", m_frame_register_count.back()).c_str());
+	ASSERT(m_frame_register_count.back() < std::numeric_limits<Register>::max());
+	return static_cast<Register>(m_frame_register_count.back()++);
+}
+
+Register BytecodeGenerator::allocate_stack_value()
+{
+	::detail::log_debug(
+		std::format("New stack value: {}", m_frame_stack_value_count.back()).c_str());
+	ASSERT(m_frame_stack_value_count.back() < std::numeric_limits<Register>::max());
+	return static_cast<Register>(m_frame_stack_value_count.back()++);
+}
+
+Register BytecodeGenerator::allocate_free_value()
+{
+	::detail::log_debug(std::format("New free value: {}", m_frame_free_var_count.back()).c_str());
+	ASSERT(m_frame_free_var_count.back() < std::numeric_limits<Register>::max());
+	return static_cast<Register>(m_frame_free_var_count.back()++);
+}
+
 namespace {
 	bool compare_values(const py::Value &lhs, const py::Value &rhs)
 	{
@@ -129,9 +123,11 @@ BytecodeValue *BytecodeGenerator::build_dict_simple(
 		for (const auto &key : key_registers) { emit<Push>(*key); }
 		for (const auto &value : value_registers) { emit<Push>(value); }
 
-		const size_t size = key_registers.size();
+		const std::size_t size = key_registers.size();
 		emit<BuildDict>(result->get_register(), size);
-		for (size_t i = 0; i < value_registers.size() + key_registers.size(); ++i) { emit<Pop>(); }
+		for (std::size_t i = 0; i < value_registers.size() + key_registers.size(); ++i) {
+			emit<Pop>();
+		}
 	} else {
 		emit<BuildDict>(result->get_register(), 0);
 	}
@@ -147,8 +143,8 @@ BytecodeValue *BytecodeGenerator::build_dict(
 			return !el.has_value();
 		})) {
 		ASSERT(key_registers.size() == value_registers.size());
-		size_t begin_key_index = 0;
-		size_t last_key_index = begin_key_index;
+		std::size_t begin_key_index = 0;
+		std::size_t last_key_index = begin_key_index;
 		BytecodeValue *dict = nullptr;
 		while (last_key_index != key_registers.size()) {
 			begin_key_index = last_key_index;
@@ -182,7 +178,7 @@ BytecodeValue *BytecodeGenerator::build_list(const std::vector<Register> &elemen
 	if (!element_registers.empty()) {
 		for (const auto &el : element_registers) { emit<Push>(el); }
 		emit<BuildList>(result->get_register(), element_registers.size());
-		for (size_t i = 0; i < element_registers.size(); ++i) { emit<Pop>(); }
+		for (std::size_t i = 0; i < element_registers.size(); ++i) { emit<Pop>(); }
 	} else {
 		emit<BuildList>(result->get_register(), 0);
 	}
@@ -195,7 +191,7 @@ BytecodeValue *BytecodeGenerator::build_set(const std::vector<Register> &element
 	if (!element_registers.empty()) {
 		for (const auto &el : element_registers) { emit<Push>(el); }
 		emit<BuildSet>(result->get_register(), element_registers.size());
-		for (size_t i = 0; i < element_registers.size(); ++i) { emit<Pop>(); }
+		for (std::size_t i = 0; i < element_registers.size(); ++i) { emit<Pop>(); }
 	} else {
 		emit<BuildSet>(result->get_register(), 0);
 	}
@@ -208,7 +204,7 @@ BytecodeValue *BytecodeGenerator::build_tuple(const std::vector<Register> &eleme
 	if (!element_registers.empty()) {
 		for (const auto &el : element_registers) { emit<Push>(el); }
 		emit<BuildTuple>(result->get_register(), element_registers.size());
-		for (size_t i = 0; i < element_registers.size(); ++i) { emit<Pop>(); }
+		for (std::size_t i = 0; i < element_registers.size(); ++i) { emit<Pop>(); }
 	} else {
 		emit<BuildTuple>(result->get_register(), 0);
 	}
@@ -221,7 +217,7 @@ BytecodeValue *BytecodeGenerator::build_string(const std::vector<Register> &elem
 	if (!element_registers.empty()) {
 		for (const auto &el : element_registers) { emit<Push>(el); }
 		emit<BuildString>(result->get_register(), element_registers.size());
-		for (size_t i = 0; i < element_registers.size(); ++i) { emit<Pop>(); }
+		for (std::size_t i = 0; i < element_registers.size(); ++i) { emit<Pop>(); }
 	} else {
 		emit<BuildString>(result->get_register(), 0);
 	}
@@ -233,7 +229,7 @@ void BytecodeGenerator::emit_call(Register func, const std::vector<Register> &ar
 	if (!args.empty()) {
 		for (const auto &arg : args) { emit<Push>(arg); }
 		emit<FunctionCall>(func, args.size(), 0);
-		for (size_t i = 0; i < args.size(); ++i) { emit<Pop>(); }
+		for (std::size_t i = 0; i < args.size(); ++i) { emit<Pop>(); }
 	} else {
 		emit<FunctionCall>(func, 0, 0);
 	}
@@ -252,13 +248,13 @@ void BytecodeGenerator::make_function(Register dst,
 	for (const auto &default_ : defaults) { emit<Push>(default_); }
 	for (const auto &default_ : kw_defaults) { emit<Push>(default_); }
 
-	const size_t defaults_size = defaults.size();
-	const size_t kw_defaults_size = kw_defaults.size();
+	const std::size_t defaults_size = defaults.size();
+	const std::size_t kw_defaults_size = kw_defaults.size();
 
 	emit<MakeFunction>(
 		dst, name_value->get_register(), defaults_size, kw_defaults_size, captures_tuple);
 
-	for (size_t i = 0; i < defaults_size + kw_defaults_size; ++i) { emit<Pop>(); }
+	for (std::size_t i = 0; i < defaults_size + kw_defaults_size; ++i) { emit<Pop>(); }
 }
 
 void BytecodeGenerator::store_name(const std::string &name, BytecodeValue *src)
@@ -434,10 +430,10 @@ void BytecodeGenerator::delete_var(const std::string &name)
 	}
 }
 
-BytecodeStaticValue *BytecodeGenerator::load_const(const py::Value &value, size_t function_id)
+BytecodeStaticValue *BytecodeGenerator::load_const(const py::Value &value, std::size_t function_id)
 {
 	auto &consts = std::next(m_functions.functions.begin(), function_id)->metadata.consts;
-	for (size_t i = 0; const auto &static_value : consts) {
+	for (std::size_t i = 0; const auto &static_value : consts) {
 		if (compare_values(static_value, value)) {
 			m_values.push_back(std::make_unique<BytecodeStaticValue>(i));
 			return static_cast<BytecodeStaticValue *>(m_values.back().get());
@@ -449,10 +445,10 @@ BytecodeStaticValue *BytecodeGenerator::load_const(const py::Value &value, size_
 	return static_cast<BytecodeStaticValue *>(m_values.back().get());
 }
 
-BytecodeNameValue *BytecodeGenerator::load_name(const std::string &name, size_t function_id)
+BytecodeNameValue *BytecodeGenerator::load_name(const std::string &name, std::size_t function_id)
 {
 	auto &names = std::next(m_functions.functions.begin(), function_id)->metadata.names;
-	for (size_t i = 0; const auto &name_ : names) {
+	for (std::size_t i = 0; const auto &name_ : names) {
 		if (name_ == name) {
 			m_values.push_back(std::make_unique<BytecodeNameValue>(name, i));
 			return static_cast<BytecodeNameValue *>(m_values.back().get());
@@ -481,7 +477,7 @@ Value *BytecodeGenerator::visit(const Name *node)
 Value *BytecodeGenerator::visit(const Constant *node)
 {
 	auto *dst = create_value();
-	auto *value = load_const(*node->value(), m_function_id);
+	auto *value = load_const(to_runtime_value(node->value()), m_function_id);
 	emit<LoadConst>(dst->get_register(), value->get_index());
 	return dst;
 }
@@ -619,11 +615,11 @@ Value *BytecodeGenerator::generate_function(const FunctionType *node)
 	}
 
 	const auto &cellvars = f->function_info().function.metadata.cellvars;
-	const size_t arg_count_ = node->args()->argument_names().size()
-							  + node->args()->kw_only_argument_names().size()
-							  + static_cast<size_t>(node->args()->vararg() != nullptr)
-							  + static_cast<size_t>(node->args()->kwarg() != nullptr);
-	std::vector<size_t> cell2arg(cellvars.size(), arg_count_);
+	const std::size_t arg_count_ = node->args()->argument_names().size()
+								   + node->args()->kw_only_argument_names().size()
+								   + static_cast<std::size_t>(node->args()->vararg() != nullptr)
+								   + static_cast<std::size_t>(node->args()->kwarg() != nullptr);
+	std::vector<std::size_t> cell2arg(cellvars.size(), arg_count_);
 
 	create_nested_scope(node->name(), function_name);
 	std::vector<std::pair<std::string, BytecodeFreeValue *>> captures;
@@ -686,19 +682,19 @@ Value *BytecodeGenerator::generate_function(const FunctionType *node)
 	emit<LoadConst>(none_value_register, value->get_index());
 	emit<ReturnValue>(none_value_register);
 
-	for (size_t idx = 0; const auto &arg_name : node->args()->argument_names()) {
+	for (std::size_t idx = 0; const auto &arg_name : node->args()->argument_names()) {
 		varnames.push_back(arg_name);
 		ASSERT(symbol_map.get_visible_symbol(arg_name).has_value());
 		if (std::find(cellvars.begin(), cellvars.end(), arg_name) != cellvars.end()) {
 			ASSERT(m_stack.top().locals.contains(arg_name));
 			const auto &l = m_stack.top().locals.at(arg_name);
 			ASSERT(std::holds_alternative<BytecodeFreeValue *>(l));
-			const size_t cell_idx = std::get<BytecodeFreeValue *>(l)->get_free_var_index();
+			const std::size_t cell_idx = std::get<BytecodeFreeValue *>(l)->get_free_var_index();
 			cell2arg[cell_idx] = idx;
 		}
 		idx++;
 	}
-	for (size_t idx = node->args()->argument_names().size();
+	for (std::size_t idx = node->args()->argument_names().size();
 		const auto &arg_name : node->args()->kw_only_argument_names()) {
 		varnames.push_back(arg_name);
 		ASSERT(symbol_map.get_visible_symbol(arg_name).has_value());
@@ -706,14 +702,14 @@ Value *BytecodeGenerator::generate_function(const FunctionType *node)
 			ASSERT(m_stack.top().locals.contains(arg_name));
 			const auto &l = m_stack.top().locals.at(arg_name);
 			ASSERT(std::holds_alternative<BytecodeFreeValue *>(l));
-			const size_t cell_idx = std::get<BytecodeFreeValue *>(l)->get_free_var_index();
+			const std::size_t cell_idx = std::get<BytecodeFreeValue *>(l)->get_free_var_index();
 			cell2arg[cell_idx] = idx;
 		}
 		idx++;
 	}
 
 	if (node->args()->vararg() != nullptr) {
-		const size_t idx =
+		const std::size_t idx =
 			node->args()->argument_names().size() + node->args()->kw_only_argument_names().size();
 		const auto &arg_name = node->args()->vararg()->name();
 		varnames.push_back(arg_name);
@@ -722,13 +718,13 @@ Value *BytecodeGenerator::generate_function(const FunctionType *node)
 			ASSERT(m_stack.top().locals.contains(arg_name));
 			const auto &l = m_stack.top().locals.at(arg_name);
 			ASSERT(std::holds_alternative<BytecodeFreeValue *>(l));
-			const size_t cell_idx = std::get<BytecodeFreeValue *>(l)->get_free_var_index();
+			const std::size_t cell_idx = std::get<BytecodeFreeValue *>(l)->get_free_var_index();
 			cell2arg[cell_idx] = idx;
 		}
 	}
 
 	if (node->args()->kwarg() != nullptr) {
-		size_t idx =
+		std::size_t idx =
 			node->args()->argument_names().size() + node->args()->kw_only_argument_names().size();
 		if (node->args()->vararg()) { idx++; }
 		const auto &arg_name = node->args()->kwarg()->name();
@@ -738,7 +734,7 @@ Value *BytecodeGenerator::generate_function(const FunctionType *node)
 			ASSERT(m_stack.top().locals.contains(arg_name));
 			const auto &l = m_stack.top().locals.at(arg_name);
 			ASSERT(std::holds_alternative<BytecodeFreeValue *>(l));
-			const size_t cell_idx = std::get<BytecodeFreeValue *>(l)->get_free_var_index();
+			const std::size_t cell_idx = std::get<BytecodeFreeValue *>(l)->get_free_var_index();
 			cell2arg[cell_idx] = idx;
 		}
 	}
@@ -748,8 +744,8 @@ Value *BytecodeGenerator::generate_function(const FunctionType *node)
 	m_stack.pop();
 	exit_function(f->function_info().function_id);
 
-	size_t arg_count = node->args()->args().size() + node->args()->posonlyargs().size();
-	size_t kwonly_arg_count = node->args()->kwonlyargs().size();
+	std::size_t arg_count = node->args()->args().size() + node->args()->posonlyargs().size();
+	std::size_t kwonly_arg_count = node->args()->kwonlyargs().size();
 
 	std::vector<Register> defaults;
 	defaults.reserve(node->args()->defaults().size());
@@ -812,7 +808,8 @@ Value *BytecodeGenerator::generate_function(const FunctionType *node)
 		std::vector<BytecodeValue *> args;
 		auto *function = load_var(node->name());
 		args.push_back(function);
-		for (int32_t i = static_cast<int32_t>(decorator_functions.size()) - 1; i >= 0; --i) {
+		for (std::int32_t i = static_cast<std::int32_t>(decorator_functions.size()) - 1; i >= 0;
+			--i) {
 			const auto &decorator_function = decorator_functions[i];
 			emit_call(decorator_function->get_register(),
 				std::vector<Register>{ args.back()->get_register() });
@@ -868,12 +865,12 @@ Value *BytecodeGenerator::visit(const Lambda *node)
 	}
 
 	const auto &cellvars = f->function_info().function.metadata.cellvars;
-	const size_t arg_count_ = node->args()->argument_names().size()
-							  + node->args()->kw_only_argument_names().size()
-							  + node->args()->kw_only_argument_names().size()
-							  + static_cast<size_t>(node->args()->vararg() != nullptr)
-							  + static_cast<size_t>(node->args()->kwarg() != nullptr);
-	std::vector<size_t> cell2arg(cellvars.size(), arg_count_);
+	const std::size_t arg_count_ = node->args()->argument_names().size()
+								   + node->args()->kw_only_argument_names().size()
+								   + node->args()->kw_only_argument_names().size()
+								   + static_cast<std::size_t>(node->args()->vararg() != nullptr)
+								   + static_cast<std::size_t>(node->args()->kwarg() != nullptr);
+	std::vector<std::size_t> cell2arg(cellvars.size(), arg_count_);
 
 	create_nested_scope("<lambda>", function_name);
 	std::vector<std::pair<std::string, BytecodeFreeValue *>> captures;
@@ -937,19 +934,19 @@ Value *BytecodeGenerator::visit(const Lambda *node)
 	emit<LoadConst>(none_value_register, value->get_index());
 	emit<ReturnValue>(none_value_register);
 
-	for (size_t idx = 0; const auto &arg_name : node->args()->argument_names()) {
+	for (std::size_t idx = 0; const auto &arg_name : node->args()->argument_names()) {
 		varnames.push_back(arg_name);
 		ASSERT(symbol_map.get_visible_symbol(arg_name).has_value());
 		if (std::find(cellvars.begin(), cellvars.end(), arg_name) != cellvars.end()) {
 			ASSERT(m_stack.top().locals.contains(arg_name));
 			const auto &l = m_stack.top().locals.at(arg_name);
 			ASSERT(std::holds_alternative<BytecodeFreeValue *>(l));
-			const size_t cell_idx = std::get<BytecodeFreeValue *>(l)->get_free_var_index();
+			const std::size_t cell_idx = std::get<BytecodeFreeValue *>(l)->get_free_var_index();
 			cell2arg[cell_idx] = idx;
 		}
 		idx++;
 	}
-	for (size_t idx = node->args()->argument_names().size();
+	for (std::size_t idx = node->args()->argument_names().size();
 		const auto &arg_name : node->args()->kw_only_argument_names()) {
 		varnames.push_back(arg_name);
 		ASSERT(symbol_map.get_visible_symbol(arg_name).has_value());
@@ -957,14 +954,14 @@ Value *BytecodeGenerator::visit(const Lambda *node)
 			ASSERT(m_stack.top().locals.contains(arg_name));
 			const auto &l = m_stack.top().locals.at(arg_name);
 			ASSERT(std::holds_alternative<BytecodeFreeValue *>(l));
-			const size_t cell_idx = std::get<BytecodeFreeValue *>(l)->get_free_var_index();
+			const std::size_t cell_idx = std::get<BytecodeFreeValue *>(l)->get_free_var_index();
 			cell2arg[cell_idx] = idx;
 		}
 		idx++;
 	}
 
 	if (node->args()->vararg() != nullptr) {
-		const size_t idx =
+		const std::size_t idx =
 			node->args()->argument_names().size() + node->args()->kw_only_argument_names().size();
 		const auto &arg_name = node->args()->vararg()->name();
 		varnames.push_back(arg_name);
@@ -973,13 +970,13 @@ Value *BytecodeGenerator::visit(const Lambda *node)
 			ASSERT(m_stack.top().locals.contains(arg_name));
 			const auto &l = m_stack.top().locals.at(arg_name);
 			ASSERT(std::holds_alternative<BytecodeFreeValue *>(l));
-			const size_t cell_idx = std::get<BytecodeFreeValue *>(l)->get_free_var_index();
+			const std::size_t cell_idx = std::get<BytecodeFreeValue *>(l)->get_free_var_index();
 			cell2arg[cell_idx] = idx;
 		}
 	}
 
 	if (node->args()->kwarg() != nullptr) {
-		size_t idx =
+		std::size_t idx =
 			node->args()->argument_names().size() + node->args()->kw_only_argument_names().size();
 		if (node->args()->vararg()) { idx++; }
 		const auto &arg_name = node->args()->kwarg()->name();
@@ -989,7 +986,7 @@ Value *BytecodeGenerator::visit(const Lambda *node)
 			ASSERT(m_stack.top().locals.contains(arg_name));
 			const auto &l = m_stack.top().locals.at(arg_name);
 			ASSERT(std::holds_alternative<BytecodeFreeValue *>(l));
-			const size_t cell_idx = std::get<BytecodeFreeValue *>(l)->get_free_var_index();
+			const std::size_t cell_idx = std::get<BytecodeFreeValue *>(l)->get_free_var_index();
 			cell2arg[cell_idx] = idx;
 		}
 	}
@@ -999,8 +996,8 @@ Value *BytecodeGenerator::visit(const Lambda *node)
 	m_stack.pop();
 	exit_function(f->function_info().function_id);
 
-	size_t arg_count = node->args()->args().size() + node->args()->posonlyargs().size();
-	size_t kwonly_arg_count = node->args()->kwonlyargs().size();
+	std::size_t arg_count = node->args()->args().size() + node->args()->posonlyargs().size();
+	std::size_t kwonly_arg_count = node->args()->kwonlyargs().size();
 
 	std::vector<Register> defaults;
 	defaults.reserve(node->args()->defaults().size());
@@ -1181,12 +1178,12 @@ Value *BytecodeGenerator::visit(const Assign *node)
 		} else if (auto ast_tuple = as<Tuple>(target)) {
 			std::vector<BytecodeValue *> unpacked_values;
 			std::vector<Register> unpacked_registers;
-			for (size_t i = 0; i < ast_tuple->elements().size(); ++i) {
+			for (std::size_t i = 0; i < ast_tuple->elements().size(); ++i) {
 				auto &unpacked_value = unpacked_values.emplace_back(create_value());
 				unpacked_registers.push_back(unpacked_value->get_register());
 			}
 			emit<UnpackSequence>(unpacked_registers, src->get_register());
-			for (size_t idx = 0; const auto &unpacked_value : unpacked_values) {
+			for (std::size_t idx = 0; const auto &unpacked_value : unpacked_values) {
 				const auto &el = ast_tuple->elements()[idx++];
 				if (auto name = as<Name>(el)) {
 					store_name(name->ids()[0], unpacked_value);
@@ -1378,12 +1375,12 @@ Value *BytecodeGenerator::visit(const Call *node)
 
 Value *BytecodeGenerator::visit(const If *node)
 {
-	static size_t if_count = 0;
+	static std::size_t if_count = 0;
 
 	ASSERT(!node->body().empty());
 
-	auto orelse_start_label = make_label(fmt::format("ORELSE_{}", if_count), m_function_id);
-	auto end_label = make_label(fmt::format("IF_END_{}", if_count++), m_function_id);
+	auto orelse_start_label = make_label(std::format("ORELSE_{}", if_count), m_function_id);
+	auto end_label = make_label(std::format("IF_END_{}", if_count++), m_function_id);
 
 	// if
 	auto *test_result = generate(node->test(), m_function_id);
@@ -1403,15 +1400,15 @@ Value *BytecodeGenerator::visit(const If *node)
 
 Value *BytecodeGenerator::visit(const For *node)
 {
-	static size_t for_loop_count = 0;
+	static std::size_t for_loop_count = 0;
 
 	ASSERT(!node->body().empty());
 
 	auto forloop_start_label =
-		make_label(fmt::format("FOR_START_{}", for_loop_count), m_function_id);
-	auto forloop_end_label = make_label(fmt::format("FOR_END_{}", for_loop_count), m_function_id);
+		make_label(std::format("FOR_START_{}", for_loop_count), m_function_id);
+	auto forloop_end_label = make_label(std::format("FOR_END_{}", for_loop_count), m_function_id);
 	auto forloop_after_else_end_label =
-		make_label(fmt::format("FOR_AFTER_ELSE_END_{}", for_loop_count++), m_function_id);
+		make_label(std::format("FOR_AFTER_ELSE_END_{}", for_loop_count++), m_function_id);
 
 	// generate the iterator
 	auto *iterator_func = generate(node->iter(), m_function_id);
@@ -1490,14 +1487,14 @@ Value *BytecodeGenerator::visit(const Break *)
 
 Value *BytecodeGenerator::visit(const While *node)
 {
-	static size_t while_loop_count = 0;
+	static std::size_t while_loop_count = 0;
 
 	ASSERT(!node->body().empty());
 
 	auto while_loop_start_label =
-		make_label(fmt::format("WHILE_START_{}", while_loop_count), m_function_id);
+		make_label(std::format("WHILE_START_{}", while_loop_count), m_function_id);
 	auto while_loop_end_label =
-		make_label(fmt::format("WHILE_END_{}", while_loop_count++), m_function_id);
+		make_label(std::format("WHILE_END_{}", while_loop_count++), m_function_id);
 
 	// test
 	bind(while_loop_start_label);
@@ -1528,7 +1525,7 @@ Value *BytecodeGenerator::visit(const Compare *node)
 	const auto &ops = node->ops();
 	BytecodeValue *result{ nullptr };
 
-	for (size_t idx = 0; idx < comparators.size(); ++idx) {
+	for (std::size_t idx = 0; idx < comparators.size(); ++idx) {
 		const auto *rhs = generate(comparators[idx], m_function_id);
 		const auto op = ops[idx];
 		result = create_value();
@@ -1652,7 +1649,7 @@ Value *BytecodeGenerator::visit(const ClassDefinition *node)
 
 	auto *class_builder_func = create_function(class_mangled_name);
 	create_nested_scope(node->name(), class_mangled_name);
-	size_t class_id = class_builder_func->function_info().function_id;
+	std::size_t class_id = class_builder_func->function_info().function_id;
 
 	const auto &symbol_map = class_scope->symbol_map;
 
@@ -1960,7 +1957,7 @@ Value *BytecodeGenerator::visit(const Import *node)
 	for (const auto &n : node->names()) {
 		auto *name = load_name(n.name, m_function_id);
 		auto *from_list = load_const(py::NameConstant{ py::NoneType{} }, m_function_id);
-		auto *level = load_const(py::Number{ int64_t{ 0 } }, m_function_id);
+		auto *level = load_const(py::Number{ std::int64_t{ 0 } }, m_function_id);
 
 		auto *from_list_value = create_value();
 		auto *level_value = create_value();
@@ -2000,7 +1997,7 @@ Value *BytecodeGenerator::visit(const ast::ImportFrom *node)
 
 	auto *name = load_name(node->module(), m_function_id);
 	auto *from_list_value = build_tuple(names);
-	auto *level = load_const(py::Number{ static_cast<int64_t>(node->level()) }, m_function_id);
+	auto *level = load_const(py::Number{ static_cast<std::int64_t>(node->level()) }, m_function_id);
 
 	auto *level_value = create_value();
 
@@ -2141,9 +2138,9 @@ Value *BytecodeGenerator::visit(const Raise *node)
 
 Value *BytecodeGenerator::visit(const With *node)
 {
-	static size_t exit_label_count = 0;
+	static std::size_t exit_label_count = 0;
 	auto cleanup_label =
-		make_label(fmt::format("WITH_CLEANUP_{}", exit_label_count++), m_function_id);
+		make_label(std::format("WITH_CLEANUP_{}", exit_label_count++), m_function_id);
 
 	auto *body_block = allocate_block(m_function_id);
 
@@ -2159,7 +2156,7 @@ Value *BytecodeGenerator::visit(const With *node)
 	set_insert_point(body_block);
 
 	auto with_exit_factory = [this, &with_item_results](bool first) {
-		auto exit_label = make_label(fmt::format("WITH_EXIT_{}", exit_label_count), m_function_id);
+		auto exit_label = make_label(std::format("WITH_EXIT_{}", exit_label_count), m_function_id);
 		for (const auto &item : with_item_results) {
 			auto *exit_result = create_value();
 			auto *exit_method = create_value();
@@ -2233,11 +2230,11 @@ Value *BytecodeGenerator::visit(const WithItem *node)
 
 Value *BytecodeGenerator::visit(const IfExpr *node)
 {
-	static size_t if_expr_count = 0;
+	static std::size_t if_expr_count = 0;
 
 	auto orelse_start_label =
-		make_label(fmt::format("IF_EXPR_ORELSE_{}", if_expr_count), m_function_id);
-	auto end_label = make_label(fmt::format("IF_EXPR_END_{}", if_expr_count++), m_function_id);
+		make_label(std::format("IF_EXPR_ORELSE_{}", if_expr_count), m_function_id);
+	auto end_label = make_label(std::format("IF_EXPR_END_{}", if_expr_count++), m_function_id);
 
 	auto return_value = create_value();
 	// if
@@ -2259,17 +2256,17 @@ Value *BytecodeGenerator::visit(const IfExpr *node)
 
 Value *BytecodeGenerator::visit(const Try *node)
 {
-	static size_t try_op_count = 0;
-	size_t exception_count = 0;
+	static std::size_t try_op_count = 0;
+	std::size_t exception_count = 0;
 
 	auto next_exception_label = make_label(
-		fmt::format("TRY_EXC_COUNT_{}_{}", try_op_count, exception_count++), m_function_id);
+		std::format("TRY_EXC_COUNT_{}_{}", try_op_count, exception_count++), m_function_id);
 	auto orelse_label =
 		node->orelse().empty()
 			? nullptr
-			: make_label(fmt::format("TRY_ORELSE_COUNT_{}", try_op_count), m_function_id);
+			: make_label(std::format("TRY_ORELSE_COUNT_{}", try_op_count), m_function_id);
 	auto finally_label =
-		make_label(fmt::format("TRY_FINALLY_OP_COUNT_{}", try_op_count++), m_function_id);
+		make_label(std::format("TRY_FINALLY_OP_COUNT_{}", try_op_count++), m_function_id);
 
 	emit<SetupExceptionHandling>(next_exception_label);
 
@@ -2308,7 +2305,7 @@ Value *BytecodeGenerator::visit(const Try *node)
 			emit<Jump>(finally_label);
 		}
 
-		const size_t exception_depth = m_current_exception_depth[m_function_id];
+		const std::size_t exception_depth = m_current_exception_depth[m_function_id];
 
 		for (const auto &handler : node->handlers()) {
 			auto *exception_handler_block = allocate_block(m_function_id);
@@ -2317,13 +2314,14 @@ Value *BytecodeGenerator::visit(const Try *node)
 			if (!handler->type()) {
 				if (handler != *(node->handlers().end() - 1)) {
 					// FIXME: implement SyntaxError and error throwing when parsing source code
-					spdlog::error("SyntaxError: default 'except:' must be last");
+					::detail::log_error(
+						std::format("SyntaxError: default 'except:' must be last").c_str());
 					std::abort();
 				}
 				next_exception_label = nullptr;
 			} else {
 				next_exception_label =
-					make_label(fmt::format("TRY_EXC_COUNT_{}_{}", try_op_count, exception_count++),
+					make_label(std::format("TRY_EXC_COUNT_{}_{}", try_op_count, exception_count++),
 						m_function_id);
 				auto *exception_type = generate(handler->type(), m_function_id);
 				emit<JumpIfNotExceptionMatch>(exception_type->get_register(), next_exception_label);
@@ -2419,8 +2417,8 @@ Value *BytecodeGenerator::visit(const UnaryExpr *node)
 
 Value *BytecodeGenerator::visit(const BoolOp *node)
 {
-	static size_t bool_op_count = 0;
-	auto end_label = make_label(fmt::format("BOOL_OP_END_{}", bool_op_count++), m_function_id);
+	static std::size_t bool_op_count = 0;
+	auto end_label = make_label(std::format("BOOL_OP_END_{}", bool_op_count++), m_function_id);
 	auto *result = create_value();
 	auto *last_result = create_value();
 	switch (node->op()) {
@@ -2453,8 +2451,8 @@ Value *BytecodeGenerator::visit(const BoolOp *node)
 
 Value *BytecodeGenerator::visit(const Assert *node)
 {
-	static size_t assert_count = 0;
-	auto end_label = make_label(fmt::format("ASSERT_END_{}", assert_count++), m_function_id);
+	static std::size_t assert_count = 0;
+	auto end_label = make_label(std::format("ASSERT_END_{}", assert_count++), m_function_id);
 
 	auto *test_result = generate(node->test(), m_function_id);
 
@@ -2495,14 +2493,17 @@ Value *BytecodeGenerator::visit(const JoinedStr *node)
 	const auto only_static_strings =
 		std::all_of(node->values().begin(), node->values().end(), [](const ASTNode *value) {
 			return as<Constant>(value)
-				   && std::holds_alternative<py::String>(*as<Constant>(value)->value());
+				   && std::holds_alternative<py::String>(
+					   to_runtime_value(as<Constant>(value)->value()));
 		});
 	if (only_static_strings) {
 		const auto string = std::accumulate(node->values().begin(),
 			node->values().end(),
 			py::String{},
 			[](py::String s, const ASTNode *value) {
-				return py::String{ s.s + std::get<py::String>(*as<Constant>(value)->value()).s };
+				return py::String{
+					s.s + std::get<py::String>(to_runtime_value(as<Constant>(value)->value())).s
+				};
 			});
 		auto *static_string = load_const(string, m_function_id);
 		auto *string_value = create_value();
@@ -2512,8 +2513,10 @@ Value *BytecodeGenerator::visit(const JoinedStr *node)
 	py::String current_string;
 	std::vector<Register> strings;
 	for (const auto &value : node->values()) {
-		if (auto c = as<Constant>(value); c && std::holds_alternative<py::String>(*c->value())) {
-			current_string.s += std::get<py::String>(*as<Constant>(value)->value()).s;
+		if (auto c = as<Constant>(value);
+			c && std::holds_alternative<py::String>(to_runtime_value(c->value()))) {
+			current_string.s +=
+				std::get<py::String>(to_runtime_value(as<Constant>(value)->value())).s;
 		} else {
 			BytecodeValue *string_value = nullptr;
 			if (!current_string.s.empty()) {
@@ -2545,7 +2548,7 @@ Value *BytecodeGenerator::visit(const FormattedValue *node)
 	ASSERT(value);
 	auto *dst = create_value();
 	emit<FormatValue>(
-		dst->get_register(), value->get_register(), static_cast<uint8_t>(node->conversion()));
+		dst->get_register(), value->get_register(), static_cast<std::uint8_t>(node->conversion()));
 	return dst;
 }
 
@@ -2554,7 +2557,7 @@ Value *BytecodeGenerator::visit(const Comprehension *) { TODO(); }
 std::tuple<std::vector<std::shared_ptr<Label>>, std::vector<std::shared_ptr<Label>>>
 	BytecodeGenerator::visit_comprehension(const std::vector<Comprehension *> &comprehensions)
 {
-	static size_t comprehension_count = 0;
+	static std::size_t comprehension_count = 0;
 
 	std::vector<std::shared_ptr<Label>> start_labels;
 	std::vector<std::shared_ptr<Label>> end_labels;
@@ -2566,9 +2569,9 @@ std::tuple<std::vector<std::shared_ptr<Label>>, std::vector<std::shared_ptr<Labe
 	for (bool first = true; const auto &comprehension : comprehensions) {
 		auto *node = comprehension;
 		auto start_label =
-			make_label(fmt::format("COMPREHENSION_START_{}", comprehension_count), m_function_id);
+			make_label(std::format("COMPREHENSION_START_{}", comprehension_count), m_function_id);
 		auto end_label =
-			make_label(fmt::format("COMPREHENSION_END_{}", comprehension_count++), m_function_id);
+			make_label(std::format("COMPREHENSION_END_{}", comprehension_count++), m_function_id);
 
 		if (!first) {
 			auto iterable = generate(comprehension->iter(), m_function_id);
@@ -3048,7 +3051,9 @@ Value *BytecodeGenerator::visit(const Await *node)
 	return result;
 }
 
-FunctionInfo::FunctionInfo(size_t function_id_, FunctionBlock &f, BytecodeGenerator *generator_)
+FunctionInfo::FunctionInfo(std::size_t function_id_,
+	FunctionBlock &f,
+	BytecodeGenerator *generator_)
 	: function_id(function_id_), function(f), generator(generator_)
 {
 	generator->enter_function();
@@ -3065,7 +3070,7 @@ BytecodeGenerator::BytecodeGenerator()
 
 BytecodeGenerator::~BytecodeGenerator() {}
 
-void BytecodeGenerator::exit_function(size_t function_id)
+void BytecodeGenerator::exit_function(std::size_t function_id)
 {
 	ASSERT(function_id < m_functions.functions.size());
 	auto function = std::next(m_functions.functions.begin(), function_id);
@@ -3095,7 +3100,7 @@ BytecodeFunctionValue *BytecodeGenerator::create_function(const std::string &nam
 void BytecodeGenerator::relocate_labels(const FunctionBlocks &functions)
 {
 	for (const auto &function : functions.functions) {
-		size_t instruction_idx{ 0 };
+		std::size_t instruction_idx{ 0 };
 		for (const auto &ins : function.blocks) { ins->relocate(instruction_idx++); }
 	}
 }
@@ -3110,7 +3115,7 @@ std::shared_ptr<Program> BytecodeGenerator::generate_executable(std::string file
 	return BytecodeProgram::create(std::move(m_functions), filename, argv);
 }
 
-InstructionVector *BytecodeGenerator::allocate_block(size_t function_id)
+InstructionVector *BytecodeGenerator::allocate_block(std::size_t function_id)
 {
 	ASSERT(function_id < m_functions.functions.size());
 
@@ -3122,13 +3127,13 @@ void BytecodeGenerator::record_location_for_next_instruction()
 {
 	ASSERT(m_function_id < m_functions.functions.size());
 	auto &func = *std::next(m_functions.functions.begin(), m_function_id);
-	const auto line = static_cast<uint32_t>(m_current_source_location.start.row + 1);
-	const auto column = static_cast<uint32_t>(m_current_source_location.start.column);
+	const auto line = static_cast<std::uint32_t>(m_current_source_location.start.row + 1);
+	const auto column = static_cast<std::uint32_t>(m_current_source_location.start.column);
 	auto &locations = func.instruction_locations;
 	if (!locations.empty() && locations.back().line == line && locations.back().column == column) {
 		return;
 	}
-	const auto next_instruction_index = static_cast<uint32_t>(func.blocks.size());
+	const auto next_instruction_index = static_cast<std::uint32_t>(func.blocks.size());
 	locations.emplace_back(next_instruction_index, line, column);
 }
 
@@ -3148,33 +3153,38 @@ std::shared_ptr<Program> BytecodeGenerator::compile(std::shared_ptr<ast::Module>
 	generator.m_variable_visibility = VariablesResolver::resolve(module);
 
 	for (const auto &[scope_name, scope] : generator.m_variable_visibility) {
-		spdlog::debug("Scope name: {}", scope_name);
+		::detail::log_debug(std::format("Scope name: {}", scope_name).c_str());
 		const auto &symbol_map = scope->symbol_map;
 		for (const auto &symbol : symbol_map.symbols) {
 			const auto &k = symbol.name;
 			const auto &v = symbol.visibility;
 			const auto &source_location = symbol.source_location;
+			const auto loc = std::format("[{}:{}-{}:{}]",
+				source_location.start.row,
+				source_location.start.column,
+				source_location.end.row,
+				source_location.end.column);
 			switch (v) {
 			case VariablesResolver::Visibility::NAME: {
-				spdlog::debug("  - {}: NAME {}", k, source_location);
+				::detail::log_debug(std::format("  - {}: NAME {}", k, loc).c_str());
 			} break;
 			case VariablesResolver::Visibility::LOCAL: {
-				spdlog::debug("  - {}: LOCAL {}", k, source_location);
+				::detail::log_debug(std::format("  - {}: LOCAL {}", k, loc).c_str());
 			} break;
 			case VariablesResolver::Visibility::FREE: {
-				spdlog::debug("  - {}: FREE {}", k, source_location);
+				::detail::log_debug(std::format("  - {}: FREE {}", k, loc).c_str());
 			} break;
 			case VariablesResolver::Visibility::CELL: {
-				spdlog::debug("  - {}: CELL {}", k, source_location);
+				::detail::log_debug(std::format("  - {}: CELL {}", k, loc).c_str());
 			} break;
 			case VariablesResolver::Visibility::EXPLICIT_GLOBAL: {
-				spdlog::debug("  - {}: EXPLICIT GLOBAL {}", k, source_location);
+				::detail::log_debug(std::format("  - {}: EXPLICIT GLOBAL {}", k, loc).c_str());
 			} break;
 			case VariablesResolver::Visibility::IMPLICIT_GLOBAL: {
-				spdlog::debug("  - {}: IMPLICIT GLOBAL {}", k, source_location);
+				::detail::log_debug(std::format("  - {}: IMPLICIT GLOBAL {}", k, loc).c_str());
 			} break;
 			case VariablesResolver::Visibility::HIDDEN: {
-				spdlog::debug("  - {}: HIDDEN {}", k, source_location);
+				::detail::log_debug(std::format("  - {}: HIDDEN {}", k, loc).c_str());
 			} break;
 			}
 		}
diff --git a/src/executable/bytecode/codegen/BytecodeGenerator.hpp b/src/executable/bytecode/codegen/BytecodeGenerator.cppm
similarity index 74%
rename from src/executable/bytecode/codegen/BytecodeGenerator.hpp
rename to src/executable/bytecode/codegen/BytecodeGenerator.cppm
index d1dfcd5e..26b39a76 100644
--- a/src/executable/bytecode/codegen/BytecodeGenerator.hpp
+++ b/src/executable/bytecode/codegen/BytecodeGenerator.cppm
@@ -1,26 +1,31 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "VariablesResolver.hpp"
-#include "ast/AST.hpp"
-#include "ast/optimizers/ConstantFolding.hpp"
-#include "executable/FunctionBlock.hpp"
+#include "ast/ASTNodeTypes.hpp"
+#include "core.hpp"
 #include "executable/Label.hpp"
-#include "executable/bytecode/instructions/Instructions.hpp"
+#include "executable/common.hpp"
 
-#include "forward.hpp"
-#include "utilities.hpp"
 
-namespace codegen {
+export module py.codegen:bytecode_generator;
+import py.ast;
+import py.runtime;
+import std;
+import :variables_resolver;
+
+export py::Value to_runtime_value(const ast::Literal &literal);
+
+export namespace codegen {
 
 class BytecodeGenerator;
 
 struct FunctionInfo
 {
-	size_t function_id;
+	std::size_t function_id;
 	FunctionBlock &function;
 	BytecodeGenerator *generator;
 
-	FunctionInfo(size_t, FunctionBlock &, BytecodeGenerator *);
+	FunctionInfo(std::size_t, FunctionBlock &, BytecodeGenerator *);
 };
 
 class BytecodeValue : public ast::Value
@@ -39,24 +44,25 @@ class BytecodeValue : public ast::Value
 
 class BytecodeStaticValue : public ast::Value
 {
-	size_t m_index;
+	std::size_t m_index;
 
   public:
-	BytecodeStaticValue(size_t index) : ast::Value("constant"), m_index(index) {}
+	BytecodeStaticValue(std::size_t index) : ast::Value("constant"), m_index(index) {}
 
-	size_t get_index() const { return m_index; }
+	std::size_t get_index() const { return m_index; }
 
 	virtual bool is_function() const { return false; }
 };
 
 class BytecodeNameValue : public ast::Value
 {
-	size_t m_index;
+	std::size_t m_index;
 
   public:
-	BytecodeNameValue(const std::string &name, size_t index) : ast::Value(name), m_index(index) {}
+	BytecodeNameValue(const std::string &name, std::size_t index) : ast::Value(name), m_index(index)
+	{}
 
-	size_t get_index() const { return m_index; }
+	std::size_t get_index() const { return m_index; }
 
 	virtual bool is_function() const { return false; }
 };
@@ -162,7 +168,7 @@ class BytecodeGenerator : public ast::CodeGenerator
 
 	struct ScopedClearExceptionBeforeReturn
 	{
-		ScopedClearExceptionBeforeReturn(BytecodeGenerator &generator_, size_t function_id_)
+		ScopedClearExceptionBeforeReturn(BytecodeGenerator &generator_, std::size_t function_id_)
 			: generator(generator_), function_id(function_id_)
 		{
 			if (!generator.m_clear_exception_before_return_functions.contains(function_id)) {
@@ -180,7 +186,7 @@ class BytecodeGenerator : public ast::CodeGenerator
 
 	  private:
 		BytecodeGenerator &generator;
-		const size_t function_id;
+		const std::size_t function_id;
 		bool requires_cleanup{ false };
 	};
 
@@ -188,7 +194,7 @@ class BytecodeGenerator : public ast::CodeGenerator
 	{
 		ScopedWithStatement(BytecodeGenerator &generator_,
 			std::function<void(bool)> return_transform,
-			size_t function_id_)
+			std::size_t function_id_)
 			: generator(generator_), function_id(function_id_)
 		{
 			generator.m_return_transform[function_id].push_back(std::move(return_transform));
@@ -205,21 +211,21 @@ class BytecodeGenerator : public ast::CodeGenerator
 
 	  protected:
 		BytecodeGenerator &generator;
-		const size_t function_id;
+		const std::size_t function_id;
 	};
 
 	struct ScopedTryStatement : ScopedWithStatement
 	{
 		ScopedTryStatement(BytecodeGenerator &generator_,
 			std::function<void(bool)> return_transform,
-			size_t function_id_)
+			std::size_t function_id_)
 			: ScopedWithStatement(generator_, return_transform, function_id_)
 		{}
 	};
 
   public:
-	static constexpr size_t start_register = 1;
-	static constexpr size_t start_stack_index = 0;
+	static constexpr std::size_t start_register = 1;
+	static constexpr std::size_t start_stack_index = 0;
 
   private:
 	FunctionBlocks m_functions;
@@ -229,27 +235,27 @@ class BytecodeGenerator : public ast::CodeGenerator
 	std::unordered_map<std::string, std::unique_ptr<VariablesResolver::Scope>>
 		m_variable_visibility;
 
-	size_t m_function_id{ 0 };
+	std::size_t m_function_id{ 0 };
 	InstructionVector *m_current_block{ nullptr };
 
 	// a non-owning list of all generated Labels
 	std::vector<std::shared_ptr<Label>> m_labels;
 
-	std::vector<size_t> m_frame_register_count;
-	std::vector<size_t> m_frame_stack_value_count;
-	std::vector<size_t> m_frame_free_var_count;
+	std::vector<std::size_t> m_frame_register_count;
+	std::vector<std::size_t> m_frame_stack_value_count;
+	std::vector<std::size_t> m_frame_free_var_count;
 
-	std::unordered_map<std::string, std::reference_wrapper<size_t>> m_function_free_var_count;
+	std::unordered_map<std::string, std::reference_wrapper<std::size_t>> m_function_free_var_count;
 
-	size_t m_value_index{ 0 };
+	std::size_t m_value_index{ 0 };
 	ASTContext m_ctx;
 	std::stack<Scope> m_stack;
 
 	SourceLocation m_current_source_location{};
 
-	std::set<size_t> m_clear_exception_before_return_functions;
-	std::unordered_map<size_t, std::vector<std::function<void(bool)>>> m_return_transform;
-	std::unordered_map<size_t, size_t> m_current_exception_depth;
+	std::set<std::size_t> m_clear_exception_before_return_functions;
+	std::unordered_map<std::size_t, std::vector<std::function<void(bool)>>> m_return_transform;
+	std::unordered_map<std::size_t, std::size_t> m_current_exception_depth;
 
   public:
 	static std::shared_ptr<Program> compile(std::shared_ptr<ast::Module> node,
@@ -275,64 +281,31 @@ class BytecodeGenerator : public ast::CodeGenerator
 
 	const FunctionBlocks &functions() const { return m_functions; }
 
-	const InstructionVector &function(size_t idx) const
+	const InstructionVector &function(std::size_t idx) const
 	{
 		ASSERT(idx < m_functions.functions.size());
 		return std::next(m_functions.functions.begin(), idx)->blocks;
 	}
 
-	std::shared_ptr<Label> make_label(const std::string &name, size_t function_id)
-	{
-		spdlog::debug("New label to be added: name={} function_id={}", name, function_id);
-		auto new_label = std::make_shared<Label>(name, function_id);
-
-		ASSERT(std::find(m_labels.begin(), m_labels.end(), new_label) == m_labels.end());
-
-		m_labels.emplace_back(new_label);
-
-		return new_label;
-	}
+	std::shared_ptr<Label> make_label(const std::string &name, std::size_t function_id);
 
 	const std::vector<std::shared_ptr<Label>> &labels() const { return m_labels; }
 
-	void bind(const std::shared_ptr<Label> &label)
-	{
-		ASSERT(std::find(m_labels.begin(), m_labels.end(), label) != m_labels.end());
-		auto &instructions = function(label->function_id());
-		const auto instructions_size = instructions.size();
-		const size_t current_instruction_position = instructions_size;
-		label->set_position(current_instruction_position);
-		spdlog::debug("bound label {}", label->name());
-	}
+	void bind(const std::shared_ptr<Label> &label);
 
-	size_t register_count() const { return m_frame_register_count.back(); }
-	size_t stack_variable_count() const { return m_frame_stack_value_count.back(); }
-	size_t free_variable_count() const { return m_frame_free_var_count.back(); }
+	std::size_t register_count() const { return m_frame_register_count.back(); }
+	std::size_t stack_variable_count() const { return m_frame_stack_value_count.back(); }
+	std::size_t free_variable_count() const { return m_frame_free_var_count.back(); }
 
-	Register allocate_register()
-	{
-		spdlog::debug("New register: {}", m_frame_register_count.back());
-		ASSERT(m_frame_register_count.back() < std::numeric_limits<Register>::max());
-		return static_cast<Register>(m_frame_register_count.back()++);
-	}
+	Register allocate_register();
 
-	Register allocate_stack_value()
-	{
-		spdlog::debug("New stack value: {}", m_frame_stack_value_count.back());
-		ASSERT(m_frame_stack_value_count.back() < std::numeric_limits<Register>::max());
-		return static_cast<Register>(m_frame_stack_value_count.back()++);
-	}
+	Register allocate_stack_value();
 
-	Register allocate_free_value()
-	{
-		spdlog::debug("New free value: {}", m_frame_free_var_count.back());
-		ASSERT(m_frame_free_var_count.back() < std::numeric_limits<Register>::max());
-		return static_cast<Register>(m_frame_free_var_count.back()++);
-	}
+	Register allocate_free_value();
 
 	BytecodeFunctionValue *create_function(const std::string &);
 
-	InstructionVector *allocate_block(size_t);
+	InstructionVector *allocate_block(std::size_t);
 
 	void enter_function()
 	{
@@ -341,14 +314,14 @@ class BytecodeGenerator : public ast::CodeGenerator
 		m_frame_free_var_count.emplace_back(start_stack_index);
 	}
 
-	void exit_function(size_t function_id);
+	void exit_function(std::size_t function_id);
 
 	void store_name(const std::string &, BytecodeValue *);
 	BytecodeValue *load_var(const std::string &);
 	void delete_var(const std::string &);
 
-	BytecodeStaticValue *load_const(const py::Value &, size_t);
-	BytecodeNameValue *load_name(const std::string &, size_t);
+	BytecodeStaticValue *load_const(const py::Value &, std::size_t);
+	BytecodeNameValue *load_name(const std::string &, std::size_t);
 
 	BytecodeValue *build_slice(const ast::Subscript::SliceType &);
 	BytecodeValue *build_dict(const std::vector<std::optional<Register>> &,
@@ -372,7 +345,7 @@ class BytecodeGenerator : public ast::CodeGenerator
 	AST_NODE_TYPES
 #undef __AST_NODE_TYPE
 
-	BytecodeValue *generate(const ast::ASTNode *node, size_t function_id)
+	BytecodeValue *generate(const ast::ASTNode *node, std::size_t function_id)
 	{
 		m_ctx.push_node(node);
 		const auto old_function_id = m_function_id;
diff --git a/src/executable/bytecode/codegen/BytecodeGenerator_tests.cpp b/src/executable/bytecode/codegen/BytecodeGenerator_tests.cpp
index 304d7792..720875e8 100644
--- a/src/executable/bytecode/codegen/BytecodeGenerator_tests.cpp
+++ b/src/executable/bytecode/codegen/BytecodeGenerator_tests.cpp
@@ -1,13 +1,14 @@
-#include "../Bytecode.hpp"
-#include "../BytecodeProgram.hpp"
-#include "BytecodeGenerator.hpp"
+#include "core.hpp"
 #include "executable/common.hpp"
-#include "lexer/Lexer.hpp"
-#include "parser/Parser.hpp"
-#include "runtime/PyCode.hpp"
-
 #include "gtest/gtest.h"
 
+import py.lexer;
+import py.runtime;
+import py.codegen;
+import py.ast;
+
+// After the import: these name module-owned types.
+
 
 namespace {
 std::shared_ptr<BytecodeProgram> generate_bytecode(std::string_view program)
diff --git a/src/executable/bytecode/codegen/VariablesResolver.cpp b/src/executable/bytecode/codegen/VariablesResolver.cpp
index 129254c8..b58bede5 100644
--- a/src/executable/bytecode/codegen/VariablesResolver.cpp
+++ b/src/executable/bytecode/codegen/VariablesResolver.cpp
@@ -1,7 +1,10 @@
-#include "VariablesResolver.hpp"
-#include "executable/Mangler.hpp"
+module;
+#include "core.hpp"
+
+module py.codegen;
+import py.ast;
+import std;
 
-#include <filesystem>
 
 namespace fs = std::filesystem;
 
@@ -391,7 +394,7 @@ Value *VariablesResolver::visit(const Delete *node)
 Value *VariablesResolver::visit(const Dict *node)
 {
 	ASSERT(node->keys().size() == node->values().size());
-	for (size_t i = 0; i < node->keys().size(); ++i) {
+	for (std::size_t i = 0; i < node->keys().size(); ++i) {
 		if (const auto &key = node->keys()[i]) { key->codegen(this); }
 		const auto &value = node->values()[i];
 		ASSERT(value);
@@ -537,12 +540,14 @@ Value *VariablesResolver::visit(const Global *node)
 			if (it->get().visibility == Visibility::NAME
 				|| it->get().visibility == Visibility::LOCAL) {
 				// TODO: raise SyntaxError
-				spdlog::error(
-					"SyntaxError: name '{}' is assigned to before global declaration", name);
+				::detail::log_error(std::format(
+					"SyntaxError: name '{}' is assigned to before global declaration", name)
+						.c_str());
 				std::abort();
 			} else if (captured_by_closure(it->get().visibility)) {
 				// TODO: raise SyntaxError
-				spdlog::error("SyntaxError: name '{}' is nonlocal and global", name);
+				::detail::log_error(
+					std::format("SyntaxError: name '{}' is nonlocal and global", name).c_str());
 				std::abort();
 			}
 		}
@@ -561,17 +566,20 @@ Value *VariablesResolver::visit(const NonLocal *node)
 		if (auto it = visibility.get_visible_symbol(name); it.has_value()) {
 			if (it->get().visibility == Visibility::EXPLICIT_GLOBAL) {
 				// TODO: raise SyntaxError
-				spdlog::error("SyntaxError: name '{}' is nonlocal and global", name);
+				::detail::log_error(
+					std::format("SyntaxError: name '{}' is nonlocal and global", name).c_str());
 				std::abort();
 			} else if (it->get().visibility == Visibility::NAME
 					   || it->get().visibility == Visibility::LOCAL) {
 				// TODO: raise SyntaxError
-				spdlog::error(
-					"SyntaxError: name '{}' is assigned to before nonlocal declaration", name);
+				::detail::log_error(std::format(
+					"SyntaxError: name '{}' is assigned to before nonlocal declaration", name)
+						.c_str());
 				std::abort();
 			} else if (captured_by_closure(it->get().visibility)) {
 				// TODO: raise SyntaxError
-				spdlog::error("SyntaxError: name '{}' is nonlocal and global", name);
+				::detail::log_error(
+					std::format("SyntaxError: name '{}' is nonlocal and global", name).c_str());
 				std::abort();
 			}
 		}
@@ -614,7 +622,7 @@ Value *VariablesResolver::visit(const Import *node)
 	return nullptr;
 }
 
-Value *VariablesResolver::visit(const ImportFrom *node)
+Value *VariablesResolver::visit(const ast::ImportFrom *node)
 {
 	for (const auto &name : node->names()) {
 		if (!name.asname.empty()) {
@@ -741,7 +749,7 @@ Value *VariablesResolver::visit(const Yield *node)
 	return nullptr;
 }
 
-Value *VariablesResolver::visit(const YieldFrom *node)
+Value *VariablesResolver::visit(const ast::YieldFrom *node)
 {
 	ASSERT(m_current_scope->get().type == Scope::Type::FUNCTION
 		   || m_current_scope->get().type == Scope::Type::CLOSURE);
diff --git a/src/executable/bytecode/codegen/VariablesResolver.hpp b/src/executable/bytecode/codegen/VariablesResolver.cppm
similarity index 94%
rename from src/executable/bytecode/codegen/VariablesResolver.hpp
rename to src/executable/bytecode/codegen/VariablesResolver.cppm
index 2cc1b919..3903acb8 100644
--- a/src/executable/bytecode/codegen/VariablesResolver.hpp
+++ b/src/executable/bytecode/codegen/VariablesResolver.cppm
@@ -1,10 +1,15 @@
-#pragma once
+module;
 
-#include "ast/AST.hpp"
 
-#include <set>
+#include "ast/ASTNodeTypes.hpp"
+#include "core.hpp"
 
-class VariablesResolver : public ast::CodeGenerator
+export module py.codegen:variables_resolver;
+import py.ast;
+import std;
+
+
+export class VariablesResolver : public ast::CodeGenerator
 {
   public:
 	enum class Visibility {
diff --git a/src/executable/bytecode/codegen/VariablesResolver_tests.cpp b/src/executable/bytecode/codegen/VariablesResolver_tests.cpp
index dda5f93a..6c90f475 100644
--- a/src/executable/bytecode/codegen/VariablesResolver_tests.cpp
+++ b/src/executable/bytecode/codegen/VariablesResolver_tests.cpp
@@ -1,10 +1,12 @@
-#include "VariablesResolver.hpp"
-
-#include "lexer/Lexer.hpp"
-#include "parser/Parser.hpp"
-
+#include "core.hpp"
 #include "gtest/gtest.h"
 
+import py.lexer;
+import py.runtime;
+import py.codegen;
+import py.ast;
+
+// After the import: these name module-owned types.
 
 namespace {
 VariablesResolver::VisibilityMap generate_resolver(std::string_view program)
diff --git a/src/executable/bytecode/codegen/codegen.cppm b/src/executable/bytecode/codegen/codegen.cppm
new file mode 100644
index 00000000..b6ab8611
--- /dev/null
+++ b/src/executable/bytecode/codegen/codegen.cppm
@@ -0,0 +1,4 @@
+export module py.codegen;
+
+export import :bytecode_generator;
+export import :variables_resolver;
diff --git a/src/executable/bytecode/instructions/BinaryOperation.cpp b/src/executable/bytecode/instructions/BinaryOperation.cpp
index e465c175..691e788a 100644
--- a/src/executable/bytecode/instructions/BinaryOperation.cpp
+++ b/src/executable/bytecode/instructions/BinaryOperation.cpp
@@ -1,6 +1,14 @@
-#include "BinaryOperation.hpp"
-#include "runtime/Value.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/BinaryOperation.hpp b/src/executable/bytecode/instructions/BinaryOperation.hpp
index 8daf53a4..11380b3c 100644
--- a/src/executable/bytecode/instructions/BinaryOperation.hpp
+++ b/src/executable/bytecode/instructions/BinaryOperation.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class BinaryOperation : public Instruction
 {
   public:
@@ -34,8 +32,11 @@ class BinaryOperation : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format(
-			"BINARY_OP       r{:<3} r{:<3} r{:<3} ({})", m_destination, m_lhs, m_rhs, m_operation);
+		return std::format("BINARY_OP       r{:<3} r{:<3} r{:<3} ({})",
+			m_destination,
+			m_lhs,
+			m_rhs,
+			static_cast<int>(m_operation));
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/BinarySubscript.cpp b/src/executable/bytecode/instructions/BinarySubscript.cpp
index d358f266..df3ade9b 100644
--- a/src/executable/bytecode/instructions/BinarySubscript.cpp
+++ b/src/executable/bytecode/instructions/BinarySubscript.cpp
@@ -1,7 +1,14 @@
-#include "BinarySubscript.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/Value.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/BinarySubscript.hpp b/src/executable/bytecode/instructions/BinarySubscript.hpp
index dbc1a498..b0e87e53 100644
--- a/src/executable/bytecode/instructions/BinarySubscript.hpp
+++ b/src/executable/bytecode/instructions/BinarySubscript.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class BinarySubscript final : public Instruction
 {
 	Register m_dst;
@@ -15,7 +13,7 @@ class BinarySubscript final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("BINARY_SUBSCR   r{:<3} r{:<3} r{:<3}", m_dst, m_src, m_index);
+		return std::format("BINARY_SUBSCR   r{:<3} r{:<3} r{:<3}", m_dst, m_src, m_index);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &, Interpreter &) const final;
diff --git a/src/executable/bytecode/instructions/BuildDict.cpp b/src/executable/bytecode/instructions/BuildDict.cpp
index eb06c9d7..4ea7c410 100644
--- a/src/executable/bytecode/instructions/BuildDict.cpp
+++ b/src/executable/bytecode/instructions/BuildDict.cpp
@@ -1,6 +1,17 @@
-#include "BuildDict.hpp"
-#include "runtime/PyDict.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
+
+// After the import: this header names Instruction and Register, which the
+// module owns, so it cannot be parsed before py.runtime is visible.
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/BuildDict.hpp b/src/executable/bytecode/instructions/BuildDict.hpp
index 49793c45..382830fe 100644
--- a/src/executable/bytecode/instructions/BuildDict.hpp
+++ b/src/executable/bytecode/instructions/BuildDict.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class BuildDict final : public Instruction
 {
 	Register m_dst;
@@ -13,7 +10,7 @@ class BuildDict final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("BUILD_DICT      r{:<3} (size={})", m_dst, m_size);
+		return std::format("BUILD_DICT      r{:<3} (size={})", m_dst, m_size);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &, Interpreter &) const final;
diff --git a/src/executable/bytecode/instructions/BuildList.cpp b/src/executable/bytecode/instructions/BuildList.cpp
index 6991e5d8..f39cf8a9 100644
--- a/src/executable/bytecode/instructions/BuildList.cpp
+++ b/src/executable/bytecode/instructions/BuildList.cpp
@@ -1,6 +1,14 @@
-#include "BuildList.hpp"
-#include "runtime/PyList.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/BuildList.hpp b/src/executable/bytecode/instructions/BuildList.hpp
index da2208c5..00920ff1 100644
--- a/src/executable/bytecode/instructions/BuildList.hpp
+++ b/src/executable/bytecode/instructions/BuildList.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class BuildList final : public Instruction
 {
 	Register m_dst;
@@ -13,7 +10,7 @@ class BuildList final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("BUILD_LIST      r{:<3} (size={})", m_dst, m_size);
+		return std::format("BUILD_LIST      r{:<3} (size={})", m_dst, m_size);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &, Interpreter &) const final;
diff --git a/src/executable/bytecode/instructions/BuildSet.cpp b/src/executable/bytecode/instructions/BuildSet.cpp
index af35552b..ab555d70 100644
--- a/src/executable/bytecode/instructions/BuildSet.cpp
+++ b/src/executable/bytecode/instructions/BuildSet.cpp
@@ -1,6 +1,14 @@
-#include "BuildSet.hpp"
-#include "runtime/PySet.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/BuildSet.hpp b/src/executable/bytecode/instructions/BuildSet.hpp
index 4f1745d9..13146b1f 100644
--- a/src/executable/bytecode/instructions/BuildSet.hpp
+++ b/src/executable/bytecode/instructions/BuildSet.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class BuildSet final : public Instruction
 {
 	Register m_dst;
@@ -12,7 +10,7 @@ class BuildSet final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("BUILD_SET       r{:<3} ({})", m_dst, m_size);
+		return std::format("BUILD_SET       r{:<3} ({})", m_dst, m_size);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &, Interpreter &) const final;
diff --git a/src/executable/bytecode/instructions/BuildSlice.cpp b/src/executable/bytecode/instructions/BuildSlice.cpp
index bb1c674c..48b0a5f8 100644
--- a/src/executable/bytecode/instructions/BuildSlice.cpp
+++ b/src/executable/bytecode/instructions/BuildSlice.cpp
@@ -1,7 +1,14 @@
-#include "BuildSlice.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PySlice.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/BuildSlice.hpp b/src/executable/bytecode/instructions/BuildSlice.hpp
index 13670364..43bfd273 100644
--- a/src/executable/bytecode/instructions/BuildSlice.hpp
+++ b/src/executable/bytecode/instructions/BuildSlice.hpp
@@ -1,15 +1,11 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-#include <optional>
-
 class BuildSlice final : public Instruction
 {
 	Register m_dst;
-	std::optional<size_t> m_start;
-	std::optional<size_t> m_end;
-	std::optional<size_t> m_step;
+	std::optional<std::size_t> m_start;
+	std::optional<std::size_t> m_end;
+	std::optional<std::size_t> m_step;
 
 
   public:
@@ -25,20 +21,20 @@ class BuildSlice final : public Instruction
 	std::string to_string() const final
 	{
 		if (!m_end) {
-			return fmt::format("BUILD_SLICE r{:<3} r{:<3}", m_dst, *m_start);
+			return std::format("BUILD_SLICE r{:<3} r{:<3}", m_dst, *m_start);
 		} else if (!m_step) {
-			return fmt::format("BUILD_SLICE r{:<3} r{:<3} r{:<3}", m_dst, *m_start, *m_end);
+			return std::format("BUILD_SLICE r{:<3} r{:<3} r{:<3}", m_dst, *m_start, *m_end);
 		} else {
-			return fmt::format(
+			return std::format(
 				"BUILD_SLICE r{:<3} r{:<3} r{:<3} r{:<3}", m_dst, *m_start, *m_end, *m_step);
 		}
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &, Interpreter &) const final;
 
-	void relocate(size_t) final {}
+	void relocate(std::size_t) final {}
 
-	std::vector<uint8_t> serialize() const final;
+	std::vector<std::uint8_t> serialize() const final;
 
-	uint8_t id() const final { return BUILD_SET; }
+	std::uint8_t id() const final { return BUILD_SET; }
 };
diff --git a/src/executable/bytecode/instructions/BuildString.cpp b/src/executable/bytecode/instructions/BuildString.cpp
index 37b93820..063eedfa 100644
--- a/src/executable/bytecode/instructions/BuildString.cpp
+++ b/src/executable/bytecode/instructions/BuildString.cpp
@@ -1,6 +1,14 @@
-#include "BuildString.hpp"
-#include "runtime/PyString.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/BuildString.hpp b/src/executable/bytecode/instructions/BuildString.hpp
index d1eeedb5..18ef748a 100644
--- a/src/executable/bytecode/instructions/BuildString.hpp
+++ b/src/executable/bytecode/instructions/BuildString.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class BuildString final : public Instruction
 {
 	Register m_dst;
@@ -12,7 +10,7 @@ class BuildString final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("BUILD_STRING    r{:<3} ({})", m_dst, m_size);
+		return std::format("BUILD_STRING    r{:<3} ({})", m_dst, m_size);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &, Interpreter &) const final;
diff --git a/src/executable/bytecode/instructions/BuildTuple.cpp b/src/executable/bytecode/instructions/BuildTuple.cpp
index fce8c3cc..80990193 100644
--- a/src/executable/bytecode/instructions/BuildTuple.cpp
+++ b/src/executable/bytecode/instructions/BuildTuple.cpp
@@ -1,6 +1,14 @@
-#include "BuildTuple.hpp"
-#include "runtime/PyTuple.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/BuildTuple.hpp b/src/executable/bytecode/instructions/BuildTuple.hpp
index 90795c9a..714f5e8f 100644
--- a/src/executable/bytecode/instructions/BuildTuple.hpp
+++ b/src/executable/bytecode/instructions/BuildTuple.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class BuildTuple final : public Instruction
 {
 	Register m_dst;
@@ -12,7 +10,7 @@ class BuildTuple final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("BUILD_TUPLE     r{:<3} ({})", m_dst, m_size);
+		return std::format("BUILD_TUPLE     r{:<3} ({})", m_dst, m_size);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &, Interpreter &) const final;
diff --git a/src/executable/bytecode/instructions/ClearExceptionState.cpp b/src/executable/bytecode/instructions/ClearExceptionState.cpp
index 5fca8c11..6534d021 100644
--- a/src/executable/bytecode/instructions/ClearExceptionState.cpp
+++ b/src/executable/bytecode/instructions/ClearExceptionState.cpp
@@ -1,9 +1,15 @@
-#include "ClearExceptionState.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/BaseException.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyTraceback.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include "spdlog/spdlog.h"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/ClearExceptionState.hpp b/src/executable/bytecode/instructions/ClearExceptionState.hpp
index 04538c07..84adddc2 100644
--- a/src/executable/bytecode/instructions/ClearExceptionState.hpp
+++ b/src/executable/bytecode/instructions/ClearExceptionState.hpp
@@ -1,12 +1,10 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class ClearExceptionState final : public Instruction
 {
   public:
 	ClearExceptionState() = default;
-	std::string to_string() const final { return fmt::format("CLEAR_EXC"); }
+	std::string to_string() const final { return std::format("CLEAR_EXC"); }
 
 	py::PyResult<py::Value> execute(VirtualMachine &, Interpreter &) const final;
 
diff --git a/src/executable/bytecode/instructions/ClearTopCleanup.cpp b/src/executable/bytecode/instructions/ClearTopCleanup.cpp
index 969f794b..1a168160 100644
--- a/src/executable/bytecode/instructions/ClearTopCleanup.cpp
+++ b/src/executable/bytecode/instructions/ClearTopCleanup.cpp
@@ -1,6 +1,14 @@
-#include "ClearTopCleanup.hpp"
-#include "runtime/PyNone.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/ClearTopCleanup.hpp b/src/executable/bytecode/instructions/ClearTopCleanup.hpp
index 54556817..be13a25d 100644
--- a/src/executable/bytecode/instructions/ClearTopCleanup.hpp
+++ b/src/executable/bytecode/instructions/ClearTopCleanup.hpp
@@ -1,12 +1,10 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class ClearTopCleanup final : public Instruction
 {
   public:
 	ClearTopCleanup() = default;
-	std::string to_string() const final { return fmt::format("CLEAR_TOP_CLEANUP"); }
+	std::string to_string() const final { return std::format("CLEAR_TOP_CLEANUP"); }
 
 	py::PyResult<py::Value> execute(VirtualMachine &, Interpreter &) const final;
 
diff --git a/src/executable/bytecode/instructions/CompareOperation.cpp b/src/executable/bytecode/instructions/CompareOperation.cpp
index f6ad9e91..5446c0a9 100644
--- a/src/executable/bytecode/instructions/CompareOperation.cpp
+++ b/src/executable/bytecode/instructions/CompareOperation.cpp
@@ -1,7 +1,14 @@
-#include "CompareOperation.hpp"
-#include "runtime/PyBool.hpp"
-#include "runtime/Value.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/CompareOperation.hpp b/src/executable/bytecode/instructions/CompareOperation.hpp
index 49551fd3..b2d15ac6 100644
--- a/src/executable/bytecode/instructions/CompareOperation.hpp
+++ b/src/executable/bytecode/instructions/CompareOperation.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class CompareOperation final : public Instruction
 {
   public:
@@ -32,8 +29,11 @@ class CompareOperation final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format(
-			"COMPARE_OP      r{:<3} r{:<3} r{:<3} ({})", m_dst, m_lhs, m_rhs, m_comparisson);
+		return std::format("COMPARE_OP      r{:<3} r{:<3} r{:<3} ({})",
+			m_dst,
+			m_lhs,
+			m_rhs,
+			static_cast<int>(m_comparisson));
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/DeleteAttr.cpp b/src/executable/bytecode/instructions/DeleteAttr.cpp
index 51a656da..f786bfae 100644
--- a/src/executable/bytecode/instructions/DeleteAttr.cpp
+++ b/src/executable/bytecode/instructions/DeleteAttr.cpp
@@ -1,9 +1,14 @@
-#include "DeleteAttr.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyString.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
@@ -11,14 +16,17 @@ PyResult<Value> DeleteAttr::execute(VirtualMachine &vm, Interpreter &intepreter)
 {
 	auto this_value = vm.reg(m_self);
 	const auto &attr_name_ = intepreter.execution_frame()->names(m_attr_name);
-	spdlog::debug("This object: {}",
-		std::visit(
-			[](const auto &val) {
-				auto obj = PyObject::from(val);
-				ASSERT(obj.is_ok());
-				return obj.unwrap()->to_string();
-			},
-			this_value));
+	if (::detail::log_debug_enabled()) {
+		::detail::log_debug(std::format("This object: {}",
+			std::visit(
+				[](const auto &val) {
+					auto obj = PyObject::from(val);
+					ASSERT(obj.is_ok());
+					return obj.unwrap()->to_string();
+				},
+				this_value))
+				.c_str());
+	}
 	if (auto *this_obj = std::get_if<PyObject *>(&this_value)) {
 		auto attr_name = PyString::create(attr_name_);
 		if (attr_name.is_err()) { return Err(attr_name.unwrap_err()); }
diff --git a/src/executable/bytecode/instructions/DeleteAttr.hpp b/src/executable/bytecode/instructions/DeleteAttr.hpp
index 9311a7df..dfaa0fb2 100644
--- a/src/executable/bytecode/instructions/DeleteAttr.hpp
+++ b/src/executable/bytecode/instructions/DeleteAttr.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class DeleteAttr final : public Instruction
 {
 	Register m_self;
@@ -13,7 +10,7 @@ class DeleteAttr final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("DELETE_ATTR     r{:<3} ({})", m_self, m_attr_name);
+		return std::format("DELETE_ATTR     r{:<3} ({})", m_self, m_attr_name);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/DeleteDeref.cpp b/src/executable/bytecode/instructions/DeleteDeref.cpp
index 6a718a8c..a1506441 100644
--- a/src/executable/bytecode/instructions/DeleteDeref.cpp
+++ b/src/executable/bytecode/instructions/DeleteDeref.cpp
@@ -1,10 +1,14 @@
-#include "DeleteDeref.hpp"
-#include "executable/bytecode/instructions/Instructions.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyCell.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyNone.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/DeleteDeref.hpp b/src/executable/bytecode/instructions/DeleteDeref.hpp
index 2ecce93f..9cd05501 100644
--- a/src/executable/bytecode/instructions/DeleteDeref.hpp
+++ b/src/executable/bytecode/instructions/DeleteDeref.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class DeleteDeref final : public Instruction
 {
 	Register m_src;
@@ -10,7 +7,7 @@ class DeleteDeref final : public Instruction
   public:
 	DeleteDeref(Register src) : m_src(src) {}
 
-	std::string to_string() const final { return fmt::format("DELETE_DEREF    f{:<3}", m_src); }
+	std::string to_string() const final { return std::format("DELETE_DEREF    f{:<3}", m_src); }
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
diff --git a/src/executable/bytecode/instructions/DeleteFast.cpp b/src/executable/bytecode/instructions/DeleteFast.cpp
index d5dc4bc9..89aaa3e8 100644
--- a/src/executable/bytecode/instructions/DeleteFast.cpp
+++ b/src/executable/bytecode/instructions/DeleteFast.cpp
@@ -1,6 +1,14 @@
-#include "DeleteFast.hpp"
-#include "runtime/PyNone.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/DeleteFast.hpp b/src/executable/bytecode/instructions/DeleteFast.hpp
index c24bc024..73b8e25e 100644
--- a/src/executable/bytecode/instructions/DeleteFast.hpp
+++ b/src/executable/bytecode/instructions/DeleteFast.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class DeleteFast final : public Instruction
 {
 	Register m_stack_index;
@@ -9,7 +7,7 @@ class DeleteFast final : public Instruction
   public:
 	DeleteFast(Register stack_index) : m_stack_index(stack_index) {}
 
-	std::string to_string() const final { return fmt::format("DELETE_FAST     {}", m_stack_index); }
+	std::string to_string() const final { return std::format("DELETE_FAST     {}", m_stack_index); }
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
diff --git a/src/executable/bytecode/instructions/DeleteGlobal.cpp b/src/executable/bytecode/instructions/DeleteGlobal.cpp
index 228f7167..75e2461f 100644
--- a/src/executable/bytecode/instructions/DeleteGlobal.cpp
+++ b/src/executable/bytecode/instructions/DeleteGlobal.cpp
@@ -1,10 +1,14 @@
-#include "DeleteGlobal.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyString.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/DeleteGlobal.hpp b/src/executable/bytecode/instructions/DeleteGlobal.hpp
index 518b1620..76f90802 100644
--- a/src/executable/bytecode/instructions/DeleteGlobal.hpp
+++ b/src/executable/bytecode/instructions/DeleteGlobal.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class DeleteGlobal final : public Instruction
 {
 	Register m_name;
@@ -9,7 +7,7 @@ class DeleteGlobal final : public Instruction
   public:
 	DeleteGlobal(Register name) : m_name(name) {}
 
-	std::string to_string() const final { return fmt::format("DELETE_GLOBAL   r{:<3}", m_name); }
+	std::string to_string() const final { return std::format("DELETE_GLOBAL   r{:<3}", m_name); }
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
diff --git a/src/executable/bytecode/instructions/DeleteName.cpp b/src/executable/bytecode/instructions/DeleteName.cpp
index 3da54a24..c2f78caf 100644
--- a/src/executable/bytecode/instructions/DeleteName.cpp
+++ b/src/executable/bytecode/instructions/DeleteName.cpp
@@ -1,10 +1,14 @@
-#include "DeleteName.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyString.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/DeleteName.hpp b/src/executable/bytecode/instructions/DeleteName.hpp
index b9409f00..bab0a4bb 100644
--- a/src/executable/bytecode/instructions/DeleteName.hpp
+++ b/src/executable/bytecode/instructions/DeleteName.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class DeleteName final : public Instruction
 {
 	Register m_name;
@@ -9,7 +7,7 @@ class DeleteName final : public Instruction
   public:
 	DeleteName(Register name) : m_name(name) {}
 
-	std::string to_string() const final { return fmt::format("DELETE_NAME     r{:<3}", m_name); }
+	std::string to_string() const final { return std::format("DELETE_NAME     r{:<3}", m_name); }
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
diff --git a/src/executable/bytecode/instructions/DeleteSubscript.cpp b/src/executable/bytecode/instructions/DeleteSubscript.cpp
index de662fcb..fc09dea4 100644
--- a/src/executable/bytecode/instructions/DeleteSubscript.cpp
+++ b/src/executable/bytecode/instructions/DeleteSubscript.cpp
@@ -1,7 +1,14 @@
-#include "DeleteSubscript.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyObject.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/DeleteSubscript.hpp b/src/executable/bytecode/instructions/DeleteSubscript.hpp
index 1f05b48a..99e1960d 100644
--- a/src/executable/bytecode/instructions/DeleteSubscript.hpp
+++ b/src/executable/bytecode/instructions/DeleteSubscript.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class DeleteSubscript final : public Instruction
 {
 	Register m_value;
@@ -12,7 +10,7 @@ class DeleteSubscript final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("DELETE_SUBSCRIPT r{:<3} r{:<3}", m_value, m_index);
+		return std::format("DELETE_SUBSCRIPT r{:<3} r{:<3}", m_value, m_index);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/DictAdd.cpp b/src/executable/bytecode/instructions/DictAdd.cpp
index a684628e..6a9de406 100644
--- a/src/executable/bytecode/instructions/DictAdd.cpp
+++ b/src/executable/bytecode/instructions/DictAdd.cpp
@@ -1,7 +1,14 @@
-#include "DictAdd.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyNone.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/DictAdd.hpp b/src/executable/bytecode/instructions/DictAdd.hpp
index 424ba1c2..500a5f6c 100644
--- a/src/executable/bytecode/instructions/DictAdd.hpp
+++ b/src/executable/bytecode/instructions/DictAdd.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class DictAdd final : public Instruction
 {
 	Register m_dict;
@@ -15,7 +12,7 @@ class DictAdd final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("DICT_ADD        r{:<3} r{:<3} r{:<3}", m_dict, m_key, m_value);
+		return std::format("DICT_ADD        r{:<3} r{:<3} r{:<3}", m_dict, m_key, m_value);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/DictMerge.cpp b/src/executable/bytecode/instructions/DictMerge.cpp
index 85e07b2f..d57c160e 100644
--- a/src/executable/bytecode/instructions/DictMerge.cpp
+++ b/src/executable/bytecode/instructions/DictMerge.cpp
@@ -1,7 +1,14 @@
-#include "DictMerge.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyTuple.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/DictMerge.hpp b/src/executable/bytecode/instructions/DictMerge.hpp
index 885ba961..d13c774e 100644
--- a/src/executable/bytecode/instructions/DictMerge.hpp
+++ b/src/executable/bytecode/instructions/DictMerge.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class DictMerge final : public Instruction
 {
 	Register m_this_dict;
@@ -15,7 +12,7 @@ class DictMerge final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("DICT_MERGE      r{:<3} r{:<3}", m_this_dict, m_other_dict);
+		return std::format("DICT_MERGE      r{:<3} r{:<3}", m_this_dict, m_other_dict);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/DictUpdate.cpp b/src/executable/bytecode/instructions/DictUpdate.cpp
index 853c07ed..f72d7ef3 100644
--- a/src/executable/bytecode/instructions/DictUpdate.cpp
+++ b/src/executable/bytecode/instructions/DictUpdate.cpp
@@ -1,8 +1,14 @@
-#include "DictUpdate.hpp"
-#include "runtime/PyBool.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyTuple.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/DictUpdate.hpp b/src/executable/bytecode/instructions/DictUpdate.hpp
index bb64887e..f68ad338 100644
--- a/src/executable/bytecode/instructions/DictUpdate.hpp
+++ b/src/executable/bytecode/instructions/DictUpdate.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class DictUpdate final : public Instruction
 {
 	Register m_dst;
@@ -13,7 +10,7 @@ class DictUpdate final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("DICT_UPDATE     r{:<3} r{:<3}", m_dst, m_src);
+		return std::format("DICT_UPDATE     r{:<3} r{:<3}", m_dst, m_src);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &, Interpreter &) const final;
diff --git a/src/executable/bytecode/instructions/ForIter.cpp b/src/executable/bytecode/instructions/ForIter.cpp
index ff071f4b..0b2df0ce 100644
--- a/src/executable/bytecode/instructions/ForIter.cpp
+++ b/src/executable/bytecode/instructions/ForIter.cpp
@@ -1,14 +1,16 @@
-#include "ForIter.hpp"
+module;
+#include "core.hpp"
 #include "executable/Label.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyTraceback.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/StopIteration.hpp"
-#include "vm/VM.hpp"
+#include <cstddef>
+#include <cstdint>
 
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 #include "../serialization/serialize.hpp"
+#include "executable/Label.hpp"
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/ForIter.hpp b/src/executable/bytecode/instructions/ForIter.hpp
index 46f8737c..1cc793b8 100644
--- a/src/executable/bytecode/instructions/ForIter.hpp
+++ b/src/executable/bytecode/instructions/ForIter.hpp
@@ -1,17 +1,13 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-#include <optional>
-
 class ForIter final : public Instruction
 {
 	Register m_dst;
 	Register m_src;
 	std::shared_ptr<Label> m_body_label;
 	std::shared_ptr<Label> m_exit_label;
-	std::optional<int32_t> m_offset;
-	std::optional<int32_t> m_body_offset;
+	std::optional<std::int32_t> m_offset;
+	std::optional<std::int32_t> m_body_offset;
 
   public:
 	ForIter(Register dst, Register src, std::shared_ptr<Label> exit_label)
@@ -26,15 +22,17 @@ class ForIter final : public Instruction
 		  m_exit_label(std::move(exit_label))
 	{}
 
-	ForIter(Register dst, Register src, int32_t offset) : ForIter(dst, src, offset, int32_t{ 0 }) {}
+	ForIter(Register dst, Register src, std::int32_t offset)
+		: ForIter(dst, src, offset, std::int32_t{ 0 })
+	{}
 
-	ForIter(Register dst, Register src, int32_t offset, int32_t body_offset)
+	ForIter(Register dst, Register src, std::int32_t offset, std::int32_t body_offset)
 		: m_dst(dst), m_src(src), m_offset(offset), m_body_offset(body_offset)
 	{}
 
 	std::string to_string() const final
 	{
-		return fmt::format("FOR_ITER        r{:<3} r{:<3} body={}, orelse={}",
+		return std::format("FOR_ITER        r{:<3} r{:<3} body={}, orelse={}",
 			m_dst,
 			m_src,
 			m_body_offset.value_or(-1),
@@ -43,9 +41,9 @@ class ForIter final : public Instruction
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
-	void relocate(size_t) final;
+	void relocate(std::size_t) final;
 
-	std::vector<uint8_t> serialize() const final;
+	std::vector<std::uint8_t> serialize() const final;
 
-	uint8_t id() const final { return FOR_ITER; }
+	std::uint8_t id() const final { return FOR_ITER; }
 };
diff --git a/src/executable/bytecode/instructions/FormatValue.cpp b/src/executable/bytecode/instructions/FormatValue.cpp
index 97eab4b8..9592a857 100644
--- a/src/executable/bytecode/instructions/FormatValue.cpp
+++ b/src/executable/bytecode/instructions/FormatValue.cpp
@@ -1,6 +1,14 @@
-#include "FormatValue.hpp"
-#include "runtime/PyString.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/FormatValue.hpp b/src/executable/bytecode/instructions/FormatValue.hpp
index cb425329..72ad4151 100644
--- a/src/executable/bytecode/instructions/FormatValue.hpp
+++ b/src/executable/bytecode/instructions/FormatValue.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class FormatValue final : public Instruction
 {
 	const Register m_dst;
@@ -15,7 +13,7 @@ class FormatValue final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("FORMAT_VALUE    r{:<3} r{:<3} {}", m_dst, m_src, m_conversion);
+		return std::format("FORMAT_VALUE    r{:<3} r{:<3} {}", m_dst, m_src, m_conversion);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &, Interpreter &) const final;
diff --git a/src/executable/bytecode/instructions/FunctionCall.cpp b/src/executable/bytecode/instructions/FunctionCall.cpp
index 3d9d483e..a76dd87e 100644
--- a/src/executable/bytecode/instructions/FunctionCall.cpp
+++ b/src/executable/bytecode/instructions/FunctionCall.cpp
@@ -1,8 +1,10 @@
-#include "FunctionCall.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFunction.hpp"
-#include "runtime/PyTuple.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "spdlog/spdlog.h"
+
+module py.runtime;
+import std;
+
 
 using namespace py;
 
@@ -43,4 +45,4 @@ std::vector<uint8_t> FunctionCall::serialize() const
 		static_cast<uint8_t>(m_size),
 		static_cast<uint8_t>(m_stack_offset),
 	};
-}
\ No newline at end of file
+}
diff --git a/src/executable/bytecode/instructions/FunctionCall.hpp b/src/executable/bytecode/instructions/FunctionCall.hpp
index d3ea22dd..36491386 100644
--- a/src/executable/bytecode/instructions/FunctionCall.hpp
+++ b/src/executable/bytecode/instructions/FunctionCall.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class FunctionCall final : public Instruction
 {
 	Register m_function_name;
@@ -15,7 +13,7 @@ class FunctionCall final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("CALL            r{:<3} ({})", m_function_name, m_size);
+		return std::format("CALL            r{:<3} ({})", m_function_name, m_size);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/FunctionCallEx.cpp b/src/executable/bytecode/instructions/FunctionCallEx.cpp
index 57a2961f..87d04db5 100644
--- a/src/executable/bytecode/instructions/FunctionCallEx.cpp
+++ b/src/executable/bytecode/instructions/FunctionCallEx.cpp
@@ -1,8 +1,15 @@
-#include "FunctionCallEx.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFunction.hpp"
-#include "runtime/PyTuple.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include "spdlog/spdlog.h"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/FunctionCallEx.hpp b/src/executable/bytecode/instructions/FunctionCallEx.hpp
index d60a729c..83353209 100644
--- a/src/executable/bytecode/instructions/FunctionCallEx.hpp
+++ b/src/executable/bytecode/instructions/FunctionCallEx.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class FunctionCallEx final : public Instruction
 {
 	Register m_function;
@@ -23,7 +20,7 @@ class FunctionCallEx final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("CALL_EX         r{:<3} r{:<3} r{:<3}", m_function, m_args, m_kwargs);
+		return std::format("CALL_EX         r{:<3} r{:<3} r{:<3}", m_function, m_args, m_kwargs);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/FunctionCallWithKeywords.cpp b/src/executable/bytecode/instructions/FunctionCallWithKeywords.cpp
index 38a34089..befc7357 100644
--- a/src/executable/bytecode/instructions/FunctionCallWithKeywords.cpp
+++ b/src/executable/bytecode/instructions/FunctionCallWithKeywords.cpp
@@ -1,14 +1,17 @@
-#include "FunctionCallWithKeywords.hpp"
-#include "FunctionCall.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include "spdlog/spdlog.h"
+#include <cstddef>
+#include <cstdint>
 
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyTuple.hpp"
-#include "vm/VM.hpp"
+module py.runtime;
+import std;
 
+// After the import: these name module-owned types.
 #include "../serialization/serialize.hpp"
 
+
 using namespace py;
 
 PyResult<Value> FunctionCallWithKeywords::execute(VirtualMachine &vm,
diff --git a/src/executable/bytecode/instructions/FunctionCallWithKeywords.hpp b/src/executable/bytecode/instructions/FunctionCallWithKeywords.hpp
index edb0fe7d..894c8807 100644
--- a/src/executable/bytecode/instructions/FunctionCallWithKeywords.hpp
+++ b/src/executable/bytecode/instructions/FunctionCallWithKeywords.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class FunctionCallWithKeywords final : public Instruction
 {
 	Register m_function_name;
@@ -23,11 +21,11 @@ class FunctionCallWithKeywords final : public Instruction
 		std::string kwargs_regs{};
 		std::string keyword_regs{};
 
-		for (const auto arg : m_args) { args_regs += fmt::format(" r{:<3}", arg); }
-		for (const auto kwarg : m_kwargs) { kwargs_regs += fmt::format(" r{:<3}", kwarg); }
-		for (const auto &keyword : m_keywords) { keyword_regs += fmt::format("r{:<3} ", keyword); }
+		for (const auto arg : m_args) { args_regs += std::format(" r{:<3}", arg); }
+		for (const auto kwarg : m_kwargs) { kwargs_regs += std::format(" r{:<3}", kwarg); }
+		for (const auto &keyword : m_keywords) { keyword_regs += std::format("r{:<3} ", keyword); }
 
-		return fmt::format("CALL_FUNCTION_KW r{:<3}args={} kwargs={} keywords={}",
+		return std::format("CALL_FUNCTION_KW r{:<3}args={} kwargs={} keywords={}",
 			m_function_name,
 			args_regs,
 			kwargs_regs,
diff --git a/src/executable/bytecode/instructions/GetAwaitable.cpp b/src/executable/bytecode/instructions/GetAwaitable.cpp
index aa9037ba..0d1e2fba 100644
--- a/src/executable/bytecode/instructions/GetAwaitable.cpp
+++ b/src/executable/bytecode/instructions/GetAwaitable.cpp
@@ -1,5 +1,14 @@
-#include "GetAwaitable.hpp"
-#include "runtime/PyObject.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/GetAwaitable.hpp b/src/executable/bytecode/instructions/GetAwaitable.hpp
index 7e0e3a15..f4ceb9c3 100644
--- a/src/executable/bytecode/instructions/GetAwaitable.hpp
+++ b/src/executable/bytecode/instructions/GetAwaitable.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class GetAwaitable final : public Instruction
 {
 	Register m_dst;
@@ -13,7 +10,7 @@ class GetAwaitable final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("GET_AWAITABLE   r{:<3} r{:<3}", m_dst, m_src);
+		return std::format("GET_AWAITABLE   r{:<3} r{:<3}", m_dst, m_src);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/GetIter.cpp b/src/executable/bytecode/instructions/GetIter.cpp
index 21034507..6cd78e71 100644
--- a/src/executable/bytecode/instructions/GetIter.cpp
+++ b/src/executable/bytecode/instructions/GetIter.cpp
@@ -1,6 +1,14 @@
-#include "GetIter.hpp"
-#include "runtime/PyObject.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/GetIter.hpp b/src/executable/bytecode/instructions/GetIter.hpp
index 6e040a49..ec5c0e69 100644
--- a/src/executable/bytecode/instructions/GetIter.hpp
+++ b/src/executable/bytecode/instructions/GetIter.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class GetIter final : public Instruction
 {
 	Register m_dst;
@@ -13,7 +10,7 @@ class GetIter final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("GET_ITER        r{:<3} r{:<3}", m_dst, m_src);
+		return std::format("GET_ITER        r{:<3} r{:<3}", m_dst, m_src);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/GetYieldFromIter.cpp b/src/executable/bytecode/instructions/GetYieldFromIter.cpp
index c66dbf06..edbedf6a 100644
--- a/src/executable/bytecode/instructions/GetYieldFromIter.cpp
+++ b/src/executable/bytecode/instructions/GetYieldFromIter.cpp
@@ -1,7 +1,14 @@
-#include "GetYieldFromIter.hpp"
-#include "runtime/PyCoroutine.hpp"
-#include "runtime/PyGenerator.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/GetYieldFromIter.hpp b/src/executable/bytecode/instructions/GetYieldFromIter.hpp
index 563229a4..bc818a5e 100644
--- a/src/executable/bytecode/instructions/GetYieldFromIter.hpp
+++ b/src/executable/bytecode/instructions/GetYieldFromIter.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class GetYieldFromIter final : public Instruction
 {
 	Register m_dst;
@@ -13,7 +10,7 @@ class GetYieldFromIter final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("GET_YIELD_FROM_ITER r{:<3} r{:<3}", m_dst, m_src);
+		return std::format("GET_YIELD_FROM_ITER r{:<3} r{:<3}", m_dst, m_src);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/ImportFrom.cpp b/src/executable/bytecode/instructions/ImportFrom.cpp
index 4918e618..59543143 100644
--- a/src/executable/bytecode/instructions/ImportFrom.cpp
+++ b/src/executable/bytecode/instructions/ImportFrom.cpp
@@ -1,10 +1,14 @@
-#include "ImportFrom.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 
-#include "interpreter/Interpreter.hpp"
-#include "runtime/ImportError.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyModule.hpp"
-#include "vm/VM.hpp"
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/ImportFrom.hpp b/src/executable/bytecode/instructions/ImportFrom.hpp
index 909cc342..01f13fb7 100644
--- a/src/executable/bytecode/instructions/ImportFrom.hpp
+++ b/src/executable/bytecode/instructions/ImportFrom.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class ImportFrom : public Instruction
 {
 	Register m_destination;
@@ -15,7 +13,7 @@ class ImportFrom : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("IMPORT_FROM     r{:<3} {:<3}", m_destination, m_name);
+		return std::format("IMPORT_FROM     r{:<3} {:<3}", m_destination, m_name);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/ImportName.cpp b/src/executable/bytecode/instructions/ImportName.cpp
index ef05dfd3..80c28de7 100644
--- a/src/executable/bytecode/instructions/ImportName.cpp
+++ b/src/executable/bytecode/instructions/ImportName.cpp
@@ -1,18 +1,15 @@
-#include "ImportName.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
 
-#include "interpreter/Interpreter.hpp"
-#include "runtime/ImportError.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyModule.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/TypeError.hpp"
-#include "vm/VM.hpp"
+module py.runtime;
+import std;
 
+// After the import: these name module-owned types.
 #include "../serialization/serialize.hpp"
 
-#include <numeric>
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/ImportName.hpp b/src/executable/bytecode/instructions/ImportName.hpp
index 6ed30924..c2f2bacc 100644
--- a/src/executable/bytecode/instructions/ImportName.hpp
+++ b/src/executable/bytecode/instructions/ImportName.hpp
@@ -1,9 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-#include <numeric>
-
 class ImportName : public Instruction
 {
 	Register m_destination;
@@ -18,14 +14,14 @@ class ImportName : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("IMPORT_NAME     r{:<3} {:<3}", m_destination, m_name);
+		return std::format("IMPORT_NAME     r{:<3} {:<3}", m_destination, m_name);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
-	void relocate(size_t) final {}
+	void relocate(std::size_t) final {}
 
-	std::vector<uint8_t> serialize() const final;
+	std::vector<std::uint8_t> serialize() const final;
 
-	uint8_t id() const final { return IMPORT_NAME; }
+	std::uint8_t id() const final { return IMPORT_NAME; }
 };
diff --git a/src/executable/bytecode/instructions/ImportStar.cpp b/src/executable/bytecode/instructions/ImportStar.cpp
index fa5f2bce..1978b4f4 100644
--- a/src/executable/bytecode/instructions/ImportStar.cpp
+++ b/src/executable/bytecode/instructions/ImportStar.cpp
@@ -1,14 +1,14 @@
-#include "ImportStar.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/AttributeError.hpp"
-#include "runtime/IndexError.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyModule.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/TypeError.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/ImportStar.hpp b/src/executable/bytecode/instructions/ImportStar.hpp
index 7ee1b47f..6d5eb73b 100644
--- a/src/executable/bytecode/instructions/ImportStar.hpp
+++ b/src/executable/bytecode/instructions/ImportStar.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class ImportStar : public Instruction
 {
 	Register m_src;
@@ -9,7 +7,7 @@ class ImportStar : public Instruction
   public:
 	ImportStar(Register src) : m_src(src) {}
 
-	std::string to_string() const final { return fmt::format("IMPORT_STAR     r{:<3}", m_src); }
+	std::string to_string() const final { return std::format("IMPORT_STAR     r{:<3}", m_src); }
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
diff --git a/src/executable/bytecode/instructions/InplaceOp.cpp b/src/executable/bytecode/instructions/InplaceOp.cpp
index 9545b392..e7e36cd5 100644
--- a/src/executable/bytecode/instructions/InplaceOp.cpp
+++ b/src/executable/bytecode/instructions/InplaceOp.cpp
@@ -1,7 +1,14 @@
-#include "InplaceOp.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/Value.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/InplaceOp.hpp b/src/executable/bytecode/instructions/InplaceOp.hpp
index 01de7206..2bff5b1f 100644
--- a/src/executable/bytecode/instructions/InplaceOp.hpp
+++ b/src/executable/bytecode/instructions/InplaceOp.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class InplaceOp : public Instruction
 {
   public:
@@ -31,7 +28,8 @@ class InplaceOp : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("INPLACE_OP      r{:<3} r{:<3} ({})", m_lhs, m_rhs, m_operation);
+		return std::format(
+			"INPLACE_OP      r{:<3} r{:<3} ({})", m_lhs, m_rhs, static_cast<int>(m_operation));
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/Instructions.cpp b/src/executable/bytecode/instructions/Instructions.cpp
index 9a619b34..a88add5a 100644
--- a/src/executable/bytecode/instructions/Instructions.cpp
+++ b/src/executable/bytecode/instructions/Instructions.cpp
@@ -1,81 +1,14 @@
-#include "Instructions.hpp"
-#include "BinaryOperation.hpp"
-#include "BinarySubscript.hpp"
-#include "BuildDict.hpp"
-#include "BuildList.hpp"
-#include "BuildSet.hpp"
-#include "BuildSlice.hpp"
-#include "BuildString.hpp"
-#include "BuildTuple.hpp"
-#include "ClearExceptionState.hpp"
-#include "ClearTopCleanup.hpp"
-#include "CompareOperation.hpp"
-#include "DeleteName.hpp"
-#include "DeleteSubscript.hpp"
-#include "DictMerge.hpp"
-#include "DictUpdate.hpp"
-#include "ForIter.hpp"
-#include "FormatValue.hpp"
-#include "FunctionCall.hpp"
-#include "FunctionCallEx.hpp"
-#include "FunctionCallWithKeywords.hpp"
-#include "GetIter.hpp"
-#include "GetYieldFromIter.hpp"
-#include "ImportFrom.hpp"
-#include "ImportName.hpp"
-#include "InplaceOp.hpp"
-#include "Jump.hpp"
-#include "JumpForward.hpp"
-#include "JumpIfExceptionMatch.hpp"
-#include "JumpIfFalse.hpp"
-#include "JumpIfFalseOrPop.hpp"
-#include "JumpIfNotExceptionMatch.hpp"
-#include "JumpIfTrue.hpp"
-#include "JumpIfTrueOrPop.hpp"
-#include "LeaveExceptionHandling.hpp"
-#include "ListAppend.hpp"
-#include "ListExtend.hpp"
-#include "ListToTuple.hpp"
-#include "LoadAssertionError.hpp"
-#include "LoadAttr.hpp"
-#include "LoadBuildClass.hpp"
-#include "LoadClosure.hpp"
-#include "LoadConst.hpp"
-#include "LoadDeref.hpp"
-#include "LoadException.hpp"
-#include "LoadFast.hpp"
-#include "LoadGlobal.hpp"
-#include "LoadMethod.hpp"
-#include "LoadName.hpp"
-#include "MakeFunction.hpp"
-#include "MethodCall.hpp"
-#include "Move.hpp"
-#include "Pop.hpp"
-#include "Push.hpp"
-#include "RaiseVarargs.hpp"
-#include "ReRaise.hpp"
-#include "ReturnValue.hpp"
-#include "SetAdd.hpp"
-#include "SetUpdate.hpp"
-#include "SetupExceptionHandling.hpp"
-#include "SetupWith.hpp"
-#include "StoreAttr.hpp"
-#include "StoreDeref.hpp"
-#include "StoreFast.hpp"
-#include "StoreGlobal.hpp"
-#include "StoreName.hpp"
-#include "StoreSubscript.hpp"
-#include "ToBool.hpp"
-#include "Unary.hpp"
-#include "UnpackSequence.hpp"
-#include "WithExceptStart.hpp"
-#include "YieldLoad.hpp"
-#include "YieldValue.hpp"
+module;
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
 
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 #include "../serialization/deserialize.hpp"
-#include "vm/VM.hpp"
 
-#include <optional>
 
 using namespace py;
 
@@ -510,6 +443,6 @@ std::unique_ptr<Instruction> deserialize(std::span<const uint8_t> &instruction_b
 		return std::make_unique<SetUpdate>(set, iterable);
 	}
 	}
-	spdlog::error("Missing opcode: {}", instruction_code);
+	::detail::log_error(std::format("Missing opcode: {}", instruction_code).c_str());
 	return nullptr;
 }
\ No newline at end of file
diff --git a/src/executable/bytecode/instructions/Instructions.cppm b/src/executable/bytecode/instructions/Instructions.cppm
new file mode 100644
index 00000000..2d6ae3c7
--- /dev/null
+++ b/src/executable/bytecode/instructions/Instructions.cppm
@@ -0,0 +1,213 @@
+module;
+
+#include "core.hpp"
+#include "executable/Label.hpp"
+
+export module py.runtime:instructions;
+import :value;
+import std;
+
+export class Program;
+
+// Instruction is referenced from both py.runtime (FunctionBlock's
+// InstructionVector) and py.codegen, so it has to have exactly one owning
+// module - as a plain header included from two different purviews it was being
+// attached to whichever module included it.
+export class VirtualMachine;
+export class Interpreter;
+
+export class Instruction : NonCopyable
+{
+  protected:
+	// RAII type that restores r0 for intructions that are not treated as call instructions
+	// but may end up calling a Python function (e.g. LoadAttribute may end up calling a Python
+	// defined __getattr__ which then clobbers r0)
+	struct RAIIStoreNonCallInstructionData
+	{
+		RAIIStoreNonCallInstructionData();
+		~RAIIStoreNonCallInstructionData();
+
+		py::Value reg0;
+	};
+
+  public:
+	virtual ~Instruction() = default;
+	virtual std::string to_string() const = 0;
+	virtual py::PyResult<py::Value> execute(VirtualMachine &, Interpreter &) const = 0;
+	virtual void relocate(std::size_t) = 0;
+	virtual std::vector<std::uint8_t> serialize() const = 0;
+	virtual std::uint8_t id() const = 0;
+};
+
+export constexpr std::uint8_t BINARY_OPERATION = 0;
+export constexpr std::uint8_t BINARY_SUBSCRIPT = 1;
+export constexpr std::uint8_t BUILD_DICT = 2;
+export constexpr std::uint8_t BUILD_LIST = 3;
+export constexpr std::uint8_t BUILD_TUPLE = 4;
+export constexpr std::uint8_t CLEAR_EXCEPTION_STATE = 5;
+export constexpr std::uint8_t COMPARE_OP = 6;
+export constexpr std::uint8_t DELETE_NAME = 7;
+export constexpr std::uint8_t DICT_MERGE = 8;
+export constexpr std::uint8_t FOR_ITER = 9;
+export constexpr std::uint8_t FUNCTION_CALL = 10;
+export constexpr std::uint8_t FUNCTION_CALL_EX = 11;
+export constexpr std::uint8_t FUNCTION_CALL_WITH_KW = 12;
+export constexpr std::uint8_t GET_ITER = 13;
+export constexpr std::uint8_t IMPORT_NAME = 14;
+export constexpr std::uint8_t JUMP = 17;
+export constexpr std::uint8_t JUMP_FORWARD = 18;
+export constexpr std::uint8_t JUMP_IF_FALSE = 19;
+export constexpr std::uint8_t JUMP_IF_FALSE_OR_POP = 20;
+export constexpr std::uint8_t JUMP_IF_NOT_EXCEPTION_MATCH = 21;
+export constexpr std::uint8_t JUMP_IF_TRUE = 22;
+export constexpr std::uint8_t JUMP_IF_TRUE_OR_POP = 23;
+export constexpr std::uint8_t LIST_EXTEND = 24;
+export constexpr std::uint8_t LIST_TO_TUPLE = 25;
+export constexpr std::uint8_t LOAD_ASSERTION_ERROR = 26;
+export constexpr std::uint8_t LOAD_ATTR = 27;
+export constexpr std::uint8_t LOAD_BUILD_CLASS = 28;
+export constexpr std::uint8_t LOAD_CLOSURE = 29;
+export constexpr std::uint8_t LOAD_CONST = 30;
+export constexpr std::uint8_t LOAD_DEREF = 31;
+export constexpr std::uint8_t LOAD_FAST = 32;
+export constexpr std::uint8_t LOAD_GLOBAL = 33;
+export constexpr std::uint8_t LOAD_METHOD = 34;
+export constexpr std::uint8_t LOAD_NAME = 35;
+export constexpr std::uint8_t MAKE_FUNCTION = 36;
+export constexpr std::uint8_t METHOD_CALL = 38;
+export constexpr std::uint8_t MOVE = 39;
+export constexpr std::uint8_t RAISE_VARARGS = 40;
+export constexpr std::uint8_t RETURN_VALUE = 41;
+export constexpr std::uint8_t SETUP_EXCEPTION_HANDLING = 42;
+export constexpr std::uint8_t STORE_ATTR = 43;
+export constexpr std::uint8_t STORE_DEREF = 44;
+export constexpr std::uint8_t STORE_FAST = 45;
+export constexpr std::uint8_t STORE_GLOBAL = 46;
+export constexpr std::uint8_t STORE_NAME = 47;
+export constexpr std::uint8_t STORE_SUBSCRIPT = 48;
+export constexpr std::uint8_t UNARY = 49;
+export constexpr std::uint8_t UNPACK_SEQUENCE = 50;
+export constexpr std::uint8_t CONTINUE = 51;
+export constexpr std::uint8_t RERAISE = 52;
+export constexpr std::uint8_t WITH_EXCEPT_START = 53;
+export constexpr std::uint8_t LEAVE_EXCEPTION_HANDLING = 54;
+export constexpr std::uint8_t DELETE_SUBSCRIPT = 55;
+export constexpr std::uint8_t SETUP_WITH = 56;
+export constexpr std::uint8_t CLEAR_TOP_CLEANUP = 57;
+export constexpr std::uint8_t LIST_APPEND = 58;
+export constexpr std::uint8_t SET_ADD = 59;
+export constexpr std::uint8_t BUILD_SET = 60;
+export constexpr std::uint8_t IMPORT_FROM = 61;
+export constexpr std::uint8_t BUILD_SLICE = 62;
+export constexpr std::uint8_t INPLACE_OP = 63;
+export constexpr std::uint8_t YIELD_VALUE = 64;
+export constexpr std::uint8_t DICT_UPDATE = 65;
+export constexpr std::uint8_t DICT_ADD = 66;
+export constexpr std::uint8_t YIELD_LOAD = 67;
+export constexpr std::uint8_t GET_YIELD_FROM_ITER = 68;
+export constexpr std::uint8_t YIELD_FROM = 69;
+export constexpr std::uint8_t IMPORT_STAR = 70;
+export constexpr std::uint8_t GET_AWAITABLE = 71;
+export constexpr std::uint8_t BUILD_STRING = 72;
+export constexpr std::uint8_t FORMAT_VALUE = 73;
+export constexpr std::uint8_t PUSH = 74;
+export constexpr std::uint8_t POP = 75;
+export constexpr std::uint8_t DELETE_FAST = 76;
+export constexpr std::uint8_t DELETE_GLOBAL = 77;
+export constexpr std::uint8_t JUMP_IF_EXCEPTION_MATCH = 78;
+export constexpr std::uint8_t TO_BOOL = 79;
+export constexpr std::uint8_t SET_UPDATE = 80;
+export constexpr std::uint8_t DELETE_ATTR = 81;
+export constexpr std::uint8_t UNPACK_EXPAND = 82;
+export constexpr std::uint8_t DELETE_DEREF = 83;
+export constexpr std::uint8_t LOAD_EXCEPTION = 84;
+
+export std::unique_ptr<Instruction> deserialize(std::span<const std::uint8_t> &instruction_buffer);
+
+// The concrete instructions live in this partition too. As plain headers they
+// were included from py.codegen's purview (BytecodeGenerator) and py.runtime's
+// (BuiltinsModule) and from ordinary TUs, so each class was attached to two
+// modules at once and its execute()/serialize() were undefined in both.
+export {
+#include "BinaryOperation.hpp"
+#include "BinarySubscript.hpp"
+#include "BuildDict.hpp"
+#include "BuildList.hpp"
+#include "BuildSet.hpp"
+#include "BuildSlice.hpp"
+#include "BuildString.hpp"
+#include "BuildTuple.hpp"
+#include "ClearExceptionState.hpp"
+#include "ClearTopCleanup.hpp"
+#include "CompareOperation.hpp"
+#include "DeleteAttr.hpp"
+#include "DeleteDeref.hpp"
+#include "DeleteFast.hpp"
+#include "DeleteGlobal.hpp"
+#include "DeleteName.hpp"
+#include "DeleteSubscript.hpp"
+#include "DictAdd.hpp"
+#include "DictMerge.hpp"
+#include "DictUpdate.hpp"
+#include "ForIter.hpp"
+#include "FormatValue.hpp"
+#include "FunctionCall.hpp"
+#include "FunctionCallEx.hpp"
+#include "FunctionCallWithKeywords.hpp"
+#include "GetAwaitable.hpp"
+#include "GetIter.hpp"
+#include "GetYieldFromIter.hpp"
+#include "ImportFrom.hpp"
+#include "ImportName.hpp"
+#include "ImportStar.hpp"
+#include "InplaceOp.hpp"
+#include "Jump.hpp"
+#include "JumpForward.hpp"
+#include "JumpIfExceptionMatch.hpp"
+#include "JumpIfFalse.hpp"
+#include "JumpIfFalseOrPop.hpp"
+#include "JumpIfNotExceptionMatch.hpp"
+#include "JumpIfTrue.hpp"
+#include "JumpIfTrueOrPop.hpp"
+#include "LeaveExceptionHandling.hpp"
+#include "ListAppend.hpp"
+#include "ListExtend.hpp"
+#include "ListToTuple.hpp"
+#include "LoadAssertionError.hpp"
+#include "LoadAttr.hpp"
+#include "LoadBuildClass.hpp"
+#include "LoadClosure.hpp"
+#include "LoadConst.hpp"
+#include "LoadDeref.hpp"
+#include "LoadException.hpp"
+#include "LoadFast.hpp"
+#include "LoadGlobal.hpp"
+#include "LoadMethod.hpp"
+#include "LoadName.hpp"
+#include "MakeFunction.hpp"
+#include "MethodCall.hpp"
+#include "Move.hpp"
+#include "Pop.hpp"
+#include "Push.hpp"
+#include "RaiseVarargs.hpp"
+#include "ReRaise.hpp"
+#include "ReturnValue.hpp"
+#include "SetAdd.hpp"
+#include "SetUpdate.hpp"
+#include "SetupExceptionHandling.hpp"
+#include "SetupWith.hpp"
+#include "StoreAttr.hpp"
+#include "StoreDeref.hpp"
+#include "StoreFast.hpp"
+#include "StoreGlobal.hpp"
+#include "StoreName.hpp"
+#include "StoreSubscript.hpp"
+#include "ToBool.hpp"
+#include "Unary.hpp"
+#include "UnpackExpand.hpp"
+#include "UnpackSequence.hpp"
+#include "WithExceptStart.hpp"
+#include "YieldFrom.hpp"
+#include "YieldLoad.hpp"
+#include "YieldValue.hpp"
+}
diff --git a/src/executable/bytecode/instructions/Instructions.hpp b/src/executable/bytecode/instructions/Instructions.hpp
deleted file mode 100644
index ff8fbc33..00000000
--- a/src/executable/bytecode/instructions/Instructions.hpp
+++ /dev/null
@@ -1,115 +0,0 @@
-#pragma once
-
-#include "runtime/Value.hpp"
-#include "utilities.hpp"
-
-#include <span>
-#include <string>
-
-class Instruction : NonCopyable
-{
-  protected:
-	// RAII type that restores r0 for intructions that are not treated as call instructions
-	// but may end up calling a Python function (e.g. LoadAttribute may end up calling a Python
-	// defined __getattr__ which then clobbers r0)
-	struct RAIIStoreNonCallInstructionData
-	{
-		RAIIStoreNonCallInstructionData();
-		~RAIIStoreNonCallInstructionData();
-
-		py::Value reg0;
-	};
-
-  public:
-	virtual ~Instruction() = default;
-	virtual std::string to_string() const = 0;
-	virtual py::PyResult<py::Value> execute(VirtualMachine &, Interpreter &) const = 0;
-	virtual void relocate(size_t) = 0;
-	virtual std::vector<uint8_t> serialize() const = 0;
-	virtual uint8_t id() const = 0;
-};
-
-static constexpr uint8_t BINARY_OPERATION = 0;
-static constexpr uint8_t BINARY_SUBSCRIPT = 1;
-static constexpr uint8_t BUILD_DICT = 2;
-static constexpr uint8_t BUILD_LIST = 3;
-static constexpr uint8_t BUILD_TUPLE = 4;
-static constexpr uint8_t CLEAR_EXCEPTION_STATE = 5;
-static constexpr uint8_t COMPARE_OP = 6;
-static constexpr uint8_t DELETE_NAME = 7;
-static constexpr uint8_t DICT_MERGE = 8;
-static constexpr uint8_t FOR_ITER = 9;
-static constexpr uint8_t FUNCTION_CALL = 10;
-static constexpr uint8_t FUNCTION_CALL_EX = 11;
-static constexpr uint8_t FUNCTION_CALL_WITH_KW = 12;
-static constexpr uint8_t GET_ITER = 13;
-static constexpr uint8_t IMPORT_NAME = 14;
-static constexpr uint8_t JUMP = 17;
-static constexpr uint8_t JUMP_FORWARD = 18;
-static constexpr uint8_t JUMP_IF_FALSE = 19;
-static constexpr uint8_t JUMP_IF_FALSE_OR_POP = 20;
-static constexpr uint8_t JUMP_IF_NOT_EXCEPTION_MATCH = 21;
-static constexpr uint8_t JUMP_IF_TRUE = 22;
-static constexpr uint8_t JUMP_IF_TRUE_OR_POP = 23;
-static constexpr uint8_t LIST_EXTEND = 24;
-static constexpr uint8_t LIST_TO_TUPLE = 25;
-static constexpr uint8_t LOAD_ASSERTION_ERROR = 26;
-static constexpr uint8_t LOAD_ATTR = 27;
-static constexpr uint8_t LOAD_BUILD_CLASS = 28;
-static constexpr uint8_t LOAD_CLOSURE = 29;
-static constexpr uint8_t LOAD_CONST = 30;
-static constexpr uint8_t LOAD_DEREF = 31;
-static constexpr uint8_t LOAD_FAST = 32;
-static constexpr uint8_t LOAD_GLOBAL = 33;
-static constexpr uint8_t LOAD_METHOD = 34;
-static constexpr uint8_t LOAD_NAME = 35;
-static constexpr uint8_t MAKE_FUNCTION = 36;
-static constexpr uint8_t METHOD_CALL = 38;
-static constexpr uint8_t MOVE = 39;
-static constexpr uint8_t RAISE_VARARGS = 40;
-static constexpr uint8_t RETURN_VALUE = 41;
-static constexpr uint8_t SETUP_EXCEPTION_HANDLING = 42;
-static constexpr uint8_t STORE_ATTR = 43;
-static constexpr uint8_t STORE_DEREF = 44;
-static constexpr uint8_t STORE_FAST = 45;
-static constexpr uint8_t STORE_GLOBAL = 46;
-static constexpr uint8_t STORE_NAME = 47;
-static constexpr uint8_t STORE_SUBSCRIPT = 48;
-static constexpr uint8_t UNARY = 49;
-static constexpr uint8_t UNPACK_SEQUENCE = 50;
-static constexpr uint8_t CONTINUE = 51;
-static constexpr uint8_t RERAISE = 52;
-static constexpr uint8_t WITH_EXCEPT_START = 53;
-static constexpr uint8_t LEAVE_EXCEPTION_HANDLING = 54;
-static constexpr uint8_t DELETE_SUBSCRIPT = 55;
-static constexpr uint8_t SETUP_WITH = 56;
-static constexpr uint8_t CLEAR_TOP_CLEANUP = 57;
-static constexpr uint8_t LIST_APPEND = 58;
-static constexpr uint8_t SET_ADD = 59;
-static constexpr uint8_t BUILD_SET = 60;
-static constexpr uint8_t IMPORT_FROM = 61;
-static constexpr uint8_t BUILD_SLICE = 62;
-static constexpr uint8_t INPLACE_OP = 63;
-static constexpr uint8_t YIELD_VALUE = 64;
-static constexpr uint8_t DICT_UPDATE = 65;
-static constexpr uint8_t DICT_ADD = 66;
-static constexpr uint8_t YIELD_LOAD = 67;
-static constexpr uint8_t GET_YIELD_FROM_ITER = 68;
-static constexpr uint8_t YIELD_FROM = 69;
-static constexpr uint8_t IMPORT_STAR = 70;
-static constexpr uint8_t GET_AWAITABLE = 71;
-static constexpr uint8_t BUILD_STRING = 72;
-static constexpr uint8_t FORMAT_VALUE = 73;
-static constexpr uint8_t PUSH = 74;
-static constexpr uint8_t POP = 75;
-static constexpr uint8_t DELETE_FAST = 76;
-static constexpr uint8_t DELETE_GLOBAL = 77;
-static constexpr uint8_t JUMP_IF_EXCEPTION_MATCH = 78;
-static constexpr uint8_t TO_BOOL = 79;
-static constexpr uint8_t SET_UPDATE = 80;
-static constexpr uint8_t DELETE_ATTR = 81;
-static constexpr uint8_t UNPACK_EXPAND = 82;
-static constexpr uint8_t DELETE_DEREF = 83;
-static constexpr uint8_t LOAD_EXCEPTION = 84;
-
-std::unique_ptr<Instruction> deserialize(std::span<const uint8_t> &instruction_buffer);
diff --git a/src/executable/bytecode/instructions/Jump.cpp b/src/executable/bytecode/instructions/Jump.cpp
index cbc3edbb..8e6266e7 100644
--- a/src/executable/bytecode/instructions/Jump.cpp
+++ b/src/executable/bytecode/instructions/Jump.cpp
@@ -1,9 +1,16 @@
-#include "Jump.hpp"
+module;
+#include "core.hpp"
 #include "executable/Label.hpp"
-#include "runtime/PyNone.hpp"
-#include "vm/VM.hpp"
+#include <cstddef>
+#include <cstdint>
 
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 #include "../serialization/serialize.hpp"
+#include "executable/Label.hpp"
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/Jump.hpp b/src/executable/bytecode/instructions/Jump.hpp
index 6872ad9d..fbe9f5ca 100644
--- a/src/executable/bytecode/instructions/Jump.hpp
+++ b/src/executable/bytecode/instructions/Jump.hpp
@@ -1,31 +1,27 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-#include <optional>
-
 class Jump final : public Instruction
 {
 	std::shared_ptr<Label> m_label;
-	std::optional<int32_t> m_offset;
+	std::optional<std::int32_t> m_offset;
 
   public:
 	Jump(std::shared_ptr<Label> label) : m_label(std::move(label)) {}
 
-	Jump(int32_t offset) : m_offset(offset) {}
+	Jump(std::int32_t offset) : m_offset(offset) {}
 
 	std::string to_string() const final
 	{
 		const std::string position =
 			m_offset.has_value() ? std::to_string(*m_offset) : "offset not evaluated";
-		return fmt::format("JUMP            position: {}", position);
+		return std::format("JUMP            position: {}", position);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
-	void relocate(size_t) final;
+	void relocate(std::size_t) final;
 
-	std::vector<uint8_t> serialize() const final;
+	std::vector<std::uint8_t> serialize() const final;
 
-	uint8_t id() const final { return JUMP; }
+	std::uint8_t id() const final { return JUMP; }
 };
diff --git a/src/executable/bytecode/instructions/JumpForward.cpp b/src/executable/bytecode/instructions/JumpForward.cpp
index a0684c16..2d4eeca9 100644
--- a/src/executable/bytecode/instructions/JumpForward.cpp
+++ b/src/executable/bytecode/instructions/JumpForward.cpp
@@ -1,9 +1,16 @@
-#include "JumpForward.hpp"
+module;
+#include "core.hpp"
 #include "executable/Label.hpp"
-#include "runtime/PyNone.hpp"
-#include "vm/VM.hpp"
+#include <cstddef>
+#include <cstdint>
 
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 #include "../serialization/serialize.hpp"
+#include "executable/Label.hpp"
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/JumpForward.hpp b/src/executable/bytecode/instructions/JumpForward.hpp
index 4918919d..85125860 100644
--- a/src/executable/bytecode/instructions/JumpForward.hpp
+++ b/src/executable/bytecode/instructions/JumpForward.hpp
@@ -1,31 +1,27 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-#include <optional>
-
 class JumpForward final : public Instruction
 {
 	std::shared_ptr<Label> m_label;
-	std::optional<uint32_t> m_offset;
+	std::optional<std::uint32_t> m_offset;
 
   public:
 	JumpForward(std::shared_ptr<Label> label) : m_label(std::move(label)) {}
 
-	JumpForward(uint32_t offset) : m_offset(offset) {}
+	JumpForward(std::uint32_t offset) : m_offset(offset) {}
 
 	std::string to_string() const final
 	{
 		const std::string position =
 			m_offset.has_value() ? std::to_string(*m_offset) : "offset not evaluated";
-		return fmt::format("JUMP_FORWARD    position: {}", position);
+		return std::format("JUMP_FORWARD    position: {}", position);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
-	void relocate(size_t) final;
+	void relocate(std::size_t) final;
 
-	std::vector<uint8_t> serialize() const final;
+	std::vector<std::uint8_t> serialize() const final;
 
-	uint8_t id() const final { return JUMP_FORWARD; }
+	std::uint8_t id() const final { return JUMP_FORWARD; }
 };
diff --git a/src/executable/bytecode/instructions/JumpIfExceptionMatch.cpp b/src/executable/bytecode/instructions/JumpIfExceptionMatch.cpp
index 42e39741..dd4f93c3 100644
--- a/src/executable/bytecode/instructions/JumpIfExceptionMatch.cpp
+++ b/src/executable/bytecode/instructions/JumpIfExceptionMatch.cpp
@@ -1,14 +1,17 @@
-#include "JumpIfExceptionMatch.hpp"
+module;
+#include "core.hpp"
 #include "executable/Label.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/TypeError.hpp"
-#include "runtime/types/builtin.hpp"
-#include "vm/VM.hpp"
+#include <cstddef>
+#include <cstdint>
 
+module py.runtime;
+import py.types;
+import std;
+
+// After the import: these name module-owned types.
 #include "../serialization/serialize.hpp"
+#include "executable/Label.hpp"
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/JumpIfExceptionMatch.hpp b/src/executable/bytecode/instructions/JumpIfExceptionMatch.hpp
index 4eea9b34..75bec23d 100644
--- a/src/executable/bytecode/instructions/JumpIfExceptionMatch.hpp
+++ b/src/executable/bytecode/instructions/JumpIfExceptionMatch.hpp
@@ -1,20 +1,16 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-#include <optional>
-
 class JumpIfExceptionMatch final : public Instruction
 {
 	Register m_exception_type_reg;
 	std::shared_ptr<Label> m_label;
-	std::optional<uint32_t> m_offset;
+	std::optional<std::uint32_t> m_offset;
 
   public:
 	JumpIfExceptionMatch(Register exception_type_reg, std::shared_ptr<Label> label)
 		: m_exception_type_reg(exception_type_reg), m_label(std::move(label))
 	{}
-	JumpIfExceptionMatch(Register exception_type_reg, uint32_t offset)
+	JumpIfExceptionMatch(Register exception_type_reg, std::uint32_t offset)
 		: m_exception_type_reg(exception_type_reg), m_offset(offset)
 	{}
 
@@ -23,14 +19,14 @@ class JumpIfExceptionMatch final : public Instruction
 		const std::string position =
 			m_offset.has_value() ? std::to_string(*m_offset) : "offset not evaluated";
 
-		return fmt::format("JUMP_IF_EXC     r{} position: {}", m_exception_type_reg, position);
+		return std::format("JUMP_IF_EXC     r{} position: {}", m_exception_type_reg, position);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
-	void relocate(size_t) final;
+	void relocate(std::size_t) final;
 
-	std::vector<uint8_t> serialize() const final;
+	std::vector<std::uint8_t> serialize() const final;
 
-	uint8_t id() const final { return JUMP_IF_EXCEPTION_MATCH; }
+	std::uint8_t id() const final { return JUMP_IF_EXCEPTION_MATCH; }
 };
diff --git a/src/executable/bytecode/instructions/JumpIfFalse.cpp b/src/executable/bytecode/instructions/JumpIfFalse.cpp
index c086a7a9..be599011 100644
--- a/src/executable/bytecode/instructions/JumpIfFalse.cpp
+++ b/src/executable/bytecode/instructions/JumpIfFalse.cpp
@@ -1,9 +1,16 @@
-#include "JumpIfFalse.hpp"
+module;
+#include "core.hpp"
 #include "executable/Label.hpp"
-#include "runtime/PyBool.hpp"
-#include "vm/VM.hpp"
+#include <cstddef>
+#include <cstdint>
 
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 #include "../serialization/serialize.hpp"
+#include "executable/Label.hpp"
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/JumpIfFalse.hpp b/src/executable/bytecode/instructions/JumpIfFalse.hpp
index 0833603e..b8168b2c 100644
--- a/src/executable/bytecode/instructions/JumpIfFalse.hpp
+++ b/src/executable/bytecode/instructions/JumpIfFalse.hpp
@@ -1,21 +1,17 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-#include <optional>
-
 class JumpIfFalse final : public Instruction
 {
 	Register m_test_register;
 	std::shared_ptr<Label> m_label;
-	std::optional<int32_t> m_offset;
+	std::optional<std::int32_t> m_offset;
 
   public:
 	JumpIfFalse(Register test_register, std::shared_ptr<Label> label)
 		: m_test_register(test_register), m_label(std::move(label))
 	{}
 
-	JumpIfFalse(Register test_register, int32_t offset)
+	JumpIfFalse(Register test_register, std::int32_t offset)
 		: m_test_register(test_register), m_offset(offset)
 	{}
 
@@ -23,14 +19,14 @@ class JumpIfFalse final : public Instruction
 	{
 		const std::string position =
 			m_offset.has_value() ? std::to_string(*m_offset) : "offset not evaluated";
-		return fmt::format("JUMP_IF_FALSE   r{:<3} position: {}", m_test_register, position);
+		return std::format("JUMP_IF_FALSE   r{:<3} position: {}", m_test_register, position);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
-	void relocate(size_t) final;
+	void relocate(std::size_t) final;
 
-	std::vector<uint8_t> serialize() const final;
+	std::vector<std::uint8_t> serialize() const final;
 
-	uint8_t id() const final { return JUMP_IF_FALSE; }
+	std::uint8_t id() const final { return JUMP_IF_FALSE; }
 };
diff --git a/src/executable/bytecode/instructions/JumpIfFalseOrPop.cpp b/src/executable/bytecode/instructions/JumpIfFalseOrPop.cpp
index 5ffa00b8..a4c806fb 100644
--- a/src/executable/bytecode/instructions/JumpIfFalseOrPop.cpp
+++ b/src/executable/bytecode/instructions/JumpIfFalseOrPop.cpp
@@ -1,9 +1,16 @@
-#include "JumpIfFalseOrPop.hpp"
+module;
+#include "core.hpp"
 #include "executable/Label.hpp"
-#include "runtime/PyBool.hpp"
-#include "vm/VM.hpp"
+#include <cstddef>
+#include <cstdint>
 
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 #include "../serialization/serialize.hpp"
+#include "executable/Label.hpp"
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/JumpIfFalseOrPop.hpp b/src/executable/bytecode/instructions/JumpIfFalseOrPop.hpp
index 504f32c2..34ae4c30 100644
--- a/src/executable/bytecode/instructions/JumpIfFalseOrPop.hpp
+++ b/src/executable/bytecode/instructions/JumpIfFalseOrPop.hpp
@@ -1,14 +1,11 @@
 #pragma once
-#include "Instructions.hpp"
-
-#include <optional>
 
 class JumpIfFalseOrPop final : public Instruction
 {
 	Register m_test_register;
 	Register m_result_register;
 	std::shared_ptr<Label> m_label;
-	std::optional<int32_t> m_offset;
+	std::optional<std::int32_t> m_offset;
 
   public:
 	JumpIfFalseOrPop(Register test_register, Register result_register, std::shared_ptr<Label> label)
@@ -16,7 +13,7 @@ class JumpIfFalseOrPop final : public Instruction
 		  m_label(std::move(label))
 	{}
 
-	JumpIfFalseOrPop(Register test_register, Register result_register, int32_t offset)
+	JumpIfFalseOrPop(Register test_register, Register result_register, std::int32_t offset)
 		: m_test_register(test_register), m_result_register(result_register), m_offset(offset)
 	{}
 
@@ -24,7 +21,7 @@ class JumpIfFalseOrPop final : public Instruction
 	{
 		const std::string position =
 			m_offset.has_value() ? std::to_string(*m_offset) : "offset not evaluated";
-		return fmt::format("JUMP_IF_FALSE_OR_POP r{:<3} r{:<3} position: {}",
+		return std::format("JUMP_IF_FALSE_OR_POP r{:<3} r{:<3} position: {}",
 			m_test_register,
 			m_result_register,
 			position);
@@ -32,9 +29,9 @@ class JumpIfFalseOrPop final : public Instruction
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
-	void relocate(size_t) final;
+	void relocate(std::size_t) final;
 
-	std::vector<uint8_t> serialize() const final;
+	std::vector<std::uint8_t> serialize() const final;
 
-	uint8_t id() const final { return JUMP_IF_FALSE_OR_POP; }
+	std::uint8_t id() const final { return JUMP_IF_FALSE_OR_POP; }
 };
diff --git a/src/executable/bytecode/instructions/JumpIfNotExceptionMatch.cpp b/src/executable/bytecode/instructions/JumpIfNotExceptionMatch.cpp
index 26af229c..afedbeb3 100644
--- a/src/executable/bytecode/instructions/JumpIfNotExceptionMatch.cpp
+++ b/src/executable/bytecode/instructions/JumpIfNotExceptionMatch.cpp
@@ -1,14 +1,17 @@
-#include "JumpIfNotExceptionMatch.hpp"
+module;
+#include "core.hpp"
 #include "executable/Label.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/TypeError.hpp"
-#include "runtime/types/builtin.hpp"
-#include "vm/VM.hpp"
+#include <cstddef>
+#include <cstdint>
 
+module py.runtime;
+import py.types;
+import std;
+
+// After the import: these name module-owned types.
 #include "../serialization/serialize.hpp"
+#include "executable/Label.hpp"
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/JumpIfNotExceptionMatch.hpp b/src/executable/bytecode/instructions/JumpIfNotExceptionMatch.hpp
index f2af757c..6315344b 100644
--- a/src/executable/bytecode/instructions/JumpIfNotExceptionMatch.hpp
+++ b/src/executable/bytecode/instructions/JumpIfNotExceptionMatch.hpp
@@ -1,20 +1,16 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-#include <optional>
-
 class JumpIfNotExceptionMatch final : public Instruction
 {
 	Register m_exception_type_reg;
 	std::shared_ptr<Label> m_label;
-	std::optional<uint32_t> m_offset;
+	std::optional<std::uint32_t> m_offset;
 
   public:
 	JumpIfNotExceptionMatch(Register exception_type_reg, std::shared_ptr<Label> label)
 		: m_exception_type_reg(exception_type_reg), m_label(std::move(label))
 	{}
-	JumpIfNotExceptionMatch(Register exception_type_reg, uint32_t offset)
+	JumpIfNotExceptionMatch(Register exception_type_reg, std::uint32_t offset)
 		: m_exception_type_reg(exception_type_reg), m_offset(offset)
 	{}
 
@@ -23,14 +19,14 @@ class JumpIfNotExceptionMatch final : public Instruction
 		const std::string position =
 			m_offset.has_value() ? std::to_string(*m_offset) : "offset not evaluated";
 
-		return fmt::format("JUMP_IF_NOT_EXC r{} position: {}", m_exception_type_reg, position);
+		return std::format("JUMP_IF_NOT_EXC r{} position: {}", m_exception_type_reg, position);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
-	void relocate(size_t) final;
+	void relocate(std::size_t) final;
 
-	std::vector<uint8_t> serialize() const final;
+	std::vector<std::uint8_t> serialize() const final;
 
-	uint8_t id() const final { return JUMP_IF_NOT_EXCEPTION_MATCH; }
+	std::uint8_t id() const final { return JUMP_IF_NOT_EXCEPTION_MATCH; }
 };
diff --git a/src/executable/bytecode/instructions/JumpIfTrue.cpp b/src/executable/bytecode/instructions/JumpIfTrue.cpp
index 04f0487d..bd44f690 100644
--- a/src/executable/bytecode/instructions/JumpIfTrue.cpp
+++ b/src/executable/bytecode/instructions/JumpIfTrue.cpp
@@ -1,10 +1,16 @@
-#include "JumpIfTrue.hpp"
+module;
+#include "core.hpp"
 #include "executable/Label.hpp"
-#include "runtime/PyBool.hpp"
-#include "runtime/PyNone.hpp"
-#include "vm/VM.hpp"
+#include <cstddef>
+#include <cstdint>
 
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 #include "../serialization/serialize.hpp"
+#include "executable/Label.hpp"
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/JumpIfTrue.hpp b/src/executable/bytecode/instructions/JumpIfTrue.hpp
index c71a4ad5..49cd5a61 100644
--- a/src/executable/bytecode/instructions/JumpIfTrue.hpp
+++ b/src/executable/bytecode/instructions/JumpIfTrue.hpp
@@ -1,21 +1,17 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-#include <optional>
-
 class JumpIfTrue final : public Instruction
 {
 	Register m_test_register;
 	std::shared_ptr<Label> m_label;
-	std::optional<int32_t> m_offset;
+	std::optional<std::int32_t> m_offset;
 
   public:
 	JumpIfTrue(Register test_register, std::shared_ptr<Label> label)
 		: m_test_register(test_register), m_label(std::move(label))
 	{}
 
-	JumpIfTrue(Register test_register, int32_t offset)
+	JumpIfTrue(Register test_register, std::int32_t offset)
 		: m_test_register(test_register), m_offset(offset)
 	{}
 
@@ -23,14 +19,14 @@ class JumpIfTrue final : public Instruction
 	{
 		const std::string position =
 			m_offset.has_value() ? std::to_string(*m_offset) : "offset not evaluated";
-		return fmt::format("JUMP_IF_TRUE    r{} position: {}", m_test_register, position);
+		return std::format("JUMP_IF_TRUE    r{} position: {}", m_test_register, position);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
-	void relocate(size_t) final;
+	void relocate(std::size_t) final;
 
-	std::vector<uint8_t> serialize() const final;
+	std::vector<std::uint8_t> serialize() const final;
 
-	uint8_t id() const final { return JUMP_IF_TRUE; }
+	std::uint8_t id() const final { return JUMP_IF_TRUE; }
 };
diff --git a/src/executable/bytecode/instructions/JumpIfTrueOrPop.cpp b/src/executable/bytecode/instructions/JumpIfTrueOrPop.cpp
index a4773e9c..c63588ce 100644
--- a/src/executable/bytecode/instructions/JumpIfTrueOrPop.cpp
+++ b/src/executable/bytecode/instructions/JumpIfTrueOrPop.cpp
@@ -1,9 +1,16 @@
-#include "JumpIfTrueOrPop.hpp"
+module;
+#include "core.hpp"
 #include "executable/Label.hpp"
-#include "runtime/PyBool.hpp"
-#include "vm/VM.hpp"
+#include <cstddef>
+#include <cstdint>
 
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 #include "../serialization/serialize.hpp"
+#include "executable/Label.hpp"
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/JumpIfTrueOrPop.hpp b/src/executable/bytecode/instructions/JumpIfTrueOrPop.hpp
index e6ead055..96a0b8c4 100644
--- a/src/executable/bytecode/instructions/JumpIfTrueOrPop.hpp
+++ b/src/executable/bytecode/instructions/JumpIfTrueOrPop.hpp
@@ -1,14 +1,11 @@
 #pragma once
-#include "Instructions.hpp"
-
-#include <optional>
 
 class JumpIfTrueOrPop final : public Instruction
 {
 	Register m_test_register;
 	Register m_result_register;
 	std::shared_ptr<Label> m_label;
-	std::optional<int32_t> m_offset;
+	std::optional<std::int32_t> m_offset;
 
   public:
 	JumpIfTrueOrPop(Register test_register, Register result_register, std::shared_ptr<Label> label)
@@ -16,7 +13,7 @@ class JumpIfTrueOrPop final : public Instruction
 		  m_label(std::move(label))
 	{}
 
-	JumpIfTrueOrPop(Register test_register, Register result_register, int32_t offset)
+	JumpIfTrueOrPop(Register test_register, Register result_register, std::int32_t offset)
 		: m_test_register(test_register), m_result_register(result_register), m_offset(offset)
 	{}
 
@@ -24,7 +21,7 @@ class JumpIfTrueOrPop final : public Instruction
 	{
 		const std::string position =
 			m_offset.has_value() ? std::to_string(*m_offset) : "offset not evaluated";
-		return fmt::format("JUMP_IF_TRUE_OR_POP r{:<3} r{:<3} position: {}",
+		return std::format("JUMP_IF_TRUE_OR_POP r{:<3} r{:<3} position: {}",
 			m_test_register,
 			m_result_register,
 			position);
@@ -32,9 +29,9 @@ class JumpIfTrueOrPop final : public Instruction
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
-	void relocate(size_t) final;
+	void relocate(std::size_t) final;
 
-	std::vector<uint8_t> serialize() const final;
+	std::vector<std::uint8_t> serialize() const final;
 
-	uint8_t id() const final { return JUMP_IF_TRUE_OR_POP; }
+	std::uint8_t id() const final { return JUMP_IF_TRUE_OR_POP; }
 };
diff --git a/src/executable/bytecode/instructions/LeaveExceptionHandling.cpp b/src/executable/bytecode/instructions/LeaveExceptionHandling.cpp
index 0c91012f..6e8b6175 100644
--- a/src/executable/bytecode/instructions/LeaveExceptionHandling.cpp
+++ b/src/executable/bytecode/instructions/LeaveExceptionHandling.cpp
@@ -1,6 +1,14 @@
-#include "LeaveExceptionHandling.hpp"
-#include "runtime/PyNone.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/LeaveExceptionHandling.hpp b/src/executable/bytecode/instructions/LeaveExceptionHandling.hpp
index f046e186..a5177e8e 100644
--- a/src/executable/bytecode/instructions/LeaveExceptionHandling.hpp
+++ b/src/executable/bytecode/instructions/LeaveExceptionHandling.hpp
@@ -1,11 +1,10 @@
-#include "Instructions.hpp"
 
 class LeaveExceptionHandling final : public Instruction
 {
   public:
 	LeaveExceptionHandling() = default;
 
-	std::string to_string() const final { return fmt::format("LEAVE_EXC_HANDLE"); }
+	std::string to_string() const final { return std::format("LEAVE_EXC_HANDLE"); }
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
diff --git a/src/executable/bytecode/instructions/ListAppend.cpp b/src/executable/bytecode/instructions/ListAppend.cpp
index f268f88d..df0984c8 100644
--- a/src/executable/bytecode/instructions/ListAppend.cpp
+++ b/src/executable/bytecode/instructions/ListAppend.cpp
@@ -1,7 +1,14 @@
-#include "ListAppend.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/PyTuple.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/ListAppend.hpp b/src/executable/bytecode/instructions/ListAppend.hpp
index 85945a32..e02cefcc 100644
--- a/src/executable/bytecode/instructions/ListAppend.hpp
+++ b/src/executable/bytecode/instructions/ListAppend.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class ListAppend final : public Instruction
 {
 	Register m_list;
@@ -13,7 +10,7 @@ class ListAppend final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("LIST_APPEND     r{:<3} r{:<3}", m_list, m_value);
+		return std::format("LIST_APPEND     r{:<3} r{:<3}", m_list, m_value);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/ListExtend.cpp b/src/executable/bytecode/instructions/ListExtend.cpp
index d871239c..fc7b079c 100644
--- a/src/executable/bytecode/instructions/ListExtend.cpp
+++ b/src/executable/bytecode/instructions/ListExtend.cpp
@@ -1,7 +1,14 @@
-#include "ListExtend.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/PyTuple.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/ListExtend.hpp b/src/executable/bytecode/instructions/ListExtend.hpp
index 9dc38f37..1b212337 100644
--- a/src/executable/bytecode/instructions/ListExtend.hpp
+++ b/src/executable/bytecode/instructions/ListExtend.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class ListExtend final : public Instruction
 {
 	Register m_list;
@@ -13,7 +10,7 @@ class ListExtend final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("LIST_EXT        r{:<3} r{:<3}", m_list, m_value);
+		return std::format("LIST_EXT        r{:<3} r{:<3}", m_list, m_value);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/ListToTuple.cpp b/src/executable/bytecode/instructions/ListToTuple.cpp
index f1b8f3b0..80aec8e1 100644
--- a/src/executable/bytecode/instructions/ListToTuple.cpp
+++ b/src/executable/bytecode/instructions/ListToTuple.cpp
@@ -1,10 +1,14 @@
-#include "ListToTuple.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/PyTuple.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 
-#include <iostream>
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/ListToTuple.hpp b/src/executable/bytecode/instructions/ListToTuple.hpp
index 66c1ed6c..7c4caf83 100644
--- a/src/executable/bytecode/instructions/ListToTuple.hpp
+++ b/src/executable/bytecode/instructions/ListToTuple.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class ListToTuple final : public Instruction
 {
 	Register m_tuple;
@@ -13,7 +10,7 @@ class ListToTuple final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("LIST_TO_TUPLE   r{:<3} r{:<3}", m_tuple, m_list);
+		return std::format("LIST_TO_TUPLE   r{:<3} r{:<3}", m_tuple, m_list);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/LoadAssertionError.cpp b/src/executable/bytecode/instructions/LoadAssertionError.cpp
index 296c45e0..1d48ed4e 100644
--- a/src/executable/bytecode/instructions/LoadAssertionError.cpp
+++ b/src/executable/bytecode/instructions/LoadAssertionError.cpp
@@ -1,7 +1,15 @@
-#include "LoadAssertionError.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+
+// Names Instruction, so it follows the import.
+import py.types;
+import std;
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/LoadAssertionError.hpp b/src/executable/bytecode/instructions/LoadAssertionError.hpp
index 23282aa0..4ae17547 100644
--- a/src/executable/bytecode/instructions/LoadAssertionError.hpp
+++ b/src/executable/bytecode/instructions/LoadAssertionError.hpp
@@ -1,4 +1,3 @@
-#include "Instructions.hpp"
 
 
 class LoadAssertionError final : public Instruction
@@ -10,7 +9,7 @@ class LoadAssertionError final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("LOAD_ASSERTION_ERROR r{}", m_assertion_location);
+		return std::format("LOAD_ASSERTION_ERROR r{}", m_assertion_location);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/LoadAttr.cpp b/src/executable/bytecode/instructions/LoadAttr.cpp
index 96f385dd..5beb6488 100644
--- a/src/executable/bytecode/instructions/LoadAttr.cpp
+++ b/src/executable/bytecode/instructions/LoadAttr.cpp
@@ -1,10 +1,15 @@
-#include "LoadAttr.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyModule.hpp"
-#include "runtime/PyString.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include "spdlog/spdlog.h"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/LoadAttr.hpp b/src/executable/bytecode/instructions/LoadAttr.hpp
index 8140f6e8..6b8986b3 100644
--- a/src/executable/bytecode/instructions/LoadAttr.hpp
+++ b/src/executable/bytecode/instructions/LoadAttr.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class LoadAttr final : public Instruction
 {
 	Register m_destination;
@@ -16,7 +13,7 @@ class LoadAttr final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format(
+		return std::format(
 			"LOAD_ATTR       r{:<3} r{:<3} ({})", m_destination, m_value_source, m_attr_name);
 	}
 
diff --git a/src/executable/bytecode/instructions/LoadBuildClass.cpp b/src/executable/bytecode/instructions/LoadBuildClass.cpp
index f8fcaaf1..592cf87c 100644
--- a/src/executable/bytecode/instructions/LoadBuildClass.cpp
+++ b/src/executable/bytecode/instructions/LoadBuildClass.cpp
@@ -1,11 +1,14 @@
-#include "LoadBuildClass.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyModule.hpp"
-#include "runtime/PyString.hpp"
-#include "vm/VM.hpp"
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/LoadBuildClass.hpp b/src/executable/bytecode/instructions/LoadBuildClass.hpp
index c6b1463f..29eca1d4 100644
--- a/src/executable/bytecode/instructions/LoadBuildClass.hpp
+++ b/src/executable/bytecode/instructions/LoadBuildClass.hpp
@@ -1,15 +1,12 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class LoadBuildClass final : public Instruction
 {
 	Register m_dst;
 
   public:
 	LoadBuildClass(Register dst) : m_dst(dst) {}
-	std::string to_string() const final { return fmt::format("LOAD_BUILD_CLASS r{}", m_dst); }
+	std::string to_string() const final { return std::format("LOAD_BUILD_CLASS r{}", m_dst); }
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 	void relocate(size_t) final {}
diff --git a/src/executable/bytecode/instructions/LoadClosure.cpp b/src/executable/bytecode/instructions/LoadClosure.cpp
index a5d7a030..d1bfbeac 100644
--- a/src/executable/bytecode/instructions/LoadClosure.cpp
+++ b/src/executable/bytecode/instructions/LoadClosure.cpp
@@ -1,8 +1,13 @@
-#include "LoadClosure.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyCell.hpp"
-#include "runtime/PyFrame.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 
 
 using namespace py;
diff --git a/src/executable/bytecode/instructions/LoadClosure.hpp b/src/executable/bytecode/instructions/LoadClosure.hpp
index 1df434c5..7e743732 100644
--- a/src/executable/bytecode/instructions/LoadClosure.hpp
+++ b/src/executable/bytecode/instructions/LoadClosure.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class LoadClosure final : public Instruction
 {
 	Register m_destination;
@@ -15,7 +12,7 @@ class LoadClosure final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("LOAD_CLOSURE    r{:<3} f{:<3}", m_destination, m_source);
+		return std::format("LOAD_CLOSURE    r{:<3} f{:<3}", m_destination, m_source);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/LoadConst.cpp b/src/executable/bytecode/instructions/LoadConst.cpp
index 95372f6d..26f1513b 100644
--- a/src/executable/bytecode/instructions/LoadConst.cpp
+++ b/src/executable/bytecode/instructions/LoadConst.cpp
@@ -1,7 +1,14 @@
-#include "LoadConst.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyFrame.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/LoadConst.hpp b/src/executable/bytecode/instructions/LoadConst.hpp
index 61b4293c..e91dd789 100644
--- a/src/executable/bytecode/instructions/LoadConst.hpp
+++ b/src/executable/bytecode/instructions/LoadConst.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class LoadConst final : public Instruction
 {
 	Register m_destination;
@@ -15,7 +12,7 @@ class LoadConst final : public Instruction
 	~LoadConst() override {}
 	std::string to_string() const final
 	{
-		return fmt::format("LOAD_CONST      r{:<3} s{:<3}", m_destination, m_static_value_index);
+		return std::format("LOAD_CONST      r{:<3} s{:<3}", m_destination, m_static_value_index);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/LoadDeref.cpp b/src/executable/bytecode/instructions/LoadDeref.cpp
index 58054d3f..7ccf3f6a 100644
--- a/src/executable/bytecode/instructions/LoadDeref.cpp
+++ b/src/executable/bytecode/instructions/LoadDeref.cpp
@@ -1,12 +1,14 @@
-#include "LoadDeref.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/NameError.hpp"
-#include "runtime/PyCell.hpp"
-#include "runtime/PyCode.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyObject.hpp"
-#include "vm/VM.hpp"
-#include <variant>
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/LoadDeref.hpp b/src/executable/bytecode/instructions/LoadDeref.hpp
index 2ec1c8c1..623af205 100644
--- a/src/executable/bytecode/instructions/LoadDeref.hpp
+++ b/src/executable/bytecode/instructions/LoadDeref.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class LoadDeref final : public Instruction
 {
 	Register m_destination;
@@ -14,7 +11,7 @@ class LoadDeref final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("LOAD_DEREF      r{:<3} f{:<3}", m_destination, m_source);
+		return std::format("LOAD_DEREF      r{:<3} f{:<3}", m_destination, m_source);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/LoadException.cpp b/src/executable/bytecode/instructions/LoadException.cpp
index 1902da40..b579da8e 100644
--- a/src/executable/bytecode/instructions/LoadException.cpp
+++ b/src/executable/bytecode/instructions/LoadException.cpp
@@ -1,8 +1,14 @@
-#include "LoadException.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/BaseException.hpp"
-#include "runtime/PyFrame.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/LoadException.hpp b/src/executable/bytecode/instructions/LoadException.hpp
index d743ab45..8e551e9b 100644
--- a/src/executable/bytecode/instructions/LoadException.hpp
+++ b/src/executable/bytecode/instructions/LoadException.hpp
@@ -1,4 +1,3 @@
-#include "Instructions.hpp"
 
 
 class LoadException final : public Instruction
@@ -10,7 +9,7 @@ class LoadException final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("LOAD_EXCEPTION  r{}", m_destination);
+		return std::format("LOAD_EXCEPTION  r{}", m_destination);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/LoadFast.cpp b/src/executable/bytecode/instructions/LoadFast.cpp
index 6c20d3ef..cb049418 100644
--- a/src/executable/bytecode/instructions/LoadFast.cpp
+++ b/src/executable/bytecode/instructions/LoadFast.cpp
@@ -1,10 +1,14 @@
-#include "LoadFast.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyCode.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/UnboundLocalError.hpp"
-#include "vm/VM.hpp"
-#include <iterator>
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/LoadFast.hpp b/src/executable/bytecode/instructions/LoadFast.hpp
index 76c8fde0..9851aa5b 100644
--- a/src/executable/bytecode/instructions/LoadFast.hpp
+++ b/src/executable/bytecode/instructions/LoadFast.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class LoadFast final : public Instruction
 {
 	Register m_destination;
@@ -16,7 +14,7 @@ class LoadFast final : public Instruction
 	~LoadFast() override {}
 	std::string to_string() const final
 	{
-		return fmt::format(
+		return std::format(
 			"LOAD_FAST       r{:<3} {} (\"{}\")", m_destination, m_stack_index, m_object_name);
 	}
 
diff --git a/src/executable/bytecode/instructions/LoadGlobal.cpp b/src/executable/bytecode/instructions/LoadGlobal.cpp
index 703d139a..0482e67c 100644
--- a/src/executable/bytecode/instructions/LoadGlobal.cpp
+++ b/src/executable/bytecode/instructions/LoadGlobal.cpp
@@ -1,13 +1,14 @@
-#include "LoadGlobal.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 
-#include "interpreter/Interpreter.hpp"
-#include "runtime/KeyError.hpp"
-#include "runtime/NameError.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyModule.hpp"
-#include "runtime/PyType.hpp"
-#include "vm/VM.hpp"
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/LoadGlobal.hpp b/src/executable/bytecode/instructions/LoadGlobal.hpp
index cb7ab0bd..6550e17a 100644
--- a/src/executable/bytecode/instructions/LoadGlobal.hpp
+++ b/src/executable/bytecode/instructions/LoadGlobal.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class LoadGlobal final : public Instruction
 {
 	Register m_destination;
@@ -15,7 +12,7 @@ class LoadGlobal final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("LOAD_GLOBAL     r{:<3} \"{}\"", m_destination, m_object_name);
+		return std::format("LOAD_GLOBAL     r{:<3} \"{}\"", m_destination, m_object_name);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/LoadMethod.cpp b/src/executable/bytecode/instructions/LoadMethod.cpp
index 8287eb8f..ad26fc54 100644
--- a/src/executable/bytecode/instructions/LoadMethod.cpp
+++ b/src/executable/bytecode/instructions/LoadMethod.cpp
@@ -1,13 +1,14 @@
-#include "LoadMethod.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/AttributeError.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyModule.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/LoadMethod.hpp b/src/executable/bytecode/instructions/LoadMethod.hpp
index f1790907..b4d1890a 100644
--- a/src/executable/bytecode/instructions/LoadMethod.hpp
+++ b/src/executable/bytecode/instructions/LoadMethod.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class LoadMethod final : public Instruction
 {
 	Register m_destination;
@@ -17,7 +14,7 @@ class LoadMethod final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format(
+		return std::format(
 			"LOAD_METHOD     r{:<3} r{:<3} ({})", m_destination, m_value_source, m_method_name);
 	}
 
diff --git a/src/executable/bytecode/instructions/LoadName.cpp b/src/executable/bytecode/instructions/LoadName.cpp
index 9647ac37..cb0795e7 100644
--- a/src/executable/bytecode/instructions/LoadName.cpp
+++ b/src/executable/bytecode/instructions/LoadName.cpp
@@ -1,8 +1,15 @@
-#include "LoadName.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 #include "executable/bytecode/serialization/serialize.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/NameError.hpp"
-#include "vm/VM.hpp"
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/LoadName.hpp b/src/executable/bytecode/instructions/LoadName.hpp
index e558ed31..1a65416e 100644
--- a/src/executable/bytecode/instructions/LoadName.hpp
+++ b/src/executable/bytecode/instructions/LoadName.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class LoadName final : public Instruction
 {
 	Register m_destination;
@@ -15,7 +12,7 @@ class LoadName final : public Instruction
 	~LoadName() override {}
 	std::string to_string() const final
 	{
-		return fmt::format("LOAD_NAME       r{:<3} \"{}\"", m_destination, m_object_name);
+		return std::format("LOAD_NAME       r{:<3} \"{}\"", m_destination, m_object_name);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/MakeFunction.cpp b/src/executable/bytecode/instructions/MakeFunction.cpp
index c97fb607..bf83b35d 100644
--- a/src/executable/bytecode/instructions/MakeFunction.cpp
+++ b/src/executable/bytecode/instructions/MakeFunction.cpp
@@ -1,10 +1,11 @@
-#include "MakeFunction.hpp"
-#include "executable/Mangler.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyCode.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyTuple.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
 
 
 using namespace py;
diff --git a/src/executable/bytecode/instructions/MakeFunction.hpp b/src/executable/bytecode/instructions/MakeFunction.hpp
index 76ab7f3a..41a46be1 100644
--- a/src/executable/bytecode/instructions/MakeFunction.hpp
+++ b/src/executable/bytecode/instructions/MakeFunction.hpp
@@ -1,21 +1,18 @@
 #pragma once
 
-#include "Instructions.hpp"
-#include <optional>
-
 class MakeFunction : public Instruction
 {
 	Register m_dst;
 	Register m_name;
-	size_t m_defaults_size;
-	size_t m_kw_defaults_size;
+	std::size_t m_defaults_size;
+	std::size_t m_kw_defaults_size;
 	std::optional<Register> m_captures_tuple;
 
   public:
 	MakeFunction(Register dst,
 		Register function_name,
-		size_t defaults_size,
-		size_t kw_defaults_size,
+		std::size_t defaults_size,
+		std::size_t kw_defaults_size,
 		std::optional<Register> captures_tuple)
 		: m_dst(dst), m_name(function_name), m_defaults_size(defaults_size),
 		  m_kw_defaults_size(kw_defaults_size), m_captures_tuple(std::move(captures_tuple))
@@ -23,14 +20,14 @@ class MakeFunction : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("MAKE_FUNCTION   r{}   ({})", m_dst, m_name);
+		return std::format("MAKE_FUNCTION   r{}   ({})", m_dst, m_name);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
-	void relocate(size_t) final {}
+	void relocate(std::size_t) final {}
 
-	std::vector<uint8_t> serialize() const final;
+	std::vector<std::uint8_t> serialize() const final;
 
-	uint8_t id() const final { return MAKE_FUNCTION; }
+	std::uint8_t id() const final { return MAKE_FUNCTION; }
 };
diff --git a/src/executable/bytecode/instructions/MethodCall.cpp b/src/executable/bytecode/instructions/MethodCall.cpp
index 14c709e7..c813ad20 100644
--- a/src/executable/bytecode/instructions/MethodCall.cpp
+++ b/src/executable/bytecode/instructions/MethodCall.cpp
@@ -1,17 +1,17 @@
-#include "MethodCall.hpp"
-#include "FunctionCall.hpp"
-
-#include "runtime/AttributeError.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyMethodDescriptor.hpp"
-#include "runtime/PySlotWrapper.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/PyType.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include "spdlog/spdlog.h"
+#include <cstddef>
+#include <cstdint>
 
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 #include "../serialization/serialize.hpp"
 
+
 using namespace py;
 
 PyResult<Value> MethodCall::execute(VirtualMachine &vm, Interpreter &) const
diff --git a/src/executable/bytecode/instructions/MethodCall.hpp b/src/executable/bytecode/instructions/MethodCall.hpp
index 9cd75a00..6dc2328f 100644
--- a/src/executable/bytecode/instructions/MethodCall.hpp
+++ b/src/executable/bytecode/instructions/MethodCall.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class MethodCall final : public Instruction
 {
 	const Register m_caller;
@@ -15,8 +13,8 @@ class MethodCall final : public Instruction
 	std::string to_string() const final
 	{
 		std::string args_regs{};
-		for (const auto arg : m_args) { args_regs += fmt::format(" r{:<3}", arg); }
-		return fmt::format("CALL_METHOD     r{:<3} {}", m_caller, args_regs);
+		for (const auto arg : m_args) { args_regs += std::format(" r{:<3}", arg); }
+		return std::format("CALL_METHOD     r{:<3} {}", m_caller, args_regs);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/Move.cpp b/src/executable/bytecode/instructions/Move.cpp
index cb936e92..79a05951 100644
--- a/src/executable/bytecode/instructions/Move.cpp
+++ b/src/executable/bytecode/instructions/Move.cpp
@@ -1,5 +1,14 @@
-#include "Move.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/Move.hpp b/src/executable/bytecode/instructions/Move.hpp
index 6c1f7c05..91579370 100644
--- a/src/executable/bytecode/instructions/Move.hpp
+++ b/src/executable/bytecode/instructions/Move.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class Move final : public Instruction
 {
 	Register m_destination;
@@ -12,7 +10,7 @@ class Move final : public Instruction
 	~Move() override {}
 	std::string to_string() const final
 	{
-		return fmt::format("MOVE            r{:<3}  r{:<3}", m_destination, m_source);
+		return std::format("MOVE            r{:<3}  r{:<3}", m_destination, m_source);
 	}
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
diff --git a/src/executable/bytecode/instructions/Pop.cpp b/src/executable/bytecode/instructions/Pop.cpp
index e18a5ae4..13fef724 100644
--- a/src/executable/bytecode/instructions/Pop.cpp
+++ b/src/executable/bytecode/instructions/Pop.cpp
@@ -1,6 +1,14 @@
-#include "Pop.hpp"
-#include "runtime/PyNone.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/Pop.hpp b/src/executable/bytecode/instructions/Pop.hpp
index ca2b8618..c94c79dc 100644
--- a/src/executable/bytecode/instructions/Pop.hpp
+++ b/src/executable/bytecode/instructions/Pop.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class Pop final : public Instruction
 {
 	bool m_discard{ true };
@@ -16,7 +14,7 @@ class Pop final : public Instruction
 		if (m_discard) {
 			return "POP";
 		} else {
-			return fmt::format("POP             r{}", m_dst);
+			return std::format("POP             r{}", m_dst);
 		}
 	}
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/Push.cpp b/src/executable/bytecode/instructions/Push.cpp
index c452eca7..177829a9 100644
--- a/src/executable/bytecode/instructions/Push.cpp
+++ b/src/executable/bytecode/instructions/Push.cpp
@@ -1,6 +1,14 @@
-#include "Push.hpp"
-#include "runtime/PyNone.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/Push.hpp b/src/executable/bytecode/instructions/Push.hpp
index cfda9178..c83a2bab 100644
--- a/src/executable/bytecode/instructions/Push.hpp
+++ b/src/executable/bytecode/instructions/Push.hpp
@@ -1,14 +1,12 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class Push final : public Instruction
 {
 	Register m_source;
 
   public:
 	Push(Register source) : m_source(source) {}
-	std::string to_string() const final { return fmt::format("PUSH            r{:<3}", m_source); }
+	std::string to_string() const final { return std::format("PUSH            r{:<3}", m_source); }
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
 	void relocate(size_t) final {}
diff --git a/src/executable/bytecode/instructions/RaiseVarargs.cpp b/src/executable/bytecode/instructions/RaiseVarargs.cpp
index 8c8c48d3..96c6917d 100644
--- a/src/executable/bytecode/instructions/RaiseVarargs.cpp
+++ b/src/executable/bytecode/instructions/RaiseVarargs.cpp
@@ -1,14 +1,14 @@
-#include "RaiseVarargs.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/BaseException.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyFunction.hpp"
-#include "runtime/PyTraceback.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/RuntimeError.hpp"
-#include "runtime/TypeError.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/RaiseVarargs.hpp b/src/executable/bytecode/instructions/RaiseVarargs.hpp
index 5bc8446e..1be33e70 100644
--- a/src/executable/bytecode/instructions/RaiseVarargs.hpp
+++ b/src/executable/bytecode/instructions/RaiseVarargs.hpp
@@ -1,9 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-#include <optional>
-
 class RaiseVarargs final : public Instruction
 {
 	std::optional<Register> m_exception;
@@ -18,19 +14,19 @@ class RaiseVarargs final : public Instruction
 	{
 		if (m_cause.has_value()) {
 			ASSERT(m_exception.has_value());
-			return fmt::format("RAISE_VARARGS   r{:<3} r{:<3}", *m_exception, *m_cause);
+			return std::format("RAISE_VARARGS   r{:<3} r{:<3}", *m_exception, *m_cause);
 		} else if (m_exception.has_value()) {
-			return fmt::format("RAISE_VARARGS   r{:<3}", *m_exception);
+			return std::format("RAISE_VARARGS   r{:<3}", *m_exception);
 		} else {
-			return fmt::format("RAISE_VARARGS");
+			return std::format("RAISE_VARARGS");
 		}
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
-	void relocate(size_t) final {}
+	void relocate(std::size_t) final {}
 
-	std::vector<uint8_t> serialize() const final;
+	std::vector<std::uint8_t> serialize() const final;
 
-	uint8_t id() const final { return RAISE_VARARGS; }
+	std::uint8_t id() const final { return RAISE_VARARGS; }
 };
diff --git a/src/executable/bytecode/instructions/ReRaise.cpp b/src/executable/bytecode/instructions/ReRaise.cpp
index d3f312f8..67e5397f 100644
--- a/src/executable/bytecode/instructions/ReRaise.cpp
+++ b/src/executable/bytecode/instructions/ReRaise.cpp
@@ -1,8 +1,14 @@
-#include "ReRaise.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/RuntimeError.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/ReRaise.hpp b/src/executable/bytecode/instructions/ReRaise.hpp
index 77aba88d..91670080 100644
--- a/src/executable/bytecode/instructions/ReRaise.hpp
+++ b/src/executable/bytecode/instructions/ReRaise.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class ReRaise final : public Instruction
 {
   public:
diff --git a/src/executable/bytecode/instructions/ReturnValue.cpp b/src/executable/bytecode/instructions/ReturnValue.cpp
index a3fa3b1e..30a01880 100644
--- a/src/executable/bytecode/instructions/ReturnValue.cpp
+++ b/src/executable/bytecode/instructions/ReturnValue.cpp
@@ -1,9 +1,14 @@
-#include "ReturnValue.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyGenerator.hpp"
-#include "runtime/StopIteration.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include "spdlog/spdlog.h"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 
 
 using namespace py;
diff --git a/src/executable/bytecode/instructions/ReturnValue.hpp b/src/executable/bytecode/instructions/ReturnValue.hpp
index 90a1786a..a7ca8e55 100644
--- a/src/executable/bytecode/instructions/ReturnValue.hpp
+++ b/src/executable/bytecode/instructions/ReturnValue.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class ReturnValue final : public Instruction
 {
 	Register m_source;
@@ -10,7 +7,7 @@ class ReturnValue final : public Instruction
   public:
 	ReturnValue(Register source) : m_source(source) {}
 	~ReturnValue() override {}
-	std::string to_string() const final { return fmt::format("RETURN_VALUE    r{:<3}", m_source); }
+	std::string to_string() const final { return std::format("RETURN_VALUE    r{:<3}", m_source); }
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 	void relocate(size_t) final {}
diff --git a/src/executable/bytecode/instructions/SetAdd.cpp b/src/executable/bytecode/instructions/SetAdd.cpp
index a0ca6f7c..4b5b54aa 100644
--- a/src/executable/bytecode/instructions/SetAdd.cpp
+++ b/src/executable/bytecode/instructions/SetAdd.cpp
@@ -1,7 +1,14 @@
-#include "SetAdd.hpp"
-#include "runtime/PySet.hpp"
-#include "runtime/PyTuple.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/SetAdd.hpp b/src/executable/bytecode/instructions/SetAdd.hpp
index 42ef32a4..43e60729 100644
--- a/src/executable/bytecode/instructions/SetAdd.hpp
+++ b/src/executable/bytecode/instructions/SetAdd.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class SetAdd final : public Instruction
 {
 	Register m_set;
@@ -13,7 +10,7 @@ class SetAdd final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("SET_ADD         r{:<3} r{:<3}", m_set, m_value);
+		return std::format("SET_ADD         r{:<3} r{:<3}", m_set, m_value);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/SetUpdate.cpp b/src/executable/bytecode/instructions/SetUpdate.cpp
index 0314f51d..a22fbca1 100644
--- a/src/executable/bytecode/instructions/SetUpdate.cpp
+++ b/src/executable/bytecode/instructions/SetUpdate.cpp
@@ -1,7 +1,14 @@
-#include "SetUpdate.hpp"
-#include "runtime/PySet.hpp"
-#include "runtime/PyTuple.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/SetUpdate.hpp b/src/executable/bytecode/instructions/SetUpdate.hpp
index 3354773c..fe73ec59 100644
--- a/src/executable/bytecode/instructions/SetUpdate.hpp
+++ b/src/executable/bytecode/instructions/SetUpdate.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-#include <optional>
 
 class SetUpdate final : public Instruction
 {
@@ -14,7 +11,7 @@ class SetUpdate final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("SET_UPDATE      r{:<3} r{:<3}", m_set, m_iterable);
+		return std::format("SET_UPDATE      r{:<3} r{:<3}", m_set, m_iterable);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/SetupExceptionHandling.cpp b/src/executable/bytecode/instructions/SetupExceptionHandling.cpp
index a3800860..a3f76dae 100644
--- a/src/executable/bytecode/instructions/SetupExceptionHandling.cpp
+++ b/src/executable/bytecode/instructions/SetupExceptionHandling.cpp
@@ -1,9 +1,16 @@
-#include "SetupExceptionHandling.hpp"
+module;
+#include "core.hpp"
 #include "executable/Label.hpp"
-#include "runtime/PyNone.hpp"
-#include "vm/VM.hpp"
+#include <cstddef>
+#include <cstdint>
 
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 #include "../serialization/serialize.hpp"
+#include "executable/Label.hpp"
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/SetupExceptionHandling.hpp b/src/executable/bytecode/instructions/SetupExceptionHandling.hpp
index d456c78b..cf526132 100644
--- a/src/executable/bytecode/instructions/SetupExceptionHandling.hpp
+++ b/src/executable/bytecode/instructions/SetupExceptionHandling.hpp
@@ -1,31 +1,27 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-#include <optional>
-
 class SetupExceptionHandling final : public Instruction
 {
 	std::shared_ptr<Label> m_label;
-	std::optional<uint32_t> m_offset;
+	std::optional<std::uint32_t> m_offset;
 
   public:
 	SetupExceptionHandling(std::shared_ptr<Label> label) : m_label(std::move(label)) {}
 
-	SetupExceptionHandling(uint32_t offset) : m_offset(offset) {}
+	SetupExceptionHandling(std::uint32_t offset) : m_offset(offset) {}
 
 	std::string to_string() const final
 	{
 		const std::string position =
 			m_offset.has_value() ? std::to_string(*m_offset) : "offset not evaluated";
-		return fmt::format("SETUP_EXC_HANDLE position: {}", position);
+		return std::format("SETUP_EXC_HANDLE position: {}", position);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
-	void relocate(size_t) final;
+	void relocate(std::size_t) final;
 
-	std::vector<uint8_t> serialize() const final;
+	std::vector<std::uint8_t> serialize() const final;
 
-	uint8_t id() const final { return SETUP_EXCEPTION_HANDLING; }
+	std::uint8_t id() const final { return SETUP_EXCEPTION_HANDLING; }
 };
diff --git a/src/executable/bytecode/instructions/SetupWith.cpp b/src/executable/bytecode/instructions/SetupWith.cpp
index b6841e47..741ea994 100644
--- a/src/executable/bytecode/instructions/SetupWith.cpp
+++ b/src/executable/bytecode/instructions/SetupWith.cpp
@@ -1,9 +1,16 @@
-#include "SetupWith.hpp"
+module;
+#include "core.hpp"
 #include "executable/Label.hpp"
-#include "runtime/PyNone.hpp"
-#include "vm/VM.hpp"
+#include <cstddef>
+#include <cstdint>
 
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 #include "../serialization/serialize.hpp"
+#include "executable/Label.hpp"
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/SetupWith.hpp b/src/executable/bytecode/instructions/SetupWith.hpp
index cdfad6bd..fb5f2a10 100644
--- a/src/executable/bytecode/instructions/SetupWith.hpp
+++ b/src/executable/bytecode/instructions/SetupWith.hpp
@@ -1,31 +1,27 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-#include <optional>
-
 class SetupWith final : public Instruction
 {
 	std::shared_ptr<Label> m_label;
-	std::optional<uint32_t> m_offset;
+	std::optional<std::uint32_t> m_offset;
 
   public:
 	SetupWith(std::shared_ptr<Label> label) : m_label(std::move(label)) {}
 
-	SetupWith(uint32_t offset) : m_offset(offset) {}
+	SetupWith(std::uint32_t offset) : m_offset(offset) {}
 
 	std::string to_string() const final
 	{
 		const std::string position =
 			m_offset.has_value() ? std::to_string(*m_offset) : "offset not evaluated";
-		return fmt::format("SETUP_WITH      position: {}", position);
+		return std::format("SETUP_WITH      position: {}", position);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
-	void relocate(size_t) final;
+	void relocate(std::size_t) final;
 
-	std::vector<uint8_t> serialize() const final;
+	std::vector<std::uint8_t> serialize() const final;
 
-	uint8_t id() const final { return SETUP_WITH; }
+	std::uint8_t id() const final { return SETUP_WITH; }
 };
diff --git a/src/executable/bytecode/instructions/StoreAttr.cpp b/src/executable/bytecode/instructions/StoreAttr.cpp
index 63c0aec1..edb90e99 100644
--- a/src/executable/bytecode/instructions/StoreAttr.cpp
+++ b/src/executable/bytecode/instructions/StoreAttr.cpp
@@ -1,9 +1,15 @@
-#include "StoreAttr.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyString.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include "spdlog/spdlog.h"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/StoreAttr.hpp b/src/executable/bytecode/instructions/StoreAttr.hpp
index 4c0c0bcc..4831f4f3 100644
--- a/src/executable/bytecode/instructions/StoreAttr.hpp
+++ b/src/executable/bytecode/instructions/StoreAttr.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class StoreAttr final : public Instruction
 {
 	Register m_dst;
@@ -16,7 +13,7 @@ class StoreAttr final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("STORE_ATTR      r{:<3} ({}) r{:<3}", m_dst, m_attr_name, m_src);
+		return std::format("STORE_ATTR      r{:<3} ({}) r{:<3}", m_dst, m_attr_name, m_src);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/StoreDeref.cpp b/src/executable/bytecode/instructions/StoreDeref.cpp
index f821781e..f13c96a8 100644
--- a/src/executable/bytecode/instructions/StoreDeref.cpp
+++ b/src/executable/bytecode/instructions/StoreDeref.cpp
@@ -1,8 +1,14 @@
-#include "StoreDeref.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyCell.hpp"
-#include "runtime/PyFrame.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/StoreDeref.hpp b/src/executable/bytecode/instructions/StoreDeref.hpp
index 2dc06155..7be8b6ce 100644
--- a/src/executable/bytecode/instructions/StoreDeref.hpp
+++ b/src/executable/bytecode/instructions/StoreDeref.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class StoreDeref final : public Instruction
 {
 	Register m_dst;
@@ -13,7 +10,7 @@ class StoreDeref final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("STORE_DEREF     f{:<3} r{:<3}", m_dst, m_src);
+		return std::format("STORE_DEREF     f{:<3} r{:<3}", m_dst, m_src);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/StoreFast.cpp b/src/executable/bytecode/instructions/StoreFast.cpp
index 70c58a37..664d1e4c 100644
--- a/src/executable/bytecode/instructions/StoreFast.cpp
+++ b/src/executable/bytecode/instructions/StoreFast.cpp
@@ -1,5 +1,14 @@
-#include "StoreFast.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/StoreFast.hpp b/src/executable/bytecode/instructions/StoreFast.hpp
index fe46cc44..258be19a 100644
--- a/src/executable/bytecode/instructions/StoreFast.hpp
+++ b/src/executable/bytecode/instructions/StoreFast.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
 class StoreFast final : public Instruction
 {
 	Register m_stack_index;
@@ -12,7 +10,7 @@ class StoreFast final : public Instruction
 	~StoreFast() override {}
 	std::string to_string() const final
 	{
-		return fmt::format("STORE_FAST       {} r{:<3}", m_stack_index, m_src);
+		return std::format("STORE_FAST       {} r{:<3}", m_stack_index, m_src);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &) const final;
diff --git a/src/executable/bytecode/instructions/StoreGlobal.cpp b/src/executable/bytecode/instructions/StoreGlobal.cpp
index 9755a2a0..7189c586 100644
--- a/src/executable/bytecode/instructions/StoreGlobal.cpp
+++ b/src/executable/bytecode/instructions/StoreGlobal.cpp
@@ -1,10 +1,14 @@
-#include "StoreGlobal.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyObject.hpp"
-#include "vm/VM.hpp"
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/StoreGlobal.hpp b/src/executable/bytecode/instructions/StoreGlobal.hpp
index 65715e0a..2facfc47 100644
--- a/src/executable/bytecode/instructions/StoreGlobal.hpp
+++ b/src/executable/bytecode/instructions/StoreGlobal.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class StoreGlobal final : public Instruction
 {
 	Register m_object_name;
@@ -14,7 +11,7 @@ class StoreGlobal final : public Instruction
 	{}
 	std::string to_string() const final
 	{
-		return fmt::format("STORE_GLOBAL    {:<3} r{:<3}", m_object_name, m_source);
+		return std::format("STORE_GLOBAL    {:<3} r{:<3}", m_object_name, m_source);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/StoreName.cpp b/src/executable/bytecode/instructions/StoreName.cpp
index f3305212..1666819e 100644
--- a/src/executable/bytecode/instructions/StoreName.cpp
+++ b/src/executable/bytecode/instructions/StoreName.cpp
@@ -1,9 +1,15 @@
-#include "StoreName.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
 
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 #include "executable/bytecode/serialization/serialize.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyNone.hpp"
-#include "vm/VM.hpp"
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/StoreName.hpp b/src/executable/bytecode/instructions/StoreName.hpp
index 0034b41c..1a50cd35 100644
--- a/src/executable/bytecode/instructions/StoreName.hpp
+++ b/src/executable/bytecode/instructions/StoreName.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class StoreName final : public Instruction
 {
 	std::string m_object_name;
@@ -14,7 +11,7 @@ class StoreName final : public Instruction
 	{}
 	std::string to_string() const final
 	{
-		return fmt::format("STORE_NAME      \"{}\" r{:<3}", m_object_name, m_source);
+		return std::format("STORE_NAME      \"{}\" r{:<3}", m_object_name, m_source);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/StoreSubscript.cpp b/src/executable/bytecode/instructions/StoreSubscript.cpp
index af987f20..63109449 100644
--- a/src/executable/bytecode/instructions/StoreSubscript.cpp
+++ b/src/executable/bytecode/instructions/StoreSubscript.cpp
@@ -1,6 +1,14 @@
-#include "StoreSubscript.hpp"
-#include "runtime/PyNone.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/StoreSubscript.hpp b/src/executable/bytecode/instructions/StoreSubscript.hpp
index ba238a5a..864f6f12 100644
--- a/src/executable/bytecode/instructions/StoreSubscript.hpp
+++ b/src/executable/bytecode/instructions/StoreSubscript.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class StoreSubscript final : public Instruction
 {
 	Register m_obj;
@@ -16,7 +13,7 @@ class StoreSubscript final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("STORE_SUBSCRIPT r{:<3} r{:<3} r{:<3}", m_obj, m_slice, m_src);
+		return std::format("STORE_SUBSCRIPT r{:<3} r{:<3} r{:<3}", m_obj, m_slice, m_src);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/ToBool.cpp b/src/executable/bytecode/instructions/ToBool.cpp
index 0ec5b4ae..69558cad 100644
--- a/src/executable/bytecode/instructions/ToBool.cpp
+++ b/src/executable/bytecode/instructions/ToBool.cpp
@@ -1,7 +1,14 @@
-#include "ToBool.hpp"
-#include "runtime/PyBool.hpp"
-#include "runtime/Value.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/ToBool.hpp b/src/executable/bytecode/instructions/ToBool.hpp
index 052c6c9b..ba0c0ec8 100644
--- a/src/executable/bytecode/instructions/ToBool.hpp
+++ b/src/executable/bytecode/instructions/ToBool.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-#include <optional>
 
 class ToBool final : public Instruction
 {
@@ -14,7 +11,7 @@ class ToBool final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("TO_BOOL         r{:<3} r{:<3}", m_dst, m_src);
+		return std::format("TO_BOOL         r{:<3} r{:<3}", m_dst, m_src);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/Unary.cpp b/src/executable/bytecode/instructions/Unary.cpp
index 58c901fe..382207bf 100644
--- a/src/executable/bytecode/instructions/Unary.cpp
+++ b/src/executable/bytecode/instructions/Unary.cpp
@@ -1,9 +1,15 @@
-#include "Unary.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyBool.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/TypeError.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+#include <gmpxx.h>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/Unary.hpp b/src/executable/bytecode/instructions/Unary.hpp
index 93e6e8ad..c147eb45 100644
--- a/src/executable/bytecode/instructions/Unary.hpp
+++ b/src/executable/bytecode/instructions/Unary.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class Unary final : public Instruction
 {
   public:
@@ -25,7 +22,7 @@ class Unary final : public Instruction
 	std::string to_string() const final
 	{
 		std::array op_str{ "+", "-", "~", "!" };
-		return fmt::format("UNARY  r{:<3} r{:<3} ({})",
+		return std::format("UNARY  r{:<3} r{:<3} ({})",
 			m_destination,
 			m_source,
 			op_str[static_cast<uint8_t>(m_operation)]);
diff --git a/src/executable/bytecode/instructions/UnpackExpand.cpp b/src/executable/bytecode/instructions/UnpackExpand.cpp
index 5cd85c33..27de36cc 100644
--- a/src/executable/bytecode/instructions/UnpackExpand.cpp
+++ b/src/executable/bytecode/instructions/UnpackExpand.cpp
@@ -1,17 +1,16 @@
-#include "UnpackExpand.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
 
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyNumber.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/TypeError.hpp"
-#include "runtime/ValueError.hpp"
-#include "vm/VM.hpp"
+module py.runtime;
+import std;
 
+// After the import: these name module-owned types.
 #include "../serialization/serialize.hpp"
 
+
 using namespace py;
 
 PyResult<Value> UnpackExpand::execute(VirtualMachine &vm, Interpreter &) const
diff --git a/src/executable/bytecode/instructions/UnpackExpand.hpp b/src/executable/bytecode/instructions/UnpackExpand.hpp
index d78ad70c..e986a799 100644
--- a/src/executable/bytecode/instructions/UnpackExpand.hpp
+++ b/src/executable/bytecode/instructions/UnpackExpand.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-#include "forward.hpp"
-
 
 class UnpackExpand final : public Instruction
 {
@@ -17,7 +14,7 @@ class UnpackExpand final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("UNPACK_EXPAND   {} r{:<3}", m_destination.size(), m_source);
+		return std::format("UNPACK_EXPAND   {} r{:<3}", m_destination.size(), m_source);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/UnpackSequence.cpp b/src/executable/bytecode/instructions/UnpackSequence.cpp
index ec49ceba..55bd1589 100644
--- a/src/executable/bytecode/instructions/UnpackSequence.cpp
+++ b/src/executable/bytecode/instructions/UnpackSequence.cpp
@@ -1,17 +1,16 @@
-#include "UnpackSequence.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
 
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyNumber.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/TypeError.hpp"
-#include "runtime/ValueError.hpp"
-#include "vm/VM.hpp"
+module py.runtime;
+import std;
 
+// After the import: these name module-owned types.
 #include "../serialization/serialize.hpp"
 
+
 using namespace py;
 
 PyResult<Value> UnpackSequence::execute(VirtualMachine &vm, Interpreter &) const
diff --git a/src/executable/bytecode/instructions/UnpackSequence.hpp b/src/executable/bytecode/instructions/UnpackSequence.hpp
index 99303391..11ba90d8 100644
--- a/src/executable/bytecode/instructions/UnpackSequence.hpp
+++ b/src/executable/bytecode/instructions/UnpackSequence.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class UnpackSequence final : public Instruction
 {
 	std::vector<Register> m_destination;
@@ -14,7 +11,7 @@ class UnpackSequence final : public Instruction
 	{}
 	std::string to_string() const final
 	{
-		return fmt::format("UNPACK_SEQUENCE {} r{:<3}", m_destination.size(), m_source);
+		return std::format("UNPACK_SEQUENCE {} r{:<3}", m_destination.size(), m_source);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/WithExceptStart.cpp b/src/executable/bytecode/instructions/WithExceptStart.cpp
index 5b3ba8cd..9c6ecee5 100644
--- a/src/executable/bytecode/instructions/WithExceptStart.cpp
+++ b/src/executable/bytecode/instructions/WithExceptStart.cpp
@@ -1,14 +1,15 @@
-#include "WithExceptStart.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
 
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 #include "executable/bytecode/serialization/serialize.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/BaseException.hpp"
-#include "runtime/PyBool.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyTraceback.hpp"
-#include "runtime/PyType.hpp"
-#include "vm/VM.hpp"
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/WithExceptStart.hpp b/src/executable/bytecode/instructions/WithExceptStart.hpp
index 2b0adfc6..6b086229 100644
--- a/src/executable/bytecode/instructions/WithExceptStart.hpp
+++ b/src/executable/bytecode/instructions/WithExceptStart.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class WithExceptStart final : public Instruction
 {
 	Register m_result;
@@ -15,7 +12,7 @@ class WithExceptStart final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("WITH_EXCEPT_START r{:<3} r{:<3}", m_result, m_exit_method);
+		return std::format("WITH_EXCEPT_START r{:<3} r{:<3}", m_result, m_exit_method);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &, Interpreter &) const final;
diff --git a/src/executable/bytecode/instructions/YieldFrom.cpp b/src/executable/bytecode/instructions/YieldFrom.cpp
index 657ed4d5..9df848c1 100644
--- a/src/executable/bytecode/instructions/YieldFrom.cpp
+++ b/src/executable/bytecode/instructions/YieldFrom.cpp
@@ -1,14 +1,14 @@
-#include "YieldFrom.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/BaseException.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyGenerator.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/StopIteration.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 
 using namespace py;
 
diff --git a/src/executable/bytecode/instructions/YieldFrom.hpp b/src/executable/bytecode/instructions/YieldFrom.hpp
index 25f988eb..45678db9 100644
--- a/src/executable/bytecode/instructions/YieldFrom.hpp
+++ b/src/executable/bytecode/instructions/YieldFrom.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class YieldFrom final : public Instruction
 {
 	Register m_dst;
@@ -16,7 +13,7 @@ class YieldFrom final : public Instruction
 
 	std::string to_string() const final
 	{
-		return fmt::format("YIELD_FROM      r{:<3} r{:<3} r{:<3}", m_dst, m_receiver, m_value);
+		return std::format("YIELD_FROM      r{:<3} r{:<3} r{:<3}", m_dst, m_receiver, m_value);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
diff --git a/src/executable/bytecode/instructions/YieldLoad.cpp b/src/executable/bytecode/instructions/YieldLoad.cpp
index 6b0ad640..72aae227 100644
--- a/src/executable/bytecode/instructions/YieldLoad.cpp
+++ b/src/executable/bytecode/instructions/YieldLoad.cpp
@@ -1,8 +1,13 @@
-#include "YieldLoad.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyGenerator.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 
 
 using namespace py;
diff --git a/src/executable/bytecode/instructions/YieldLoad.hpp b/src/executable/bytecode/instructions/YieldLoad.hpp
index 364f231f..39c1b6a3 100644
--- a/src/executable/bytecode/instructions/YieldLoad.hpp
+++ b/src/executable/bytecode/instructions/YieldLoad.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class YieldLoad final : public Instruction
 {
 	Register m_dst;
@@ -10,7 +7,7 @@ class YieldLoad final : public Instruction
   public:
 	YieldLoad(Register dst) : m_dst(dst) {}
 
-	std::string to_string() const final { return fmt::format("YIELD_LOAD      r{:<3}", m_dst); }
+	std::string to_string() const final { return std::format("YIELD_LOAD      r{:<3}", m_dst); }
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 	void relocate(size_t) final {}
diff --git a/src/executable/bytecode/instructions/YieldValue.cpp b/src/executable/bytecode/instructions/YieldValue.cpp
index eadb612d..75e90cae 100644
--- a/src/executable/bytecode/instructions/YieldValue.cpp
+++ b/src/executable/bytecode/instructions/YieldValue.cpp
@@ -1,7 +1,14 @@
-#include "YieldValue.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyFrame.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "executable/Label.hpp"
+#include "spdlog/spdlog.h"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
+// After the import: these name module-owned types.
 
 
 using namespace py;
diff --git a/src/executable/bytecode/instructions/YieldValue.hpp b/src/executable/bytecode/instructions/YieldValue.hpp
index 90a95b61..22f42992 100644
--- a/src/executable/bytecode/instructions/YieldValue.hpp
+++ b/src/executable/bytecode/instructions/YieldValue.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Instructions.hpp"
-
-
 class YieldValue final : public Instruction
 {
 	Register m_source;
@@ -10,7 +7,7 @@ class YieldValue final : public Instruction
   public:
 	YieldValue(Register source) : m_source(source) {}
 	~YieldValue() override {}
-	std::string to_string() const final { return fmt::format("YIELD_VALUE     r{:<3}", m_source); }
+	std::string to_string() const final { return std::format("YIELD_VALUE     r{:<3}", m_source); }
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 	void relocate(size_t) final {}
diff --git a/src/executable/bytecode/serialization/deserialize.hpp b/src/executable/bytecode/serialization/deserialize.hpp
index 9bcd704c..dfa36a44 100644
--- a/src/executable/bytecode/serialization/deserialize.hpp
+++ b/src/executable/bytecode/serialization/deserialize.hpp
@@ -1,13 +1,7 @@
 #pragma once
 
-#include "forward.hpp"
-#include "runtime/Value.hpp"
 #include "serialize.hpp"
-#include "utilities.hpp"
 
-#include <iostream>
-#include <span>
-#include <string>
 
 namespace py {
 
@@ -65,7 +59,7 @@ inline auto deserialize(std::span<const uint8_t> &buffer)
 		return result;
 	} else if constexpr (std::is_same_v<T, std::byte>) {
 		static_assert(sizeof(std::byte) == sizeof(uint8_t));
-		std::byte result = bit_cast<std::byte>(buffer.front());
+		std::byte result = std::bit_cast<std::byte>(buffer.front());
 		buffer = buffer.subspan(sizeof(std::byte));
 		return result;
 	} else if constexpr (std::is_same_v<T, bool>) {
@@ -122,4 +116,4 @@ inline auto deserialize(std::span<const uint8_t> &buffer)
 	}
 	ASSERT_NOT_REACHED();
 }
-}// namespace py
\ No newline at end of file
+}// namespace py
diff --git a/src/executable/bytecode/serialization/serialize.hpp b/src/executable/bytecode/serialization/serialize.hpp
index 94c8c4ea..a1d3b58c 100644
--- a/src/executable/bytecode/serialization/serialize.hpp
+++ b/src/executable/bytecode/serialization/serialize.hpp
@@ -1,11 +1,5 @@
 #pragma once
 
-#include "runtime/PyTuple.hpp"
-#include "utilities.hpp"
-
-#include <cstdint>
-#include <string>
-#include <vector>
 
 namespace py {
 
@@ -39,7 +33,7 @@ enum class ValueType {
 
 template<typename T> inline void serialize(const T &value, std::vector<uint8_t> &result)
 {
-	auto *data = bit_cast<const uint8_t *>(&value);
+	auto *data = std::bit_cast<const uint8_t *>(&value);
 	result.insert(result.end(), data, data + sizeof(T));
 }
 
@@ -52,7 +46,7 @@ template<> inline void serialize<bool>(const bool &value, std::vector<uint8_t> &
 
 template<> inline void serialize<std::byte>(const std::byte &value, std::vector<uint8_t> &result)
 {
-	result.push_back(::bit_cast<uint8_t>(value));
+	result.push_back(std::bit_cast<uint8_t>(value));
 }
 
 template<>
diff --git a/src/executable/common.hpp b/src/executable/common.hpp
index 9b469022..8b1a90d4 100644
--- a/src/executable/common.hpp
+++ b/src/executable/common.hpp
@@ -12,5 +12,3 @@ enum class OptimizationLevel {
 	Basic = 1,
 };
 }// namespace compiler
-
-class Program;
\ No newline at end of file
diff --git a/src/executable/llvm/LLVMFunction.cpp b/src/executable/llvm/LLVMFunction.cpp
index c1310a71..77fbe219 100644
--- a/src/executable/llvm/LLVMFunction.cpp
+++ b/src/executable/llvm/LLVMFunction.cpp
@@ -1,5 +1,8 @@
+#include "core.hpp"
+import py.runtime;
+
+// After the import: these name module-owned types.
 #include "LLVMGenerator.hpp"
-#include "runtime/Value.hpp"
 
 using namespace codegen;
 
@@ -14,4 +17,4 @@ py::PyResult<py::Value> LLVMFunction::call_without_setup(VirtualMachine &vm,
 	Interpreter &interpreter) const
 {
 	return call(vm, interpreter);
-}
\ No newline at end of file
+}
diff --git a/src/executable/llvm/LLVMGenerator.cpp b/src/executable/llvm/LLVMGenerator.cpp
index 6dafb233..dc235122 100644
--- a/src/executable/llvm/LLVMGenerator.cpp
+++ b/src/executable/llvm/LLVMGenerator.cpp
@@ -1,12 +1,16 @@
-#include "LLVMGenerator.hpp"
-#include "LLVMProgram.hpp"
-
+#include "core.hpp"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/raw_ostream.h"
 
+import py.runtime;
+
+// After the import: these name module-owned types.
+#include "LLVMGenerator.hpp"
+#include "LLVMProgram.hpp"
+
 using namespace llvm;
 using namespace codegen;
 
@@ -83,6 +87,8 @@ struct LLVMGenerator::Context
 
 LLVMGenerator::LLVMGenerator() : m_ctx(std::make_unique<Context>("test")) {}
 
+LLVMGenerator::~LLVMGenerator() = default;
+
 std::shared_ptr<Program> LLVMGenerator::compile(std::shared_ptr<ast::ASTNode> node,
 	std::vector<std::string> argv,
 	compiler::OptimizationLevel lvl)
diff --git a/src/executable/llvm/LLVMGenerator.hpp b/src/executable/llvm/LLVMGenerator.hpp
index f6c4334d..abc7ecef 100644
--- a/src/executable/llvm/LLVMGenerator.hpp
+++ b/src/executable/llvm/LLVMGenerator.hpp
@@ -1,7 +1,5 @@
-#include "ast/AST.hpp"
-#include "ast/optimizers/ConstantFolding.hpp"
+#include "ast/ASTNodeTypes.hpp"
 
-#include "executable/Function.hpp"
 
 namespace llvm {
 class Function;
@@ -20,6 +18,10 @@ class LLVMGenerator : public ast::CodeGenerator
 
 	LLVMGenerator();
 
+	// Out of line: m_ctx is a unique_ptr to an incomplete Context, so the
+	// deleter must instantiate where Context is defined, not at each use.
+	~LLVMGenerator();
+
   public:
 	static std::shared_ptr<Program> compile(std::shared_ptr<ast::ASTNode> node,
 		std::vector<std::string> argv,
@@ -50,7 +52,7 @@ class LLVMFunction : public ::Function
 
 	const llvm::Function &impl() const { return m_function; }
 
-	std::vector<uint8_t> serialize() const override { TODO(); }
+	std::vector<std::uint8_t> serialize() const override { TODO(); }
 
 	py::PyResult<py::Value> call(VirtualMachine &, Interpreter &) const override;
 	py::PyResult<py::Value> call_without_setup(VirtualMachine &, Interpreter &) const override;
diff --git a/src/executable/llvm/LLVMGenerator_tests.cpp b/src/executable/llvm/LLVMGenerator_tests.cpp
index 50870991..6001ef38 100644
--- a/src/executable/llvm/LLVMGenerator_tests.cpp
+++ b/src/executable/llvm/LLVMGenerator_tests.cpp
@@ -1,10 +1,13 @@
-#include "LLVMGenerator.hpp"
-#include "LLVMProgram.hpp"
+#include "core.hpp"
+#include "gtest/gtest.h"
 
-#include "lexer/Lexer.hpp"
-#include "parser/Parser.hpp"
+import py.lexer;
+import py.runtime;
+import py.ast;
 
-#include "gtest/gtest.h"
+// After the import: these name module-owned types.
+#include "LLVMGenerator.hpp"
+#include "LLVMProgram.hpp"
 
 namespace {
 std::shared_ptr<Program> generate_llvm_module(std::string_view program)
diff --git a/src/executable/llvm/LLVMProgram.cpp b/src/executable/llvm/LLVMProgram.cpp
index 9350cae6..0b02285d 100644
--- a/src/executable/llvm/LLVMProgram.cpp
+++ b/src/executable/llvm/LLVMProgram.cpp
@@ -1,9 +1,5 @@
-#include "LLVMProgram.hpp"
-#include "LLVMPyUtils.hpp"
-#include "executable/Function.hpp"
-#include "executable/Mangler.hpp"
-#include "executable/llvm/LLVMGenerator.hpp"
-#include "runtime/Value.hpp"
+#include "core.hpp"
+
 
 #include "llvm/ExecutionEngine/Orc/CompileUtils.h"
 #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
@@ -14,6 +10,14 @@
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
 
+import py.runtime;
+
+// After the import: these name module-owned types.
+#include "LLVMProgram.hpp"
+#include "LLVMPyUtils.hpp"
+#include "executable/llvm/LLVMGenerator.hpp"
+
+
 namespace py {
 class PyTuple;
 class PyDict;
@@ -273,4 +277,4 @@ py::PyObject *LLVMProgram::as_pyfunction(const std::string &function_name,
 	return create_llvm_function(demangled_name, std::move(llvm_func));
 }
 
-py::PyObject *LLVMProgram::main_function() { return as_pyfunction("main", {}, {}, {}); }
\ No newline at end of file
+py::PyObject *LLVMProgram::main_function() { return as_pyfunction("main", {}, {}, {}); }
diff --git a/src/executable/llvm/LLVMProgram.hpp b/src/executable/llvm/LLVMProgram.hpp
index 50f2b197..267d2e23 100644
--- a/src/executable/llvm/LLVMProgram.hpp
+++ b/src/executable/llvm/LLVMProgram.hpp
@@ -1,6 +1,6 @@
 #pragma once
+#include "core.hpp"
 
-#include "executable/Program.hpp"
 
 class Function;
 class PyFunction;
diff --git a/src/executable/llvm/LLVMPyUtils.cpp b/src/executable/llvm/LLVMPyUtils.cpp
index 8a4a755e..eeca8634 100644
--- a/src/executable/llvm/LLVMPyUtils.cpp
+++ b/src/executable/llvm/LLVMPyUtils.cpp
@@ -1,11 +1,10 @@
+#include "core.hpp"
+
+
+import py.runtime;
+
+// After the import: these name module-owned types.
 #include "LLVMPyUtils.hpp"
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyLLVMFunction.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/Value.hpp"
-#include "runtime/types/builtin.hpp"
-#include "vm/VM.hpp"
 
 using namespace py;
 
@@ -44,7 +43,7 @@ PyObject *create_llvm_function(const std::string &name,
 
 int64_t from_args_i64(uint8_t *args, int64_t idx)
 {
-	return from_args<int64_t>(bit_cast<PyTuple *>(args), idx);
+	return from_args<int64_t>(std::bit_cast<PyTuple *>(args), idx);
 }
 
-uint8_t *from_i64(int64_t value) { return bit_cast<uint8_t *>(from<int64_t>(value)); }
\ No newline at end of file
+uint8_t *from_i64(int64_t value) { return std::bit_cast<uint8_t *>(from<int64_t>(value)); }
diff --git a/src/executable/mlir/Conversion/CMakeLists.txt b/src/executable/mlir/Conversion/CMakeLists.txt
index fbc1c130..e2a025fd 100644
--- a/src/executable/mlir/Conversion/CMakeLists.txt
+++ b/src/executable/mlir/Conversion/CMakeLists.txt
@@ -17,4 +17,7 @@ add_mlir_library(PythonConversionPasses
     ${PYTHON_CONVERSION_LIBS}
 )
 
-python_cpp_link_project_options(PythonConversionPasses)
\ No newline at end of file
+python_cpp_link_project_options(PythonConversionPasses)
+# See the note in Conversion/PythonToPythonBytecode/CMakeLists.txt: the obj.<name>
+# twin does not inherit TableGen ordering.
+add_dependencies(obj.PythonConversionPasses MLIRPythonOpsIncGen MLIREmitPythonBytecodeIncGen PythonConversionPassIncGen)
diff --git a/src/executable/mlir/Conversion/Passes.cpp b/src/executable/mlir/Conversion/Passes.cpp
index b6880576..b95be265 100644
--- a/src/executable/mlir/Conversion/Passes.cpp
+++ b/src/executable/mlir/Conversion/Passes.cpp
@@ -3,6 +3,9 @@
 
 #include "mlir/Pass/Pass.h"
 
+// After the third-party headers: these name module-owned types.
+import py.runtime;
+
 namespace {
 
 #define GEN_PASS_REGISTRATION
diff --git a/src/executable/mlir/Conversion/PythonToPythonBytecode/ArithPatterns.cpp b/src/executable/mlir/Conversion/PythonToPythonBytecode/ArithPatterns.cpp
index 51c3a3ad..63fcbe56 100644
--- a/src/executable/mlir/Conversion/PythonToPythonBytecode/ArithPatterns.cpp
+++ b/src/executable/mlir/Conversion/PythonToPythonBytecode/ArithPatterns.cpp
@@ -1,14 +1,15 @@
-#include "Conversion/PythonToPythonBytecode/LoweringHelpers.hpp"
 #include "Conversion/PythonToPythonBytecode/PatternPopulators.hpp"
-
 #include "Dialect/EmitPythonBytecode/IR/EmitPythonBytecode.hpp"
 #include "Dialect/Python/IR/PythonOps.hpp"
+#include "core.hpp"
+#include "mlir/IR/PatternMatch.h"
 
-#include "executable/bytecode/instructions/BinaryOperation.hpp"
-#include "executable/bytecode/instructions/Unary.hpp"
-#include "utilities.hpp"
+import py.runtime;
 
-#include "mlir/IR/PatternMatch.h"
+// After the import: these name ast:: / py:: types.
+#include "Conversion/PythonToPythonBytecode/LoweringHelpers.hpp"
+
+// After the import: these name module-owned types.
 
 namespace mlir::py {
 namespace {
diff --git a/src/executable/mlir/Conversion/PythonToPythonBytecode/AttributeSubscriptPatterns.cpp b/src/executable/mlir/Conversion/PythonToPythonBytecode/AttributeSubscriptPatterns.cpp
index 972ab37d..7ed5bd2a 100644
--- a/src/executable/mlir/Conversion/PythonToPythonBytecode/AttributeSubscriptPatterns.cpp
+++ b/src/executable/mlir/Conversion/PythonToPythonBytecode/AttributeSubscriptPatterns.cpp
@@ -6,6 +6,9 @@
 
 #include "mlir/IR/PatternMatch.h"
 
+// After the third-party headers: these name module-owned types.
+import py.runtime;
+
 namespace mlir::py {
 namespace {
 
diff --git a/src/executable/mlir/Conversion/PythonToPythonBytecode/CMakeLists.txt b/src/executable/mlir/Conversion/PythonToPythonBytecode/CMakeLists.txt
index 1e07fdc3..d736f1c9 100644
--- a/src/executable/mlir/Conversion/PythonToPythonBytecode/CMakeLists.txt
+++ b/src/executable/mlir/Conversion/PythonToPythonBytecode/CMakeLists.txt
@@ -28,4 +28,15 @@ target_include_directories(PythonToPythonBytecode PUBLIC
 )
 
 target_link_libraries(PythonToPythonBytecode PRIVATE spdlog)
-python_cpp_link_project_options(PythonToPythonBytecode)
\ No newline at end of file
+python_cpp_link_project_options(PythonToPythonBytecode)
+
+# add_mlir_conversion_library also creates an obj.<name> object-library twin, and
+# that twin does not inherit the TableGen ordering the named target gets through
+# LINK_LIBS. Without this a clean parallel build can start compiling these
+# sources before Python/IR/*.inc has been generated and fails with
+# "fatal error: Python/IR/PythonTypes.h.inc: No such file or directory".
+# It only shows up at some -j values, so it looks intermittent.
+add_dependencies(obj.PythonToPythonBytecode
+    MLIRPythonOpsIncGen
+    MLIREmitPythonBytecodeIncGen
+    PythonConversionPassIncGen)
diff --git a/src/executable/mlir/Conversion/PythonToPythonBytecode/CollectionPatterns.cpp b/src/executable/mlir/Conversion/PythonToPythonBytecode/CollectionPatterns.cpp
index cfd6e6d0..1f850306 100644
--- a/src/executable/mlir/Conversion/PythonToPythonBytecode/CollectionPatterns.cpp
+++ b/src/executable/mlir/Conversion/PythonToPythonBytecode/CollectionPatterns.cpp
@@ -1,18 +1,17 @@
-#include "Conversion/PythonToPythonBytecode/LoweringHelpers.hpp"
 #include "Conversion/PythonToPythonBytecode/PatternPopulators.hpp"
-
 #include "Dialect/EmitPythonBytecode/IR/EmitPythonBytecode.hpp"
 #include "Dialect/Python/IR/PythonOps.hpp"
-
-#include "utilities.hpp"
-
+#include "core.hpp"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/PatternMatch.h"
 #include "llvm/ADT/STLExtras.h"
 
-#include <optional>
-#include <vector>
+import py.runtime;
+import std;
+
+// After the import: these name ast:: / py:: types.
+#include "Conversion/PythonToPythonBytecode/LoweringHelpers.hpp"
 
 namespace mlir::py {
 namespace {
diff --git a/src/executable/mlir/Conversion/PythonToPythonBytecode/ControlFlowPatterns.cpp b/src/executable/mlir/Conversion/PythonToPythonBytecode/ControlFlowPatterns.cpp
index f2262c50..eccc4c3e 100644
--- a/src/executable/mlir/Conversion/PythonToPythonBytecode/ControlFlowPatterns.cpp
+++ b/src/executable/mlir/Conversion/PythonToPythonBytecode/ControlFlowPatterns.cpp
@@ -1,16 +1,17 @@
-#include "Conversion/PythonToPythonBytecode/LoweringHelpers.hpp"
 #include "Conversion/PythonToPythonBytecode/PatternPopulators.hpp"
-
 #include "Dialect/EmitPythonBytecode/IR/EmitPythonBytecode.hpp"
 #include "Dialect/Python/IR/PythonOps.hpp"
-
-#include "utilities.hpp"
-
+#include "core.hpp"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/PatternMatch.h"
 #include "llvm/ADT/TypeSwitch.h"
 
+import py.runtime;
+
+// After the import: these name ast:: / py:: types.
+#include "Conversion/PythonToPythonBytecode/LoweringHelpers.hpp"
+
 namespace mlir::py {
 namespace {
 
diff --git a/src/executable/mlir/Conversion/PythonToPythonBytecode/FunctionPatterns.cpp b/src/executable/mlir/Conversion/PythonToPythonBytecode/FunctionPatterns.cpp
index 440717ee..5fbee9d1 100644
--- a/src/executable/mlir/Conversion/PythonToPythonBytecode/FunctionPatterns.cpp
+++ b/src/executable/mlir/Conversion/PythonToPythonBytecode/FunctionPatterns.cpp
@@ -1,19 +1,18 @@
-#include "Conversion/PythonToPythonBytecode/LoweringHelpers.hpp"
 #include "Conversion/PythonToPythonBytecode/PatternPopulators.hpp"
-
 #include "Dialect/EmitPythonBytecode/IR/EmitPythonBytecode.hpp"
 #include "Dialect/Python/IR/PythonOps.hpp"
-
-#include "utilities.hpp"
-
+#include "core.hpp"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/Visitors.h"
 
-#include <algorithm>
-#include <vector>
+import py.runtime;
+import std;
+
+// After the import: these name ast:: / py:: types.
+#include "Conversion/PythonToPythonBytecode/LoweringHelpers.hpp"
 
 namespace mlir::py {
 namespace {
diff --git a/src/executable/mlir/Conversion/PythonToPythonBytecode/ImportPatterns.cpp b/src/executable/mlir/Conversion/PythonToPythonBytecode/ImportPatterns.cpp
index 6f703919..1b9e00f9 100644
--- a/src/executable/mlir/Conversion/PythonToPythonBytecode/ImportPatterns.cpp
+++ b/src/executable/mlir/Conversion/PythonToPythonBytecode/ImportPatterns.cpp
@@ -9,6 +9,9 @@
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/PatternMatch.h"
 
+// After the third-party headers: these name module-owned types.
+import py.runtime;
+
 namespace mlir::py {
 namespace {
 
diff --git a/src/executable/mlir/Conversion/PythonToPythonBytecode/LoadStorePatterns.cpp b/src/executable/mlir/Conversion/PythonToPythonBytecode/LoadStorePatterns.cpp
index 4426dbca..cbe4eee2 100644
--- a/src/executable/mlir/Conversion/PythonToPythonBytecode/LoadStorePatterns.cpp
+++ b/src/executable/mlir/Conversion/PythonToPythonBytecode/LoadStorePatterns.cpp
@@ -7,6 +7,9 @@
 
 #include "mlir/IR/PatternMatch.h"
 
+// After the third-party headers: these name module-owned types.
+import py.runtime;
+
 namespace mlir::py {
 namespace {
 
diff --git a/src/executable/mlir/Conversion/PythonToPythonBytecode/PythonToPythonBytecode.cpp b/src/executable/mlir/Conversion/PythonToPythonBytecode/PythonToPythonBytecode.cpp
index b3c4808d..aa7562a8 100644
--- a/src/executable/mlir/Conversion/PythonToPythonBytecode/PythonToPythonBytecode.cpp
+++ b/src/executable/mlir/Conversion/PythonToPythonBytecode/PythonToPythonBytecode.cpp
@@ -4,12 +4,7 @@
 #include "Dialect/Python/IR/Dialect.hpp"
 #include "Dialect/Python/IR/PythonAttributes.hpp"
 #include "Dialect/Python/IR/PythonOps.hpp"
-#include "ast/AST.hpp"
-#include "executable/Mangler.hpp"
-#include "executable/bytecode/instructions/BinaryOperation.hpp"
-#include "executable/bytecode/instructions/GetAwaitable.hpp"
-#include "executable/bytecode/instructions/Unary.hpp"
-
+#include "core.hpp"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/Attributes.h"
@@ -27,15 +22,18 @@
 #include "mlir/Pass/Pass.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Transforms/DialectConversion.h"
+#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "mlir/Transforms/RegionUtils.h"
-#include "utilities.hpp"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/TypeSwitch.h"
 
-#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
+import py.runtime;
+import py.ast;
+import std;
+
+// After the import: these name module-owned types.
 
-#include <algorithm>
 
 namespace mlir {
 namespace py {
diff --git a/src/executable/mlir/Dialect/EmitPythonBytecode/IR/CMakeLists.txt b/src/executable/mlir/Dialect/EmitPythonBytecode/IR/CMakeLists.txt
index d469b48e..58c20f69 100644
--- a/src/executable/mlir/Dialect/EmitPythonBytecode/IR/CMakeLists.txt
+++ b/src/executable/mlir/Dialect/EmitPythonBytecode/IR/CMakeLists.txt
@@ -20,3 +20,7 @@ target_include_directories(EmitPythonBytecodeDialect PRIVATE
                             ${CMAKE_SOURCE_DIR}/src/executable/mlir/Dialect
                             ${CMAKE_BINARY_DIR}/src/executable/mlir/Dialect)
 python_cpp_link_project_options(EmitPythonBytecodeDialect)
+
+# See the note in Conversion/PythonToPythonBytecode/CMakeLists.txt: the obj.<name>
+# twin does not inherit TableGen ordering.
+add_dependencies(obj.EmitPythonBytecodeDialect MLIRPythonOpsIncGen MLIREmitPythonBytecodeIncGen PythonConversionPassIncGen)
diff --git a/src/executable/mlir/Dialect/Python/CMakeLists.txt b/src/executable/mlir/Dialect/Python/CMakeLists.txt
index f5834565..80a47af1 100644
--- a/src/executable/mlir/Dialect/Python/CMakeLists.txt
+++ b/src/executable/mlir/Dialect/Python/CMakeLists.txt
@@ -32,4 +32,7 @@ target_link_libraries(PythonMLIRDialect
                         ${GMP_LIBRARIES}
                       PUBLIC
                         spdlog)
-python_cpp_link_project_options(PythonMLIRDialect)
\ No newline at end of file
+python_cpp_link_project_options(PythonMLIRDialect)
+# See the note in Conversion/PythonToPythonBytecode/CMakeLists.txt: the obj.<name>
+# twin does not inherit TableGen ordering.
+add_dependencies(obj.PythonMLIRDialect MLIRPythonOpsIncGen MLIREmitPythonBytecodeIncGen PythonConversionPassIncGen)
diff --git a/src/executable/mlir/Dialect/Python/IR/Ops.cpp b/src/executable/mlir/Dialect/Python/IR/Ops.cpp
index e38bf0fc..daf805df 100644
--- a/src/executable/mlir/Dialect/Python/IR/Ops.cpp
+++ b/src/executable/mlir/Dialect/Python/IR/Ops.cpp
@@ -15,6 +15,9 @@
 
 #include "llvm/ADT/TypeSwitch.h"
 
+// After the third-party headers: the generated .inc code names py:: types.
+import py.runtime;
+
 #include "Python/IR/Dialect.cpp.inc"
 
 #include "Python/IR/PythonInterfaces.cpp.inc"
diff --git a/src/executable/mlir/Dialect/Python/MLIRGenerator.cpp b/src/executable/mlir/Dialect/Python/MLIRGenerator.cpp
index 86521dc3..6cbe185a 100644
--- a/src/executable/mlir/Dialect/Python/MLIRGenerator.cpp
+++ b/src/executable/mlir/Dialect/Python/MLIRGenerator.cpp
@@ -1,36 +1,34 @@
-#include "Python/MLIRGenerator.hpp"
-#include "Python/IR/Dialect.hpp"
-#include "Python/IR/PythonOps.hpp"
-
-#include "ast/AST.hpp"
-#include "executable/Mangler.hpp"
-#include "executable/Program.hpp"
+module;
+#include "core.hpp"
 #include "executable/mlir/Conversion/Passes.hpp"
 #include "executable/mlir/Conversion/PythonToPythonBytecode/PythonToPythonBytecode.hpp"
-#include "executable/mlir/Target/PythonBytecode/PythonBytecodeEmitter.hpp"
-#include "mlir/IR/BuiltinAttributes.h"
-#include "runtime/Value.hpp"
-
 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/IR/AsmState.h"
 #include "mlir/IR/Builders.h"
+#include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Target/LLVMIR/ModuleTranslation.h"
 #include "mlir/Transforms/RegionUtils.h"
-#include "utilities.hpp"
+#include <gmpxx.h>
+
+#include "Python/IR/Dialect.hpp"
+#include "Python/IR/PythonOps.hpp"
 #include "llvm/ADT/SmallVector.h"
 
-#include <algorithm>
-#include <filesystem>
-#include <memory>
-#include <ranges>
-#include <variant>
+module py.runtime;
+import py.ast;
+import py.codegen;
+import std;
+
+#include "Python/MLIRGenerator.hpp"
+#include "executable/mlir/Target/PythonBytecode/PythonBytecodeEmitter.hpp"
+
 
 namespace fs = std::filesystem;
 
@@ -734,7 +732,7 @@ ast::Value *MLIRGenerator::visit(const ast::AugAssign *node)
 				*target_value,
 				*target_slice));
 		} else {
-			std::cerr << fmt::format("Invalid node type ({}) for augmented assignment",
+			std::cerr << std::format("Invalid node type ({}) for augmented assignment",
 				ast::node_type_to_string(node->node_type()));
 			ASSERT_NOT_REACHED();
 		}
@@ -1343,7 +1341,9 @@ ast::Value *MLIRGenerator::visit(const ast::Comprehension *)
 
 ast::Value *MLIRGenerator::visit(const ast::Constant *node)
 {
-	const auto &value = *node->value();
+	// The AST stores an ast::Literal now; the visitor below is written against
+	// py::Value alternatives, so convert once here.
+	const auto value = to_runtime_value(node->value());
 	return std::visit(
 		overloaded{
 			[this, node](const py::Number &number) -> ast::Value * {
@@ -1729,8 +1729,8 @@ ast::Value *MLIRGenerator::visit(const ast::JoinedStr *node)
 	std::vector<mlir::Value> strings;
 	for (const auto &value : node->values()) {
 		if (auto c = as<ast::Constant>(value);
-			c && std::holds_alternative<py::String>(*c->value())) {
-			current_string.s += std::get<py::String>(*as<ast::Constant>(value)->value()).s;
+			c && std::holds_alternative<std::string>(c->value())) {
+			current_string.s += std::get<std::string>(as<ast::Constant>(value)->value());
 		} else {
 			if (!current_string.s.empty()) {
 				strings.push_back(load_const(m_context.builder(),
@@ -2992,4 +2992,28 @@ std::string MLIRGenerator::mangle_namespace(const std::deque<MLIRGenerator::Scop
 		});
 }
 
+
+Context::ContextImpl *Context::operator->() { return m_impl.get(); }
+
+MLIRGenerator::ClearExceptionBeforeReturn::ClearExceptionBeforeReturn(Scope &scope) : scope(scope)
+{
+	scope.clear_exception_before_return.push_back(true);
+}
+
+MLIRGenerator::ClearExceptionBeforeReturn::~ClearExceptionBeforeReturn()
+{
+	ASSERT(!scope.clear_exception_before_return.empty());
+	scope.clear_exception_before_return.pop_back();
+}
+
+MLIRGenerator::RAIIScope::~RAIIScope()
+{
+	ASSERT(!this_->m_scope.empty());
+	this_->m_scope.pop_back();
+}
+
+MLIRGenerator::Scope &MLIRGenerator::scope() { return m_scope.back(); }
+
+const MLIRGenerator::Scope &MLIRGenerator::scope() const { return m_scope.back(); }
+
 }// namespace codegen
diff --git a/src/executable/mlir/Dialect/Python/MLIRGenerator.hpp b/src/executable/mlir/Dialect/Python/MLIRGenerator.hpp
index 2523777d..ac3d8a62 100644
--- a/src/executable/mlir/Dialect/Python/MLIRGenerator.hpp
+++ b/src/executable/mlir/Dialect/Python/MLIRGenerator.hpp
@@ -1,20 +1,16 @@
 #pragma once
 
-#include "ast/AST.hpp"
-#include "executable/Program.hpp"
-#include "executable/bytecode/codegen/VariablesResolver.hpp"
-
-#include <memory>
-
-namespace mlir {
-class MLIRContext;
-class ModuleOp;
-class OpBuilder;
-class Block;
-namespace func {
-	class FuncOp;
-}
-}// namespace mlir
+#include "core.hpp"
+
+
+#include "ast/ASTNodeTypes.hpp"
+
+
+// No forward declarations of mlir:: classes here: this header is included from
+// py.runtime's purview (compile.cpp), where a forward declaration would create a
+// module-attached entity conflicting with the real MLIR headers. Includers must
+// bring in mlir/IR/MLIRContext.h, mlir/IR/Builders.h, mlir/IR/BuiltinOps.h and
+// mlir/Dialect/Func/IR/FuncOps.h themselves.
 
 namespace codegen {
 
@@ -35,7 +31,7 @@ class Context
 
 	static Context create();
 
-	ContextImpl *operator->() { return m_impl.get(); }
+	ContextImpl *operator->();
 };
 
 class MLIRGenerator : ast::CodeGenerator
@@ -71,16 +67,8 @@ class MLIRGenerator : ast::CodeGenerator
 
 	struct ClearExceptionBeforeReturn
 	{
-		ClearExceptionBeforeReturn(Scope &scope) : scope(scope)
-		{
-			scope.clear_exception_before_return.push_back(true);
-		}
-
-		~ClearExceptionBeforeReturn()
-		{
-			ASSERT(!scope.clear_exception_before_return.empty());
-			scope.clear_exception_before_return.pop_back();
-		}
+		ClearExceptionBeforeReturn(Scope &scope);
+		~ClearExceptionBeforeReturn();
 
 		Scope &scope;
 	};
@@ -89,11 +77,7 @@ class MLIRGenerator : ast::CodeGenerator
 	{
 		Scope &scope;
 		MLIRGenerator *this_;
-		~RAIIScope()
-		{
-			ASSERT(!this_->m_scope.empty());
-			this_->m_scope.pop_back();
-		}
+		~RAIIScope();
 	};
 
   private:
@@ -186,7 +170,7 @@ class MLIRGenerator : ast::CodeGenerator
 
 	std::string mangle_namespace(const std::deque<Scope> &s) const;
 
-	Scope &scope() { return m_scope.back(); }
-	const Scope &scope() const { return m_scope.back(); }
+	Scope &scope();
+	const Scope &scope() const;
 };
 }// namespace codegen
diff --git a/src/executable/mlir/Target/PythonBytecode/LinearScanRegisterAllocation.hpp b/src/executable/mlir/Target/PythonBytecode/LinearScanRegisterAllocation.hpp
index 14ce3280..47c5c1d3 100644
--- a/src/executable/mlir/Target/PythonBytecode/LinearScanRegisterAllocation.hpp
+++ b/src/executable/mlir/Target/PythonBytecode/LinearScanRegisterAllocation.hpp
@@ -1,12 +1,13 @@
 #pragma once
 
+#include "core.hpp"
+
 #include "Dialect/EmitPythonBytecode/IR/EmitPythonBytecode.hpp"
 #include "LiveIntervalAnalysis.hpp"
 #include "RegisterAllocationLogger.hpp"
 #include "RegisterAllocationTypes.hpp"
 
 #include "mlir/IR/Builders.h"
-#include "utilities.hpp"
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Format.h"
@@ -20,6 +21,7 @@
 #include <span>
 #include <variant>
 
+
 namespace codegen {
 
 /**
@@ -791,7 +793,7 @@ class LinearScanRegisterAllocation
 		// Print each value's liveness
 		for (const auto &interval : live_interval_analysis->sorted_live_intervals) {
 			// Print value name (truncate to 55 chars)
-			std::string value_str = fmt::format("{}", interval.value);
+			std::string value_str = std::format("{}", interval.value);
 			if (value_str.length() > 55) { value_str = value_str.substr(0, 52) + "..."; }
 			llvm::outs() << llvm::format("%-55s", value_str.c_str()) << " | ";
 
@@ -841,7 +843,7 @@ class LinearScanRegisterAllocation
 		// Print each value's register assignment
 		for (const auto &interval : live_interval_analysis->sorted_live_intervals) {
 			// Print value name (truncate to 55 chars)
-			std::string value_str = fmt::format("{}", interval.value);
+			std::string value_str = std::format("{}", interval.value);
 			if (value_str.length() > 55) { value_str = value_str.substr(0, 52) + "..."; }
 			llvm::outs() << llvm::format("%-55s", value_str.c_str()) << " | ";
 
diff --git a/src/executable/mlir/Target/PythonBytecode/LiveAnalysis.hpp b/src/executable/mlir/Target/PythonBytecode/LiveAnalysis.hpp
index 1f737fa7..95711c72 100644
--- a/src/executable/mlir/Target/PythonBytecode/LiveAnalysis.hpp
+++ b/src/executable/mlir/Target/PythonBytecode/LiveAnalysis.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include "core.hpp"
+
 #include "Dialect/EmitPythonBytecode/IR/EmitPythonBytecode.hpp"
 #include "RegisterAllocationLogger.hpp"
 #include "RegisterAllocationTypes.hpp"
@@ -10,7 +12,6 @@
 #include "mlir/IR/Dominance.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/Operation.h"
-#include "utilities.hpp"
 
 #include <algorithm>
 #include <map>
@@ -20,6 +21,7 @@
 #include <tuple>
 #include <vector>
 
+
 namespace codegen {
 
 /**
diff --git a/src/executable/mlir/Target/PythonBytecode/PythonBytecodeEmitter.hpp b/src/executable/mlir/Target/PythonBytecode/PythonBytecodeEmitter.hpp
index ffd8d997..fb4bd338 100644
--- a/src/executable/mlir/Target/PythonBytecode/PythonBytecodeEmitter.hpp
+++ b/src/executable/mlir/Target/PythonBytecode/PythonBytecodeEmitter.hpp
@@ -1,13 +1,13 @@
 #pragma once
 
-#include <memory>
+// Names ::Program, which py.runtime owns, so this header must be included
+// after `import py.runtime;` rather than forward-declaring it here: a
+// global-module `class Program;` would be a different entity from the
+// module-attached one.
 
-class Program;
-
-namespace mlir {
-class Operation;
-}
+// mlir::Operation likewise comes from the includer's own MLIR headers rather
+// than a forward declaration here.
 
 namespace codegen {
 std::shared_ptr<Program> translateToPythonBytecode(mlir::Operation *op);
-}
\ No newline at end of file
+}
diff --git a/src/executable/mlir/Target/PythonBytecode/RegisterAllocationLogger.hpp b/src/executable/mlir/Target/PythonBytecode/RegisterAllocationLogger.hpp
index 7a14fac9..2ca2f295 100644
--- a/src/executable/mlir/Target/PythonBytecode/RegisterAllocationLogger.hpp
+++ b/src/executable/mlir/Target/PythonBytecode/RegisterAllocationLogger.hpp
@@ -18,7 +18,7 @@ using ForwardedOutput = std::pair<mlir::Operation *, size_t>;
 
 }
 
-template<> struct fmt::formatter<mlir::Value, char>
+template<> struct std::formatter<mlir::Value, char>
 {
 	template<class ParseContext> constexpr ParseContext::iterator parse(ParseContext &ctx)
 	{
@@ -32,11 +32,11 @@ template<> struct fmt::formatter<mlir::Value, char>
 		os << "Value@" << value.getImpl() << "[";
 		value.print(os);
 		os << "]";
-		return fmt::format_to(ctx.out(), "{}", result);
+		return std::format_to(ctx.out(), "{}", result);
 	}
 };
 
-template<> struct fmt::formatter<codegen::ForwardedOutput, char>
+template<> struct std::formatter<codegen::ForwardedOutput, char>
 {
 	template<class ParseContext> constexpr ParseContext::iterator parse(ParseContext &ctx)
 	{
@@ -51,12 +51,12 @@ template<> struct fmt::formatter<codegen::ForwardedOutput, char>
 		os << "ForwardedOutput@" << static_cast<void *>(output.first) << "[";
 		output.first->print(os);
 		os << ", result_idx=" << output.second << "]";
-		return fmt::format_to(ctx.out(), "{}", result);
+		return std::format_to(ctx.out(), "{}", result);
 	}
 };
 
 
-template<> struct fmt::formatter<std::variant<mlir::Value, codegen::ForwardedOutput>, char>
+template<> struct std::formatter<std::variant<mlir::Value, codegen::ForwardedOutput>, char>
 {
 
 	template<class ParseContext> constexpr ParseContext::iterator parse(ParseContext &ctx)
@@ -69,9 +69,9 @@ template<> struct fmt::formatter<std::variant<mlir::Value, codegen::ForwardedOut
 		FmtContext &ctx) const
 	{
 		if (std::holds_alternative<mlir::Value>(value)) {
-			return fmt::format_to(ctx.out(), "{}", std::get<mlir::Value>(value));
+			return std::format_to(ctx.out(), "{}", std::get<mlir::Value>(value));
 		} else {
-			return fmt::format_to(ctx.out(), "{}", std::get<codegen::ForwardedOutput>(value));
+			return std::format_to(ctx.out(), "{}", std::get<codegen::ForwardedOutput>(value));
 		}
 	}
 };
diff --git a/src/executable/mlir/Target/PythonBytecode/TranslateToPythonBytecode.cpp b/src/executable/mlir/Target/PythonBytecode/TranslateToPythonBytecode.cpp
index fe1a4dfa..600ce663 100644
--- a/src/executable/mlir/Target/PythonBytecode/TranslateToPythonBytecode.cpp
+++ b/src/executable/mlir/Target/PythonBytecode/TranslateToPythonBytecode.cpp
@@ -1,85 +1,10 @@
+module;
 #include "Dialect/EmitPythonBytecode/IR/EmitPythonBytecode.hpp"
 #include "Dialect/Python/IR/PythonOps.hpp"
-#include "Target/PythonBytecode/PythonBytecodeEmitter.hpp"
-#include "executable/Mangler.hpp"
-#include "executable/bytecode/BytecodeProgram.hpp"
-#include "executable/bytecode/instructions/BinaryOperation.hpp"
-#include "executable/bytecode/instructions/BinarySubscript.hpp"
-#include "executable/bytecode/instructions/BuildDict.hpp"
-#include "executable/bytecode/instructions/BuildList.hpp"
-#include "executable/bytecode/instructions/BuildSet.hpp"
-#include "executable/bytecode/instructions/BuildSlice.hpp"
-#include "executable/bytecode/instructions/BuildString.hpp"
-#include "executable/bytecode/instructions/BuildTuple.hpp"
-#include "executable/bytecode/instructions/ClearExceptionState.hpp"
-#include "executable/bytecode/instructions/CompareOperation.hpp"
-#include "executable/bytecode/instructions/DeleteAttr.hpp"
-#include "executable/bytecode/instructions/DeleteDeref.hpp"
-#include "executable/bytecode/instructions/DeleteFast.hpp"
-#include "executable/bytecode/instructions/DeleteGlobal.hpp"
-#include "executable/bytecode/instructions/DeleteName.hpp"
-#include "executable/bytecode/instructions/DeleteSubscript.hpp"
-#include "executable/bytecode/instructions/DictAdd.hpp"
-#include "executable/bytecode/instructions/DictUpdate.hpp"
-#include "executable/bytecode/instructions/ForIter.hpp"
-#include "executable/bytecode/instructions/FormatValue.hpp"
-#include "executable/bytecode/instructions/FunctionCall.hpp"
-#include "executable/bytecode/instructions/FunctionCallEx.hpp"
-#include "executable/bytecode/instructions/FunctionCallWithKeywords.hpp"
-#include "executable/bytecode/instructions/GetAwaitable.hpp"
-#include "executable/bytecode/instructions/GetIter.hpp"
-#include "executable/bytecode/instructions/GetYieldFromIter.hpp"
-#include "executable/bytecode/instructions/ImportFrom.hpp"
-#include "executable/bytecode/instructions/ImportName.hpp"
-#include "executable/bytecode/instructions/ImportStar.hpp"
-#include "executable/bytecode/instructions/InplaceOp.hpp"
-#include "executable/bytecode/instructions/Instructions.hpp"
-#include "executable/bytecode/instructions/Jump.hpp"
-#include "executable/bytecode/instructions/JumpIfExceptionMatch.hpp"
-#include "executable/bytecode/instructions/JumpIfFalse.hpp"
-#include "executable/bytecode/instructions/JumpIfNotExceptionMatch.hpp"
-#include "executable/bytecode/instructions/JumpIfTrue.hpp"
-#include "executable/bytecode/instructions/LeaveExceptionHandling.hpp"
-#include "executable/bytecode/instructions/ListAppend.hpp"
-#include "executable/bytecode/instructions/ListExtend.hpp"
-#include "executable/bytecode/instructions/ListToTuple.hpp"
-#include "executable/bytecode/instructions/LoadAssertionError.hpp"
-#include "executable/bytecode/instructions/LoadAttr.hpp"
-#include "executable/bytecode/instructions/LoadBuildClass.hpp"
-#include "executable/bytecode/instructions/LoadClosure.hpp"
-#include "executable/bytecode/instructions/LoadConst.hpp"
-#include "executable/bytecode/instructions/LoadDeref.hpp"
-#include "executable/bytecode/instructions/LoadException.hpp"
-#include "executable/bytecode/instructions/LoadFast.hpp"
-#include "executable/bytecode/instructions/LoadGlobal.hpp"
-#include "executable/bytecode/instructions/LoadMethod.hpp"
-#include "executable/bytecode/instructions/LoadName.hpp"
-#include "executable/bytecode/instructions/MakeFunction.hpp"
-#include "executable/bytecode/instructions/Move.hpp"
-#include "executable/bytecode/instructions/Pop.hpp"
-#include "executable/bytecode/instructions/Push.hpp"
-#include "executable/bytecode/instructions/RaiseVarargs.hpp"
-#include "executable/bytecode/instructions/ReRaise.hpp"
-#include "executable/bytecode/instructions/ReturnValue.hpp"
-#include "executable/bytecode/instructions/SetAdd.hpp"
-#include "executable/bytecode/instructions/SetUpdate.hpp"
-#include "executable/bytecode/instructions/SetupExceptionHandling.hpp"
-#include "executable/bytecode/instructions/SetupWith.hpp"
-#include "executable/bytecode/instructions/StoreAttr.hpp"
-#include "executable/bytecode/instructions/StoreDeref.hpp"
-#include "executable/bytecode/instructions/StoreFast.hpp"
-#include "executable/bytecode/instructions/StoreGlobal.hpp"
-#include "executable/bytecode/instructions/StoreName.hpp"
-#include "executable/bytecode/instructions/StoreSubscript.hpp"
-#include "executable/bytecode/instructions/ToBool.hpp"
-#include "executable/bytecode/instructions/Unary.hpp"
-#include "executable/bytecode/instructions/UnpackExpand.hpp"
-#include "executable/bytecode/instructions/UnpackSequence.hpp"
-#include "executable/bytecode/instructions/WithExceptStart.hpp"
-#include "executable/bytecode/instructions/YieldFrom.hpp"
-#include "executable/bytecode/instructions/YieldLoad.hpp"
-#include "executable/bytecode/instructions/YieldValue.hpp"
-#include "executable/mlir/Target/PythonBytecode/LinearScanRegisterAllocation.hpp"
+#include "Target/PythonBytecode/LinearScanRegisterAllocation.hpp"
+#include "core.hpp"
+#include "executable/CodeFlags.hpp"
+#include "executable/Label.hpp"
 
 #include "mlir/Analysis/TopologicalSortUtils.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
@@ -93,15 +18,22 @@
 #include "mlir/IR/Verifier.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Target/LLVMIR/ModuleTranslation.h"
-#include "runtime/Value.hpp"
-#include "utilities.hpp"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/TypeSwitch.h"
 
-#include <algorithm>
-#include <map>
-#include <optional>
-#include <ranges>
+#include <gmp.h>
+
+
+module py.runtime;
+import py.ast;
+import std;
+
+// The concrete instruction classes are global-module types deriving from
+// py.runtime's Instruction, so they follow the import.
+
+// Names ::Program, so it follows the import.
+#include "Target/PythonBytecode/PythonBytecodeEmitter.hpp"
+
 
 using namespace mlir;
 
@@ -284,7 +216,8 @@ struct PythonBytecodeEmitter
 					std::vector<std::byte> bytes;
 					for (const auto &el : bytes_attr) {
 						ASSERT(el.isIntN(8));
-						bytes.push_back(std::byte{ *bit_cast<const uint8_t *>(el.getRawData()) });
+						bytes.push_back(
+							std::byte{ *std::bit_cast<const uint8_t *>(el.getRawData()) });
 					}
 					return ::py::Bytes{ std::move(bytes) };
 				})
diff --git a/src/executable/mlir/Target/test/PythonBytecode/LiveAnalysis_tests.cpp b/src/executable/mlir/Target/test/PythonBytecode/LiveAnalysis_tests.cpp
index fe8a34c9..5dddc77b 100644
--- a/src/executable/mlir/Target/test/PythonBytecode/LiveAnalysis_tests.cpp
+++ b/src/executable/mlir/Target/test/PythonBytecode/LiveAnalysis_tests.cpp
@@ -1,5 +1,6 @@
 #include "Target/PythonBytecode/LiveAnalysis.hpp"
 #include "Target/PythonBytecode/RegisterAllocationLogger.hpp"
+#include "core.hpp"
 
 #include "Dialect/EmitPythonBytecode/IR/EmitPythonBytecode.hpp"
 #include "Dialect/Python/IR/Dialect.hpp"
@@ -9,7 +10,6 @@
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/OwningOpRef.h"
 #include "mlir/Parser/Parser.h"
-#include "utilities.hpp"
 
 #include "gtest/gtest.h"
 #include <mlir/IR/Block.h>
@@ -17,6 +17,9 @@
 #include <mlir/IR/Visitors.h>
 #include <spdlog/spdlog.h>
 
+// After the third-party headers: these name module-owned types.
+import py.runtime;
+
 using namespace codegen;
 
 
diff --git a/src/executable/mlir/Target/test/PythonBytecode/RegisterAllocation_tests.cpp b/src/executable/mlir/Target/test/PythonBytecode/RegisterAllocation_tests.cpp
index 1f724327..dedc8344 100644
--- a/src/executable/mlir/Target/test/PythonBytecode/RegisterAllocation_tests.cpp
+++ b/src/executable/mlir/Target/test/PythonBytecode/RegisterAllocation_tests.cpp
@@ -16,6 +16,9 @@
 #include <mlir/IR/Visitors.h>
 #include <spdlog/spdlog.h>
 
+// After the third-party headers: these name module-owned types.
+import py.runtime;
+
 using namespace codegen;
 
 namespace {
diff --git a/src/executable/mlir/compile.cpp b/src/executable/mlir/compile.cpp
index 7276b557..158a3a26 100644
--- a/src/executable/mlir/compile.cpp
+++ b/src/executable/mlir/compile.cpp
@@ -1,17 +1,32 @@
-#include "compile.hpp"
+module;
+#include "core.hpp"
+#include "executable/common.hpp"
+
 #include "Conversion/Passes.hpp"
 #include "Conversion/PythonToPythonBytecode/PythonToPythonBytecode.hpp"
-#include "Dialect/Python/MLIRGenerator.hpp"
-#include "Target/PythonBytecode/PythonBytecodeEmitter.hpp"
 
 #include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
+#include "mlir/IR/MLIRContext.h"
+#include "mlir/IR/Operation.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/Passes.h"
 #include "mlir/Transforms/ViewOpGraph.h"
 #include "llvm/Support/GraphWriter.h"
 
+module py.runtime;
+import std;
+import py.ast;
+import py.codegen;
+
+#include "Target/PythonBytecode/PythonBytecodeEmitter.hpp"
+
+// After the import: these name module-owned types.
+#include "Dialect/Python/MLIRGenerator.hpp"
+#include "compile.hpp"
+
 
 namespace compiler::mlir {
 
@@ -128,4 +143,4 @@ std::shared_ptr<Program> compile(std::shared_ptr<ast::Module> node,
 	return codegen::translateToPythonBytecode(ctx.module());
 }
 
-}// namespace compiler::mlir
\ No newline at end of file
+}// namespace compiler::mlir
diff --git a/src/executable/mlir/compile.hpp b/src/executable/mlir/compile.hpp
index 4b8ff06f..d02cd9a4 100644
--- a/src/executable/mlir/compile.hpp
+++ b/src/executable/mlir/compile.hpp
@@ -1,14 +1,8 @@
 #pragma once
 
-#include "../common.hpp"
+// Include after `import py.runtime;`. Ordinary TUs must include
+// executable/common.hpp themselves, ahead of the import.
 
-#include <memory>
-#include <string>
-#include <vector>
-
-namespace ast {
-class Module;
-}
 
 namespace compiler::mlir {
 std::shared_ptr<Program> compile(std::shared_ptr<ast::Module>,
diff --git a/src/executable/mlir/tools/python-mlir-opt/python-mlir-opt.cpp b/src/executable/mlir/tools/python-mlir-opt/python-mlir-opt.cpp
index e653ea19..7390027e 100644
--- a/src/executable/mlir/tools/python-mlir-opt/python-mlir-opt.cpp
+++ b/src/executable/mlir/tools/python-mlir-opt/python-mlir-opt.cpp
@@ -17,6 +17,9 @@
 #include "mlir/InitAllPasses.h"
 #include "mlir/Tools/mlir-opt/MlirOptMain.h"
 
+// After the third-party headers: these name module-owned types.
+import py.runtime;
+
 int main(int argc, char **argv)
 {
 	mlir::DialectRegistry registry;
diff --git a/src/forward.hpp b/src/forward.hpp
deleted file mode 100644
index ebc996e5..00000000
--- a/src/forward.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <variant>
-
-namespace ast {
-class ASTNode;
-class Module;
-}// namespace ast
-
-class Bytecode;
-class BytecodeProgram;
-namespace codegen {
-class BytecodeGenerator;
-}
-class Function;
-class Interpreter;
-class InterpreterSession;
-class Instruction;
-class Program;
-class VirtualMachine;
-class Label;
-
-namespace parser {
-class Parser;
-}
-
-struct Load;
-
-namespace py {
-struct Number;
-struct String;
-struct Bytes;
-struct Ellipsis;
-struct NoneType;
-struct NameConstant;
-struct Tuple;
-class PyObject;
-using Value = std::variant<Number, String, Bytes, Ellipsis, NameConstant, Tuple, PyObject *>;
-template<typename T> class PyResult;
-}// namespace py
-
-using Register = uint8_t;
diff --git a/src/interpreter/Interpreter.cpp b/src/interpreter/Interpreter.cpp
index 23a6beb4..8c3bbb3e 100644
--- a/src/interpreter/Interpreter.cpp
+++ b/src/interpreter/Interpreter.cpp
@@ -1,35 +1,10 @@
-#include "Interpreter.hpp"
-
-#include "runtime/BaseException.hpp"
-#include "runtime/Import.hpp"
-#include "runtime/KeyError.hpp"
-#include "runtime/NameError.hpp"
-#include "runtime/PyBool.hpp"
-#include "runtime/PyCode.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyFunction.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyNumber.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/Value.hpp"
-#include "runtime/modules/Modules.hpp"
-#include "runtime/modules/config.hpp"
-#include "runtime/types/builtin.hpp"
-
-#include "executable/Program.hpp"
-#include "executable/bytecode/Bytecode.hpp"
-#include "executable/bytecode/BytecodeProgram.hpp"
-#include "utilities.hpp"
-
-#include <cstdio>
-#include <filesystem>
-#include <ranges>
+module;
+#include "core.hpp"
 #include <unistd.h>
 
+module py.runtime;
+import py.types;
+
 namespace fs = std::filesystem;
 using namespace py;
 
@@ -129,7 +104,7 @@ Interpreter::Interpreter() {}
 void Interpreter::internal_setup(const std::string &name,
 	std::string entry_script,
 	std::vector<std::string> argv,
-	size_t local_registers,
+	std::size_t local_registers,
 	const PyTuple *consts,
 	const std::vector<std::string> &names,
 	Config &&config,
@@ -271,7 +246,9 @@ void Interpreter::internal_setup(const std::string &name,
 		if (args.is_err()) { TODO(); }
 		auto result = install.unwrap()->call(args.unwrap(), nullptr);
 		if (result.is_err()) {
-			spdlog::error("Error calling _install: {}", result.unwrap_err()->to_string());
+			::detail::log_error(
+				std::format("Error calling _install: {}", result.unwrap_err()->to_string())
+					.c_str());
 			TODO();
 		}
 
@@ -281,8 +258,9 @@ void Interpreter::internal_setup(const std::string &name,
 
 		result = install_external.unwrap()->call(PyTuple::create().unwrap(), nullptr);
 		if (result.is_err()) {
-			spdlog::error(
-				"Error calling _install_external_importers: {}", result.unwrap_err()->to_string());
+			::detail::log_error(std::format(
+				"Error calling _install_external_importers: {}", result.unwrap_err()->to_string())
+					.c_str());
 			TODO();
 		}
 	}
@@ -399,7 +377,8 @@ PyResult<PyObject *> Interpreter::call(PyNativeFunction *native_func, PyTuple *a
 	auto &vm = VirtualMachine::the();
 	ASSERT(native_func->is_function());
 	return native_func->operator()(args, kwargs).and_then([&vm](PyObject *result) {
-		spdlog::debug("Native function return value: {}", result->to_string());
+		::detail::log_debug(
+			std::format("Native function return value: {}", result->to_string()).c_str());
 		vm.reg(0) = result;
 		return Ok(result);
 	});
@@ -411,7 +390,8 @@ PyResult<PyObject *>
 	auto &vm = VirtualMachine::the();
 	ASSERT(native_func->is_method());
 	return native_func->operator()(self, args, kwargs).and_then([&vm](PyObject *result) {
-		spdlog::debug("Native function return value: {}", result->to_string());
+		::detail::log_debug(
+			std::format("Native function return value: {}", result->to_string()).c_str());
 		vm.reg(0) = result;
 		return Ok(result);
 	});
@@ -419,17 +399,19 @@ PyResult<PyObject *>
 
 PyResult<std::monostate> Interpreter::store_object(const std::string &name, const Value &value)
 {
-	if (spdlog::get_level() == spdlog::level::debug) {
-		spdlog::debug("Interpreter::store_object(name={}, value={}, current_frame={})",
-			name,
-			std::visit(
-				[](const auto &val) {
-					std::ostringstream os;
-					os << val;
-					return os.str();
-				},
-				value),
-			(void *)m_current_frame);
+	if (::detail::log_debug_enabled()) {
+		::detail::log_debug(
+			std::format("Interpreter::store_object(name={}, value={}, current_frame={})",
+				name,
+				std::visit(
+					[](const auto &val) {
+						std::ostringstream os;
+						os << val;
+						return os.str();
+					},
+					value),
+				(void *)m_current_frame)
+				.c_str());
 	}
 	return m_current_frame->put_local(name, value);
 }
diff --git a/src/interpreter/Interpreter.hpp b/src/interpreter/Interpreter.cppm
similarity index 89%
rename from src/interpreter/Interpreter.hpp
rename to src/interpreter/Interpreter.cppm
index 542052cf..7cb654d3 100644
--- a/src/interpreter/Interpreter.hpp
+++ b/src/interpreter/Interpreter.cppm
@@ -1,12 +1,26 @@
-#pragma once
-
-#include "forward.hpp"
-#include "runtime/forward.hpp"
-#include "vm/VM.hpp"
-
-#include <string>
-#include <string_view>
-#include <variant>
+module;
+#include "memory/allocate.hpp"
+
+#include "core.hpp"
+
+#include <cstddef>
+
+export module py.runtime:interpreter;
+import :baseexception;
+import :dict;
+import :frame;
+import :function;
+import :list;
+import :object;
+import :string;
+import :tuple;
+import :value;
+import :vm;
+import std;
+
+namespace py {
+class PyModule;
+}
 
 class BytecodeProgram;
 
@@ -18,7 +32,7 @@ struct ScopedStack
 	std::unique_ptr<StackFrame> release();
 };
 
-class Interpreter
+export class Interpreter
 	: NonCopyable
 	, NonMoveable
 {
@@ -111,7 +125,6 @@ class Interpreter
 		py::PyTuple *args,
 		py::PyDict *kwargs);
 
-
 	void register_callback(py::PyObject *callback, py::PyTuple *args);
 	void unregister_callback(py::PyObject *callback);
 
@@ -121,11 +134,11 @@ class Interpreter
 	void internal_setup(const std::string &name,
 		std::string entry_script,
 		std::vector<std::string> argv,
-		size_t local_registers,
+		std::size_t local_registers,
 		const py::PyTuple *consts,
 		const std::vector<std::string> &names,
 		Config &&,
 		std::shared_ptr<Program> &&);
 };
 
-void initialize_types();
+export void initialize_types();
diff --git a/src/interpreter/InterpreterSession.cpp b/src/interpreter/InterpreterSession.cpp
index 454c0205..9ba12ec5 100644
--- a/src/interpreter/InterpreterSession.cpp
+++ b/src/interpreter/InterpreterSession.cpp
@@ -1,5 +1,14 @@
-#include "InterpreterSession.hpp"
+module;
+#include "core.hpp"
 
+module py.runtime;
+
+void InterpreterSession::shutdown(Interpreter &interpreter)
+{
+	const std::size_t initial_size = m_interpreters.size();
+	m_interpreters.remove_if([&interpreter](const auto &i) { return &interpreter == i.get(); });
+	ASSERT(initial_size != m_interpreters.size());
+}
 
 Interpreter &InterpreterSession::start_new_interpreter(const BytecodeProgram &)
 {
diff --git a/src/interpreter/InterpreterSession.hpp b/src/interpreter/InterpreterSession.cppm
similarity index 53%
rename from src/interpreter/InterpreterSession.hpp
rename to src/interpreter/InterpreterSession.cppm
index 076c076e..1ffbce16 100644
--- a/src/interpreter/InterpreterSession.hpp
+++ b/src/interpreter/InterpreterSession.cppm
@@ -1,10 +1,16 @@
-#pragma once
+module;
+#include "core.hpp"
 
-#include "Interpreter.hpp"
 
-#include "utilities.hpp"
+export module py.runtime:interpreter_session;
+// :interpreter (not a forward declaration) because m_interpreters holds
+// unique_ptr<Interpreter>: remove_if and the destructor erase elements, which
+// instantiates default_delete<Interpreter> and needs the complete type.
+import :interpreter;
+import std;
 
-#include <list>
+export class Interpreter;
+class BytecodeProgram;
 
 class InterpreterSession
 	: NonCopyable
@@ -20,6 +26,8 @@ class InterpreterSession
 		return *m_interpreters.back();
 	}
 
+	~InterpreterSession();
+
 	const Interpreter &interpreter() const
 	{
 		ASSERT(!m_interpreters.empty());
@@ -28,12 +36,7 @@ class InterpreterSession
 
 	const std::list<std::unique_ptr<Interpreter>> &interpreters() const { return m_interpreters; }
 
-	void shutdown(Interpreter &interpreter)
-	{
-		const size_t initial_size = m_interpreters.size();
-		m_interpreters.remove_if([&interpreter](const auto &i) { return &interpreter == i.get(); });
-		ASSERT(initial_size != m_interpreters.size());
-	}
+	void shutdown(Interpreter &interpreter);
 
 	Interpreter &start_new_interpreter(const BytecodeProgram &program);
-};
\ No newline at end of file
+};
diff --git a/src/lexer/Lexer.cpp b/src/lexer/Lexer.cpp
index 5650cab7..51b2de94 100644
--- a/src/lexer/Lexer.cpp
+++ b/src/lexer/Lexer.cpp
@@ -1,44 +1,49 @@
-#include "Lexer.hpp"
+module;
+#include "core.hpp"
 
-#include <filesystem>
-#include <fstream>
-#include <optional>
-#include <string>
+module py.lexer;
+
+
+std::string Token::to_string() const
+{
+	std::string value{ m_start.pointer_to_program, m_end.pointer_to_program };
+	if (m_token_exact_type == TokenType::NEWLINE) { value = "\\n"; }
+	return std::format("{:<12} {:>1}:{:>3} - {:>1}:{:>3} \t\"{}\"",
+		stringify_token_type(m_token_type),
+		m_start.row,
+		m_start.column,
+		m_end.row,
+		m_end.column,
+		value);
+}
 
 std::optional<std::string> read_file(const std::string &filename)
 {
 	std::filesystem::path path = filename;
 	if (!std::filesystem::exists(path)) {
-		std::cerr << fmt::format("File {} does not exist", path.c_str()) << std::endl;
+		std::cerr << std::format("File {} does not exist", path.c_str()) << std::endl;
 		return {};
 	}
-
 	std::ifstream in(std::filesystem::absolute(path).c_str());
 	if (!in.is_open()) {
-		std::cerr << fmt::format("Failed to open {}", std::filesystem::absolute(path).c_str())
+		std::cerr << std::format("Failed to open {}", std::filesystem::absolute(path).c_str())
 				  << std::endl;
 		return {};
 	}
-
 	std::string program;
-
 	in.seekg(0, std::ios::end);
 	program.reserve(in.tellg());
 	in.seekg(0, std::ios::beg);
-
 	program.assign((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
 	if (program.back() != '\n') { program.append("\n"); }
-
-	spdlog::debug("Input program: \n----\n{}\n----\n", program.c_str());
+	::detail::log_debug(std::format("Input program: \n----\n{}\n----\n", program.c_str()).c_str());
 	return program;
 }
-
 void Lexer::push_token(Token::TokenType token_type, const Position &start, const Position &end)
 {
 	m_tokens_to_emit.emplace_back(token_type, start, end);
 	m_current_line_tokens.emplace_back(token_type, start, end);
 }
-
 bool Lexer::read_more_tokens_loop()
 {
 	if (m_cursor > m_program.size()) { return false; }
@@ -53,7 +58,6 @@ bool Lexer::read_more_tokens_loop()
 		push_token(Token::TokenType::ENDMARKER, original_position, m_position);
 		return true;
 	}
-
 	if (current_mode() == Mode::NORMAL) {
 		if (try_empty_line()) { return true; }
 		if (try_read_comment()) { return true; }
@@ -68,32 +72,35 @@ bool Lexer::read_more_tokens_loop()
 	} else {
 		if (try_fstring()) { return true; }
 	}
-
 	return false;
 }
-
 bool Lexer::read_more_tokens()
 {
-	const size_t token_size = m_tokens_to_emit.size();
+	const std::size_t token_size = m_tokens_to_emit.size();
 	while (token_size >= m_tokens_to_emit.size()) {
+		const std::size_t already_filtered = m_tokens_to_emit.size();
 		bool read_tokens = read_more_tokens_loop();
 		if (read_tokens) {
-			std::erase_if(m_tokens_to_emit, [this](Token &token) {
-				if (m_ignore_comments && token.token_type() == Token::TokenType::COMMENT) {
-					return true;
-				}
-				if (m_ignore_nl_token && token.token_type() == Token::TokenType::NL) {
-					return true;
-				}
-				return false;
-			});
+			const auto first = m_tokens_to_emit.begin() + already_filtered;
+			m_tokens_to_emit.erase(
+				std::remove_if(first,
+					m_tokens_to_emit.end(),
+					[this](const Token &token) {
+						if (m_ignore_comments && token.token_type() == Token::TokenType::COMMENT) {
+							return true;
+						}
+						if (m_ignore_nl_token && token.token_type() == Token::TokenType::NL) {
+							return true;
+						}
+						return false;
+					}),
+				m_tokens_to_emit.end());
 		} else {
 			return false;
 		}
 	}
 	return true;
 }
-
 void Lexer::push_new_line()
 {
 	const auto original_position = m_position;
@@ -105,7 +112,6 @@ void Lexer::push_new_line()
 	}
 	increment_row_position();
 }
-
 void Lexer::push_empty_line()
 {
 	const auto original_position = m_position;
@@ -113,11 +119,9 @@ void Lexer::push_empty_line()
 	push_token(Token::TokenType::NL, original_position, m_position);
 	increment_row_position();
 }
-
-
-std::optional<size_t> Lexer::comment_start() const
+std::optional<std::size_t> Lexer::comment_start() const
 {
-	size_t n = 0;
+	std::size_t n = 0;
 	if (m_cursor >= m_program.size()) { return {}; }
 	if (peek(n) == '#') { return n; }
 	while (std::isblank(peek(n)) && peek(n) != '\n') {
@@ -126,21 +130,18 @@ std::optional<size_t> Lexer::comment_start() const
 	}
 	return {};
 }
-
 bool Lexer::try_read_comment()
 {
 	if (auto start = comment_start(); start.has_value()) {
 		// advance to '#'
 		advance(*start);
 		const auto original_position = m_position;
-
 		// skip '#'
 		advance(1);
 		advance_while([](const char c) {
 			// TODO: make newline check platform agnostic in Windows this can be "\r\n"
 			return std::isalnum(c) || c != '\n';
 		});
-
 		push_token(Token::TokenType::COMMENT, original_position, m_position);
 		// if we want NL tokens, we need to look back and see if this
 		// line has a non-comment token
@@ -162,10 +163,8 @@ bool Lexer::try_read_comment()
 		}
 		return true;
 	}
-
 	return false;
 }
-
 bool Lexer::try_empty_line()
 {
 	const auto original_position = m_position;
@@ -189,7 +188,6 @@ bool Lexer::try_empty_line()
 	m_cursor = cursor;
 	return false;
 }
-
 bool Lexer::try_read_indent()
 {
 	// if we are the start of a new line we need to check indent/dedent
@@ -212,11 +210,10 @@ bool Lexer::try_read_indent()
 	}
 	return false;
 }
-
-std::tuple<size_t, size_t> Lexer::compute_indent_level()
+std::tuple<std::size_t, std::size_t> Lexer::compute_indent_level()
 {
-	size_t pos = 0;
-	size_t indentation_value = 0;
+	std::size_t pos = 0;
+	std::size_t indentation_value = 0;
 	while (std::isblank(peek(pos))) {
 		if (peek(pos) == '\t') {
 			indentation_value += tab_size;
@@ -227,9 +224,8 @@ std::tuple<size_t, size_t> Lexer::compute_indent_level()
 	}
 	return { indentation_value, pos };
 }
-
 template<typename FunctorType>
-std::optional<size_t> Lexer::parse_digits(size_t n, FunctorType &&f) const
+std::optional<std::size_t> Lexer::parse_digits(std::size_t n, FunctorType &&f) const
 {
 	bool previous_is_underscore = false;
 	while (f(peek(n)) || peek(n) == '_') {
@@ -251,8 +247,7 @@ std::optional<size_t> Lexer::parse_digits(size_t n, FunctorType &&f) const
 	}
 	return n;
 }
-
-std::optional<size_t> Lexer::int_number(size_t n) const
+std::optional<std::size_t> Lexer::int_number(std::size_t n) const
 {
 	// ugly, but it isn't trivial to chain/pipe these operations in a generic way
 	if (auto end = hex_number(n)) {
@@ -267,8 +262,7 @@ std::optional<size_t> Lexer::int_number(size_t n) const
 		return {};
 	}
 }
-
-std::optional<size_t> Lexer::hex_number(size_t n) const
+std::optional<std::size_t> Lexer::hex_number(std::size_t n) const
 {
 	if (peek(n++) != '0') { return {}; }
 	if (peek(n) != 'x' && peek(n) != 'X') { return {}; }
@@ -283,8 +277,7 @@ std::optional<size_t> Lexer::hex_number(size_t n) const
 	if (result.has_value() && *result < 3) { return {}; }
 	return result;
 }
-
-std::optional<size_t> Lexer::bin_number(size_t n) const
+std::optional<std::size_t> Lexer::bin_number(std::size_t n) const
 {
 	if (peek(n++) != '0') { return {}; }
 	if (peek(n) != 'b' && peek(n) != 'B') { return {}; }
@@ -299,8 +292,7 @@ std::optional<size_t> Lexer::bin_number(size_t n) const
 	if (result.has_value() && *result < 3) { return {}; }
 	return result;
 }
-
-std::optional<size_t> Lexer::oct_number(size_t n) const
+std::optional<std::size_t> Lexer::oct_number(std::size_t n) const
 {
 	if (peek(n++) != '0') { return {}; }
 	if (peek(n) != 'o' && peek(n) != 'O') { return {}; }
@@ -315,8 +307,7 @@ std::optional<size_t> Lexer::oct_number(size_t n) const
 	if (result.has_value() && *result < 3) { return {}; }
 	return result;
 }
-
-std::optional<size_t> Lexer::dec_number(size_t n) const
+std::optional<std::size_t> Lexer::dec_number(std::size_t n) const
 {
 	bool previous_is_underscore = false;
 	// (?:0(?:_?0)*
@@ -332,7 +323,6 @@ std::optional<size_t> Lexer::dec_number(size_t n) const
 		// we found a valid decimal number with just 0s (possibly with '_')
 		return n;
 	}
-
 	ASSERT(n == 0);
 	ASSERT(previous_is_underscore == false);
 	// [1-9](?:_?[0-9])*)
@@ -344,19 +334,16 @@ std::optional<size_t> Lexer::dec_number(size_t n) const
 	if (n > 0) { return n; }
 	return {};
 }
-
-std::optional<size_t> Lexer::exp_number(size_t n) const
+std::optional<std::size_t> Lexer::exp_number(std::size_t n) const
 {
 	if (peek(n) != 'e' && peek(n) != 'E') { return {}; }
 	n++;
 	if (peek(n) == '-' || peek(n) == '+') { n++; }
-
 	if (!std::isdigit(peek(n))) { return {}; }
 	n++;
 	return parse_digits(n, [](const char c) { return std::isdigit(c); });
 }
-
-std::optional<size_t> Lexer::point_float_number(size_t n) const
+std::optional<std::size_t> Lexer::point_float_number(std::size_t n) const
 {
 	// [0-9](?:_?[0-9])*
 	if (std::isdigit(peek(n))) {
@@ -365,7 +352,6 @@ std::optional<size_t> Lexer::point_float_number(size_t n) const
 		if (!result) { return {}; }
 		n = *result;
 	}
-
 	// \.(?:[0-9](?:_?[0-9])*)?`
 	if (peek(n) != '.') { return {}; }
 	n++;
@@ -373,8 +359,7 @@ std::optional<size_t> Lexer::point_float_number(size_t n) const
 	n++;
 	return parse_digits(n, [](const char c) { return std::isdigit(c); });
 }
-
-std::optional<size_t> Lexer::exp_float_number(size_t n) const
+std::optional<std::size_t> Lexer::exp_float_number(std::size_t n) const
 {
 	// [0-9](?:_?[0-9])*)
 	if (!(peek(n) >= '0' && peek(n) <= '9')) { return {}; }
@@ -384,35 +369,30 @@ std::optional<size_t> Lexer::exp_float_number(size_t n) const
 	if (result) { return exp_number(*result); }
 	return {};
 }
-
-std::optional<size_t> Lexer::imag_number(size_t n) const
+std::optional<std::size_t> Lexer::imag_number(std::size_t n) const
 {
-	auto result = [this](size_t n) -> std::optional<size_t> {
+	auto result = [this](std::size_t n) -> std::optional<std::size_t> {
 		// [0-9](?:_?[0-9])*)
 		if (!(peek(n) >= '0' && peek(n) <= '9')) { return {}; }
 		n++;
 		auto result = parse_digits(n, [](const char c) { return std::isdigit(c); });
 		if (!result) { return {}; }
 		n = *result;
-
 		if (!(peek(n) == 'j' && peek(n) == 'J')) { return {}; }
 		n++;
 		return n;
 	}(n);
-
 	if (!result) {
-		result = [this](size_t n) -> std::optional<size_t> {
+		result = [this](std::size_t n) -> std::optional<std::size_t> {
 			if (auto result = float_number(n)) {
 				if (peek(*result) == 'j' || peek(*result) == 'J') { return *result + 1; }
 			}
 			return {};
 		}(n);
 	}
-
 	return result;
 }
-
-std::optional<size_t> Lexer::float_number(size_t n) const
+std::optional<std::size_t> Lexer::float_number(std::size_t n) const
 {
 	if (auto end = exp_float_number(n)) {
 		return *end;
@@ -422,14 +402,11 @@ std::optional<size_t> Lexer::float_number(size_t n) const
 		return {};
 	}
 }
-
 bool Lexer::try_read_number()
 {
 	const Position original_position = m_position;
-	size_t n = 0;
-
+	std::size_t n = 0;
 	if (m_cursor >= m_program.size()) { return false; }
-
 	if (auto end = imag_number(n)) {
 		increment_column_position(*end);
 	} else if (auto end = float_number(n)) {
@@ -442,25 +419,21 @@ bool Lexer::try_read_number()
 	push_token(Token::TokenType::NUMBER, original_position, m_position);
 	return true;
 }
-
-bool Lexer::single_quote_string(size_t n)
+bool Lexer::single_quote_string(std::size_t n)
 {
 	const auto original_position = m_position;
 	const auto original_cursor = m_cursor;
 	while (true) {
 		// [^'\\]*(?:\\.[^'\\]*)*'
-
 		// [^'\\]*
 		while (peek(n) != '\\' && peek(n) != '\'') { n++; }
-
-		auto advance = [this](size_t n) -> std::optional<size_t> {
+		auto advance = [this](std::size_t n) -> std::optional<std::size_t> {
 			// (?:\\.[^'\\]*)
 			if (peek(n++) != '\\') return {};
 			if (peek(n++) == '\n') return {};
 			while (peek(n) != '\\' && peek(n) != '\'') { n++; }
 			return n;
 		};
-
 		// (?:\\.[^'\\]*)*
 		while (true) {
 			if (auto inc = advance(n); inc.has_value()) {
@@ -469,7 +442,6 @@ bool Lexer::single_quote_string(size_t n)
 				break;
 			}
 		}
-
 		if (peek(n) == '\\' && peek(n + 1) == '\n') {
 			Lexer::advance(n + 2);
 			n = 0;
@@ -486,28 +458,23 @@ bool Lexer::single_quote_string(size_t n)
 		n = 0;
 		break;
 	}
-
 	return true;
 }
-
-bool Lexer::double_quote_string(size_t n)
+bool Lexer::double_quote_string(std::size_t n)
 {
 	const auto original_position = m_position;
 	const auto original_cursor = m_cursor;
 	while (true) {
 		// [^"\\]*(?:\\.[^"\\]*)*"
-
 		// [^"\\]*
 		while (peek(n) != '\\' && peek(n) != '\"') { n++; }
-
-		auto advance = [this](size_t n) -> std::optional<size_t> {
+		auto advance = [this](std::size_t n) -> std::optional<std::size_t> {
 			// (?:\\.[^"\\]*)
 			if (peek(n++) != '\\') return {};
 			if (peek(n++) == '\n') return {};
 			while (peek(n) != '\\' && peek(n) != '\"') { n++; }
 			return n;
 		};
-
 		// (?:\\.[^"\\]*)*
 		while (true) {
 			if (auto inc = advance(n); inc.has_value()) {
@@ -516,14 +483,12 @@ bool Lexer::double_quote_string(size_t n)
 				break;
 			}
 		}
-
 		if (peek(n) == '\\' && peek(n + 1) == '\n') {
 			Lexer::advance(n + 2);
 			n = 0;
 			increment_row_position();
 			continue;
 		}
-
 		// "
 		if (peek(n) != '"') {
 			m_position = original_position;
@@ -534,45 +499,35 @@ bool Lexer::double_quote_string(size_t n)
 		n = 0;
 		break;
 	}
-
 	return true;
 }
-
-
-bool Lexer::single_triple_quote_string(size_t n)
+bool Lexer::single_triple_quote_string(std::size_t n)
 {
 	const auto original_position = m_position;
 	const auto original_cursor = m_cursor;
 	while (true) {
 		// [^'\\]*(?:(?:\\.|'(?!''))[^'\\]*)*'''
-
 		// [^'\\]*
 		while (peek(n) != '\\' && peek(n) != '\'') {
 			if (peek(n) == '\n') { increment_row_position(); }
 			n++;
 		}
-
-		auto advance = [this](size_t n) -> std::optional<size_t> {
+		auto advance = [this](std::size_t n) -> std::optional<std::size_t> {
 			// (?:\\.|'(?!''))
-
 			if (peek(n) == '\\' && peek(n + 1) != '\n') {
 				// \\.
 				return n + 2;
 			} else {
 				// '(?!'')
-
 				// '
 				if (peek(n) != '\'') return {};
 				if (peek(n) == '\n') { increment_row_position(); }
 				n++;
-
 				// (?!'')
 				if (peek(n) == '\'' && peek(n + 1) == '\'') return {};
-
 				return n;
 			}
 		};
-
 		// (?:(?:\\.|'(?!''))[^'\\]*)*
 		while (true) {
 			if (auto inc = advance(n); inc.has_value()) {
@@ -585,14 +540,12 @@ bool Lexer::single_triple_quote_string(size_t n)
 				break;
 			}
 		}
-
 		if (peek(n) == '\\' && peek(n + 1) == '\n') {
 			Lexer::advance(n + 2);
 			n = 0;
 			increment_row_position();
 			continue;
 		}
-
 		// '''
 		if (peek(n) != '\'' || peek(n + 1) != '\'' || peek(n + 2) != '\'') {
 			m_position = original_position;
@@ -603,44 +556,35 @@ bool Lexer::single_triple_quote_string(size_t n)
 		n = 0;
 		break;
 	}
-
 	return true;
 }
-
-bool Lexer::double_triple_quote_string(size_t n)
+bool Lexer::double_triple_quote_string(std::size_t n)
 {
 	const auto original_position = m_position;
 	const auto original_cursor = m_cursor;
 	while (true) {
 		// [^"\\]*(?:(?:\\.|"(?!""))[^"\\]*)*"""
-
 		// [^"\\]*
 		while (peek(n) != '\\' && peek(n) != '\"') {
 			if (peek(n) == '\n') { increment_row_position(); }
 			n++;
 		}
-
-		auto advance = [this](size_t n) -> std::optional<size_t> {
+		auto advance = [this](std::size_t n) -> std::optional<std::size_t> {
 			// (?:\\.|"(?!""))
-
 			if (peek(n) == '\\' && peek(n + 1) != '\n') {
 				// \\.
 				return n + 2;
 			} else {
 				// "(?!"")
-
 				// "
 				if (peek(n) != '\"') return {};
 				if (peek(n) == '\n') { increment_row_position(); }
 				n++;
-
 				// (?!"")
 				if (peek(n) == '\"' && peek(n + 1) == '\"') return {};
-
 				return n;
 			}
 		};
-
 		// (?:(?:\\.|"(?!""))[^"\\]*)*
 		while (true) {
 			if (auto inc = advance(n); inc.has_value()) {
@@ -653,14 +597,12 @@ bool Lexer::double_triple_quote_string(size_t n)
 				break;
 			}
 		}
-
 		if (peek(n) == '\\' && peek(n + 1) == '\n') {
 			Lexer::advance(n + 2);
 			n = 0;
 			increment_row_position();
 			continue;
 		}
-
 		// """
 		if (peek(n) != '\"' || peek(n + 1) != '\"' || peek(n + 2) != '\"') {
 			m_position = original_position;
@@ -671,14 +613,11 @@ bool Lexer::double_triple_quote_string(size_t n)
 		n = 0;
 		break;
 	}
-
 	return true;
 }
-
 bool Lexer::try_read_string()
 {
 	if (m_cursor >= m_program.size()) { return false; }
-
 	static constexpr std::array<std::string_view, 25> string_possible_prefixes = { "",
 		"br",
 		"f",
@@ -704,33 +643,25 @@ bool Lexer::try_read_string()
 		"FR",
 		"Rf",
 		"Rb" };
-
 	const Position original_position = m_position;
 	const auto original_cursor = m_cursor;
-
-	size_t idx = 0;
-
+	std::size_t idx = 0;
 	const auto it = std::find_if(string_possible_prefixes.begin(),
 		string_possible_prefixes.end(),
 		[this, idx](std::string_view el) {
-			for (size_t i = idx; i < el.size(); ++i) {
+			for (std::size_t i = idx; i < el.size(); ++i) {
 				if (peek(i) != el[i]) return false;
 			}
 			return peek(idx + el.size()) == '\'' || peek(idx + el.size()) == '\"';
 		});
-
 	if (it == string_possible_prefixes.end()) { return false; }
-
 	idx += it->size();
-
 	auto is_triple_quote = [this, idx](const char quote) {
 		ASSERT(quote == '\'' || quote == '\"');
 		return peek(idx) == quote && peek(idx + 1) == quote && peek(idx + 2) == quote;
 	};
-
 	const bool is_fstring =
 		(it->find('f') != std::string_view::npos || it->find('F') != std::string_view::npos);
-
 	auto push_string_token =
 		[this, original_position, is_fstring, original_cursor, is_triple_quote, idx]() {
 			if (!is_fstring) {
@@ -738,18 +669,15 @@ bool Lexer::try_read_string()
 			} else {
 				m_cursor = original_cursor;
 				m_position = original_position;
-
 				auto quote_size = (is_triple_quote('\'') || is_triple_quote('\"')) ? 3 : 1;
 				m_quote.push(quote_type(std::string_view{ m_program.begin() + m_cursor + idx,
 					m_program.begin() + m_cursor + idx + quote_size }));
-
 				Lexer::advance(idx + quote_size);
 				push_token(Token::TokenType::FSTRING_START, original_position, m_position);
 				m_mode.push(Mode::FSTRING);
 				m_fstring_paren_level.push(m_parenthesis_level);
 			}
 		};
-
 	if (is_triple_quote('\'')) {
 		idx += 3;
 		if (single_triple_quote_string(idx)) {
@@ -785,11 +713,9 @@ bool Lexer::try_read_string()
 	}
 	return false;
 }
-
 bool Lexer::try_fstring()
 {
 	const auto original_position = m_position;
-
 	auto reached_end = [this, original_position]() {
 		auto position = m_position;
 		if ((m_cursor + 1) < m_program.size() && peek(0) == '}') {
@@ -842,17 +768,12 @@ bool Lexer::try_fstring()
 		}
 		return false;
 	};
-
 	while (!reached_end()) { ASSERT(!peek("\n")); }
-
 	return true;
 }
-
-
 std::optional<Token::TokenType> Lexer::try_read_operation_with_one_character()
 {
 	if (std::isalnum(peek(0))) return {};
-
 	if (peek(0) == '(') {
 		m_parenthesis_level++;
 		return Token::TokenType::LPAREN;
@@ -915,7 +836,6 @@ std::optional<Token::TokenType> Lexer::try_read_operation_with_one_character()
 											 // easier
 	return {};
 }
-
 std::optional<Token::TokenType> Lexer::try_read_operation_with_two_characters() const
 {
 	if (m_cursor + 1 >= m_program.size()) return {};
@@ -941,7 +861,6 @@ std::optional<Token::TokenType> Lexer::try_read_operation_with_two_characters()
 	if (peek(0) == '-' && peek(1) == '>') return Token::TokenType::RARROW;
 	return {};
 }
-
 std::optional<Token::TokenType> Lexer::try_read_operation_with_three_characters() const
 {
 	if (m_cursor + 2 >= m_program.size()) return {};
@@ -956,14 +875,11 @@ std::optional<Token::TokenType> Lexer::try_read_operation_with_three_characters(
 	if (peek(0) == '.' && peek(1) == '.' && peek(2) == '.') return Token::TokenType::ELLIPSIS;
 	return {};
 }
-
 bool Lexer::try_read_operation()
 {
 	const Position original_position = m_position;
 	std::optional<Token::TokenType> type;
-
 	if (m_cursor >= m_program.size()) { return false; }
-
 	if (type = try_read_operation_with_three_characters(); type.has_value()) {
 		advance(3);
 	} else if (type = try_read_operation_with_two_characters(); type.has_value()) {
@@ -973,12 +889,9 @@ bool Lexer::try_read_operation()
 	} else {
 		return false;
 	}
-
 	push_token(*type, original_position, m_position);
-
 	return true;
 }
-
 void Lexer::try_read_backslash()
 {
 	try_read_space();
@@ -992,59 +905,49 @@ void Lexer::try_read_backslash()
 		}
 	}
 }
-
 bool Lexer::try_read_space()
 {
-	const size_t whitespace_size = advance_while([](const char c) { return std::isblank(c); });
+	const std::size_t whitespace_size = advance_while([](const char c) { return std::isblank(c); });
 	if (whitespace_size > 0) {
 		return true;
 	} else {
 		return false;
 	}
 }
-
 bool Lexer::try_read_newline()
 {
 	if (!peek("\n")) { return false; }
 	push_new_line();
 	return true;
 }
-
 bool Lexer::try_read_name()
 {
 	if (m_cursor >= m_program.size()) { return false; }
-
 	auto valid_start_name = [](const char c) { return std::isalpha(c) || c == '_'; };
-
 	if (!valid_start_name(peek(0))) { return false; }
 	const Position original_position = m_position;
 	// name must start with alpha
 	if (!advance_if([valid_start_name](const char c) { return valid_start_name(c); })) {
 		return false;
 	}
-
 	auto valid_name = [](const char c) { return std::isalnum(c) || c == '_'; };
-
 	advance_while([valid_name](const char c) { return valid_name(c); });
 	push_token(Token::TokenType::NAME, original_position, m_position);
 	return true;
 }
-
-char Lexer::peek(size_t i) const
+char Lexer::peek(std::size_t i) const
 {
 	ASSERT(m_cursor + i < m_program.size());
 	return m_program[m_cursor + i];
 }
-
 bool Lexer::peek(std::string_view pattern) const
 {
 	int j = 0;
-	for (size_t i = m_cursor; i < m_cursor + pattern.size(); ++i) {
+	for (std::size_t i = m_cursor; i < m_cursor + pattern.size(); ++i) {
 		if (m_program[i] != pattern[j++]) { return false; }
 	}
 	return true;
 }
-
 void Lexer::increment_row_position()
 {
 	m_position.column = 0;
@@ -1052,21 +955,18 @@ void Lexer::increment_row_position()
 	m_position.pointer_to_program = &m_program[m_cursor];
 	m_current_line_tokens.clear();
 }
-
-void Lexer::increment_column_position(size_t idx)
+void Lexer::increment_column_position(std::size_t idx)
 {
 	m_cursor += idx;
 	m_position.column += idx;
 	m_position.pointer_to_program = &m_program[m_cursor];
 }
-
-void Lexer::advance(const size_t positions)
+void Lexer::advance(const std::size_t positions)
 {
 	m_cursor += positions;
 	m_position.column += positions;
 	m_position.pointer_to_program = &m_program[m_cursor];
 }
-
 bool Lexer::advance_if(const char pattern)
 {
 	if (m_program[m_cursor] == pattern) {
@@ -1075,7 +975,6 @@ bool Lexer::advance_if(const char pattern)
 	}
 	return false;
 }
-
 Token Lexer::pop_front()
 {
 	auto &result = m_tokens_to_emit.front();
diff --git a/src/lexer/Lexer.hpp b/src/lexer/Lexer.cppm
similarity index 73%
rename from src/lexer/Lexer.hpp
rename to src/lexer/Lexer.cppm
index 8c22abcc..3646cafa 100644
--- a/src/lexer/Lexer.hpp
+++ b/src/lexer/Lexer.cppm
@@ -1,24 +1,16 @@
-#pragma once
+module;
 
-#include "utilities.hpp"
+#include "core.hpp"
 
-#include <deque>
-#include <functional>
-#include <iostream>
-#include <optional>
-#include <stack>
-#include <string_view>
-#include <vector>
+export module py.lexer;
+import std;
 
-#include "spdlog/fmt/fmt.h"
-#include "spdlog/spdlog.h"
+constexpr std::size_t tab_size = 8;
 
-static constexpr size_t tab_size = 8;
-
-struct Position
+export struct Position
 {
-	size_t row;
-	size_t column;
+	std::size_t row;
+	std::size_t column;
 	const char *pointer_to_program;
 
 	friend std::ostream &operator<<(std::ostream &os, const Position &position)
@@ -30,17 +22,6 @@ struct Position
 };
 
 
-template<> struct fmt::formatter<Position>
-{
-	constexpr auto parse(format_parse_context &ctx) { return ctx.end(); }
-
-	template<typename FormatContext> auto format(const Position &pos, FormatContext &ctx)
-	{
-		return format_to(ctx.out(), "{}:{}", pos.row + 1, pos.column);
-	}
-};
-
-
 #define ENUMERATE_TOKENS      \
 	__TOKEN(EOF_)             \
 	__TOKEN(ENDMARKER)        \
@@ -105,7 +86,7 @@ template<> struct fmt::formatter<Position>
 	__TOKEN(FSTRING_MIDDLE)   \
 	__TOKEN(FSTRING_END)
 
-class Token
+export class Token
 {
   public:
 	enum class TokenType;
@@ -133,18 +114,7 @@ class Token
 
 	Position end() const { return m_end; }
 
-	std::string to_string() const
-	{
-		std::string value{ m_start.pointer_to_program, m_end.pointer_to_program };
-		if (m_token_exact_type == TokenType::NEWLINE) { value = "\\n"; }
-		return fmt::format("{:<12} {:>1}:{:>3} - {:>1}:{:>3} \t\"{}\"",
-			stringify_token_type(m_token_type),
-			m_start.row,
-			m_start.column,
-			m_end.row,
-			m_end.column,
-			value);
-	}
+	std::string to_string() const;
 
 	friend std::ostream &operator<<(std::ostream &os, const Token &t)
 	{
@@ -169,7 +139,7 @@ class Token
 
 std::optional<std::string> read_file(const std::string &filename);
 
-class Lexer
+export class Lexer
 {
   public:
 	enum class Mode {
@@ -187,17 +157,17 @@ class Lexer
   private:
 	std::deque<Token> m_tokens_to_emit;
 	const std::string m_program;
-	size_t m_cursor{ 0 };
+	std::size_t m_cursor{ 0 };
 	Position m_position;
-	std::vector<size_t> m_indent_values;
+	std::vector<std::size_t> m_indent_values;
 	bool m_ignore_nl_token{ false };
 	bool m_ignore_comments{ false };
 	const std::string m_filename;
 	std::vector<Token> m_current_line_tokens;
-	size_t m_parenthesis_level{ 0 };
+	std::size_t m_parenthesis_level{ 0 };
 	std::stack<Mode> m_mode;
 	std::stack<Quote> m_quote;
-	std::stack<size_t> m_fstring_paren_level;
+	std::stack<std::size_t> m_fstring_paren_level;
 
   private:
 	Lexer(const Lexer &) = delete;
@@ -234,13 +204,13 @@ class Lexer
 	// 	if (read_more_tokens()) { return pop_front(); }
 	// 	if (m_tokens_to_emit.empty() && m_cursor > m_program.size()) { return {}; }
 	// 	if (m_tokens_to_emit.empty()) {
-	// 		spdlog::error("Failed to parse program at position {}", m_position);
-	// 		std::abort();
+	// 		::detail::log_error(std::format("Failed to parse program at position {}",
+	// m_position).c_str()); 		std::abort();
 	// 	}
 	// 	ASSERT_NOT_REACHED();
 	// }
 
-	std::optional<Token> peek_token(size_t positions)
+	std::optional<Token> peek_token(std::size_t positions)
 	{
 		while (positions >= m_tokens_to_emit.size()) {
 			if (m_cursor > m_program.size()) { return {}; }
@@ -252,7 +222,8 @@ class Lexer
 
 	std::string_view get(Position start, Position end)
 	{
-		const auto size = static_cast<size_t>(end.pointer_to_program - start.pointer_to_program);
+		const auto size =
+			static_cast<std::size_t>(end.pointer_to_program - start.pointer_to_program);
 		return std::string_view{ start.pointer_to_program, size };
 	}
 
@@ -270,7 +241,7 @@ class Lexer
 
 	void push_empty_line();
 
-	std::optional<size_t> comment_start() const;
+	std::optional<std::size_t> comment_start() const;
 
 	void try_read_backslash();
 
@@ -280,7 +251,7 @@ class Lexer
 
 	bool try_read_indent();
 
-	std::tuple<size_t, size_t> compute_indent_level();
+	std::tuple<std::size_t, std::size_t> compute_indent_level();
 
 	bool try_read_number();
 
@@ -302,39 +273,39 @@ class Lexer
 
 	bool try_fstring();
 
-	std::optional<size_t> hex_number(size_t) const;
-	std::optional<size_t> bin_number(size_t) const;
-	std::optional<size_t> oct_number(size_t) const;
-	std::optional<size_t> dec_number(size_t) const;
-	std::optional<size_t> int_number(size_t) const;
-	std::optional<size_t> exp_number(size_t) const;
-	std::optional<size_t> point_float_number(size_t) const;
-	std::optional<size_t> exp_float_number(size_t) const;
-	std::optional<size_t> float_number(size_t) const;
-	std::optional<size_t> imag_number(size_t) const;
-
-	bool single_quote_string(size_t);
-	bool double_quote_string(size_t);
-	bool single_triple_quote_string(size_t);
-	bool double_triple_quote_string(size_t);
+	std::optional<std::size_t> hex_number(std::size_t) const;
+	std::optional<std::size_t> bin_number(std::size_t) const;
+	std::optional<std::size_t> oct_number(std::size_t) const;
+	std::optional<std::size_t> dec_number(std::size_t) const;
+	std::optional<std::size_t> int_number(std::size_t) const;
+	std::optional<std::size_t> exp_number(std::size_t) const;
+	std::optional<std::size_t> point_float_number(std::size_t) const;
+	std::optional<std::size_t> exp_float_number(std::size_t) const;
+	std::optional<std::size_t> float_number(std::size_t) const;
+	std::optional<std::size_t> imag_number(std::size_t) const;
+
+	bool single_quote_string(std::size_t);
+	bool double_quote_string(std::size_t);
+	bool single_triple_quote_string(std::size_t);
+	bool double_triple_quote_string(std::size_t);
 
 	template<typename FunctorType>
-	std::optional<size_t> parse_digits(size_t n, FunctorType &&f) const;
+	std::optional<std::size_t> parse_digits(std::size_t n, FunctorType &&f) const;
 
-	char peek(size_t i) const;
+	char peek(std::size_t i) const;
 
 	bool peek(std::string_view pattern) const;
 
-	template<typename ConditionType> size_t advance_while(ConditionType &&condition)
+	template<typename ConditionType> std::size_t advance_while(ConditionType &&condition)
 	{
-		const size_t start = m_cursor;
+		const std::size_t start = m_cursor;
 		while (condition(m_program[m_cursor])) { increment_column_position(1); }
 		return m_cursor - start;
 	}
 
 	void advance(std::string_view pattern) { advance(pattern.size()); }
 
-	void advance(const size_t positions);
+	void advance(const std::size_t positions);
 
 	bool advance_if(const char pattern);
 
@@ -349,7 +320,7 @@ class Lexer
 
 	void increment_row_position();
 
-	void increment_column_position(size_t idx);
+	void increment_column_position(std::size_t idx);
 
 	Mode current_mode() const { return m_mode.top(); }
 
diff --git a/src/lexer/Lexer_tests.cpp b/src/lexer/Lexer_tests.cpp
index 275bbe58..14058cec 100644
--- a/src/lexer/Lexer_tests.cpp
+++ b/src/lexer/Lexer_tests.cpp
@@ -1,6 +1,8 @@
-#include "Lexer.hpp"
 #include "gtest/gtest.h"
 
+import py.lexer;
+import py.ast;
+
 namespace {
 std::vector<Token>
 	generate_tokens(std::string_view program, bool ignore_nl_token, bool ignore_comments)
@@ -21,7 +23,7 @@ void assert_generates_tokens_without_nl_token(std::string_view program,
 	ASSERT_EQ(expected_tokens.size(), tokens.size());
 	for (size_t i = 0; i < expected_tokens.size(); ++i) {
 		ASSERT_EQ(expected_tokens[i], tokens[i].token_type())
-			<< fmt::format("Expected {}, but got {} at position {}",
+			<< std::format("Expected {}, but got {} at position {}",
 				   Token::stringify_token_type(expected_tokens[i]),
 				   Token::stringify_token_type(tokens[i].token_type()),
 				   i);
@@ -35,7 +37,7 @@ void assert_generates_tokens_without_comment_tokens(std::string_view program,
 	ASSERT_EQ(expected_tokens.size(), tokens.size());
 	for (size_t i = 0; i < expected_tokens.size(); ++i) {
 		ASSERT_EQ(expected_tokens[i], tokens[i].token_type())
-			<< fmt::format("Expected {}, but got {} at position {}",
+			<< std::format("Expected {}, but got {} at position {}",
 				   Token::stringify_token_type(expected_tokens[i]),
 				   Token::stringify_token_type(tokens[i].token_type()),
 				   i);
@@ -49,7 +51,7 @@ void assert_generates_tokens(std::string_view program,
 	ASSERT_EQ(expected_tokens.size(), tokens.size());
 	for (size_t i = 0; i < expected_tokens.size(); ++i) {
 		ASSERT_EQ(expected_tokens[i], tokens[i].token_type())
-			<< fmt::format("Expected {}, but got {} at position {}",
+			<< std::format("Expected {}, but got {} at position {}",
 				   Token::stringify_token_type(expected_tokens[i]),
 				   Token::stringify_token_type(tokens[i].token_type()),
 				   i);
@@ -607,6 +609,24 @@ TEST(Lexer, IgnoreCommentsAndNL)
 	assert_generates_tokens_without_comment_tokens(program, expected_tokens);
 }
 
+TEST(Lexer, IgnoreCommentsAndNLLateInTheProgram)
+{
+	constexpr std::size_t line_count = 200;
+	std::string program;
+	std::vector<Token::TokenType> expected_tokens;
+	for (std::size_t i = 0; i < line_count; ++i) {
+		program += std::format("# leading comment {}\n", i);
+		program += "\n";
+		program += std::format("a{} = {} # trailing comment\n", i, i);
+		expected_tokens.push_back(Token::TokenType::NAME);
+		expected_tokens.push_back(Token::TokenType::EQUAL);
+		expected_tokens.push_back(Token::TokenType::NUMBER);
+		expected_tokens.push_back(Token::TokenType::NEWLINE);
+	}
+	expected_tokens.push_back(Token::TokenType::ENDMARKER);
+	assert_generates_tokens_without_comment_tokens(program, expected_tokens);
+}
+
 TEST(Lexer, Ellipsis)
 {
 	constexpr std::string_view program = "...\n";
diff --git a/src/lexer/PositionFormatter.hpp b/src/lexer/PositionFormatter.hpp
new file mode 100644
index 00000000..87981558
--- /dev/null
+++ b/src/lexer/PositionFormatter.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+// fmt formatting for lexer::Position.
+//
+// Kept out of the py.lexer module on purpose: spdlog/fmt/fmt.h pulls in 231
+// libstdc++ headers, and anything in a module's global module fragment ends up
+// in its BMI, where it collides with the same headers #included by consumers.
+// Only the few places that log a Position need this, so they include it here.
+
+#include <format>
+
+template<> struct std::formatter<Position>
+{
+	constexpr auto parse(std::format_parse_context &ctx) { return ctx.end(); }
+
+	template<typename FormatContext> auto format(const Position &pos, FormatContext &ctx) const
+	{
+		return std::format_to(ctx.out(), "{}:{}", pos.row + 1, pos.column);
+	}
+};
diff --git a/src/memory/GarbageCollector.cpp b/src/memory/GarbageCollector.cpp
index fd0d334e..f67886ac 100644
--- a/src/memory/GarbageCollector.cpp
+++ b/src/memory/GarbageCollector.cpp
@@ -1,17 +1,11 @@
-#include "GarbageCollector.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "interpreter/InterpreterSession.hpp"
-#include "memory/Heap.hpp"
-#include "runtime/PyCode.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyModule.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyType.hpp"
-#include "vm/VM.hpp"
-
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
 #include <csetjmp>
-#include <unordered_set>
+
+module py.memory;
+import py.runtime;
+
 
 using namespace py;
 
@@ -36,7 +30,8 @@ typename std::enable_if_t<sizeof(To) == sizeof(From) && std::is_trivially_copyab
 
 void add_root(GarbageCollected *obj_header, std::stack<Cell *> &roots)
 {
-	auto *cell = bit_cast<Cell *>(bit_cast<uint8_t *>(obj_header) + sizeof(GarbageCollected));
+	auto *cell =
+		std::bit_cast<Cell *>(std::bit_cast<std::uint8_t *>(obj_header) + sizeof(GarbageCollected));
 
 	ASSERT(!obj_header->black());
 
@@ -46,7 +41,8 @@ void add_root(GarbageCollected *obj_header, std::stack<Cell *> &roots)
 
 	if (cell->is_pyobject()) {
 		auto *obj = static_cast<PyObject *>(cell);
-		spdlog::debug("adding root {}@{}", obj->type()->name(), (void *)obj);
+		::detail::log_debug(
+			std::format("adding root {}@{}", obj->type()->name(), (void *)obj).c_str());
 	}
 
 	obj_header->mark(GarbageCollected::Color::GREY);
@@ -55,7 +51,7 @@ void add_root(GarbageCollected *obj_header, std::stack<Cell *> &roots)
 
 
 __attribute__((no_sanitize_address)) std::stack<Cell *> collect_roots_on_the_stack(const Heap &heap,
-	uint8_t *stack_bottom)
+	std::uint8_t *stack_bottom)
 {
 	std::stack<Cell *> roots;
 
@@ -64,15 +60,17 @@ __attribute__((no_sanitize_address)) std::stack<Cell *> collect_roots_on_the_sta
 	std::jmp_buf jump_buffer;
 	setjmp(jump_buffer);
 
-	auto scan_range = [&](uint8_t *begin, uint8_t *end) {
-		for (uint8_t *p = begin; p < end; p += sizeof(uintptr_t)) {
-			uint8_t *address =
-				bit_cast_without_sanitizer<uint8_t *>(*bit_cast_without_sanitizer<uintptr_t *>(p))
-				- sizeof(GarbageCollected);
-			spdlog::trace("checking address {}, pointer address={}", (void *)address, (void *)p);
+	auto scan_range = [&](std::uint8_t *begin, std::uint8_t *end) {
+		for (std::uint8_t *p = begin; p < end; p += sizeof(std::uintptr_t)) {
+			std::uint8_t *address = bit_cast_without_sanitizer<std::uint8_t *>(
+										*bit_cast_without_sanitizer<std::uintptr_t *>(p))
+									- sizeof(GarbageCollected);
+			::detail::log_trace(
+				std::format("checking address {}, pointer address={}", (void *)address, (void *)p)
+					.c_str());
 			if (heap.slab().has_address(address)) {
-				spdlog::trace("valid address {}", (void *)address);
-				auto *obj_header = bit_cast<GarbageCollected *>(address);
+				::detail::log_trace(std::format("valid address {}", (void *)address).c_str());
+				auto *obj_header = std::bit_cast<GarbageCollected *>(address);
 				add_root(obj_header, roots);
 			}
 		}
@@ -83,47 +81,49 @@ __attribute__((no_sanitize_address)) std::stack<Cell *> collect_roots_on_the_sta
 	// scan below therefore skips it, which would lose any GC root whose only
 	// live reference is in a callee-saved register at this point. Scan the
 	// buffer's bytes explicitly to recover those spilled values.
-	auto *jb_begin = bit_cast_without_sanitizer<uint8_t *>(&jump_buffer);
+	auto *jb_begin = bit_cast_without_sanitizer<std::uint8_t *>(&jump_buffer);
 	scan_range(jb_begin, jb_begin + sizeof(jump_buffer));
 
 	// Traverse the stack from the current frame pointer up to the recorded
 	// stack bottom; this covers everything in our callers' frames.
-	uint8_t *rsp = bit_cast_without_sanitizer<uint8_t *>(__builtin_frame_address(0));
+	std::uint8_t *rsp = bit_cast_without_sanitizer<std::uint8_t *>(__builtin_frame_address(0));
 	scan_range(rsp, stack_bottom);
 
-	spdlog::debug("Done collecting roots from the stack, found {} roots", roots.size());
+	::detail::log_debug(
+		std::format("Done collecting roots from the stack, found {} roots", roots.size()).c_str());
 	return roots;
 }
 
-bool is_static_memory(uint8_t *cell_start, const Heap &heap)
+bool is_static_memory(std::uint8_t *cell_start, const Heap &heap)
 {
-	return bit_cast<uintptr_t>(cell_start) >= bit_cast<uintptr_t>(heap.static_memory())
-		   && bit_cast<uintptr_t>(cell_start)
-				  < bit_cast<uintptr_t>(heap.static_memory() + heap.static_memory_size());
+	return std::bit_cast<std::uintptr_t>(cell_start)
+			   >= std::bit_cast<std::uintptr_t>(heap.static_memory())
+		   && std::bit_cast<std::uintptr_t>(cell_start)
+				  < std::bit_cast<std::uintptr_t>(heap.static_memory() + heap.static_memory_size());
 }
 
 }// namespace
 
-void GarbageCollector::remove_weakref(Heap &heap, uint8_t *obj) const
+void GarbageCollector::remove_weakref(Heap &heap, std::uint8_t *obj) const
 {
 	heap.m_weakrefs.erase(obj);
 }
 
 std::stack<Cell *> MarkSweepGC::collect_roots(const Heap &heap) const
 {
-	if (!m_stack_bottom) { m_stack_bottom = bit_cast<uint8_t *>(heap.start_sp()); }
+	if (!m_stack_bottom) { m_stack_bottom = std::bit_cast<std::uint8_t *>(heap.start_sp()); }
 
 	auto roots = collect_roots_on_the_stack(heap, m_stack_bottom);
 
-	spdlog::trace("adding objects in VM stack to roots");
+	::detail::log_trace(std::format("adding objects in VM stack to roots").c_str());
 	for (const auto &s : VirtualMachine::the().stack_objects()) {
 		for (const auto &val : s) {
 			if (std::holds_alternative<PyObject *>(*val)) {
 				auto *obj = std::get<PyObject *>(*val);
 				if (obj) {
-					if (!is_static_memory(bit_cast<uint8_t *>(obj), heap)) {
-						auto *obj_header = bit_cast<GarbageCollected *>(
-							bit_cast<uint8_t *>(obj) - sizeof(GarbageCollected));
+					if (!is_static_memory(std::bit_cast<std::uint8_t *>(obj), heap)) {
+						auto *obj_header = std::bit_cast<GarbageCollected *>(
+							std::bit_cast<std::uint8_t *>(obj) - sizeof(GarbageCollected));
 						add_root(obj_header, roots);
 					}
 				}
@@ -142,9 +142,9 @@ std::stack<Cell *> MarkSweepGC::collect_roots(const Heap &heap) const
 			{
 				auto *obj = static_cast<PyObject *>(&cell);
 				if (obj) {
-					if (!is_static_memory(bit_cast<uint8_t *>(obj), heap_)) {
-						auto *obj_header = bit_cast<GarbageCollected *>(
-							bit_cast<uint8_t *>(obj) - sizeof(GarbageCollected));
+					if (!is_static_memory(std::bit_cast<std::uint8_t *>(obj), heap_)) {
+						auto *obj_header = std::bit_cast<GarbageCollected *>(
+							std::bit_cast<std::uint8_t *>(obj) - sizeof(GarbageCollected));
 						add_root(obj_header, roots_);
 					}
 				}
@@ -188,36 +188,41 @@ struct MarkGCVisitor : Cell::Visitor
 
 	void visit(Cell &cell)
 	{
-		uint8_t *cell_start = bit_cast<uint8_t *>(&cell);
+		std::uint8_t *cell_start = std::bit_cast<std::uint8_t *>(&cell);
 
 		if (!is_static_memory(cell_start, m_heap)) {
 			NeighbourVisitor nv{};
 			nv.collect_neighbours_of(cell);
 			auto &neighbours = nv.m_neighbours;
-			spdlog::trace("node: {}", static_cast<void *>(&cell));
+			::detail::log_trace(std::format("node: {}", static_cast<void *>(&cell)).c_str());
 			for (auto *neighbour : neighbours) {
-				if (is_static_memory(bit_cast<uint8_t *>(neighbour), m_heap)) { continue; }
-				auto *obj_header = bit_cast<GarbageCollected *>(
-					bit_cast<uint8_t *>(neighbour) - sizeof(GarbageCollected));
+				if (is_static_memory(std::bit_cast<std::uint8_t *>(neighbour), m_heap)) {
+					continue;
+				}
+				auto *obj_header = std::bit_cast<GarbageCollected *>(
+					std::bit_cast<std::uint8_t *>(neighbour) - sizeof(GarbageCollected));
 
 				// already visited
 				if (obj_header->black()) {
-					spdlog::trace("already visited @{}", static_cast<void *>(neighbour));
+					::detail::log_trace(
+						std::format("already visited @{}", static_cast<void *>(neighbour)).c_str());
 					continue;
 				}
 
 				// already on the 'to be visited' stack
 				if (obj_header->grey()) {
-					spdlog::trace(
-						"already added @{} to the visited stack", static_cast<void *>(neighbour));
+					::detail::log_trace(std::format(
+						"already added @{} to the visited stack", static_cast<void *>(neighbour))
+							.c_str());
 					continue;
 				}
 
 				if (neighbour->is_pyobject()) {
 					auto *obj = static_cast<PyObject *>(neighbour);
-					spdlog::trace("Adding PyObject to be visited stack {}@{}",
+					::detail::log_trace(std::format("Adding PyObject to be visited stack {}@{}",
 						obj->type_prototype().__name__,
-						(void *)obj);
+						(void *)obj)
+							.c_str());
 				}
 
 				obj_header->mark(GarbageCollected::Color::GREY);
@@ -251,7 +256,7 @@ void MarkSweepGC::mark_all_cell_unreachable(Heap &heap) const
 	};
 	for (const auto &block : blocks) {
 		for (auto &chunk : block.get()->chunks()) {
-			chunk.for_each_cell([](uint8_t *memory) {
+			chunk.for_each_cell([](std::uint8_t *memory) {
 				auto *header = static_cast<GarbageCollected *>(static_cast<void *>(memory));
 				header->mark(GarbageCollected::Color::WHITE);
 			});
@@ -269,36 +274,39 @@ void MarkSweepGC::mark_all_live_objects(Heap &heap, std::stack<Cell *> &&roots)
 		Cell *root = roots.top();
 		roots.pop();
 
-		if (is_static_memory(bit_cast<uint8_t *>(root), heap)) { continue; }
+		if (is_static_memory(std::bit_cast<std::uint8_t *>(root), heap)) { continue; }
 
-		spdlog::trace("Visiting root {}", (void *)root);
+		::detail::log_trace(std::format("Visiting root {}", (void *)root).c_str());
 
-		auto *obj_header =
-			bit_cast<GarbageCollected *>(bit_cast<uint8_t *>(root) - sizeof(GarbageCollected));
+		auto *obj_header = std::bit_cast<GarbageCollected *>(
+			std::bit_cast<std::uint8_t *>(root) - sizeof(GarbageCollected));
 		ASSERT(obj_header->grey());
 		obj_header->mark(GarbageCollected::Color::BLACK);
 		mark_visitor->visit(*root);
 	}
-	spdlog::debug("Done marking all live objects");
+	::detail::log_debug(std::format("Done marking all live objects").c_str());
 }
 
 
 void MarkSweepGC::sweep(Heap &heap) const
 {
-	spdlog::trace("MarkSweepGC::sweep start");
+	::detail::log_trace(std::format("MarkSweepGC::sweep start").c_str());
 
 	heap.slab().for_each_block([this, &heap](Block &block) {
 		for (auto &chunk : block.chunks()) {
-			chunk.for_each_cell_alive([this, &chunk, &heap](uint8_t *memory) {
-				auto *header = bit_cast<GarbageCollected *>(memory);
+			chunk.for_each_cell_alive([this, &chunk, &heap](std::uint8_t *memory) {
+				auto *header = std::bit_cast<GarbageCollected *>(memory);
 				if (header->white()) {
-					auto *cell = bit_cast<Cell *>(memory + sizeof(GarbageCollected));
+					auto *cell = std::bit_cast<Cell *>(memory + sizeof(GarbageCollected));
 					if (cell->is_pyobject()) {
 						auto *obj = static_cast<PyObject *>(cell);
-						spdlog::debug("Deallocating {}@{}", obj->type()->name(), (void *)obj);
+						::detail::log_debug(
+							std::format("Deallocating {}@{}", obj->type()->name(), (void *)obj)
+								.c_str());
 					}
-					spdlog::debug("Calling destructor of object at {}", (void *)cell);
-					this->remove_weakref(heap, bit_cast<uint8_t *>(cell));
+					::detail::log_debug(
+						std::format("Calling destructor of object at {}", (void *)cell).c_str());
+					this->remove_weakref(heap, std::bit_cast<std::uint8_t *>(cell));
 					cell->~Cell();
 					chunk.deallocate(memory);
 					new (header) GarbageCollected();
@@ -306,7 +314,7 @@ void MarkSweepGC::sweep(Heap &heap) const
 			});
 		}
 	});
-	spdlog::trace("MarkSweepGC::sweep done");
+	::detail::log_trace(std::format("MarkSweepGC::sweep done").c_str());
 }
 
 
diff --git a/src/memory/GarbageCollector.hpp b/src/memory/GarbageCollector.cppm
similarity index 80%
rename from src/memory/GarbageCollector.hpp
rename to src/memory/GarbageCollector.cppm
index 113936da..c89644a5 100644
--- a/src/memory/GarbageCollector.hpp
+++ b/src/memory/GarbageCollector.cppm
@@ -1,11 +1,14 @@
-#pragma once
+module;
+#include "core.hpp"
 
-#include "utilities.hpp"
 
-#include <bitset>
-#include <stack>
+export module py.memory:gc;
 
-class GarbageCollected
+import std;
+
+export class Heap;
+
+export class GarbageCollected
 {
   public:
 	enum class Color {
@@ -36,7 +39,7 @@ class GarbageCollected
 	std::bitset<2> m_state{ 0b00 };
 };
 
-class Cell
+export class Cell
 	: NonCopyable
 	, NonMoveable
 {
@@ -58,9 +61,7 @@ class Cell
 };
 
 
-class Heap;
-
-class GarbageCollector
+export class GarbageCollector
 {
   public:
 	virtual ~GarbageCollector() = default;
@@ -77,15 +78,15 @@ class GarbageCollector
 	virtual void pause() = 0;
 	virtual bool is_active() const = 0;
 
-	void remove_weakref(Heap &heap, uint8_t *obj) const;
+	void remove_weakref(Heap &heap, std::uint8_t *obj) const;
 
-	void set_frequency(size_t new_frequency) { m_frequency = new_frequency; }
+	void set_frequency(std::size_t new_frequency) { m_frequency = new_frequency; }
 
   protected:
-	size_t m_frequency;
+	std::size_t m_frequency;
 };
 
-class MarkSweepGC : public GarbageCollector
+export class MarkSweepGC : public GarbageCollector
 {
   public:
 	MarkSweepGC();
@@ -105,7 +106,7 @@ class MarkSweepGC : public GarbageCollector
 
 	// Lazily initialised once on first collect_roots; afterwards immutable.
 	// `mutable` is the textbook one-time-cache use case.
-	mutable uint8_t *m_stack_bottom{ nullptr };
-	size_t m_iterations_since_last_sweep{ 0 };
+	mutable std::uint8_t *m_stack_bottom{ nullptr };
+	std::size_t m_iterations_since_last_sweep{ 0 };
 	bool m_pause{ false };
 };
diff --git a/src/memory/GarbageCollector_tests.cpp b/src/memory/GarbageCollector_tests.cpp
index 53c91fe3..8a85f908 100644
--- a/src/memory/GarbageCollector_tests.cpp
+++ b/src/memory/GarbageCollector_tests.cpp
@@ -1,9 +1,16 @@
-#include "GarbageCollector.hpp"
-#include "Heap_test.hpp"
+#include "core.hpp"
+
+#include <gtest/gtest.h>
 
 #include <cstdint>
 #include <cstring>
 
+import py.memory;
+import py.runtime;
+import std;
+
+#include "Heap_test.hpp"
+
 namespace {
 
 static int64_t g_counter = 0;
diff --git a/src/memory/Heap.cpp b/src/memory/Heap.cpp
index 0b1434d1..286fbc76 100644
--- a/src/memory/Heap.cpp
+++ b/src/memory/Heap.cpp
@@ -1,17 +1,24 @@
-#include "Heap.hpp"
-#include "GarbageCollector.hpp"
-#include "runtime/PyType.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstring>
+
+module py.memory;
+import py.runtime;
+import std;
 
 using namespace py;
 
 Block::Chunk::~Chunk()
 {
-	for_each_cell_alive([](uint8_t *memory) {
-		auto *cell = bit_cast<Cell *>(memory + sizeof(GarbageCollected));
-		spdlog::debug("Calling destructor of object at {}", (void *)cell);
+	for_each_cell_alive([](std::uint8_t *memory) {
+		auto *cell = std::bit_cast<Cell *>(memory + sizeof(GarbageCollected));
+		::detail::log_debug(
+			std::format("Calling destructor of object at {}", (void *)cell).c_str());
 		if (cell->is_pyobject()) {
 			auto *obj = static_cast<PyObject *>(cell);
-			spdlog::debug("Deallocating {}@{}", obj->type()->name(), (void *)obj);
+			::detail::log_debug(
+				std::format("Deallocating {}@{}", obj->type()->name(), (void *)obj).c_str());
 		}
 		cell->~Cell();
 	});
@@ -20,23 +27,26 @@ Block::Chunk::~Chunk()
 void Block::Chunk::reset()
 {
 	// before resetting make sure we are calling all the destructors
-	for_each_cell_alive([](uint8_t *memory) {
-		auto *cell = bit_cast<Cell *>(memory + sizeof(GarbageCollected));
-		spdlog::trace("Calling destructor of object at {}", (void *)cell);
+	for_each_cell_alive([](std::uint8_t *memory) {
+		auto *cell = std::bit_cast<Cell *>(memory + sizeof(GarbageCollected));
+		::detail::log_trace(
+			std::format("Calling destructor of object at {}", (void *)cell).c_str());
 		if (cell->is_pyobject()) {
 			auto *obj = static_cast<PyObject *>(cell);
-			spdlog::trace("Deallocating {}@{}", obj->type()->name(), (void *)obj);
+			::detail::log_trace(
+				std::format("Deallocating {}@{}", obj->type()->name(), (void *)obj).c_str());
 		}
 		cell->~Cell();
 	});
 	m_chunk_view.reset();
 }
 
-bool Block::Chunk::has_address(uint8_t *memory) const
+bool Block::Chunk::has_address(std::uint8_t *memory) const
 {
-	auto address = bit_cast<uintptr_t>(memory);
-	uintptr_t start = bit_cast<uintptr_t>(m_memory);
-	uintptr_t end = bit_cast<uintptr_t>(m_memory + m_object_size * ChunkView<>::ChunkCount);
+	auto address = std::bit_cast<std::uintptr_t>(memory);
+	std::uintptr_t start = std::bit_cast<std::uintptr_t>(m_memory);
+	std::uintptr_t end =
+		std::bit_cast<std::uintptr_t>(m_memory + m_object_size * ChunkView<>::ChunkCount);
 
 	if (address < start || address >= end) { return false; }
 
@@ -47,27 +57,29 @@ bool Block::Chunk::has_address(uint8_t *memory) const
 	}
 }
 
-Block::Block(size_t object_size, size_t capacity)
+Block::Block(std::size_t object_size, std::size_t capacity)
 {
-	size_t chunks_needed = capacity / 64;
-	spdlog::debug(
+	std::size_t chunks_needed = capacity / 64;
+	::detail::log_debug(std::format(
 		"Initialising a block with {} chunks, each managing memory for 64 objects of size {}",
 		chunks_needed,
-		object_size);
+		object_size)
+			.c_str());
 
 	auto &mem =
-		m_memory.emplace_back(std::make_unique<uint8_t[]>(chunks_needed * 64 * object_size));
-	spdlog::debug(
-		"Allocated {} bytes at address {}", chunks_needed * 64 * object_size, (void *)mem.get());
+		m_memory.emplace_back(std::make_unique<std::uint8_t[]>(chunks_needed * 64 * object_size));
+	::detail::log_debug(std::format(
+		"Allocated {} bytes at address {}", chunks_needed * 64 * object_size, (void *)mem.get())
+			.c_str());
 
-	size_t idx{ 0 };
+	std::size_t idx{ 0 };
 	while (chunks_needed--) {
 		m_chunks.emplace_back(mem.get() + idx * (object_size * 64), object_size);
 		idx++;
 	}
 
 	// TODO: this should only be needed for debug builds
-	memset(mem.get(), 0xCD, m_chunks.size() * object_size * 64);
+	std::memset(mem.get(), 0xCD, m_chunks.size() * object_size * 64);
 }
 
 
@@ -76,28 +88,30 @@ void Block::reset()
 	for (auto &chunk : m_chunks) { chunk.reset(); }
 }
 
-uint8_t *Block::allocate()
+std::uint8_t *Block::allocate()
 {
-	for (size_t idx = 0; auto &chunk : m_chunks) {
+	for (std::size_t idx = 0; auto &chunk : m_chunks) {
 		if (auto *ptr = chunk.allocate()) {
-			spdlog::trace("Allocated pointer in chunk {} (block size={})", idx, object_size());
+			::detail::log_trace(
+				std::format("Allocated pointer in chunk {} (block size={})", idx, object_size())
+					.c_str());
 			return ptr;
 		}
 		++idx;
 	}
 
-	spdlog::debug("Need to allocate more chunks");
+	::detail::log_debug(std::format("Need to allocate more chunks").c_str());
 
 	// add more chunks -> new chunk count is old count multiplied by golden ration (1.618)
-	size_t old_chunk_count = m_chunks.size();
-	size_t new_chunk_count =
-		static_cast<size_t>(std::round(static_cast<float>(m_chunks.size()) * 1.618f));
-	size_t new_chunks_to_allocate = new_chunk_count - old_chunk_count;
-	size_t idx{ 0 };
-	const size_t object_size = m_chunks.back().object_size();
-	const size_t new_memory_size = new_chunk_count * 64 * object_size;
+	std::size_t old_chunk_count = m_chunks.size();
+	std::size_t new_chunk_count =
+		static_cast<std::size_t>(std::round(static_cast<float>(m_chunks.size()) * 1.618f));
+	std::size_t new_chunks_to_allocate = new_chunk_count - old_chunk_count;
+	std::size_t idx{ 0 };
+	const std::size_t object_size = m_chunks.back().object_size();
+	const std::size_t new_memory_size = new_chunk_count * 64 * object_size;
 
-	auto &new_memory = m_memory.emplace_back(new uint8_t[new_memory_size]);
+	auto &new_memory = m_memory.emplace_back(new std::uint8_t[new_memory_size]);
 
 	while (new_chunks_to_allocate--) {
 		m_chunks.emplace_back(new_memory.get() + idx * (object_size * 64), object_size);
@@ -107,35 +121,41 @@ uint8_t *Block::allocate()
 	if (auto *ptr = m_chunks[old_chunk_count].allocate()) {
 		return ptr;
 	} else {
-		spdlog::warn("Failed to allocate in new chunk {}/{}", old_chunk_count, m_chunks.size());
+		::detail::log_error(
+			std::format("Failed to allocate in new chunk {}/{}", old_chunk_count, m_chunks.size())
+				.c_str());
 		// TODO: handle this more gracefully
 		std::abort();
 	}
 }
 
-void Block::deallocate(uint8_t *ptr)
+void Block::deallocate(std::uint8_t *ptr)
 {
 	for (auto &mem : m_memory) {
-		const size_t object_size = m_chunks.back().object_size();
-		const size_t current_size = m_chunks.size() * 64 * object_size;
-		uintptr_t start = bit_cast<uintptr_t>(mem.get());
-		uintptr_t end = bit_cast<uintptr_t>(mem.get() + current_size);
+		const std::size_t object_size = m_chunks.back().object_size();
+		const std::size_t current_size = m_chunks.size() * 64 * object_size;
+		std::uintptr_t start = std::bit_cast<std::uintptr_t>(mem.get());
+		std::uintptr_t end = std::bit_cast<std::uintptr_t>(mem.get() + current_size);
 		// if ptr not in this piece of memory move to next one
-		if (bit_cast<uintptr_t>(ptr) < start || bit_cast<uintptr_t>(ptr) >= end) { continue; }
+		if (std::bit_cast<std::uintptr_t>(ptr) < start
+			|| std::bit_cast<std::uintptr_t>(ptr) >= end) {
+			continue;
+		}
 
-		const size_t chunk_idx = (bit_cast<uintptr_t>(ptr) - start) / (64 * object_size);
+		const std::size_t chunk_idx =
+			(std::bit_cast<std::uintptr_t>(ptr) - start) / (64 * object_size);
 		ASSERT(chunk_idx < m_chunks.size());
 
 		m_chunks[chunk_idx].deallocate(ptr);
 
 		return;
 	}
-	spdlog::error("Failed to find memory piece of ptr {}", (void *)ptr);
+	::detail::log_error(std::format("Failed to find memory piece of ptr {}", (void *)ptr).c_str());
 	std::abort();
 }
 
 
-bool Slab::has_address(uint8_t *address) const
+bool Slab::has_address(std::uint8_t *address) const
 {
 	bool found = false;
 	for_each_block([&](const Block &block) {
@@ -152,7 +172,7 @@ bool Slab::has_address(uint8_t *address) const
 
 Heap::Heap()
 {
-	m_static_memory = std::make_unique<uint8_t[]>(m_static_memory_size);
+	m_static_memory = std::make_unique<std::uint8_t[]>(m_static_memory_size);
 	m_gc = std::make_unique<MarkSweepGC>();
 }
 
@@ -161,8 +181,7 @@ void Heap::collect_garbage()
 	if (m_gc) m_gc->run(*this);
 }
 
-
-uint8_t *Heap::allocate_gc(uint8_t *ptr) const
+std::uint8_t *Heap::allocate_gc(std::uint8_t *ptr) const
 {
 	new (ptr) GarbageCollected();
 	return ptr + sizeof(GarbageCollected);
diff --git a/src/memory/Heap.hpp b/src/memory/Heap.cppm
similarity index 52%
rename from src/memory/Heap.hpp
rename to src/memory/Heap.cppm
index abdf17d6..cbbe9673 100644
--- a/src/memory/Heap.hpp
+++ b/src/memory/Heap.cppm
@@ -1,36 +1,31 @@
-#pragma once
+module;
 
-#include "GarbageCollector.hpp"
-#include "runtime/forward.hpp"
-#include "utilities.hpp"
+#include "core.hpp"
 
-#include <algorithm>
-#include <array>
-#include <bitset>
 #include <cstdint>
-#include <memory>
-#include <optional>
-#include <unordered_map>
 
-static constexpr size_t KB = 1024;
-static constexpr size_t MB = 1024 * KB;
+export module py.memory:heap;
+import :gc;
+import std;
 
+static constexpr std::size_t KB = 1024;
+static constexpr std::size_t MB = 1024 * KB;
 
 class Block
 {
 	class Chunk : NonCopyable
 	{
-		template<size_t ChunkCount_ = 64> class ChunkView
+		template<std::size_t ChunkCount_ = 64> class ChunkView
 		{
 		  public:
-			static constexpr size_t ChunkCount = ChunkCount_;
+			static constexpr std::size_t ChunkCount = ChunkCount_;
 
 			bool has_free_chunk() const { return !m_occupied_chunks.all(); }
 
-			std::optional<size_t> next_free_chunk() const
+			std::optional<std::size_t> next_free_chunk() const
 			{
 				if (has_free_chunk()) {
-					size_t i{ 0 };
+					std::size_t i{ 0 };
 					while (m_occupied_chunks[i]) { i++; }
 					return i;
 				} else {
@@ -38,25 +33,30 @@ class Block
 				}
 			}
 
-			std::optional<size_t> mark_next_free_chunk()
+			std::optional<std::size_t> mark_next_free_chunk()
 			{
-				spdlog::trace(
-					"mark_next_free_chunk -> chunk bit mask: {}", m_occupied_chunks.to_string());
+				::detail::log_trace(std::format(
+					"mark_next_free_chunk -> chunk bit mask: {}", m_occupied_chunks.to_string())
+						.c_str());
 				if (auto chunk_idx = next_free_chunk()) {
 					ASSERT(!m_occupied_chunks[*chunk_idx]);
-					spdlog::trace("marking next free chunk -> old chunk bit mask: {}",
-						m_occupied_chunks.to_string());
+					::detail::log_trace(
+						std::format("marking next free chunk -> old chunk bit mask: {}",
+							m_occupied_chunks.to_string())
+							.c_str());
 					m_occupied_chunks.flip(*chunk_idx);
-					spdlog::trace("marking next free chunk -> new chunk bit mask: {} (index: {})",
-						m_occupied_chunks.to_string(),
-						*chunk_idx);
+					::detail::log_trace(
+						std::format("marking next free chunk -> new chunk bit mask: {} (index: {})",
+							m_occupied_chunks.to_string(),
+							*chunk_idx)
+							.c_str());
 					return *chunk_idx;
 				} else {
 					return {};
 				}
 			}
 
-			void mark_chunk_as_free(size_t idx)
+			void mark_chunk_as_free(std::size_t idx)
 			{
 				ASSERT(m_occupied_chunks[idx]);
 				m_occupied_chunks.flip(idx);
@@ -70,7 +70,9 @@ class Block
 		};
 
 	  public:
-		Chunk(uint8_t *memory, size_t object_size) : m_memory(memory), m_object_size(object_size) {}
+		Chunk(std::uint8_t *memory, std::size_t object_size)
+			: m_memory(memory), m_object_size(object_size)
+		{}
 
 		~Chunk();
 
@@ -82,34 +84,39 @@ class Block
 			other.m_chunk_view.reset();
 		}
 
-		uint8_t *allocate()
+		std::uint8_t *allocate()
 		{
 			if (auto chunk_idx = m_chunk_view.mark_next_free_chunk()) {
-				spdlog::trace("Allocating memory at index {}, address {} (chunk base address @{})",
+				::detail::log_trace(std::format(
+					"Allocating memory at index {}, address {} (chunk base address @{})",
 					*chunk_idx,
 					(void *)(m_memory + *chunk_idx * m_object_size),
-					(void *)m_memory);
+					(void *)m_memory)
+						.c_str());
 				return m_memory + *chunk_idx * m_object_size;
 			} else {
 				return nullptr;
 			}
 		}
 
-		bool has_address(uint8_t *memory) const;
+		bool has_address(std::uint8_t *memory) const;
 
-		void deallocate(uint8_t *ptr)
+		void deallocate(std::uint8_t *ptr)
 		{
-			uintptr_t start = bit_cast<uintptr_t>(m_memory);
-			uintptr_t end = bit_cast<uintptr_t>(m_memory + m_object_size * ChunkView<>::ChunkCount);
-			ASSERT(bit_cast<uintptr_t>(ptr) >= start && bit_cast<uintptr_t>(ptr) < end);
-			ASSERT((bit_cast<uintptr_t>(ptr) - start) % m_object_size == 0);
-
-			size_t ptr_idx = (bit_cast<uintptr_t>(ptr) - start) / m_object_size;
+			std::uintptr_t start = std::bit_cast<std::uintptr_t>(m_memory);
+			std::uintptr_t end =
+				std::bit_cast<std::uintptr_t>(m_memory + m_object_size * ChunkView<>::ChunkCount);
+			ASSERT(std::bit_cast<std::uintptr_t>(ptr) >= start
+				   && std::bit_cast<std::uintptr_t>(ptr) < end);
+			ASSERT((std::bit_cast<std::uintptr_t>(ptr) - start) % m_object_size == 0);
+
+			std::size_t ptr_idx = (std::bit_cast<std::uintptr_t>(ptr) - start) / m_object_size;
 			ASSERT(ptr_idx < ChunkView<>::ChunkCount);
 			m_chunk_view.mark_chunk_as_free(ptr_idx);
-			spdlog::debug("Marking memory at index {} as free, address {}",
+			::detail::log_debug(std::format("Marking memory at index {} as free, address {}",
 				ptr_idx,
-				(void *)(m_memory + ptr_idx * m_object_size));
+				(void *)(m_memory + ptr_idx * m_object_size))
+					.c_str());
 
 			// TODO: this should only be needed for debug builds
 			std::fill_n(ptr, m_object_size, 0xDD);
@@ -126,59 +133,59 @@ class Block
 
 		void reset();
 
-		size_t object_size() const { return m_object_size; }
+		std::size_t object_size() const { return m_object_size; }
 
-		void for_each_cell_alive(std::function<void(uint8_t *)> &&callback)
+		void for_each_cell_alive(std::function<void(std::uint8_t *)> &&callback)
 		{
-			for (size_t i{ 0 }; i < m_chunk_view.m_occupied_chunks.size(); ++i) {
+			for (std::size_t i{ 0 }; i < m_chunk_view.m_occupied_chunks.size(); ++i) {
 				const auto bit = m_chunk_view.m_occupied_chunks[i];
 				if (bit) { callback(m_memory + i * m_object_size); }
 			}
 		}
 
-		void for_each_cell(std::function<void(uint8_t *)> &&callback)
+		void for_each_cell(std::function<void(std::uint8_t *)> &&callback)
 		{
-			for (size_t i{ 0 }; i < m_chunk_view.m_occupied_chunks.size(); ++i) {
+			for (std::size_t i{ 0 }; i < m_chunk_view.m_occupied_chunks.size(); ++i) {
 				callback(m_memory + i * m_object_size);
 			}
 		}
 
-		uint8_t *m_memory;
-		size_t m_object_size;
+		std::uint8_t *m_memory;
+		std::size_t m_object_size;
 
 	  private:
 		ChunkView<> m_chunk_view;
 	};
 
-
   public:
-	Block(size_t object_size, size_t capacity);
+	Block(std::size_t object_size, std::size_t capacity);
 
 	void reset();
 
-	uint8_t *allocate();
+	std::uint8_t *allocate();
 
-	void deallocate(uint8_t *ptr);
+	void deallocate(std::uint8_t *ptr);
 
 	std::vector<Chunk> &chunks() { return m_chunks; }
 	const std::vector<Chunk> &chunks() const { return m_chunks; }
 
-	size_t object_size() const { return m_chunks.back().object_size(); }
+	std::size_t object_size() const { return m_chunks.back().object_size(); }
 
   private:
-	std::vector<std::unique_ptr<uint8_t[]>> m_memory;
+	std::vector<std::unique_ptr<std::uint8_t[]>> m_memory;
 	std::vector<Chunk> m_chunks;
 };
 
 class Slab
 {
   public:
-	static constexpr std::array<size_t, 8> kBlockSizes{ 16, 32, 64, 128, 256, 512, 1024, 2048 };
-	static constexpr size_t kBlockCount = kBlockSizes.size();
+	static constexpr std::array<std::size_t, 8>
+		kBlockSizes{ 16, 32, 64, 128, 256, 512, 1024, 2048 };
+	static constexpr std::size_t kBlockCount = kBlockSizes.size();
 
 	Slab()
 	{
-		for (size_t i = 0; i < kBlockCount; ++i) {
+		for (std::size_t i = 0; i < kBlockCount; ++i) {
 			m_blocks[i] = std::make_unique<Block>(kBlockSizes[i], 1000);
 		}
 	}
@@ -201,46 +208,37 @@ class Slab
 		for (const auto &b : m_blocks) { f(*b); }
 	}
 
+	std::uint8_t *raw_allocate(std::size_t size)
+	{
+		for (std::size_t i = 0; i < kBlockCount; ++i) {
+			if (size <= kBlockSizes[i]) { return m_blocks[i]->allocate(); }
+		}
+		TODO();
+	}
+
 	template<typename T>
-	uint8_t *allocate()
+	std::uint8_t *allocate()
 		requires std::is_base_of_v<Cell, T>
 	{
-		spdlog::trace("Allocating Cell object memory for object of size {}", sizeof(T));
-		constexpr size_t needed = sizeof(T) + sizeof(GarbageCollected);
+		::detail::log_trace(
+			std::format("Allocating Cell object memory for object of size {}", sizeof(T)).c_str());
+		constexpr std::size_t needed = sizeof(T) + sizeof(GarbageCollected);
 		static_assert(needed <= kBlockSizes.back(),
 			"only object sizes <= 2048 bytes are currently supported");
-		if constexpr (needed <= 16) {
-			return m_blocks[0]->allocate();
-		} else if constexpr (needed <= 32) {
-			return m_blocks[1]->allocate();
-		} else if constexpr (needed <= 64) {
-			return m_blocks[2]->allocate();
-		} else if constexpr (needed <= 128) {
-			return m_blocks[3]->allocate();
-		} else if constexpr (needed <= 256) {
-			return m_blocks[4]->allocate();
-		} else if constexpr (needed <= 512) {
-			return m_blocks[5]->allocate();
-		} else if constexpr (needed <= 1024) {
-			return m_blocks[6]->allocate();
-		} else {
-			return m_blocks[7]->allocate();
-		}
+		return raw_allocate(needed);
 	}
 
 	template<typename T>
-	uint8_t *allocate(size_t extra_bytes)
+	std::uint8_t *allocate(std::size_t extra_bytes)
 		requires std::is_base_of_v<Cell, T>
 	{
-		spdlog::trace("Allocating Cell object memory for object of size {}", sizeof(T));
-		const size_t needed = sizeof(T) + extra_bytes + sizeof(GarbageCollected);
-		for (size_t i = 0; i < kBlockCount; ++i) {
-			if (needed <= kBlockSizes[i]) { return m_blocks[i]->allocate(); }
-		}
-		TODO();
+		::detail::log_trace(
+			std::format("Allocating Cell object memory for object of size {}", sizeof(T)).c_str());
+		const std::size_t needed = sizeof(T) + extra_bytes + sizeof(GarbageCollected);
+		return raw_allocate(needed);
 	}
 
-	template<typename T> uint8_t *allocate()
+	template<typename T> std::uint8_t *allocate()
 	{
 		[]<bool flag = false>() {
 			static_assert(flag, "only GC collected objects are currently supported");
@@ -248,7 +246,7 @@ class Slab
 		return nullptr;
 	}
 
-	bool has_address(uint8_t *addr) const;
+	bool has_address(std::uint8_t *addr) const;
 
 	void reset()
 	{
@@ -259,21 +257,19 @@ class Slab
 	std::array<std::unique_ptr<Block>, kBlockCount> m_blocks;
 };
 
-class Heap
+export class Heap
 	: NonCopyable
 	, NonMoveable
 {
-	friend class VirtualMachine;
 	friend GarbageCollector;
-	friend struct TestHeap;
 
-	std::unique_ptr<uint8_t[]> m_static_memory;
-	size_t m_static_memory_size{ 1 * MB };
-	size_t m_static_offset{ 8 };
+	std::unique_ptr<std::uint8_t[]> m_static_memory;
+	std::size_t m_static_memory_size{ 1 * MB };
+	std::size_t m_static_offset{ 8 };
 	Slab m_slab;
 	std::unique_ptr<GarbageCollector> m_gc;
-	std::unordered_map<uint8_t *, std::vector<py::PyObject *>> m_weakrefs;
-	uintptr_t *m_bottom_stack_pointer;
+	std::unordered_map<std::uint8_t *, std::vector<Cell *>> m_weakrefs;
+	std::uintptr_t *m_bottom_stack_pointer;
 	bool m_allocate_in_static{ false };
 
 	struct ScopedGCPause
@@ -302,18 +298,43 @@ class Heap
 
 	friend ScopedStaticAllocation;
 
+  public:
 	static std::unique_ptr<Heap> create() { return std::unique_ptr<Heap>(new Heap); }
 
-  public:
 	void reset()
 	{
 		collect_garbage();
 		m_slab.reset();
 	}
 
-	void set_start_stack_pointer(uintptr_t *address) { m_bottom_stack_pointer = address; }
+	void set_start_stack_pointer(std::uintptr_t *address) { m_bottom_stack_pointer = address; }
+
+	std::uintptr_t *start_sp() const { return m_bottom_stack_pointer; }
+
+	std::uint8_t *__attribute__((noinline)) allocate(std::size_t size, std::size_t extra_bytes)
+	{
+		// py::detail::allocate_raw funnels every runtime type through here, so
+		// this has to honour scoped_static_allocation() the same way the
+		// templated allocate<T> does by way of allocate_static<T>.
+		if (m_allocate_in_static) { return allocate_static_raw(size + extra_bytes); }
+		collect_garbage();
+		// allocate_gc writes a GarbageCollected header at the front and returns
+		// the address past it, so the slot has to be big enough for both - the
+		// same sum Slab::allocate<T> computes.
+		auto *ptr = m_slab.raw_allocate(size + extra_bytes + sizeof(GarbageCollected));
+
+		return allocate_gc(ptr);
+	}
 
-	uintptr_t *start_sp() const { return m_bottom_stack_pointer; }
+	// Bump-allocates out of the static arena. Like allocate_static<T>, the
+	// result carries no GarbageCollected header: static objects outlive the GC.
+	std::uint8_t *allocate_static_raw(std::size_t size)
+	{
+		if (m_static_offset + size >= m_static_memory_size) { TODO(); }
+		std::uint8_t *ptr = m_static_memory.get() + m_static_offset;
+		m_static_offset += size;
+		return ptr;
+	}
 
 	template<typename T, typename... Args> T *__attribute__((noinline)) allocate(Args &&...args)
 	{
@@ -321,23 +342,23 @@ class Heap
 		collect_garbage();
 		auto *ptr = m_slab.allocate<T>();
 
-		uint8_t *obj_ptr = allocate_gc(ptr);
+		std::uint8_t *obj_ptr = allocate_gc(ptr);
 		T *obj = new (obj_ptr) T(std::forward<Args>(args)...);
 
 		return obj;
 	}
 
 	template<typename T, typename... Args>
-	T *__attribute__((noinline)) allocate_with_extra_bytes(size_t bytes, Args &&...args)
+	T *__attribute__((noinline)) allocate_with_extra_bytes(std::size_t bytes, Args &&...args)
 	{
 		if (bytes == 0) { return allocate<T>(std::forward<Args>(args)...); }
 		if (m_allocate_in_static) { TODO(); }
 		collect_garbage();
 		auto *ptr = m_slab.allocate<T>(bytes);
 
-		uint8_t *obj_ptr = allocate_gc(ptr);
+		std::uint8_t *obj_ptr = allocate_gc(ptr);
 		T *obj = new (obj_ptr) T(std::forward<Args>(args)...);
-		memset(obj_ptr + sizeof(T), 0, bytes);
+		std::memset(obj_ptr + sizeof(T), 0, bytes);
 
 		return obj;
 	}
@@ -346,7 +367,7 @@ class Heap
 	T *__attribute__((noinline)) allocate_weakref(TargetT &&target, Args &&...args)
 	{
 		T *obj = allocate<T>(std::forward<TargetT>(target), std::forward<Args>(args)...);
-		if (obj) { m_weakrefs[bit_cast<uint8_t *>(target)].push_back(obj); }
+		if (obj) { m_weakrefs[std::bit_cast<std::uint8_t *>(target)].push_back(obj); }
 		return obj;
 	}
 
@@ -366,8 +387,8 @@ class Heap
 		return ptr;
 	}
 
-	const uint8_t *static_memory() const { return m_static_memory.get(); }
-	size_t static_memory_size() const { return m_static_memory_size; }
+	const std::uint8_t *static_memory() const { return m_static_memory.get(); }
+	std::size_t static_memory_size() const { return m_static_memory_size; }
 
 	Slab &slab() { return m_slab; }
 	const Slab &slab() const { return m_slab; }
@@ -379,13 +400,13 @@ class Heap
 		return ScopedStaticAllocation(*this);
 	}
 
-	bool has_weakref_object(uint8_t *obj) const { return m_weakrefs.contains(obj); }
-	size_t weakref_count(uint8_t *obj) const
+	bool has_weakref_object(std::uint8_t *obj) const { return m_weakrefs.contains(obj); }
+	std::size_t weakref_count(std::uint8_t *obj) const
 	{
 		if (auto it = m_weakrefs.find(obj); it != m_weakrefs.end()) { return it->second.size(); }
 		return 0;
 	}
-	std::vector<py::PyObject *> get_weakrefs(uint8_t *obj) const
+	std::vector<Cell *> get_weakrefs(std::uint8_t *obj) const
 	{
 		if (auto it = m_weakrefs.find(obj); it != m_weakrefs.end()) { return it->second; }
 		return {};
@@ -395,7 +416,7 @@ class Heap
 	// (not the target) is being collected. Without this, m_weakrefs[target]
 	// would retain a dangling pointer that getweakrefs/getweakrefcount
 	// would later hand back to user code.
-	void unregister_weakref(uint8_t *target, py::PyObject *wrapper)
+	void unregister_weakref(std::uint8_t *target, Cell *wrapper)
 	{
 		auto it = m_weakrefs.find(target);
 		if (it == m_weakrefs.end()) { return; }
@@ -405,7 +426,7 @@ class Heap
 	}
 
   private:
-	uint8_t *allocate_gc(uint8_t *ptr) const;
+	std::uint8_t *allocate_gc(std::uint8_t *ptr) const;
 
 	Heap();
 };
diff --git a/src/memory/Heap_test.hpp b/src/memory/Heap_test.hpp
index 30833c60..0a2fa42d 100644
--- a/src/memory/Heap_test.hpp
+++ b/src/memory/Heap_test.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include "Heap.hpp"
-#include "vm/VM.hpp"
-
 #include <gtest/gtest.h>
 
 struct TestHeap : ::testing::Test
diff --git a/src/memory/Heap_tests.cpp b/src/memory/Heap_tests.cpp
index 21d2692b..0bd7ce8c 100644
--- a/src/memory/Heap_tests.cpp
+++ b/src/memory/Heap_tests.cpp
@@ -1,4 +1,15 @@
+#include "core.hpp"
+
+#include <cstdint>
+#include <cstring>
+#include <gtest/gtest.h>
+
+import py.memory;
+import py.runtime;
+import std;
+
 #include "Heap_test.hpp"
+
 namespace {
 static constexpr size_t chunk_size = 64;
 }
@@ -62,7 +73,8 @@ TEST_F(TestHeap, AllocatesInOldBlockWhenPossible)
 	static constexpr size_t index = 100;
 	ASSERT(index < n_chunks * chunk_size);
 	auto *old_ptr = data[index];
-	m_heap->slab().block_32()->deallocate(bit_cast<uint8_t *>(old_ptr) - sizeof(GarbageCollected));
+	m_heap->slab().block_32()->deallocate(
+		std::bit_cast<uint8_t *>(old_ptr) - sizeof(GarbageCollected));
 
 	auto *ptr = m_heap->allocate<Data>(n_chunks * chunk_size + 1);
 
@@ -96,7 +108,8 @@ TEST_F(TestHeap, DeallocatesAllChunkSlotsIncludingLast)
 	for (size_t idx = 0; idx < chunk_size; ++idx) { data.push_back(m_heap->allocate<Data>(idx)); }
 
 	for (auto *d : data) {
-		m_heap->slab().block_32()->deallocate(bit_cast<uint8_t *>(d) - sizeof(GarbageCollected));
+		m_heap->slab().block_32()->deallocate(
+			std::bit_cast<uint8_t *>(d) - sizeof(GarbageCollected));
 	}
 }
 
@@ -132,4 +145,4 @@ TEST_F(TestHeap, ResetCallsDestructorOfAllHeapAllocatecObjects)
 	m_heap->reset();
 
 	ASSERT_EQ(counter, n_chunks * chunk_size);
-}
\ No newline at end of file
+}
diff --git a/src/memory/allocate.cpp b/src/memory/allocate.cpp
new file mode 100644
index 00000000..45e8d661
--- /dev/null
+++ b/src/memory/allocate.cpp
@@ -0,0 +1,12 @@
+#include "memory/allocate.hpp"
+
+import py.runtime;
+
+namespace py::detail {
+
+unsigned char *allocate_raw(size_type size, size_type extra_bytes)
+{
+	return VirtualMachine::the().heap().allocate(size, extra_bytes);
+}
+
+}// namespace py::detail
diff --git a/src/memory/allocate.hpp b/src/memory/allocate.hpp
new file mode 100644
index 00000000..fd83827c
--- /dev/null
+++ b/src/memory/allocate.hpp
@@ -0,0 +1,61 @@
+#pragma once
+
+
+// Allocation entry point for module units that must not pull the VM in.
+//
+// PyObject.cppm allocates from inside TypePrototype::create<Type>, a template in
+// the module interface. Including vm/VM.hpp there would put VirtualMachine and
+// Heap into a py.runtime partition's global module fragment and close a
+// dependency cycle. Only sizeof(T) is type-dependent, so the sizing and the GC
+// bookkeeping live behind allocate_raw() in a .cpp that can see the VM, and the
+// placement new stays here where T is known.
+//
+// Deliberately free of libstdc++: this header is included by module GMFs, and
+// anything a GMF pulls in lands in the BMI, where it collides with the same
+// headers a consumer #includes. Hence the compiler builtins instead of
+// <cstddef>/<cstdint> and the hand-written forward instead of <utility>.
+//
+// The placement new is a static member of Allocator rather than a free function
+// because the runtime types keep their constructors private and grant access
+// with `friend class ::Heap;`. Allocator is befriended the same way.
+
+namespace py::detail {
+
+using size_type = __SIZE_TYPE__;
+
+unsigned char *allocate_raw(size_type size, size_type extra_bytes);
+
+class Allocator
+{
+  public:
+	template<typename T, typename... Args> [[nodiscard]] static T *allocate(Args &&...args)
+	{
+		unsigned char *mem = allocate_raw(sizeof(T), 0);
+		if (!mem) { return nullptr; }
+		return new (mem) T(static_cast<Args &&>(args)...);
+	}
+
+	template<typename T, typename... Args>
+	[[nodiscard]] static T *allocate_with_extra_bytes(size_type extra, Args &&...args)
+	{
+		unsigned char *mem = allocate_raw(sizeof(T), extra);
+		if (!mem) { return nullptr; }
+		// The extra bytes hold __slots__ storage, and both PyObject::visit_graph and the
+		// member accessor installed by PyType test those entries against nullptr. Slab
+		// memory is poisoned (0xCD when a block is created, 0xDD when a slot is freed), so
+		// an unset slot left uninitialised reads as a non-null garbage pointer: the GC
+		// dereferences it and the accessor hands it back instead of raising AttributeError.
+		// __builtin_memset rather than std::memset - see the note above on keeping
+		// libstdc++ out of this header.
+		if (extra) { __builtin_memset(mem + sizeof(T), 0, extra); }
+		return new (mem) T(static_cast<Args &&>(args)...);
+	}
+};
+
+// Kept so existing call sites do not have to change.
+template<typename T, typename... Args> [[nodiscard]] T *allocate(Args &&...args)
+{
+	return Allocator::allocate<T>(static_cast<Args &&>(args)...);
+}
+
+}// namespace py::detail
diff --git a/src/memory/memory.cppm b/src/memory/memory.cppm
new file mode 100644
index 00000000..3d7ec851
--- /dev/null
+++ b/src/memory/memory.cppm
@@ -0,0 +1,5 @@
+export module py.memory;
+
+export import :gc;
+export import :heap;
+import std;
diff --git a/src/parser/Parser.cpp b/src/parser/Parser.cpp
index 699460e3..1802516e 100644
--- a/src/parser/Parser.cpp
+++ b/src/parser/Parser.cpp
@@ -1,10 +1,16 @@
-#include "Parser.hpp"
-#include "runtime/SyntaxError.hpp"
-#include "runtime/Value.hpp"
+module;
+#include "core.hpp"
+#include "spdlog/spdlog.h"
 
 #include <gmpxx.h>
 
-#include <sstream>
+
+module py.runtime;
+import std;
+import py.ast;
+import py.lexer;
+
+// After the import: these name module-owned types.
 
 using namespace py;
 using namespace ast;
@@ -37,7 +43,7 @@ using namespace parser;
 size_t Parser::CacheHash::operator()(const Parser::CacheKey &cache) const
 {
 	size_t seed = cache.rule.hash_code();
-	seed ^= bit_cast<size_t>(cache.token.start().pointer_to_program) + 0x9e3779b9 + (seed << 6)
+	seed ^= std::bit_cast<size_t>(cache.token.start().pointer_to_program) + 0x9e3779b9 + (seed << 6)
 			+ (seed >> 2);
 	seed ^= static_cast<size_t>(cache.token.token_type()) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
 	return seed;
@@ -1551,7 +1557,7 @@ struct StarTargetsPattern : PatternV2<StarTargetsPattern>
 
 Constant *parse_bytes(Parser &p, Token string)
 {
-	Bytes byte_collection;
+	ast::Bytes byte_collection;
 	auto *start = string.start().pointer_to_program;
 	const auto *end = string.end().pointer_to_program;
 
@@ -1569,8 +1575,10 @@ Constant *parse_bytes(Parser &p, Token string)
 			return std::string{ start + 1, end - 1 };
 		}
 	}();
+	// py::Bytes::from_unescaped_string does the unescaping; the AST stores the
+	// raw bytes (ast::Bytes) so it stays independent of the runtime's types.
 	return p.arena().create<Constant>(
-		Bytes::from_unescaped_string(value), SourceLocation{ string.start(), string.end() });
+		py::Bytes::from_unescaped_string(value).b, SourceLocation{ string.start(), string.end() });
 }
 
 template<> struct traits<struct FStringReplacementFieldPattern>
@@ -1745,7 +1753,7 @@ struct FStringMiddlePattern : PatternV2<FStringMiddlePattern>
 					str.push_back(middle_str[i]);
 				}
 			}
-			return p.arena().create<Constant>(String::from_unescaped_string(std::move(str)),
+			return p.arena().create<Constant>(py::String::from_unescaped_string(std::move(str)).s,
 				SourceLocation{ middle.token.start(), middle.token.end() });
 		}
 
@@ -1863,10 +1871,11 @@ struct StringPattern : PatternV2<StringPattern>
 			}
 
 			if (is_raw_string) {
-				return p.arena().create<Constant>(String(std::string{ value }),
-					SourceLocation{ str.token.start(), str.token.end() });
+				return p.arena().create<Constant>(
+					std::string{ value }, SourceLocation{ str.token.start(), str.token.end() });
 			}
-			return p.arena().create<Constant>(String::from_unescaped_string(std::string{ value }),
+			return p.arena().create<Constant>(
+				py::String::from_unescaped_string(std::string{ value }).s,
 				SourceLocation{ str.token.start(), str.token.end() });
 		}
 		return {};
@@ -1909,17 +1918,18 @@ struct StringsPattern : PatternV2<StringsPattern>
 				string_nodes.end(),
 				[](const auto &el) -> bool { return static_cast<bool>(as<Constant>(el)); });
 			if (all_constant) {
-				if (std::holds_alternative<Bytes>(*as<Constant>(string_nodes.front())->value())) {
-					Bytes bytes;
+				if (std::holds_alternative<ast::Bytes>(
+						as<Constant>(string_nodes.front())->value())) {
+					ast::Bytes bytes;
 					for (const auto &el : string_nodes) {
 						ASSERT(as<Constant>(el));
 						auto c = as<Constant>(el);
-						if (!std::holds_alternative<Bytes>(*c->value())) {
+						if (!std::holds_alternative<ast::Bytes>(c->value())) {
 							std::cerr << "SyntaxError: cannot mix bytes and nonbytes literals\n";
 							std::abort();
 						}
-						const auto &byte = std::get<Bytes>(*c->value());
-						bytes.b.insert(bytes.b.end(), byte.b.begin(), byte.b.end());
+						const auto &byte = std::get<ast::Bytes>(c->value());
+						bytes.insert(bytes.end(), byte.begin(), byte.end());
 					}
 					return p.arena().create<Constant>(bytes, sl);
 				} else {
@@ -1929,8 +1939,8 @@ struct StringsPattern : PatternV2<StringsPattern>
 						[](std::string acc, const auto &el) {
 							ASSERT(as<Constant>(el));
 							auto c = as<Constant>(el);
-							ASSERT(std::holds_alternative<String>(*c->value()));
-							return acc + std::get<String>(*c->value()).s;
+							ASSERT(std::holds_alternative<std::string>(c->value()));
+							return acc + std::get<std::string>(c->value());
 						});
 					return p.arena().create<Constant>(std::move(str), sl);
 				}
@@ -2535,7 +2545,7 @@ struct AtomPattern : PatternV2<AtomPattern>
 				return p.arena().create<Constant>(
 					false, SourceLocation{ token.token.start(), token.token.end() });
 			} else if (name == "None") {
-				return p.arena().create<Constant>(py::NameConstant{ py::NoneType{} },
+				return p.arena().create<Constant>(ast::Literal{ std::monostate{} },
 					SourceLocation{ token.token.start(), token.token.end() });
 			} else {
 				return p.arena().create<Name>(name,
@@ -2590,8 +2600,8 @@ struct AtomPattern : PatternV2<AtomPattern>
 		using pattern11 = PatternMatchV2<SingleTokenPatternV2<Token::TokenType::ELLIPSIS>>;
 		if (auto result = pattern11::match(p)) {
 			auto [token] = *result;
-			return p.arena().create<Constant>(
-				Ellipsis{}, SourceLocation{ token.token.start(), token.token.end() });
+			return p.arena().create<Constant>(ast::Literal{ ast::EllipsisType{} },
+				SourceLocation{ token.token.start(), token.token.end() });
 		}
 
 		return {};
@@ -4704,7 +4714,7 @@ struct YieldExpressionPattern : PatternV2<YieldExpressionPattern>
 		if (auto result = pattern1::match(p)) {
 			DEBUG_LOG("'yield' 'from' expression");
 			auto [yield_token, from_token, expression] = *result;
-			return p.arena().create<YieldFrom>(expression,
+			return p.arena().create<ast::YieldFrom>(expression,
 				SourceLocation{ yield_token.start(), expression->source_location().end });
 		}
 
@@ -4721,7 +4731,7 @@ struct YieldExpressionPattern : PatternV2<YieldExpressionPattern>
 			}
 			const auto end = p.lexer().peek_token(p.token_position() - 1);
 			auto value = p.arena().create<Constant>(
-				NameConstant{ NoneType{} }, SourceLocation{ end->start(), end->end() });
+				ast::Literal{ std::monostate{} }, SourceLocation{ end->start(), end->end() });
 			return p.arena().create<Yield>(
 				value, SourceLocation{ yield_token.start(), value->source_location().end });
 		}
@@ -5187,7 +5197,7 @@ struct ImportFromTargetsPattern : PatternV2<ImportFromTargetsPattern>
 
 template<> struct traits<struct ImportFromPattern>
 {
-	using result_type = ImportFrom *;
+	using result_type = ast::ImportFrom *;
 };
 
 struct ImportFromPattern : PatternV2<ImportFromPattern>
@@ -5245,7 +5255,7 @@ struct ImportFromPattern : PatternV2<ImportFromPattern>
 					}
 				});
 
-			return p.arena().create<ImportFrom>(module,
+			return p.arena().create<ast::ImportFrom>(module,
 				std::move(aliases),
 				level,
 				SourceLocation{ from_token.start(),
@@ -5290,7 +5300,7 @@ struct ImportFromPattern : PatternV2<ImportFromPattern>
 					}
 				});
 
-			return p.arena().create<ImportFrom>(module,
+			return p.arena().create<ast::ImportFrom>(module,
 				std::move(aliases),
 				level,
 				SourceLocation{ from_token.start(),
diff --git a/src/parser/Parser.hpp b/src/parser/Parser.cppm
similarity index 75%
rename from src/parser/Parser.hpp
rename to src/parser/Parser.cppm
index 2a8a6d64..6dc89de8 100644
--- a/src/parser/Parser.hpp
+++ b/src/parser/Parser.cppm
@@ -1,22 +1,17 @@
-#pragma once
+export module py.runtime:parser;
 
-#include "ast/AST.hpp"
-#include "lexer/Lexer.hpp"
-#include "utilities.hpp"
+import std;
+import py.ast;
+import py.lexer;
+import :value;
 
-#include <memory>
-#include <string_view>
-#include <tuple>
-#include <unordered_set>
-#include <variant>
-
-namespace parser {
+export namespace parser {
 
 class Parser
 {
 	std::shared_ptr<ast::Module> m_module;
 	Lexer &m_lexer;
-	size_t m_token_position{ 0 };
+	std::size_t m_token_position{ 0 };
 
   public:
 	struct CacheKey
@@ -27,7 +22,7 @@ class Parser
 
 	struct CacheHash
 	{
-		size_t operator()(const CacheKey &cache) const;
+		std::size_t operator()(const CacheKey &cache) const;
 	};
 
 	struct CacheEqual
@@ -41,7 +36,7 @@ class Parser
 		// raw pointers safe to alias across backtracking attempts.
 		using ValueType = std::variant<ast::ASTNode *, std::vector<Token>>;
 		std::variant<bool, ValueType> value;
-		size_t position;
+		std::size_t position;
 	};
 
 	std::unordered_map<CacheKey, std::optional<CacheValue>, CacheHash, CacheEqual> m_cache;
@@ -60,8 +55,8 @@ class Parser
 	// Arena that owns every child node reachable from the parsed Module.
 	ast::ASTArena &arena() { return m_module->arena(); }
 
-	const size_t &token_position() const { return m_token_position; }
-	size_t &token_position() { return m_token_position; }
+	const std::size_t &token_position() const { return m_token_position; }
+	std::size_t &token_position() { return m_token_position; }
 
 	// parses a file
 	void parse();
diff --git a/src/parser/Parser_tests.cpp b/src/parser/Parser_tests.cpp
index 417b1d5b..3f35a286 100644
--- a/src/parser/Parser_tests.cpp
+++ b/src/parser/Parser_tests.cpp
@@ -1,10 +1,20 @@
-#include "ast/AST.hpp"
-#include "parser/Parser.hpp"
-#include "runtime/Value.hpp"
-#include "utilities.hpp"
+#include "core.hpp"
+
+// gmpxx's operators are declared in py.ast's global module fragment, so they
+// are not exported with mpz_class and have to be included here.
+#include <gmpxx.h>
+
+#include <spdlog/spdlog.h>
 
 #include "gtest/gtest.h"
 
+import py.lexer;
+import py.ast;
+import py.runtime;
+import std;
+
+// After the import: these name module-owned types.
+
 using namespace ast;
 using namespace py;
 
@@ -15,43 +25,28 @@ void dispatch(const ASTNode *result, const ASTNode *expected);
 void compare_constant(const ASTNode *result, const ASTNode *expected)
 {
 	ASSERT_EQ(result->node_type(), ASTNodeType::Constant);
-	const auto result_value = as<Constant>(result)->value();
-	const auto expected_value = as<Constant>(expected)->value();
+	const auto &result_value = as<Constant>(result)->value();
+	const auto &expected_value = as<Constant>(expected)->value();
 
-	ASSERT_EQ(result_value->index(), expected_value->index());
+	ASSERT_EQ(result_value.index(), expected_value.index());
 	std::visit(
-		overloaded{ [&](const Number &number_value) {
-					   if (auto *int_result = std::get_if<BigIntType>(&number_value.value)) {
-						   ASSERT_EQ(*int_result,
-							   std::get<BigIntType>(std::get<Number>(*expected_value).value));
-					   } else if (auto *double_result = std::get_if<double>(&number_value.value)) {
-						   ASSERT_EQ(*double_result,
-							   std::get<double>(std::get<Number>(*expected_value).value));
-					   } else {
-						   TODO();
-					   }
-				   },
-			[&](const String &string_value) {
-				ASSERT_EQ(string_value.s, std::get<String>(*expected_value).s);
+		overloaded{
+			[&](std::monostate) {},
+			[&](bool value) { ASSERT_EQ(value, std::get<bool>(expected_value)); },
+			[&](std::int64_t value) { ASSERT_EQ(value, std::get<std::int64_t>(expected_value)); },
+			[&](const mpz_class &value) {
+				ASSERT_EQ(value.get_str(), std::get<mpz_class>(expected_value).get_str());
 			},
-			[&](const NameConstant &name_constant_value) {
-				if (auto *bool_result = std::get_if<bool>(&name_constant_value.value)) {
-					ASSERT_EQ(*bool_result,
-						std::get<bool>(std::get<NameConstant>(*expected_value).value));
-				} else if (std::holds_alternative<NoneType>(
-							   std::get<NameConstant>(*expected_value).value)) {
-					ASSERT_TRUE(std::holds_alternative<NoneType>(name_constant_value.value));
-				} else {
-					TODO();
-				}
+			[&](double value) { ASSERT_EQ(value, std::get<double>(expected_value)); },
+			[&](const std::string &value) {
+				ASSERT_EQ(value, std::get<std::string>(expected_value));
 			},
-			[&](const Bytes &bytes) { ASSERT_EQ(bytes.b, std::get<Bytes>(*expected_value).b); },
-			[&](const auto &val) {
-				(void)val;
-				TODO();
-				// ASSERT_EQ(result_, std::get<result_.index()>(expected_));
-			} },
-		*result_value);
+			[&](const ast::Bytes &value) {
+				ASSERT_EQ(value, std::get<ast::Bytes>(expected_value));
+			},
+			[&](ast::EllipsisType) {},
+		},
+		result_value);
 }
 
 void compare_assign(const ASTNode *result, const ASTNode *expected)
@@ -240,8 +235,8 @@ void compare_yieldfrom(const ASTNode *result, const ASTNode *expected)
 {
 	ASSERT_EQ(result->node_type(), ASTNodeType::YieldFrom);
 
-	const auto result_value = as<YieldFrom>(result)->value();
-	const auto expected_value = as<YieldFrom>(expected)->value();
+	const auto result_value = as<ast::YieldFrom>(result)->value();
+	const auto expected_value = as<ast::YieldFrom>(expected)->value();
 	dispatch(result_value, expected_value);
 }
 
@@ -486,8 +481,8 @@ void compare_import_from(const ASTNode *result, const ASTNode *expected)
 {
 	ASSERT_EQ(result->node_type(), ASTNodeType::ImportFrom);
 
-	const auto result_names = as<ImportFrom>(result)->names();
-	const auto expected_names = as<ImportFrom>(expected)->names();
+	const auto result_names = as<ast::ImportFrom>(result)->names();
+	const auto expected_names = as<ast::ImportFrom>(expected)->names();
 	ASSERT_EQ(result_names.size(), expected_names.size());
 
 	for (size_t i = 0; i < result_names.size(); ++i) {
@@ -495,8 +490,8 @@ void compare_import_from(const ASTNode *result, const ASTNode *expected)
 		ASSERT_EQ(result_names[i].asname, expected_names[i].asname);
 	}
 
-	ASSERT_EQ(as<ImportFrom>(result)->level(), as<ImportFrom>(expected)->level());
-	ASSERT_EQ(as<ImportFrom>(result)->module(), as<ImportFrom>(expected)->module());
+	ASSERT_EQ(as<ast::ImportFrom>(result)->level(), as<ast::ImportFrom>(expected)->level());
+	ASSERT_EQ(as<ast::ImportFrom>(result)->module(), as<ast::ImportFrom>(expected)->module());
 }
 
 void compare_slices(const Subscript::SliceType &result, const Subscript::SliceType &expected)
@@ -1198,7 +1193,7 @@ TEST(Parser, SingleValueAssignmentTuple)
 			"_CASE_INSENSITIVE_PLATFORMS_STR_KEY", ContextType::STORE, SourceLocation{}) },
 		expected_ast->arena().create<ast::Tuple>(
 			std::vector<ASTNode *>{
-				expected_ast->arena().create<Constant>(String{ "win" }, SourceLocation{}),
+				expected_ast->arena().create<Constant>(std::string{ "win" }, SourceLocation{}),
 			},
 			ContextType::LOAD,
 			SourceLocation{}),
@@ -2050,8 +2045,8 @@ TEST(Parser, ImportFrom)
 			.name = "fibo",
 		},
 	};
-	auto import =
-		expected_ast->arena().create<ImportFrom>("sequence", std::move(names), 0, SourceLocation{});
+	auto import = expected_ast->arena().create<ast::ImportFrom>(
+		"sequence", std::move(names), 0, SourceLocation{});
 	expected_ast->emplace(import);
 
 	assert_generates_ast(program, expected_ast);
@@ -2065,7 +2060,7 @@ TEST(Parser, ImportFromDotted)
 	std::vector<alias> names{ alias{
 		.name = "fibo",
 	} };
-	auto import = expected_ast->arena().create<ImportFrom>(
+	auto import = expected_ast->arena().create<ast::ImportFrom>(
 		"internal.math.sequence", std::move(names), 0, SourceLocation{});
 	expected_ast->emplace(import);
 
@@ -2088,7 +2083,7 @@ TEST(Parser, ImportFromDottedMutiple)
 			.name = "factorial",
 		},
 	};
-	auto import = expected_ast->arena().create<ImportFrom>(
+	auto import = expected_ast->arena().create<ast::ImportFrom>(
 		"internal.math.sequence", std::move(names), 0, SourceLocation{});
 	expected_ast->emplace(import);
 
@@ -2111,7 +2106,7 @@ TEST(Parser, ImportFromDottedMutipleInParen)
 			.name = "factorial",
 		},
 	};
-	auto import = expected_ast->arena().create<ImportFrom>(
+	auto import = expected_ast->arena().create<ast::ImportFrom>(
 		"internal.math.sequence", std::move(names), 0, SourceLocation{});
 	expected_ast->emplace(import);
 
@@ -2128,7 +2123,7 @@ TEST(Parser, ImportFromParent)
 		.name = "fibonacci_cpu",
 		.asname = "fib",
 	} };
-	auto import = expected_ast->arena().create<ImportFrom>(
+	auto import = expected_ast->arena().create<ast::ImportFrom>(
 		"fibonacci.impl", std::move(names), 1, SourceLocation{});
 	expected_ast->emplace(import);
 
@@ -2145,7 +2140,7 @@ TEST(Parser, ImportFromParentLevel2)
 		.name = "fibonacci_cpu",
 		.asname = "fib",
 	} };
-	auto import = expected_ast->arena().create<ImportFrom>(
+	auto import = expected_ast->arena().create<ast::ImportFrom>(
 		"fibonacci.impl", std::move(names), 2, SourceLocation{});
 	expected_ast->emplace(import);
 
@@ -2162,7 +2157,7 @@ TEST(Parser, ImportFromParentLevel3)
 		.name = "fibonacci_cpu",
 		.asname = "fib",
 	} };
-	auto import = expected_ast->arena().create<ImportFrom>(
+	auto import = expected_ast->arena().create<ast::ImportFrom>(
 		"fibonacci.impl", std::move(names), 3, SourceLocation{});
 	expected_ast->emplace(import);
 
@@ -2179,7 +2174,7 @@ TEST(Parser, ImportFromParentLevel4)
 		.name = "fibonacci_cpu",
 		.asname = "fib",
 	} };
-	auto import = expected_ast->arena().create<ImportFrom>(
+	auto import = expected_ast->arena().create<ast::ImportFrom>(
 		"fibonacci.impl", std::move(names), 4, SourceLocation{});
 	expected_ast->emplace(import);
 
@@ -2974,8 +2969,7 @@ TEST(Parser, FunctionDefinitionWithDecoratorList)
 			SourceLocation{}),// args
 		std::vector<ASTNode *>{
 			expected_ast->arena().create<Return>(
-				expected_ast->arena().create<Constant>(
-					py::NameConstant{ py::NoneType{} }, SourceLocation{}),
+				expected_ast->arena().create<Constant>(std::monostate{}, SourceLocation{}),
 				SourceLocation{}),
 		},// body
 		std::vector<ASTNode *>{
@@ -3236,8 +3230,7 @@ TEST(Parser, FunctionDefinitionWithOnlyDefaultArguments)
 			std::vector<ASTNode *>{},
 			nullptr,
 			std::vector<ASTNode *>{
-				expected_ast->arena().create<Constant>(
-					NameConstant{ NoneType{} }, SourceLocation{}),
+				expected_ast->arena().create<Constant>(std::monostate{}, SourceLocation{}),
 			},
 			SourceLocation{}),// args
 		std::vector<ASTNode *>{
@@ -3495,7 +3488,7 @@ TEST(Parser, Bytes)
 	constexpr std::string_view program = "b\"hello\"\n";
 
 	auto expected_ast = create_test_module();
-	expected_ast->emplace(expected_ast->arena().create<Constant>(Bytes{ { std::byte{ 'h' },
+	expected_ast->emplace(expected_ast->arena().create<Constant>(ast::Bytes{ { std::byte{ 'h' },
 																	 std::byte{ 'e' },
 																	 std::byte{ 'l' },
 																	 std::byte{ 'l' },
@@ -3576,8 +3569,8 @@ TEST(Parser, YieldEmpty)
 	expected_ast->emplace(expected_ast->arena().create<FunctionDefinition>("gen",// function_name
 		expected_ast->arena().create<Arguments>(std::vector<Argument *>{}, SourceLocation{}),// args
 		std::vector<ASTNode *>{
-			expected_ast->arena().create<Yield>(expected_ast->arena().create<Constant>(
-													NameConstant{ NoneType{} }, SourceLocation{}),
+			expected_ast->arena().create<Yield>(
+				expected_ast->arena().create<Constant>(std::monostate{}, SourceLocation{}),
 				SourceLocation{}),
 		},// body
 		std::vector<ASTNode *>{},// decorator_list
@@ -3624,7 +3617,7 @@ TEST(Parser, YieldFrom)
 	expected_ast->emplace(expected_ast->arena().create<FunctionDefinition>("foo",// function_name
 		expected_ast->arena().create<Arguments>(std::vector<Argument *>{}, SourceLocation{}),// args
 		std::vector<ASTNode *>{
-			expected_ast->arena().create<YieldFrom>(
+			expected_ast->arena().create<ast::YieldFrom>(
 				expected_ast->arena().create<Name>("bar", ContextType::LOAD, SourceLocation{}),
 				SourceLocation{}),
 		},// body
diff --git a/src/repl/repl.cpp b/src/repl/repl.cpp
index 37852cdb..72e7910c 100644
--- a/src/repl/repl.cpp
+++ b/src/repl/repl.cpp
@@ -1,20 +1,19 @@
+#include "core.hpp"
+#include "executable/common.hpp"
+#include "linenoise.h"
 #include <cstdio>
 #include <cstdlib>
-
-#include "linenoise.h"
 #include <cxxopts.hpp>
+#include <spdlog/spdlog.h>
 
-#include <filesystem>
-#include <iostream>
-#include <optional>
-#include <string>
+import py.lexer;
+import py.runtime;
+import std;
 
-#include "executable/Program.hpp"
+#ifdef USE_LLVM
+// Names ast:: and Program, so it follows the import.
 #include "executable/llvm/LLVMGenerator.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "parser/Parser.hpp"
-#include "runtime/modules/Modules.hpp"
-#include "vm/VM.hpp"
+#endif
 
 using namespace py;
 
@@ -215,8 +214,8 @@ int main(int argc, char **argv)
 	// static constexpr std::string_view compiler = "Clang 11.0.0";
 	// static constexpr std::string_view platform = "Linux";
 
-	// std::cout << fmt::format("Python {}.{}.{}\n", major_version, minor_version, build_version);
-	// std::cout << fmt::format("[{}] :: {}\n", compiler, platform);
+	// std::cout << std::format("Python {}.{}.{}\n", major_version, minor_version, build_version);
+	// std::cout << std::format("[{}] :: {}\n", compiler, platform);
 	// std::cout << "Type \"help\", \"copyright\", \"credits\" or \"license\" for more
 	// information."; std::cout << std::endl;
 
diff --git a/src/runtime/AssertionError.cpp b/src/runtime/AssertionError.cpp
index 692474bf..89000911 100644
--- a/src/runtime/AssertionError.cpp
+++ b/src/runtime/AssertionError.cpp
@@ -1,10 +1,29 @@
-#include "AssertionError.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
+PyResult<AssertionError *> AssertionError::create(PyTuple *args)
+{
+	auto &heap = VirtualMachine::the().heap();
+	auto result = heap.allocate<AssertionError>(args);
+	if (!result) { return Err(memory_error(sizeof(AssertionError))); }
+	return Ok(result);
+}
+
+BaseException *make_assertion_error(std::string &&message)
+{
+	auto msg = PyString::create(std::move(message));
+	ASSERT(msg.is_ok());
+	auto args_tuple = PyTuple::create(msg.unwrap());
+	ASSERT(args_tuple.is_ok());
+	return AssertionError::create(args_tuple.unwrap()).unwrap();
+}
+
 AssertionError::AssertionError(PyType *type) : Exception(type->underlying_type(), nullptr) {}
 
 AssertionError::AssertionError(PyTuple *args)
diff --git a/src/runtime/AssertionError.cppm b/src/runtime/AssertionError.cppm
new file mode 100644
index 00000000..6a7e3173
--- /dev/null
+++ b/src/runtime/AssertionError.cppm
@@ -0,0 +1,53 @@
+module;
+#include "memory/allocate.hpp"
+
+export module py.runtime:assertion_error;
+import :exception;
+import :object;
+import py.memory;
+import std;
+
+export namespace py {
+struct Number;
+class PyTuple;
+class PyString;
+class PyDict;
+class BaseException;
+class PyType;
+
+class AssertionError : public Exception
+{
+	friend class ::Heap;
+	friend class py::detail::Allocator;
+	friend BaseException *make_assertion_error(std::string &&);
+
+  private:
+	AssertionError(PyType *t);
+
+	AssertionError(PyTuple *args);
+
+	static PyResult<AssertionError *> create(PyTuple *args);
+
+  public:
+	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
+
+	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
+
+	PyType *static_type() const override;
+
+	static PyType *this_type();
+
+	std::string to_string() const override;
+};
+
+// Defined in AssertionError.cpp. Keeping the PyString/PyTuple construction and the
+// heap allocation out of the interface means this partition no longer has
+// to materialise those types just to declare one exception class.
+BaseException *make_assertion_error(std::string &&message);
+
+template<typename... Args>
+inline BaseException *assertion_error(const std::string &message, Args &&...args)
+{
+	return make_assertion_error(std::vformat(message, std::make_format_args(args...)));
+}
+}// namespace py
diff --git a/src/runtime/AssertionError.hpp b/src/runtime/AssertionError.hpp
deleted file mode 100644
index 16cacae9..00000000
--- a/src/runtime/AssertionError.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-#pragma once
-
-#include "Exception.hpp"
-#include "MemoryError.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
-
-class AssertionError : public Exception
-{
-	friend class ::Heap;
-	template<typename... Args>
-	friend BaseException *assertion_error(const std::string &message, Args &&...args);
-
-  private:
-	AssertionError(PyType *t);
-
-	AssertionError(PyTuple *args);
-
-	static PyResult<AssertionError *> create(PyTuple *args)
-	{
-		auto &heap = VirtualMachine::the().heap();
-		auto result = heap.allocate<AssertionError>(args);
-		if (!result) { return Err(memory_error(sizeof(AssertionError))); }
-		return Ok(result);
-	}
-
-  public:
-	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
-
-	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-
-	PyType *static_type() const override;
-
-	static PyType *this_type();
-
-	std::string to_string() const override;
-};
-
-template<typename... Args>
-inline BaseException *assertion_error(const std::string &message, Args &&...args)
-{
-	auto *args_tuple =
-		PyTuple::create(PyString::create(fmt::format(message, std::forward<Args>(args)...)));
-	return AssertionError::create(args_tuple).unwrap();
-}
-}// namespace py
diff --git a/src/runtime/AttributeError.cpp b/src/runtime/AttributeError.cpp
index 30629924..54835b10 100644
--- a/src/runtime/AttributeError.cpp
+++ b/src/runtime/AttributeError.cpp
@@ -1,10 +1,27 @@
-#include "AttributeError.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
+AttributeError *AttributeError::create(PyTuple *args)
+{
+	auto &heap = VirtualMachine::the().heap();
+	return heap.allocate<AttributeError>(args);
+}
+
+BaseException *make_attribute_error(std::string &&message)
+{
+	auto msg = PyString::create(std::move(message));
+	ASSERT(msg.is_ok());
+	auto args_tuple = PyTuple::create(msg.unwrap());
+	ASSERT(args_tuple.is_ok());
+	return AttributeError::create(args_tuple.unwrap());
+}
+
 AttributeError::AttributeError(PyType *type) : Exception(type) {}
 
 AttributeError::AttributeError(PyTuple *args)
diff --git a/src/runtime/AttributeError.cppm b/src/runtime/AttributeError.cppm
new file mode 100644
index 00000000..c9533638
--- /dev/null
+++ b/src/runtime/AttributeError.cppm
@@ -0,0 +1,50 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+export module py.runtime:attribute_error;
+import :exception;
+import :object;
+import std;
+
+export namespace py {
+struct Number;
+class BaseException;
+// Same-module forward declarations: these bind to the definitions in :dict,
+// :tuple and :type, so this partition does not have to import them just to
+// name them in signatures.
+class PyType;
+class PyTuple;
+class PyDict;
+
+class AttributeError : public Exception
+{
+	friend class ::Heap;
+	friend class py::detail::Allocator;
+	friend BaseException *make_attribute_error(std::string &&);
+
+  private:
+	AttributeError(PyType *type);
+
+	AttributeError(PyTuple *args);
+
+	static AttributeError *create(PyTuple *args);
+
+  public:
+	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
+
+	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
+
+	PyType *static_type() const override;
+
+	static PyType *class_type();
+};
+
+BaseException *make_attribute_error(std::string &&message);
+
+template<typename... Args>
+inline BaseException *attribute_error(const std::string &message, Args &&...args)
+{
+	return make_attribute_error(std::vformat(message, std::make_format_args(args...)));
+}
+}// namespace py
diff --git a/src/runtime/AttributeError.hpp b/src/runtime/AttributeError.hpp
deleted file mode 100644
index db5b2e6d..00000000
--- a/src/runtime/AttributeError.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#pragma once
-
-#include "Exception.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
-class AttributeError : public Exception
-{
-	friend class ::Heap;
-	template<typename... Args>
-	friend BaseException *attribute_error(const std::string &message, Args &&...args);
-
-  private:
-	AttributeError(PyType *type);
-
-	AttributeError(PyTuple *args);
-
-	static AttributeError *create(PyTuple *args)
-	{
-		auto &heap = VirtualMachine::the().heap();
-		return heap.allocate<AttributeError>(args);
-	}
-
-  public:
-	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-
-	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
-
-	PyType *static_type() const override;
-
-	static PyType *class_type();
-};
-
-
-template<typename... Args>
-inline BaseException *attribute_error(const std::string &message, Args &&...args)
-{
-	auto msg = PyString::create(fmt::format(message, std::forward<Args>(args)...));
-	ASSERT(msg.is_ok());
-	auto args_tuple = PyTuple::create(msg.unwrap());
-	ASSERT(args_tuple.is_ok());
-	return AttributeError::create(args_tuple.unwrap());
-}
-}// namespace py
diff --git a/src/runtime/BaseException.cpp b/src/runtime/BaseException.cpp
index 9ad905aa..67b4baa8 100644
--- a/src/runtime/BaseException.cpp
+++ b/src/runtime/BaseException.cpp
@@ -1,17 +1,14 @@
-#include "BaseException.hpp"
-#include "MemoryError.hpp"
-#include "PyBool.hpp"
-#include "PyCode.hpp"
-#include "PyFrame.hpp"
-#include "PyNone.hpp"
-#include "PyString.hpp"
-#include "PyTraceback.hpp"
-#include "PyTuple.hpp"
-#include "PyType.hpp"
-#include "SourceManager.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+// SourceManager names no py:: types, so it belongs in the global module
+// fragment like any other ordinary header.
+#include "runtime/SourceManager.hpp"
+
+module py.runtime;
+import std;
+import py.types;
 
 namespace py {
 
@@ -60,7 +57,7 @@ PyResult<PyObject *> BaseException::__new__(const PyType *type, PyTuple *args, P
 	}
 }
 
-PyResult<int32_t> BaseException::__init__(PyTuple *args, PyDict *kwargs)
+PyResult<std::int32_t> BaseException::__init__(PyTuple *args, PyDict *kwargs)
 {
 	// takes no keyword arguments
 	ASSERT(!kwargs || kwargs->map().empty());
@@ -114,7 +111,7 @@ std::string BaseException::format_traceback() const
 	auto *tb = m_traceback;
 	while (tb) {
 		const auto &filename = tb->m_tb_frame->code()->m_filename;
-		out << fmt::format("  File \"{}\", line {}, in {}\n",
+		out << std::format("  File \"{}\", line {}, in {}\n",
 			filename,
 			tb->m_tb_lineno,
 			tb->m_tb_frame->code()->name());
@@ -133,7 +130,7 @@ PyResult<PyObject *> BaseException::__repr__() const
 	if (m_args && m_args->size() == 1) {
 		auto r = repr_value(m_args->elements()[0]);
 		if (r.is_err()) { return r; }
-		args_part = fmt::format("({})", r.unwrap()->to_string());
+		args_part = std::format("({})", r.unwrap()->to_string());
 	} else if (m_args) {
 		auto r = m_args->repr();
 		if (r.is_err()) { return r; }
@@ -141,7 +138,7 @@ PyResult<PyObject *> BaseException::__repr__() const
 	} else {
 		args_part = "()";
 	}
-	return PyString::create(fmt::format("{}{}", type()->name(), args_part));
+	return PyString::create(std::format("{}{}", type()->name(), args_part));
 }
 
 PyResult<PyObject *> BaseException::__str__() const { return PyString::create(to_string()); }
diff --git a/src/runtime/BaseException.hpp b/src/runtime/BaseException.cppm
similarity index 85%
rename from src/runtime/BaseException.hpp
rename to src/runtime/BaseException.cppm
index 5d8e7804..1b0ed0ad 100644
--- a/src/runtime/BaseException.hpp
+++ b/src/runtime/BaseException.cppm
@@ -1,12 +1,23 @@
-#pragma once
+module;
 
-#include "PyObject.hpp"
+#include "memory/allocate.hpp"
+
+export module py.runtime:baseexception;
+
+
+import :object;
+import std;
+import py.memory;
+
+export namespace py {
+class PyTraceback;
+class PyType;
 
-namespace py {
 
 class BaseException : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	template<typename T> friend struct klass;
 
 	friend BaseException *as<>(PyObject *obj);
@@ -34,7 +45,7 @@ class BaseException : public PyBaseObject
 	std::string what() const;
 
 	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs);
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs);
 	PyResult<PyObject *> __repr__() const;
 	PyResult<PyObject *> __str__() const;
 
diff --git a/src/runtime/CustomPyObject.cpp b/src/runtime/CustomPyObject.cpp
deleted file mode 100644
index eaadab7c..00000000
--- a/src/runtime/CustomPyObject.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#include "CustomPyObject.hpp"
-#include "PyBoundMethod.hpp"
-#include "PyDict.hpp"
-#include "PyFunction.hpp"
-#include "PyString.hpp"
-#include "PyType.hpp"
-#include "TypeError.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
-
-using namespace py;
-
-CustomPyObject::CustomPyObject(const PyType *type) : PyBaseObject(const_cast<PyType *>(type))
-{
-	m_attributes = PyDict::create().unwrap();
-}
-
-std::string CustomPyObject::to_string() const
-{
-	return fmt::format("CustomPyObject of type \"{}\"", type()->to_string());
-}
diff --git a/src/runtime/CustomPyObject.hpp b/src/runtime/CustomPyObject.hpp
deleted file mode 100644
index 407bd9e7..00000000
--- a/src/runtime/CustomPyObject.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-
-#include "PyObject.hpp"
-
-namespace py {
-class CustomPyObject : public PyBaseObject
-{
-  public:
-	CustomPyObject(const PyType *type);
-
-	std::string to_string() const override;
-};
-}// namespace py
\ No newline at end of file
diff --git a/src/runtime/Exception.cpp b/src/runtime/Exception.cpp
index 2528e565..dc29a172 100644
--- a/src/runtime/Exception.cpp
+++ b/src/runtime/Exception.cpp
@@ -1,10 +1,27 @@
-#include "Exception.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
+Exception *Exception::create(PyTuple *args)
+{
+	auto &heap = VirtualMachine::the().heap();
+	return heap.allocate<Exception>(args);
+}
+
+BaseException *make_exception(std::string &&message)
+{
+	auto msg = PyString::create(std::move(message));
+	ASSERT(msg.is_ok());
+	auto args_tuple = PyTuple::create(msg.unwrap());
+	ASSERT(args_tuple.is_ok());
+	return Exception::create(args_tuple.unwrap());
+}
+
 Exception::Exception(PyType *t) : BaseException(t->underlying_type(), nullptr) {}
 
 Exception::Exception(PyType *t, PyTuple *args) : BaseException(t, args) {}
diff --git a/src/runtime/Exception.cppm b/src/runtime/Exception.cppm
new file mode 100644
index 00000000..b9d788b4
--- /dev/null
+++ b/src/runtime/Exception.cppm
@@ -0,0 +1,49 @@
+module;
+#include "memory/allocate.hpp"
+
+export module py.runtime:exception;
+import :baseexception;
+import py.memory;
+
+export namespace py {
+class PyString;
+class PyType;
+class Exception : public BaseException
+{
+	friend class ::Heap;
+	friend class py::detail::Allocator;
+	friend BaseException *make_exception(std::string &&);
+
+  protected:
+	Exception(PyType *);
+
+	Exception(PyType *, PyTuple *args);
+	Exception(const TypePrototype &type, PyTuple *args);
+
+  private:
+	Exception(PyTuple *args);
+
+	static Exception *create(PyTuple *args);
+
+  public:
+	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
+
+	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
+
+	PyType *static_type() const override;
+
+	static PyType *class_type();
+};
+
+// Defined in Exception.cpp. Keeping the PyString/PyTuple construction and the
+// heap allocation out of the interface means this partition no longer has
+// to materialise those types just to declare one exception class.
+BaseException *make_exception(std::string &&message);
+
+template<typename... Args>
+inline BaseException *exception(const std::string &message, Args &&...args)
+{
+	return make_exception(std::vformat(message, std::make_format_args(args...)));
+}
+
+}// namespace py
diff --git a/src/runtime/Exception.hpp b/src/runtime/Exception.hpp
deleted file mode 100644
index b804c58c..00000000
--- a/src/runtime/Exception.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-#pragma once
-
-#include "BaseException.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
-class Exception : public BaseException
-{
-	friend class ::Heap;
-	template<typename... Args>
-	friend BaseException *exception(const std::string &message, Args &&...args);
-
-  protected:
-	Exception(PyType *);
-
-	Exception(PyType *, PyTuple *args);
-	Exception(const TypePrototype &type, PyTuple *args);
-
-  private:
-	Exception(PyTuple *args);
-
-	static Exception *create(PyTuple *args)
-	{
-		auto &heap = VirtualMachine::the().heap();
-		return heap.allocate<Exception>(args);
-	}
-
-  public:
-	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-
-	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
-
-	PyType *static_type() const override;
-
-	static PyType *class_type();
-};
-
-
-template<typename... Args>
-inline BaseException *exception(const std::string &message, Args &&...args)
-{
-	auto *args_tuple =
-		PyTuple::create(PyString::create(fmt::format(message, std::forward<Args>(args)...)));
-	return Exception::create(args_tuple);
-}
-
-}// namespace py
diff --git a/src/runtime/GeneratorInterface.cpp b/src/runtime/GeneratorInterface.cpp
index c1a14013..66c265a6 100644
--- a/src/runtime/GeneratorInterface.cpp
+++ b/src/runtime/GeneratorInterface.cpp
@@ -1,17 +1,8 @@
-#include "GeneratorInterface.hpp"
-#include "PyAsyncGenerator.hpp"
-#include "PyCode.hpp"
-#include "PyCoroutine.hpp"
-#include "PyFrame.hpp"
-#include "PyGenerator.hpp"
-#include "PyNone.hpp"
-#include "PyTraceback.hpp"
-#include "PyType.hpp"
-#include "RuntimeError.hpp"
-#include "StopIteration.hpp"
-#include "ValueError.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+
+module py.runtime;
+import :detail;
 
 namespace py {
 
@@ -29,10 +20,12 @@ GeneratorInterface<T>::GeneratorInterface(TypePrototype &type,
 	  m_is_running(is_running), m_code(code), m_name(name), m_qualname(qualname)
 {}
 
+template<typename T> GeneratorInterface<T>::~GeneratorInterface() = default;
+
 template<typename T> std::string GeneratorInterface<T>::to_string() const
 {
 	// FIXME: use qualname
-	return fmt::format("<{} object {} at {}>",
+	return std::format("<{} object {} at {}>",
 		T::GeneratorTypeName,
 		m_name->value(),
 		static_cast<const void *>(this));
@@ -78,12 +71,14 @@ template<typename T> PyResult<PyObject *> GeneratorInterface<T>::send(PyObject *
 	m_last_sent_value = nullptr;
 
 	if (m_invalid_return && result.is_ok()) {
-		spdlog::debug("generator returned value {}", result.unwrap()->to_string());
+		::detail::log_debug(
+			std::format("generator returned value {}", result.unwrap()->to_string()).c_str());
 	} else if (!m_invalid_return && result.is_err()
 			   && result.unwrap_err()->type()->issubclass(stop_iteration()->type())) {
 		result = Err(runtime_error("generator raised StopIteration"));
 	} else if (result.is_ok()) {
-		spdlog::debug("generator yielded {}", result.unwrap()->to_string());
+		::detail::log_debug(
+			std::format("generator yielded {}", result.unwrap()->to_string()).c_str());
 	}
 
 	if (result.is_err()) { m_frame = nullptr; }
diff --git a/src/runtime/GeneratorInterface.hpp b/src/runtime/GeneratorInterface.cppm
similarity index 86%
rename from src/runtime/GeneratorInterface.hpp
rename to src/runtime/GeneratorInterface.cppm
index 5516126f..d0e6de2a 100644
--- a/src/runtime/GeneratorInterface.hpp
+++ b/src/runtime/GeneratorInterface.cppm
@@ -1,9 +1,14 @@
-#pragma once
+export module py.runtime:detail;
 
-#include "PyFrame.hpp"
-#include "PyObject.hpp"
+import :object;
+import :frame;
+import std;
 
-namespace py {
+export struct StackFrame;
+
+export namespace py {
+class PyType;
+class PyFrame;
 
 template<typename GeneratorType> class GeneratorInterface : public PyBaseObject
 {
@@ -28,6 +33,8 @@ template<typename GeneratorType> class GeneratorInterface : public PyBaseObject
 		PyString *name,
 		PyString *qualname);
 
+	~GeneratorInterface();
+
   public:
 	void set_invalid_return(bool invalid_return) { m_invalid_return = invalid_return; }
 
diff --git a/src/runtime/Import.cpp b/src/runtime/Import.cpp
index 5390d824..30876f92 100644
--- a/src/runtime/Import.cpp
+++ b/src/runtime/Import.cpp
@@ -1,24 +1,20 @@
-#include "Import.hpp"
-#include "ImportError.hpp"
-#include "PyBool.hpp"
-#include "PyCode.hpp"
-#include "PyDict.hpp"
-#include "PyFrame.hpp"
-#include "PyModule.hpp"
-#include "PyNone.hpp"
-#include "PyType.hpp"
-#include "TypeError.hpp"
-#include "ValueError.hpp"
-#include "executable/bytecode/BytecodeProgram.hpp"
+module;
+#include "core.hpp"
+
+// <vector> must precede the frozen headers: they define std::vector<uint8_t>
+// objects at namespace scope. clang-format's include sorting will happily
+// reorder these and break the build.
+// clang-format off
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
 #include "frozen/importlib.h"
 #include "frozen/importlib_external.h"
-#include "interpreter/Interpreter.hpp"
-#include "modules/config.hpp"
-#include "runtime/KeyError.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/Value.hpp"
-#include "vm/VM.hpp"
+// clang-format on
+
+module py.runtime;
+import std;
 
 namespace py {
 
@@ -114,7 +110,7 @@ namespace {
 
 		if (name->to_string().empty()) { return PyString::create(base); }
 
-		auto abs_name_str = fmt::format("{}.{}", base->to_string(), name->to_string());
+		auto abs_name_str = std::format("{}.{}", base->to_string(), name->to_string());
 		auto abs_name = PyString::create(abs_name_str);
 
 		return abs_name;
@@ -336,7 +332,7 @@ PyResult<PyModule *> import_frozen_module(PyString *name)
 
 	if (result.is_err()) {
 		remove_module(name);
-		spdlog::error("{}", result.unwrap_err()->to_string());
+		::detail::log_error(std::format("{}", result.unwrap_err()->to_string()).c_str());
 		TODO();
 		return Err(import_error("TODO"));
 	}
@@ -374,4 +370,4 @@ PyResult<PyObject *> create_builtin(PyObject *spec)
 	return Ok(py_none());
 }
 
-}// namespace py
\ No newline at end of file
+}// namespace py
diff --git a/src/runtime/Import.hpp b/src/runtime/Import.cppm
similarity index 66%
rename from src/runtime/Import.hpp
rename to src/runtime/Import.cppm
index 46b108c1..256ad95f 100644
--- a/src/runtime/Import.hpp
+++ b/src/runtime/Import.cppm
@@ -1,15 +1,22 @@
-#pragma once
+module;
 
-#include "PyObject.hpp"
+#include "core.hpp"
+#include <cstdint>
 
-namespace py {
+export module py.runtime:import;
+import :pymodule;
+import std;
+
+export namespace py {
+class PyString;
+struct Number;
 
 struct FrozenModule
 	: NonCopyable
 	, NonMoveable
 {
 	std::string_view name;
-	const std::vector<uint8_t> &code;
+	const std::vector<std::uint8_t> &code;
 	const bool is_package;
 };
 
@@ -19,7 +26,7 @@ PyResult<PyObject *> import_module_level_object(PyString *name,
 	PyDict *globals,
 	PyObject *locals,
 	PyObject *fromlist,
-	uint32_t level);
+	std::uint32_t level);
 
 PyResult<PyModule *> import_frozen_module(PyString *name);
 
diff --git a/src/runtime/ImportError.cpp b/src/runtime/ImportError.cpp
index d671ece4..9dbcdd23 100644
--- a/src/runtime/ImportError.cpp
+++ b/src/runtime/ImportError.cpp
@@ -1,10 +1,28 @@
-#include "ImportError.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+#include <cstdint>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
+ImportError *ImportError::create(PyTuple *args)
+{
+	auto &heap = VirtualMachine::the().heap();
+	return heap.allocate<ImportError>(args);
+}
+
+BaseException *make_import_error(std::string &&message)
+{
+	auto msg = PyString::create(std::move(message));
+	ASSERT(msg.is_ok());
+	auto args_tuple = PyTuple::create(msg.unwrap());
+	ASSERT(args_tuple.is_ok());
+	return ImportError::create(args_tuple.unwrap());
+}
+
 ImportError::ImportError(PyType *type) : ImportError(type->underlying_type(), nullptr) {}
 
 ImportError::ImportError(PyType *type, PyTuple *args) : ImportError(type->underlying_type(), args)
diff --git a/src/runtime/ImportError.cppm b/src/runtime/ImportError.cppm
new file mode 100644
index 00000000..4d8a2e34
--- /dev/null
+++ b/src/runtime/ImportError.cppm
@@ -0,0 +1,64 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+export module py.runtime:import_error;
+import :exception;
+import :object;
+import py.memory;
+import std;
+
+export namespace py {
+struct Number;
+class PyTuple;
+class PyString;
+class PyDict;
+class BaseException;
+class PyType;
+
+class ImportError : public Exception
+{
+	friend class ::Heap;
+	friend class py::detail::Allocator;
+	friend BaseException *make_import_error(std::string &&);
+
+  public:
+	PyObject *m_name{ nullptr };
+
+  protected:
+	ImportError(PyType *);
+
+	ImportError(PyType *, PyTuple *args);
+
+	ImportError(TypePrototype &, PyTuple *args);
+
+  private:
+	ImportError(PyTuple *args);
+
+	static ImportError *create(PyTuple *args);
+
+  public:
+	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs);
+
+	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
+
+	static PyType *class_type();
+
+	PyType *static_type() const override;
+
+	void visit_graph(Visitor &) override;
+};
+
+// Defined in ImportError.cpp. Keeping the PyString/PyTuple construction and the
+// heap allocation out of the interface means this partition no longer has
+// to materialise those types just to declare one exception class.
+BaseException *make_import_error(std::string &&message);
+
+template<typename... Args>
+inline BaseException *import_error(const std::string &message, Args &&...args)
+{
+	return make_import_error(std::vformat(message, std::make_format_args(args...)));
+}
+
+}// namespace py
diff --git a/src/runtime/ImportError.hpp b/src/runtime/ImportError.hpp
deleted file mode 100644
index fd8e4724..00000000
--- a/src/runtime/ImportError.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#pragma once
-
-#include "Exception.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
-
-class ImportError : public Exception
-{
-	friend class ::Heap;
-	template<typename... Args>
-	friend BaseException *import_error(const std::string &message, Args &&...args);
-
-  public:
-	PyObject *m_name{ nullptr };
-
-  protected:
-	ImportError(PyType *);
-
-	ImportError(PyType *, PyTuple *args);
-
-	ImportError(TypePrototype &, PyTuple *args);
-
-  private:
-	ImportError(PyTuple *args);
-
-	static ImportError *create(PyTuple *args)
-	{
-		auto &heap = VirtualMachine::the().heap();
-		return heap.allocate<ImportError>(args);
-	}
-
-  public:
-	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs);
-
-	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
-
-	static PyType *class_type();
-
-	PyType *static_type() const override;
-
-	void visit_graph(Visitor &) override;
-};
-
-
-template<typename... Args>
-inline BaseException *import_error(const std::string &message, Args &&...args)
-{
-	auto msg = PyString::create(fmt::format(message, std::forward<Args>(args)...));
-	ASSERT(msg.is_ok());
-	auto args_tuple = PyTuple::create(msg.unwrap());
-	ASSERT(args_tuple.is_ok());
-	return ImportError::create(args_tuple.unwrap());
-}
-
-}// namespace py
diff --git a/src/runtime/IndexError.cpp b/src/runtime/IndexError.cpp
index 5ea8c264..6368d757 100644
--- a/src/runtime/IndexError.cpp
+++ b/src/runtime/IndexError.cpp
@@ -1,10 +1,27 @@
-#include "IndexError.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
+IndexError *IndexError::create(PyTuple *args)
+{
+	auto &heap = VirtualMachine::the().heap();
+	return heap.allocate<IndexError>(args);
+}
+
+BaseException *make_index_error(std::string &&message)
+{
+	auto msg = PyString::create(std::move(message));
+	ASSERT(msg.is_ok());
+	auto args_tuple = PyTuple::create(msg.unwrap());
+	ASSERT(args_tuple.is_ok());
+	return IndexError::create(args_tuple.unwrap());
+}
+
 IndexError::IndexError(PyType *type) : LookupError(type, nullptr) {}
 
 IndexError::IndexError(PyTuple *args) : LookupError(types::BuiltinTypes::the().index_error(), args)
diff --git a/src/runtime/IndexError.cppm b/src/runtime/IndexError.cppm
new file mode 100644
index 00000000..8301f054
--- /dev/null
+++ b/src/runtime/IndexError.cppm
@@ -0,0 +1,52 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+export module py.runtime:index_error;
+import :lookup_error;
+import :baseexception;
+import :dict;
+import :object;
+import :string;
+import :tuple;
+import :value;
+import py.memory;
+import std;
+
+export namespace py {
+class PyType;
+
+class IndexError : public LookupError
+{
+	friend class ::Heap;
+	friend class py::detail::Allocator;
+	friend BaseException *make_index_error(std::string &&);
+
+  private:
+	IndexError(PyType *type);
+
+	IndexError(PyTuple *msg);
+
+	static IndexError *create(PyTuple *args);
+
+  public:
+	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
+
+	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
+
+	PyType *static_type() const override;
+	static PyType *class_type();
+};
+
+// Defined in IndexError.cpp. Keeping the PyString/PyTuple construction and the
+// heap allocation out of the interface means this partition no longer has
+// to materialise those types just to declare one exception class.
+BaseException *make_index_error(std::string &&message);
+
+template<typename... Args>
+inline BaseException *index_error(const std::string &message, Args &&...args)
+{
+	return make_index_error(std::vformat(message, std::make_format_args(args...)));
+}
+
+}// namespace py
diff --git a/src/runtime/IndexError.hpp b/src/runtime/IndexError.hpp
deleted file mode 100644
index adc779dd..00000000
--- a/src/runtime/IndexError.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#pragma once
-
-#include "Exception.hpp"
-#include "LookupError.hpp"
-#include "PyNone.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
-
-class IndexError : public LookupError
-{
-	friend class ::Heap;
-	template<typename... Args>
-	friend BaseException *index_error(const std::string &message, Args &&...args);
-
-  private:
-	IndexError(PyType *type);
-
-	IndexError(PyTuple *msg);
-
-	static IndexError *create(PyTuple *args)
-	{
-		auto &heap = VirtualMachine::the().heap();
-		return heap.allocate<IndexError>(args);
-	}
-
-  public:
-	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
-
-	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-
-	PyType *static_type() const override;
-	static PyType *class_type();
-};
-
-template<typename... Args>
-inline BaseException *index_error(const std::string &message, Args &&...args)
-{
-	auto msg = PyString::create(fmt::format(message, std::forward<Args>(args)...));
-	ASSERT(msg.is_ok());
-	auto args_tuple = PyTuple::create(msg.unwrap());
-	ASSERT(args_tuple.is_ok());
-	return IndexError::create(args_tuple.unwrap());
-}
-
-}// namespace py
diff --git a/src/runtime/KeyError.cpp b/src/runtime/KeyError.cpp
index 91caeff4..8be25787 100644
--- a/src/runtime/KeyError.cpp
+++ b/src/runtime/KeyError.cpp
@@ -1,11 +1,22 @@
-#include "KeyError.hpp"
-#include "MemoryError.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
+BaseException *make_key_error(std::string &&message)
+{
+	auto msg = PyString::create(std::move(message));
+	ASSERT(msg.is_ok());
+	auto args_tuple = PyTuple::create(msg.unwrap());
+	ASSERT(args_tuple.is_ok());
+	return KeyError::create(args_tuple.unwrap()).unwrap();
+}
+
 template<> KeyError *as(PyObject *obj)
 {
 	ASSERT(types::key_error());
diff --git a/src/runtime/KeyError.cppm b/src/runtime/KeyError.cppm
new file mode 100644
index 00000000..15061375
--- /dev/null
+++ b/src/runtime/KeyError.cppm
@@ -0,0 +1,43 @@
+module;
+#include "memory/allocate.hpp"
+
+export module py.runtime:key_error;
+import :exception;
+import py.memory;
+
+export namespace py {
+class PyType;
+
+class KeyError : public Exception
+{
+	friend class ::Heap;
+	friend class py::detail::Allocator;
+	friend BaseException *make_key_error(std::string &&);
+
+  private:
+	KeyError(PyType *type);
+
+	KeyError(PyTuple *args);
+
+  public:
+	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
+	static PyResult<KeyError *> create(PyTuple *args);
+
+	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
+
+	PyType *static_type() const override;
+	static PyType *class_type();
+};
+
+// Defined in KeyError.cpp. Keeping the PyString/PyTuple construction and the
+// heap allocation out of the interface means this partition no longer has
+// to materialise those types just to declare one exception class.
+BaseException *make_key_error(std::string &&message);
+
+template<typename... Args>
+inline BaseException *key_error(const std::string &message, Args &&...args)
+{
+	return make_key_error(std::vformat(message, std::make_format_args(args...)));
+}
+
+}// namespace py
diff --git a/src/runtime/KeyError.hpp b/src/runtime/KeyError.hpp
deleted file mode 100644
index 0cae1e8b..00000000
--- a/src/runtime/KeyError.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-
-#include "Exception.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
-
-class KeyError : public Exception
-{
-	friend class ::Heap;
-	template<typename... Args>
-	friend BaseException *key_error(const std::string &message, Args &&...args);
-
-  private:
-	KeyError(PyType *type);
-
-	KeyError(PyTuple *args);
-
-  public:
-	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-	static PyResult<KeyError *> create(PyTuple *args);
-
-	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
-
-	PyType *static_type() const override;
-	static PyType *class_type();
-};
-
-template<typename... Args>
-inline BaseException *key_error(const std::string &message, Args &&...args)
-{
-	auto msg = PyString::create(fmt::format(message, std::forward<Args>(args)...));
-	ASSERT(msg.is_ok());
-	auto args_tuple = PyTuple::create(msg.unwrap());
-	ASSERT(args_tuple.is_ok());
-	return KeyError::create(args_tuple.unwrap()).unwrap();
-}
-
-}// namespace py
diff --git a/src/runtime/types/api.hpp b/src/runtime/Klass.cppm
similarity index 85%
rename from src/runtime/types/api.hpp
rename to src/runtime/Klass.cppm
index a93f6ef3..0b58b053 100644
--- a/src/runtime/types/api.hpp
+++ b/src/runtime/Klass.cppm
@@ -1,17 +1,38 @@
-#pragma once
+module;
 
-#include "builtin.hpp"
-#include "runtime/PyArgParser.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyModule.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/TypeError.hpp"
+#include "core.hpp"
 
-namespace py {
+export module py.runtime:klass;
+import :arg_parser;
+import :dict;
+import :type_error;
+import :integer;
+import :string;
+import :tuple;
+import :object;
+import :pymodule;
+import :none;
+import :type;
+import std;
 
-PyObject *py_none();
+namespace detail {
+// A local copy of utilities.hpp's trait: that header pulls spdlog (and with it
+// 262 libstdc++ headers), which cannot enter a module GMF.
+template<class T> struct member_pointer_helper : std::false_type
+{
+};
+template<class T, class U> struct member_pointer_helper<T U::*> : std::true_type
+{
+	using type = T;
+};
+}// namespace detail
+
+template<class T>
+struct member_pointer : detail::member_pointer_helper<typename std::remove_cv<T>::type>
+{
+};
+
+export namespace py {
 
 template<typename T> struct klass
 {
@@ -101,11 +122,12 @@ template<typename T> struct klass
 				} else if constexpr (std::numeric_limits<MemberType>::is_integer) {
 					if constexpr (std::numeric_limits<MemberType>::is_signed) {
 						return PyInteger::create(
-							static_cast<int64_t>(static_cast<T *>(self)->*member));
+							static_cast<std::int64_t>(static_cast<T *>(self)->*member));
 					} else {
-						const auto value = static_cast<uint64_t>(static_cast<T *>(self)->*member);
-						if (value > std::numeric_limits<int64_t>::max()) { TODO(); }
-						return PyInteger::create(static_cast<int64_t>(value));
+						const auto value =
+							static_cast<std::uint64_t>(static_cast<T *>(self)->*member);
+						if (value > std::numeric_limits<std::int64_t>::max()) { TODO(); }
+						return PyInteger::create(static_cast<std::int64_t>(value));
 					}
 				} else {
 					[]<bool flag = false>() { static_assert(flag, "unsupported member type"); }();
@@ -155,11 +177,12 @@ template<typename T> struct klass
 				} else if constexpr (std::numeric_limits<MemberType>::is_integer) {
 					if constexpr (std::numeric_limits<MemberType>::is_signed) {
 						return PyInteger::create(
-							static_cast<int64_t>(static_cast<T *>(self)->*member));
+							static_cast<std::int64_t>(static_cast<T *>(self)->*member));
 					} else {
-						const auto value = static_cast<uint64_t>(static_cast<T *>(self)->*member);
-						if (value > std::numeric_limits<int64_t>::max()) { TODO(); }
-						return PyInteger::create(static_cast<int64_t>(value));
+						const auto value =
+							static_cast<std::uint64_t>(static_cast<T *>(self)->*member);
+						if (value > std::numeric_limits<std::int64_t>::max()) { TODO(); }
+						return PyInteger::create(static_cast<std::int64_t>(value));
 					}
 				} else if constexpr (std::is_same_v<MemberType, std::string>) {
 					return PyString::create(static_cast<T *>(self)->*member);
@@ -181,7 +204,8 @@ template<typename T> struct klass
 			.name = std::string(name),
 			.method = [F, name](
 						  PyObject *self, PyTuple *args, PyDict *kwargs) -> PyResult<PyObject *> {
-				const size_t arg_count = (args ? args->size() : 0) + (kwargs ? kwargs->size() : 0);
+				const std::size_t arg_count =
+					(args ? args->size() : 0) + (kwargs ? kwargs->size() : 0);
 				if (arg_count) {
 					return Err(type_error("{}() takes no arguments ({} given)", name, arg_count));
 				}
@@ -208,8 +232,8 @@ template<typename T> struct klass
 				auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 					kwargs,
 					name_str,
-					std::integral_constant<size_t, 1>{},
-					std::integral_constant<size_t, 1>{});
+					std::integral_constant<std::size_t, 1>{},
+					std::integral_constant<std::size_t, 1>{});
 				if (result.is_err()) return Err(result.unwrap_err());
 				return (static_cast<T *>(self)->*F)(std::get<0>(result.unwrap()));
 			},
@@ -297,7 +321,8 @@ template<typename T> struct klass
 		//        ownership
 		[[maybe_unused]] auto scope = VirtualMachine::the().heap().scoped_gc_pause();
 		auto *type_ = PyType::initialize(std::move(type));
-		spdlog::trace("Added type@{} with name {}", (void *)type_, type_->name());
+		::detail::log_trace(
+			std::format("Added type@{} with name {}", (void *)type_, type_->name()).c_str());
 		auto name = PyString::create(type_->name());
 		if (name.is_err()) { TODO(); }
 		m_module->add_symbol(name.unwrap(), type_);
diff --git a/src/runtime/Lock.hpp b/src/runtime/Lock.hpp
deleted file mode 100644
index cdc8fcfa..00000000
--- a/src/runtime/Lock.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "PyObject.hpp"
-
-
-class Lock : public PyBaseObject
-{
-};
\ No newline at end of file
diff --git a/src/runtime/LookupError.cpp b/src/runtime/LookupError.cpp
index 8d4131f7..1f090081 100644
--- a/src/runtime/LookupError.cpp
+++ b/src/runtime/LookupError.cpp
@@ -1,10 +1,27 @@
-#include "LookupError.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
+LookupError *LookupError::create(PyTuple *args)
+{
+	auto &heap = VirtualMachine::the().heap();
+	return heap.allocate<LookupError>(args);
+}
+
+BaseException *make_lookup_error(std::string &&message)
+{
+	auto msg = PyString::create(std::move(message));
+	ASSERT(msg.is_ok());
+	auto args_tuple = PyTuple::create(msg.unwrap());
+	ASSERT(args_tuple.is_ok());
+	return LookupError::create(args_tuple.unwrap());
+}
+
 LookupError::LookupError(PyType *type) : Exception(type->underlying_type(), nullptr) {}
 
 LookupError::LookupError(PyType *type, PyTuple *args) : Exception(type->underlying_type(), args) {}
diff --git a/src/runtime/LookupError.cppm b/src/runtime/LookupError.cppm
new file mode 100644
index 00000000..ed88a44e
--- /dev/null
+++ b/src/runtime/LookupError.cppm
@@ -0,0 +1,57 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+export module py.runtime:lookup_error;
+import :exception;
+import :object;
+import py.memory;
+import std;
+
+export namespace py {
+struct Number;
+class PyTuple;
+class PyString;
+class PyDict;
+class BaseException;
+class PyType;
+
+class LookupError : public Exception
+{
+	friend class ::Heap;
+	friend class py::detail::Allocator;
+	friend BaseException *make_lookup_error(std::string &&);
+
+  protected:
+	LookupError(PyType *);
+
+	LookupError(PyType *, PyTuple *msg);
+
+	LookupError(TypePrototype &, PyTuple *msg);
+
+  private:
+	LookupError(PyTuple *msg);
+
+	static LookupError *create(PyTuple *args);
+
+  public:
+	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
+
+	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
+
+	PyType *static_type() const override;
+	static PyType *class_type();
+};
+
+// Defined in LookupError.cpp. Keeping the PyString/PyTuple construction and the
+// heap allocation out of the interface means this partition no longer has
+// to materialise those types just to declare one exception class.
+BaseException *make_lookup_error(std::string &&message);
+
+template<typename... Args>
+inline BaseException *lookup_error(const std::string &message, Args &&...args)
+{
+	return make_lookup_error(std::vformat(message, std::make_format_args(args...)));
+}
+
+}// namespace py
diff --git a/src/runtime/LookupError.hpp b/src/runtime/LookupError.hpp
deleted file mode 100644
index 961f2bcc..00000000
--- a/src/runtime/LookupError.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-#pragma once
-
-#include "Exception.hpp"
-#include "PyNone.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
-
-class LookupError : public Exception
-{
-	friend class ::Heap;
-	template<typename... Args>
-	friend BaseException *lookup_error(const std::string &message, Args &&...args);
-
-  protected:
-	LookupError(PyType *);
-
-	LookupError(PyType *, PyTuple *msg);
-
-	LookupError(TypePrototype &, PyTuple *msg);
-
-  private:
-	LookupError(PyTuple *msg);
-
-	static LookupError *create(PyTuple *args)
-	{
-		auto &heap = VirtualMachine::the().heap();
-		return heap.allocate<LookupError>(args);
-	}
-
-  public:
-	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
-
-	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-
-	PyType *static_type() const override;
-	static PyType *class_type();
-};
-
-template<typename... Args>
-inline BaseException *lookup_error(const std::string &message, Args &&...args)
-{
-	auto msg = PyString::create(fmt::format(message, std::forward<Args>(args)...));
-	ASSERT(msg.is_ok());
-	auto args_tuple = PyTuple::create(msg.unwrap());
-	ASSERT(args_tuple.is_ok());
-	return LookupError::create(args_tuple.unwrap());
-}
-
-}// namespace py
diff --git a/src/runtime/MemoryError.cpp b/src/runtime/MemoryError.cpp
index 6dcc1fc9..3ae3a894 100644
--- a/src/runtime/MemoryError.cpp
+++ b/src/runtime/MemoryError.cpp
@@ -1,10 +1,35 @@
-#include "MemoryError.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
+PyResult<MemoryError *> MemoryError::create(PyTuple *args)
+{
+	auto &heap = VirtualMachine::the().heap();
+	auto result = heap.allocate<MemoryError>(args);
+	if (!result) {
+		// TODO: if this exception fails to allocated we need to find a solution to signal it.
+		//       could force a GC run and try again?
+		TODO();
+	}
+	return Ok(result);
+}
+
+BaseException *memory_error(std::size_t failed_allocation_size)
+{
+	// if the allocation of the exception parameters fail, we bail (for now at least)
+	auto msg = PyString::create(
+		std::format("memory allocation failed, allocating {} bytes", failed_allocation_size));
+	if (msg.is_err()) { TODO(); }
+	auto args_tuple = PyTuple::create(msg.unwrap());
+	if (args_tuple.is_err()) { TODO(); }
+	return MemoryError::create(args_tuple.unwrap()).unwrap();
+}
+
 template<> MemoryError *as(PyObject *obj)
 {
 	ASSERT(types::memory_error());
diff --git a/src/runtime/MemoryError.cppm b/src/runtime/MemoryError.cppm
new file mode 100644
index 00000000..da2e2a9a
--- /dev/null
+++ b/src/runtime/MemoryError.cppm
@@ -0,0 +1,51 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+export module py.runtime:memory_error;
+import :exception;
+import :object;
+import py.memory;
+import std;
+
+export namespace py {
+struct Number;
+class PyTuple;
+class PyString;
+class PyDict;
+class BaseException;
+class PyType;
+
+class MemoryError : public Exception
+{
+	friend class ::Heap;
+	friend class py::detail::Allocator;
+	friend BaseException *memory_error(std::size_t failed_allocation_size);
+
+  private:
+	MemoryError(PyType *type);
+
+	MemoryError(PyTuple *args);
+
+	static PyResult<MemoryError *> create(PyTuple *args);
+
+  public:
+	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
+
+	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
+
+	PyType *static_type() const override;
+
+	static PyType *this_type();
+
+	std::string to_string() const override;
+};
+
+template<> MemoryError *as(PyObject *obj);
+template<> const MemoryError *as(const PyObject *obj);
+
+// Defined in MemoryError.cpp: keeping the PyString/PyTuple construction out
+// of the interface means this partition no longer materialises those types.
+BaseException *memory_error(std::size_t failed_allocation_size);
+
+}// namespace py
diff --git a/src/runtime/MemoryError.hpp b/src/runtime/MemoryError.hpp
deleted file mode 100644
index 29882369..00000000
--- a/src/runtime/MemoryError.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#pragma once
-
-#include "Exception.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
-
-class MemoryError : public Exception
-{
-	friend class ::Heap;
-	friend BaseException *memory_error(size_t failed_allocation_size);
-
-  private:
-	MemoryError(PyType *type);
-
-	MemoryError(PyTuple *args);
-
-	static PyResult<MemoryError *> create(PyTuple *args)
-	{
-		auto &heap = VirtualMachine::the().heap();
-		auto result = heap.allocate<MemoryError>(args);
-		if (!result) {
-			// TODO: if this exception fails to allocated we need to find a solution to signal it.
-			//       could force a GC run and try again?
-			TODO();
-		}
-		return Ok(result);
-	}
-
-  public:
-	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
-
-	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-
-	PyType *static_type() const override;
-
-	static PyType *this_type();
-
-	std::string to_string() const override;
-};
-
-template<> MemoryError *as(PyObject *obj);
-template<> const MemoryError *as(const PyObject *obj);
-
-inline BaseException *memory_error(size_t failed_allocation_size)
-{
-	// if the allocation of the exception parameters fail, we bail (for now at least)
-	auto msg = PyString::create(
-		fmt::format("memory allocation failed, allocating {} bytes", failed_allocation_size));
-	if (msg.is_err()) { TODO(); }
-	auto args_tuple = PyTuple::create(msg.unwrap());
-	if (args_tuple.is_err()) { TODO(); }
-	return MemoryError::create(args_tuple.unwrap()).unwrap();
-}
-
-}// namespace py
diff --git a/src/runtime/ModuleNotFoundError.cpp b/src/runtime/ModuleNotFoundError.cpp
index 459cc5b4..e713fa67 100644
--- a/src/runtime/ModuleNotFoundError.cpp
+++ b/src/runtime/ModuleNotFoundError.cpp
@@ -1,10 +1,28 @@
-#include "ModuleNotFoundError.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+#include <cstdint>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
+ModuleNotFoundError *ModuleNotFoundError::create(PyTuple *args, PyObject *name, PyObject *path)
+{
+	auto &heap = VirtualMachine::the().heap();
+	return heap.allocate<ModuleNotFoundError>(args, name, path);
+}
+
+BaseException *make_module_not_found_error(std::string &&message)
+{
+	auto msg = PyString::create(std::move(message));
+	ASSERT(msg.is_ok());
+	auto args_tuple = PyTuple::create(msg.unwrap());
+	ASSERT(args_tuple.is_ok());
+	return ModuleNotFoundError::create(args_tuple.unwrap(), py_none(), py_none());
+}
+
 ModuleNotFoundError::ModuleNotFoundError(PyType *type) : ImportError(type, nullptr) {}
 
 ModuleNotFoundError::ModuleNotFoundError(PyTuple *args, PyObject *name, PyObject *path)
diff --git a/src/runtime/ModuleNotFoundError.cppm b/src/runtime/ModuleNotFoundError.cppm
new file mode 100644
index 00000000..7d285d0b
--- /dev/null
+++ b/src/runtime/ModuleNotFoundError.cppm
@@ -0,0 +1,56 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+export module py.runtime:module_not_found_error;
+import :import_error;
+import :object;
+import py.memory;
+import std;
+
+export namespace py {
+struct Number;
+class PyTuple;
+class PyString;
+class PyDict;
+class BaseException;
+class PyNone;
+class PyType;
+
+class ModuleNotFoundError : public ImportError
+{
+	friend class ::Heap;
+	friend class py::detail::Allocator;
+	friend BaseException *make_module_not_found_error(std::string &&);
+
+	PyObject *m_name{ nullptr };
+	PyObject *m_path{ nullptr };
+
+  private:
+	ModuleNotFoundError(PyTuple *msg, PyObject *name, PyObject *path);
+
+	ModuleNotFoundError(PyType *type);
+
+	static ModuleNotFoundError *create(PyTuple *args, PyObject *name, PyObject *path);
+
+  public:
+	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
+
+	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs);
+
+	PyType *static_type() const override;
+};
+
+// Defined in ModuleNotFoundError.cpp. Keeping the PyString/PyTuple construction and the
+// heap allocation out of the interface means this partition no longer has
+// to materialise those types just to declare one exception class.
+BaseException *make_module_not_found_error(std::string &&message);
+
+template<typename... Args>
+inline BaseException *module_not_found_error(const std::string &message, Args &&...args)
+{
+	return make_module_not_found_error(std::vformat(message, std::make_format_args(args...)));
+}
+
+}// namespace py
diff --git a/src/runtime/ModuleNotFoundError.hpp b/src/runtime/ModuleNotFoundError.hpp
deleted file mode 100644
index 8e486ad3..00000000
--- a/src/runtime/ModuleNotFoundError.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#pragma once
-
-#include "Exception.hpp"
-#include "ImportError.hpp"
-#include "PyNone.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
-
-class ModuleNotFoundError : public ImportError
-{
-	friend class ::Heap;
-	template<typename... Args>
-	friend BaseException *module_not_found_error(const std::string &message, Args &&...args);
-
-	PyObject *m_name{ nullptr };
-	PyObject *m_path{ nullptr };
-
-  private:
-	ModuleNotFoundError(PyTuple *msg, PyObject *name, PyObject *path);
-
-	ModuleNotFoundError(PyType *type);
-
-	static ModuleNotFoundError *create(PyTuple *args, PyObject *name, PyObject *path)
-	{
-		auto &heap = VirtualMachine::the().heap();
-		return heap.allocate<ModuleNotFoundError>(args, name, path);
-	}
-
-  public:
-	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
-
-	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs);
-
-	PyType *static_type() const override;
-};
-
-template<typename... Args>
-inline BaseException *module_not_found_error(const std::string &message, Args &&...args)
-{
-	auto msg = PyString::create(fmt::format(message, std::forward<Args>(args)...));
-	ASSERT(msg.is_ok());
-	auto args_tuple = PyTuple::create(msg.unwrap());
-	ASSERT(args_tuple.is_ok());
-	return ModuleNotFoundError::create(args_tuple.unwrap(), py_none(), py_none());
-}
-
-}// namespace py
diff --git a/src/runtime/NameError.cpp b/src/runtime/NameError.cpp
index 15a7d507..c999ed4f 100644
--- a/src/runtime/NameError.cpp
+++ b/src/runtime/NameError.cpp
@@ -1,12 +1,27 @@
-#include "NameError.hpp"
-#include "MemoryError.hpp"
-#include "PyDict.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
+NameError *NameError::create(PyTuple *args)
+{
+	auto &heap = VirtualMachine::the().heap();
+	return heap.allocate<NameError>(args);
+}
+
+BaseException *make_name_error(std::string &&message)
+{
+	auto msg = PyString::create(std::move(message));
+	ASSERT(msg.is_ok());
+	auto args_tuple = PyTuple::create(msg.unwrap());
+	ASSERT(args_tuple.is_ok());
+	return NameError::create(args_tuple.unwrap());
+}
+
 NameError::NameError(PyType *type) : Exception(type) {}
 
 NameError::NameError(PyTuple *args) : Exception(types::BuiltinTypes::the().name_error(), args) {}
diff --git a/src/runtime/NameError.cppm b/src/runtime/NameError.cppm
new file mode 100644
index 00000000..754d41e3
--- /dev/null
+++ b/src/runtime/NameError.cppm
@@ -0,0 +1,44 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+export module py.runtime:name_error;
+import :exception;
+import py.memory;
+
+export namespace py {
+class PyType;
+
+class NameError : public Exception
+{
+	friend class ::Heap;
+	friend class py::detail::Allocator;
+	friend BaseException *make_name_error(std::string &&);
+
+  private:
+	NameError(PyType *type);
+
+	NameError(PyTuple *args);
+
+	static NameError *create(PyTuple *args);
+
+  public:
+	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
+
+	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
+
+	PyType *static_type() const override;
+};
+
+// Defined in NameError.cpp. Keeping the PyString/PyTuple construction and the
+// heap allocation out of the interface means this partition no longer has
+// to materialise those types just to declare one exception class.
+BaseException *make_name_error(std::string &&message);
+
+template<typename... Args>
+inline BaseException *name_error(const std::string &message, Args &&...args)
+{
+	return make_name_error(std::vformat(message, std::make_format_args(args...)));
+}
+
+}// namespace py
diff --git a/src/runtime/NameError.hpp b/src/runtime/NameError.hpp
deleted file mode 100644
index ca0ea31b..00000000
--- a/src/runtime/NameError.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#pragma once
-
-#include "Exception.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
-
-class NameError : public Exception
-{
-	friend class ::Heap;
-	template<typename... Args>
-	friend BaseException *name_error(const std::string &message, Args &&...args);
-
-  private:
-	NameError(PyType *type);
-
-	NameError(PyTuple *args);
-
-	static NameError *create(PyTuple *args)
-	{
-		auto &heap = VirtualMachine::the().heap();
-		return heap.allocate<NameError>(args);
-	}
-
-  public:
-	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-
-	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
-
-	PyType *static_type() const override;
-};
-
-
-template<typename... Args>
-inline BaseException *name_error(const std::string &message, Args &&...args)
-{
-	auto msg = PyString::create(fmt::format(message, std::forward<Args>(args)...));
-	ASSERT(msg.is_ok());
-	auto args_tuple = PyTuple::create(msg.unwrap());
-	ASSERT(args_tuple.is_ok());
-	return NameError::create(args_tuple.unwrap());
-}
-
-}// namespace py
diff --git a/src/runtime/NotImplemented.cpp b/src/runtime/NotImplemented.cpp
index 6ed64cdf..5c315690 100644
--- a/src/runtime/NotImplemented.cpp
+++ b/src/runtime/NotImplemented.cpp
@@ -1,7 +1,9 @@
-#include "NotImplemented.hpp"
-#include "MemoryError.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
diff --git a/src/runtime/NotImplemented.hpp b/src/runtime/NotImplemented.cppm
similarity index 68%
rename from src/runtime/NotImplemented.hpp
rename to src/runtime/NotImplemented.cppm
index 3a86299f..246c2701 100644
--- a/src/runtime/NotImplemented.hpp
+++ b/src/runtime/NotImplemented.cppm
@@ -1,12 +1,19 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
+export module py.runtime:not_implemented;
+import :object;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+struct Number;
+class PyType;
 
 class NotImplemented : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	friend NotImplemented *not_implemented();
 
 	NotImplemented();
diff --git a/src/runtime/NotImplementedError.cpp b/src/runtime/NotImplementedError.cpp
index c351f326..66d423f2 100644
--- a/src/runtime/NotImplementedError.cpp
+++ b/src/runtime/NotImplementedError.cpp
@@ -1,10 +1,27 @@
-#include "NotImplementedError.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
+NotImplementedError *NotImplementedError::create(PyTuple *args)
+{
+	auto &heap = VirtualMachine::the().heap();
+	return heap.allocate<NotImplementedError>(args);
+}
+
+BaseException *make_not_implemented_error(std::string &&message)
+{
+	auto msg = PyString::create(std::move(message));
+	ASSERT(msg.is_ok());
+	auto args_tuple = PyTuple::create(msg.unwrap());
+	ASSERT(args_tuple.is_ok());
+	return NotImplementedError::create(args_tuple.unwrap());
+}
+
 NotImplementedError::NotImplementedError(PyType *type) : Exception(type) {}
 
 NotImplementedError::NotImplementedError(PyTuple *args)
diff --git a/src/runtime/NotImplementedError.cppm b/src/runtime/NotImplementedError.cppm
new file mode 100644
index 00000000..e25f2100
--- /dev/null
+++ b/src/runtime/NotImplementedError.cppm
@@ -0,0 +1,51 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+export module py.runtime:not_implemented_error;
+import :exception;
+import :object;
+import py.memory;
+import std;
+
+export namespace py {
+struct Number;
+class PyTuple;
+class PyString;
+class PyDict;
+class BaseException;
+class PyType;
+
+class NotImplementedError : public Exception
+{
+	friend class ::Heap;
+	friend class py::detail::Allocator;
+	friend BaseException *make_not_implemented_error(std::string &&);
+
+  private:
+	NotImplementedError(PyType *);
+
+	NotImplementedError(PyTuple *args);
+
+	static NotImplementedError *create(PyTuple *args);
+
+  public:
+	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
+
+	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
+
+	PyType *static_type() const override;
+};
+
+// Defined in NotImplementedError.cpp. Keeping the PyString/PyTuple construction and the
+// heap allocation out of the interface means this partition no longer has
+// to materialise those types just to declare one exception class.
+BaseException *make_not_implemented_error(std::string &&message);
+
+template<typename... Args>
+inline BaseException *not_implemented_error(const std::string &message, Args &&...args)
+{
+	return make_not_implemented_error(std::vformat(message, std::make_format_args(args...)));
+}
+
+}// namespace py
diff --git a/src/runtime/NotImplementedError.hpp b/src/runtime/NotImplementedError.hpp
deleted file mode 100644
index e8cc0746..00000000
--- a/src/runtime/NotImplementedError.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#pragma once
-
-#include "Exception.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
-
-class NotImplementedError : public Exception
-{
-	friend class ::Heap;
-	template<typename... Args>
-	friend BaseException *not_implemented_error(const std::string &message, Args &&...args);
-
-  private:
-	NotImplementedError(PyType *);
-
-	NotImplementedError(PyTuple *args);
-
-	static NotImplementedError *create(PyTuple *args)
-	{
-		auto &heap = VirtualMachine::the().heap();
-		return heap.allocate<NotImplementedError>(args);
-	}
-
-  public:
-	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-
-	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
-
-	PyType *static_type() const override;
-};
-
-
-template<typename... Args>
-inline BaseException *not_implemented_error(const std::string &message, Args &&...args)
-{
-	auto msg = PyString::create(fmt::format(message, std::forward<Args>(args)...));
-	ASSERT(msg.is_ok());
-	auto args_tuple = PyTuple::create(msg.unwrap());
-	ASSERT(args_tuple.is_ok());
-	return NotImplementedError::create(args_tuple.unwrap());
-}
-
-}// namespace py
diff --git a/src/runtime/OSError.cpp b/src/runtime/OSError.cpp
index 2bf1ce73..c67f8519 100644
--- a/src/runtime/OSError.cpp
+++ b/src/runtime/OSError.cpp
@@ -1,12 +1,22 @@
-#include "OSError.hpp"
-#include "MemoryError.hpp"
-#include "PyString.hpp"
-#include "runtime/PyType.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
+BaseException *make_os_error(std::string &&message)
+{
+	auto msg = PyString::create(std::move(message));
+	ASSERT(msg.is_ok());
+	auto args_tuple = PyTuple::create(msg.unwrap());
+	ASSERT(args_tuple.is_ok());
+	return OSError::create(args_tuple.unwrap()).unwrap();
+}
+
 template<> OSError *as(PyObject *obj)
 {
 	ASSERT(types::os_error());
diff --git a/src/runtime/OSError.cppm b/src/runtime/OSError.cppm
new file mode 100644
index 00000000..44f16422
--- /dev/null
+++ b/src/runtime/OSError.cppm
@@ -0,0 +1,54 @@
+module;
+#include "memory/allocate.hpp"
+
+export module py.runtime:o_s_error;
+import :exception;
+import :object;
+import py.memory;
+import std;
+
+export namespace py {
+struct Number;
+class PyTuple;
+class PyString;
+class PyDict;
+class BaseException;
+class PyType;
+
+class OSError : public Exception
+{
+	friend class ::Heap;
+	friend class py::detail::Allocator;
+	friend BaseException *make_os_error(std::string &&);
+
+  private:
+	OSError(PyTuple *args);
+
+  protected:
+	OSError(PyType *);
+	OSError(PyType *, PyTuple *args);
+
+  public:
+	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
+	static PyResult<OSError *> create(PyTuple *args);
+	static PyResult<OSError *> create(PyType *, PyTuple *args);
+
+	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
+
+	PyType *static_type() const override;
+
+	static PyType *class_type();
+};
+
+// Defined in OSError.cpp. Keeping the PyString/PyTuple construction and the
+// heap allocation out of the interface means this partition no longer has
+// to materialise those types just to declare one exception class.
+BaseException *make_os_error(std::string &&message);
+
+template<typename... Args>
+inline BaseException *os_error(const std::string &message, Args &&...args)
+{
+	return make_os_error(std::vformat(message, std::make_format_args(args...)));
+}
+
+}// namespace py
diff --git a/src/runtime/OSError.hpp b/src/runtime/OSError.hpp
deleted file mode 100644
index d8f87faa..00000000
--- a/src/runtime/OSError.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#pragma once
-
-#include "Exception.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
-
-class OSError : public Exception
-{
-	friend class ::Heap;
-	template<typename... Args>
-	friend BaseException *os_error(const std::string &message, Args &&...args);
-
-  private:
-	OSError(PyTuple *args);
-
-  protected:
-	OSError(PyType *);
-	OSError(PyType *, PyTuple *args);
-
-  public:
-	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-	static PyResult<OSError *> create(PyTuple *args);
-	static PyResult<OSError *> create(PyType *, PyTuple *args);
-
-	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
-
-	PyType *static_type() const override;
-
-	static PyType *class_type();
-};
-
-template<typename... Args>
-inline BaseException *os_error(const std::string &message, Args &&...args)
-{
-	auto msg = PyString::create(fmt::format(message, std::forward<Args>(args)...));
-	ASSERT(msg.is_ok());
-	auto args_tuple = PyTuple::create(msg.unwrap());
-	ASSERT(args_tuple.is_ok());
-	return OSError::create(args_tuple.unwrap()).unwrap();
-}
-
-}// namespace py
diff --git a/src/runtime/PyArgParser.hpp b/src/runtime/PyArgParser.cppm
similarity index 72%
rename from src/runtime/PyArgParser.hpp
rename to src/runtime/PyArgParser.cppm
index 4079aef0..310f1487 100644
--- a/src/runtime/PyArgParser.hpp
+++ b/src/runtime/PyArgParser.cppm
@@ -1,29 +1,58 @@
-#pragma once
+module;
+#include "core.hpp"
 
-#include "PyDict.hpp"
-#include "PyInteger.hpp"
-#include "PyNone.hpp"
-#include "PyTuple.hpp"
-#include "PyType.hpp"
-#include "TypeError.hpp"
-#include "vm/VM.hpp"
+export module py.runtime:arg_parser;
+import :type;
+import :type_error;
+import :vm;
+import :dict;
+import :integer;
+import :object;
+import :tuple;
+import :value;
+import py.memory;
+import std;
 
-#include <limits>
+// Moved from utilities.hpp, which pulls spdlog and so cannot enter a GMF.
+template<typename T>
+concept Integral = std::is_integral_v<T>;
 
-namespace py {
+export template<Integral Target, Integral Source> bool fits_in(Source value)
+{
+	constexpr bool source_is_signed = std::is_signed<Source>::value;
+	constexpr bool target_is_signed = std::is_signed<Target>::value;
+
+	// Case 1: Source is signed, Target is unsigned
+	if constexpr (source_is_signed && !target_is_signed) {
+		if (value < 0) { return false; }
+		// Now we know value is non-negative, safe to cast and compare
+		return static_cast<std::make_unsigned_t<Source>>(value)
+			   <= std::numeric_limits<Target>::max();
+	}
+	// Case 2: Source is unsigned, Target is signed
+	else if constexpr (!source_is_signed && target_is_signed) {
+		return value
+			   <= static_cast<std::make_unsigned_t<Target>>(std::numeric_limits<Target>::max());
+	} else {
+		// Case 3: Both signed or both unsigned
+		return value >= std::numeric_limits<Target>::min()
+			   && value <= std::numeric_limits<Target>::max();
+	}
+}
+export namespace py {
 
 template<typename... ArgTypes> struct PyArgsParser
 {
   private:
-	template<size_t Idx,
-		size_t MinSize,
-		size_t MaxSize,
+	template<std::size_t Idx,
+		std::size_t MinSize,
+		std::size_t MaxSize,
 		typename ResultType,
 		typename... DefaultArgs>
 	static constexpr PyResult<std::monostate> unpack_tuple_helper(const std::vector<Value> &args,
 		std::string_view function_name,
-		std::integral_constant<size_t, MinSize> min_size,
-		std::integral_constant<size_t, MaxSize> max_size,
+		std::integral_constant<std::size_t, MinSize> min_size,
+		std::integral_constant<std::size_t, MaxSize> max_size,
 		ResultType &result,
 		DefaultArgs &&...default_args)
 	{
@@ -95,12 +124,12 @@ template<typename... ArgTypes> struct PyArgsParser
 	}
 
   public:
-	template<size_t MinSize, size_t MaxSize, typename... DefaultArgs>
+	template<std::size_t MinSize, std::size_t MaxSize, typename... DefaultArgs>
 	static constexpr PyResult<std::tuple<ArgTypes...>> unpack_tuple(PyTuple *args,
 		PyDict *kwargs,
 		std::string_view function_name,
-		std::integral_constant<size_t, MinSize> min_size,
-		std::integral_constant<size_t, MaxSize> max_size,
+		std::integral_constant<std::size_t, MinSize> min_size,
+		std::integral_constant<std::size_t, MaxSize> max_size,
 		DefaultArgs &&...default_values)
 	{
 		if constexpr (max_size() - min_size() > sizeof...(DefaultArgs)) {
diff --git a/src/runtime/PyAsyncGenerator.cpp b/src/runtime/PyAsyncGenerator.cpp
index c2c2a4b3..f7e14372 100644
--- a/src/runtime/PyAsyncGenerator.cpp
+++ b/src/runtime/PyAsyncGenerator.cpp
@@ -1,9 +1,11 @@
-#include "PyAsyncGenerator.hpp"
-#include "MemoryError.hpp"
-#include "PyCode.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.types;
+
+
+import :object;
 
 namespace py {
 
diff --git a/src/runtime/PyAsyncGenerator.hpp b/src/runtime/PyAsyncGenerator.cppm
similarity index 71%
rename from src/runtime/PyAsyncGenerator.hpp
rename to src/runtime/PyAsyncGenerator.cppm
index 022b5291..74e2c2bc 100644
--- a/src/runtime/PyAsyncGenerator.hpp
+++ b/src/runtime/PyAsyncGenerator.cppm
@@ -1,11 +1,22 @@
-#pragma once
+module;
 
-#include "GeneratorInterface.hpp"
+#include "memory/allocate.hpp"
+
+export module py.runtime:asyncgenerator;
+import :object;
+import :detail;
+import py.memory;
+import std;
+
+export struct StackFrame;
+
+export namespace py {
+class PyType;
 
-namespace py {
 class PyAsyncGenerator : public GeneratorInterface<PyAsyncGenerator>
 {
-	friend ::Heap;
+	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	PyAsyncGenerator(PyType *);
 
diff --git a/src/runtime/PyBool.cpp b/src/runtime/PyBool.cpp
index aa735520..d3132ce3 100644
--- a/src/runtime/PyBool.cpp
+++ b/src/runtime/PyBool.cpp
@@ -1,9 +1,12 @@
-#include "PyBool.hpp"
-#include "PyArgParser.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+#include <gmpxx.h>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
diff --git a/src/runtime/PyBool.hpp b/src/runtime/PyBool.cppm
similarity index 78%
rename from src/runtime/PyBool.hpp
rename to src/runtime/PyBool.cppm
index 81d34d8d..5af872b0 100644
--- a/src/runtime/PyBool.hpp
+++ b/src/runtime/PyBool.cppm
@@ -1,12 +1,17 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyInteger.hpp"
+export module py.runtime:bool_;
+import :integer;
+import py.memory;
 
-namespace py {
+export namespace py {
+class PyType;
 
 class PyBool : public PyInteger
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	friend PyObject *py_true();
 	friend PyObject *py_false();
 
diff --git a/src/runtime/PyBoundMethod.cpp b/src/runtime/PyBoundMethod.cpp
index 5a1bc862..90a30b75 100644
--- a/src/runtime/PyBoundMethod.cpp
+++ b/src/runtime/PyBoundMethod.cpp
@@ -1,9 +1,10 @@
-#include "PyBoundMethod.hpp"
-#include "PyFunction.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
@@ -33,7 +34,7 @@ std::string PyBoundMethod::to_string() const
 	if (qualname_str.is_err()) { TODO(); }
 	auto self_qualname = m_self->getattribute(qualname_str.unwrap());
 	if (self_qualname.is_err()) { TODO(); }
-	return fmt::format(
+	return std::format(
 		"<bound method '{}' of '{}'>", m_method->to_string(), self_qualname.unwrap()->to_string());
 }
 
diff --git a/src/runtime/PyBoundMethod.hpp b/src/runtime/PyBoundMethod.cppm
similarity index 72%
rename from src/runtime/PyBoundMethod.hpp
rename to src/runtime/PyBoundMethod.cppm
index 9203fcbd..1a08ce33 100644
--- a/src/runtime/PyBoundMethod.hpp
+++ b/src/runtime/PyBoundMethod.cppm
@@ -1,12 +1,22 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
+export module py.runtime:bound_method;
+import :dict;
+import :function;
+import :object;
+import :tuple;
+import :value;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+class PyType;
 
 class PyBoundMethod : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	PyObject *m_self;
 	PyFunction *m_method;
 
diff --git a/src/runtime/PyBuiltInMethod.cpp b/src/runtime/PyBuiltInMethod.cpp
index 2f36285e..be244924 100644
--- a/src/runtime/PyBuiltInMethod.cpp
+++ b/src/runtime/PyBuiltInMethod.cpp
@@ -1,9 +1,10 @@
-#include "PyBuiltInMethod.hpp"
-#include "MemoryError.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
@@ -39,7 +40,7 @@ std::string PyBuiltInMethod::to_string() const
 	ASSERT(m_ml);
 	ASSERT(m_self);
 
-	return fmt::format("<built-in method '{}' of '{}' object at {}>",
+	return std::format("<built-in method '{}' of '{}' object at {}>",
 		m_ml->get().name,
 		m_self->type()->name(),
 		static_cast<const void *>(this));
diff --git a/src/runtime/PyBuiltInMethod.hpp b/src/runtime/PyBuiltInMethod.cppm
similarity index 73%
rename from src/runtime/PyBuiltInMethod.hpp
rename to src/runtime/PyBuiltInMethod.cppm
index 522a782c..61ad2556 100644
--- a/src/runtime/PyBuiltInMethod.hpp
+++ b/src/runtime/PyBuiltInMethod.cppm
@@ -1,12 +1,21 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
+export module py.runtime:built_in_method;
+import :object;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+struct Number;
+class PyTuple;
+class PyDict;
+class PyType;
 
 class PyBuiltInMethod : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	std::optional<std::reference_wrapper<MethodDefinition>> m_ml;
 	PyObject *m_self;
diff --git a/src/runtime/PyByteArray.cpp b/src/runtime/PyByteArray.cpp
index e404cf3c..2e39d27d 100644
--- a/src/runtime/PyByteArray.cpp
+++ b/src/runtime/PyByteArray.cpp
@@ -1,28 +1,13 @@
-#include "PyByteArray.hpp"
-#include "MemoryError.hpp"
-#include "PyArgParser.hpp"
-#include "PyBytes.hpp"
-#include "StopIteration.hpp"
-#include "runtime/IndexError.hpp"
-#include "runtime/PyBool.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PySlice.hpp"
-#include "runtime/TypeError.hpp"
-#include "runtime/Value.hpp"
-#include "runtime/ValueError.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "utilities.hpp"
-#include "vm/VM.hpp"
-
-#include <algorithm>
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
 #include <cstddef>
-#include <iterator>
-#include <memory>
-#include <numeric>
-#include <variant>
+#include <cstdint>
+#include <gmpxx.h>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 namespace {
@@ -63,34 +48,36 @@ PyResult<PyObject *> PyByteArray::__new__(const PyType *type, PyTuple *, PyDict
 	return PyByteArray::create();
 }
 
-struct ByteBackInserter
-{
-	using iterator_category = std::output_iterator_tag;
-	using value_type = void;
-	using difference_type = std::ptrdiff_t;
-	using pointer = void;
-	using reference = void;
-	using container_type = std::vector<std::byte>;
-
-	container_type &m_bytes;
-	BaseException *m_exception{ nullptr };
-	ByteBackInserter(std::vector<std::byte> &bytes) : m_bytes(bytes) {}
-
-	BaseException *last_error() const { return m_exception; }
-
-	ByteBackInserter &operator=(PyObject *value)
+namespace {
+	struct ByteBackInserter
 	{
-		if (auto int_obj = as<PyInteger>(value)) {
-			if (int_obj->as_i64() >= 0 && int_obj->as_i64() <= 255) {
-				m_bytes.push_back(static_cast<std::byte>(int_obj->as_i64()));
+		using iterator_category = std::output_iterator_tag;
+		using value_type = void;
+		using difference_type = std::ptrdiff_t;
+		using pointer = void;
+		using reference = void;
+		using container_type = std::vector<std::byte>;
+
+		container_type &m_bytes;
+		BaseException *m_exception{ nullptr };
+		ByteBackInserter(std::vector<std::byte> &bytes) : m_bytes(bytes) {}
+
+		BaseException *last_error() const { return m_exception; }
+
+		ByteBackInserter &operator=(PyObject *value)
+		{
+			if (auto int_obj = as<PyInteger>(value)) {
+				if (int_obj->as_i64() >= 0 && int_obj->as_i64() <= 255) {
+					m_bytes.push_back(static_cast<std::byte>(int_obj->as_i64()));
+				}
+			} else {
+				m_exception = type_error(
+					"'{}' object cannot be interpreted as an integer", value->type()->name());
 			}
-		} else {
-			m_exception = type_error(
-				"'{}' object cannot be interpreted as an integer", value->type()->name());
+			return *this;
 		}
-		return *this;
-	}
-};
+	};
+}// namespace
 
 static_assert(detail::has_output_iterator_error<ByteBackInserter>);
 
@@ -522,7 +509,7 @@ PyResult<PyByteArrayIterator *> PyByteArrayIterator::create(PyByteArray *bytes_a
 
 std::string PyByteArrayIterator::to_string() const
 {
-	return fmt::format("<bytearray_iterator object at {}>", static_cast<const void *>(this));
+	return std::format("<bytearray_iterator object at {}>", static_cast<const void *>(this));
 }
 
 PyResult<PyObject *> PyByteArrayIterator::__repr__() const { return PyString::create(to_string()); }
diff --git a/src/runtime/PyByteArray.hpp b/src/runtime/PyByteArray.cppm
similarity index 74%
rename from src/runtime/PyByteArray.hpp
rename to src/runtime/PyByteArray.cppm
index bba823e4..062d293d 100644
--- a/src/runtime/PyByteArray.hpp
+++ b/src/runtime/PyByteArray.cppm
@@ -1,15 +1,21 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyTuple.hpp"
-#include <variant>
+export module py.runtime:byte_array;
+import :object;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+struct Number;
+class PyTuple;
+class PyDict;
+class PyType;
 
 class PyByteArray : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	Bytes m_value;
 
@@ -23,16 +29,16 @@ class PyByteArray : public PyBaseObject
 	std::string to_string() const override;
 
 	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs);
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs);
 
 	PyResult<PyObject *> __add__(const PyObject *obj) const;
 	PyResult<PyObject *> __iter__() const;
 	PyResult<PyObject *> __repr__() const;
-	PyResult<size_t> __len__() const;
+	PyResult<std::size_t> __len__() const;
 	PyResult<PyObject *> __eq__(const PyObject *other) const;
 
-	PyResult<PyObject *> __getitem__(int64_t index);
-	PyResult<std::monostate> __setitem__(int64_t index, PyObject *value);
+	PyResult<PyObject *> __getitem__(std::int64_t index);
+	PyResult<std::monostate> __setitem__(std::int64_t index, PyObject *value);
 
 	PyResult<PyObject *> __getitem__(PyObject *index);
 	PyResult<std::monostate> __setitem__(PyObject *key, PyObject *value);
@@ -56,9 +62,10 @@ class PyByteArray : public PyBaseObject
 class PyByteArrayIterator : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	PyByteArray *m_bytes{ nullptr };
-	size_t m_index{ 0 };
+	std::size_t m_index{ 0 };
 
 	PyByteArrayIterator(PyType *);
 
@@ -75,7 +82,7 @@ class PyByteArrayIterator : public PyBaseObject
 	void visit_graph(Visitor &) override;
 
   private:
-	PyByteArrayIterator(PyByteArray *bytes, size_t index);
+	PyByteArrayIterator(PyByteArray *bytes, std::size_t index);
 };
 
 }// namespace py
diff --git a/src/runtime/PyBytes.cpp b/src/runtime/PyBytes.cpp
index eabdb5ae..01ae03aa 100644
--- a/src/runtime/PyBytes.cpp
+++ b/src/runtime/PyBytes.cpp
@@ -1,24 +1,14 @@
-#include "PyBytes.hpp"
-#include "MemoryError.hpp"
-#include "PyArgParser.hpp"
-#include "PyBool.hpp"
-#include "StopIteration.hpp"
-#include "runtime/IndexError.hpp"
-#include "runtime/PyByteArray.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PySlice.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/TypeError.hpp"
-#include "runtime/Value.hpp"
-#include "runtime/utilities.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
-
-#include <string_view>
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+#include <gmpxx.h>
+
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import py.types;
 
 namespace py {
 
@@ -43,34 +33,36 @@ PyBytes::PyBytes(Bytes number)
 PyBytes::PyBytes() : PyBytes(Bytes{}) {}
 
 
-struct ByteBackInserter
-{
-	using iterator_category = std::output_iterator_tag;
-	using value_type = void;
-	using difference_type = std::ptrdiff_t;
-	using pointer = void;
-	using reference = void;
-	using container_type = std::vector<std::byte>;
-
-	container_type &m_bytes;
-	BaseException *m_exception{ nullptr };
-	ByteBackInserter(std::vector<std::byte> &bytes) : m_bytes(bytes) {}
-
-	BaseException *last_error() const { return m_exception; }
-
-	ByteBackInserter &operator=(PyObject *value)
+namespace {
+	struct ByteBackInserter
 	{
-		if (auto int_obj = as<PyInteger>(value)) {
-			if (int_obj->as_i64() >= 0 && int_obj->as_i64() <= 255) {
-				m_bytes.push_back(static_cast<std::byte>(int_obj->as_i64()));
+		using iterator_category = std::output_iterator_tag;
+		using value_type = void;
+		using difference_type = std::ptrdiff_t;
+		using pointer = void;
+		using reference = void;
+		using container_type = std::vector<std::byte>;
+
+		container_type &m_bytes;
+		BaseException *m_exception{ nullptr };
+		ByteBackInserter(std::vector<std::byte> &bytes) : m_bytes(bytes) {}
+
+		BaseException *last_error() const { return m_exception; }
+
+		ByteBackInserter &operator=(PyObject *value)
+		{
+			if (auto int_obj = as<PyInteger>(value)) {
+				if (int_obj->as_i64() >= 0 && int_obj->as_i64() <= 255) {
+					m_bytes.push_back(static_cast<std::byte>(int_obj->as_i64()));
+				}
+			} else {
+				m_exception = type_error(
+					"'{}' object cannot be interpreted as an integer", value->type()->name());
 			}
-		} else {
-			m_exception = type_error(
-				"'{}' object cannot be interpreted as an integer", value->type()->name());
+			return *this;
 		}
-		return *this;
-	}
-};
+	};
+}// namespace
 
 PyResult<int32_t> PyBytes::__init__(PyTuple *args, PyDict *kwargs)
 {
@@ -248,7 +240,7 @@ PyResult<int64_t> PyBytes::__hash__() const
 {
 	// bytes and str have the same hash
 	// e.g. hash("123") == hash(b"123")
-	std::string_view sv{ bit_cast<char *>(m_value.b.data()), m_value.b.size() };
+	std::string_view sv{ std::bit_cast<char *>(m_value.b.data()), m_value.b.size() };
 	return Ok(static_cast<int64_t>(std::hash<std::string_view>{}(sv)));
 }
 
@@ -324,7 +316,7 @@ PyResult<PyBytesIterator *> PyBytesIterator::create(PyBytes *bytes)
 
 std::string PyBytesIterator::to_string() const
 {
-	return fmt::format("<bytes_iterator object at {}>", static_cast<const void *>(this));
+	return std::format("<bytes_iterator object at {}>", static_cast<const void *>(this));
 }
 
 PyResult<PyObject *> PyBytesIterator::__repr__() const { return PyString::create(to_string()); }
diff --git a/src/runtime/PyBytes.hpp b/src/runtime/PyBytes.cppm
similarity index 74%
rename from src/runtime/PyBytes.hpp
rename to src/runtime/PyBytes.cppm
index 0e1ecdf0..3d9aa16e 100644
--- a/src/runtime/PyBytes.hpp
+++ b/src/runtime/PyBytes.cppm
@@ -1,15 +1,21 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/Value.hpp"
+export module py.runtime:bytes;
+import :object;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+struct Number;
+class PyTuple;
+class PyDict;
+class PyType;
 
 class PyBytes : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	Bytes m_value;
 
@@ -20,24 +26,24 @@ class PyBytes : public PyBaseObject
 	static PyResult<PyBytes *> create();
 
 	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs);
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs);
 
 	~PyBytes() = default;
 	std::string to_string() const override;
 
 	PyResult<PyObject *> __add__(const PyObject *obj) const;
 	PyResult<PyObject *> __mul__(const PyObject *obj) const;
-	PyResult<size_t> __len__() const;
+	PyResult<std::size_t> __len__() const;
 	PyResult<PyObject *> __eq__(const PyObject *obj) const;
 	PyResult<PyObject *> __iter__() const;
 
-	PyResult<PyObject *> __getitem__(int64_t index);
+	PyResult<PyObject *> __getitem__(std::int64_t index);
 
 	PyResult<PyObject *> __getitem__(PyObject *index);
 	// PyResult<std::monostate> __setitem__(PyObject *index, PyObject *value);
 
 	PyResult<PyObject *> __repr__() const;
-	PyResult<int64_t> __hash__() const;
+	PyResult<std::int64_t> __hash__() const;
 
 	PyResult<std::monostate> __getbuffer__(PyBuffer &, int);
 
@@ -56,9 +62,10 @@ class PyBytes : public PyBaseObject
 class PyBytesIterator : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	PyBytes *m_bytes{ nullptr };
-	size_t m_index{ 0 };
+	std::size_t m_index{ 0 };
 
 	PyBytesIterator(PyType *);
 
@@ -75,7 +82,7 @@ class PyBytesIterator : public PyBaseObject
 	void visit_graph(Visitor &) override;
 
   private:
-	PyBytesIterator(PyBytes *bytes, size_t index);
+	PyBytesIterator(PyBytes *bytes, std::size_t index);
 };
 
 }// namespace py
diff --git a/src/runtime/PyCell.cpp b/src/runtime/PyCell.cpp
index 55e1f820..552c82de 100644
--- a/src/runtime/PyCell.cpp
+++ b/src/runtime/PyCell.cpp
@@ -1,8 +1,10 @@
-#include "PyCell.hpp"
-#include "MemoryError.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
@@ -43,7 +45,7 @@ std::string PyCell::to_string() const
 {
 	if (std::holds_alternative<PyObject *>(m_content)) {
 		if (auto *obj = std::get<PyObject *>(m_content)) {
-			return fmt::format("<cell at {}: {} object at {}>",
+			return std::format("<cell at {}: {} object at {}>",
 				(void *)this,
 				obj->type()->to_string(),
 				(void *)obj);
@@ -51,7 +53,7 @@ std::string PyCell::to_string() const
 			return "<cell: empty>";
 		}
 	} else {
-		return fmt::format("<cell at {}: {} object at {}>",
+		return std::format("<cell at {}: {} object at {}>",
 			(void *)this,
 			PyObject::from(m_content).unwrap()->type()->to_string(),
 			(void *)&m_content);
diff --git a/src/runtime/PyCell.hpp b/src/runtime/PyCell.cppm
similarity index 75%
rename from src/runtime/PyCell.hpp
rename to src/runtime/PyCell.cppm
index 0776f3de..7d5cf969 100644
--- a/src/runtime/PyCell.hpp
+++ b/src/runtime/PyCell.cppm
@@ -1,12 +1,20 @@
-#pragma once
+module;
 
-#include "PyObject.hpp"
+#include "memory/allocate.hpp"
 
-namespace py {
+export module py.runtime:cell;
+
+import :object;
+import std;
+import py.memory;
+
+export namespace py {
+class PyType;
 
 class PyCell : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	Value m_content{ nullptr };
 
diff --git a/src/runtime/PyClassMethod.cpp b/src/runtime/PyClassMethod.cpp
index 22a21e0f..1b1e44a3 100644
--- a/src/runtime/PyClassMethod.cpp
+++ b/src/runtime/PyClassMethod.cpp
@@ -1,14 +1,12 @@
-#include "PyClassMethod.hpp"
-#include "MemoryError.hpp"
-#include "PyArgParser.hpp"
-#include "PyDict.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "RuntimeError.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
@@ -50,7 +48,7 @@ PyClassMethod::PyClassMethod(PyType *type) : PyBaseObject(type) {}
 
 std::string PyClassMethod::to_string() const
 {
-	return fmt::format("<classmethod object at {}>", static_cast<const void *>(this));
+	return std::format("<classmethod object at {}>", static_cast<const void *>(this));
 }
 
 PyResult<PyClassMethod *> PyClassMethod::create()
diff --git a/src/runtime/PyClassMethod.hpp b/src/runtime/PyClassMethod.cppm
similarity index 67%
rename from src/runtime/PyClassMethod.hpp
rename to src/runtime/PyClassMethod.cppm
index d369bf7a..8e339425 100644
--- a/src/runtime/PyClassMethod.hpp
+++ b/src/runtime/PyClassMethod.cppm
@@ -1,12 +1,21 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
+export module py.runtime:class_method;
+import :object;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+struct Number;
+class PyTuple;
+class PyDict;
+class PyType;
 
 class PyClassMethod : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
   public:
 	PyObject *m_callable;
@@ -21,7 +30,7 @@ class PyClassMethod : public PyBaseObject
 	std::string to_string() const override;
 
 	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs);
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs);
 	PyResult<PyObject *> __repr__() const;
 	PyResult<PyObject *> __get__(PyObject *instance, PyObject *owner) const;
 
diff --git a/src/runtime/PyClassMethodDescriptor.cpp b/src/runtime/PyClassMethodDescriptor.cpp
index 9251814a..7c8ef928 100644
--- a/src/runtime/PyClassMethodDescriptor.cpp
+++ b/src/runtime/PyClassMethodDescriptor.cpp
@@ -1,11 +1,10 @@
-#include "PyClassMethodDescriptor.hpp"
-#include "PyFunction.hpp"
-#include "PyString.hpp"
-#include "PyType.hpp"
-#include "TypeError.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+#include <cstddef>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
@@ -47,7 +46,7 @@ void PyClassMethodDescriptor::visit_graph(Visitor &visitor)
 
 std::string PyClassMethodDescriptor::to_string() const
 {
-	return fmt::format(
+	return std::format(
 		"<method '{}' of '{}' objects>", m_name->to_string(), m_underlying_type->name());
 }
 
diff --git a/src/runtime/PyClassMethodDescriptor.hpp b/src/runtime/PyClassMethodDescriptor.cppm
similarity index 81%
rename from src/runtime/PyClassMethodDescriptor.hpp
rename to src/runtime/PyClassMethodDescriptor.cppm
index 18485b13..6e34a4ef 100644
--- a/src/runtime/PyClassMethodDescriptor.hpp
+++ b/src/runtime/PyClassMethodDescriptor.cppm
@@ -1,14 +1,24 @@
-#pragma once
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
 
-#include "MemoryError.hpp"
-#include "PyObject.hpp"
-#include "vm/VM.hpp"
+export module py.runtime:class_method_descriptor;
+import :vm;
+import :dict;
+import :object;
+import :string;
+import :tuple;
+import :value;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+class PyType;
 
 class PyClassMethodDescriptor : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	PyString *m_name;
 	PyType *m_underlying_type;
diff --git a/src/runtime/PyCode.cpp b/src/runtime/PyCode.cpp
index 7ebd759a..2d85ab5f 100644
--- a/src/runtime/PyCode.cpp
+++ b/src/runtime/PyCode.cpp
@@ -1,22 +1,16 @@
-#include "PyCode.hpp"
-#include "MemoryError.hpp"
-#include "PyAsyncGenerator.hpp"
-#include "PyCell.hpp"
-#include "PyCoroutine.hpp"
-#include "PyFrame.hpp"
-#include "PyFunction.hpp"
-#include "PyGenerator.hpp"
-#include "PyList.hpp"
-#include "PyTuple.hpp"
-#include "executable/Function.hpp"
-#include "executable/bytecode/Bytecode.hpp"
-#include "executable/bytecode/instructions/Instructions.hpp"
+module;
+#include "core.hpp"
+#include "executable/CodeFlags.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import py.types;
+
 #include "executable/bytecode/serialization/deserialize.hpp"
 #include "executable/bytecode/serialization/serialize.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include <cstdint>
+
 
 namespace py {
 
@@ -116,7 +110,7 @@ PyCode::~PyCode() {}
 
 std::string PyCode::to_string() const
 {
-	return fmt::format("<code object {} at {}, file \"{}\", line {}>",
+	return std::format("<code object {} at {}, file \"{}\", line {}>",
 		m_name,
 		static_cast<const void *>(this),
 		m_filename,
diff --git a/src/runtime/PyCode.hpp b/src/runtime/PyCode.cppm
similarity index 71%
rename from src/runtime/PyCode.hpp
rename to src/runtime/PyCode.cppm
index f14a085c..625cfb69 100644
--- a/src/runtime/PyCode.hpp
+++ b/src/runtime/PyCode.cppm
@@ -1,20 +1,27 @@
-#include "PyObject.hpp"
-#include "executable/Program.hpp"
-#include <span>
+module;
 
-namespace py {
+#include "executable/CodeFlags.hpp"
+
+export module py.runtime:code;
+import :object;
+import :executable_program;
+import :executable_function;
+import std;
+
+export namespace py {
+class PyType;
 
 class PyCode : public PyBaseObject
 {
   public:
 	// implementation details
 	const std::unique_ptr<Function> m_function;
-	const size_t m_register_count;
-	const std::vector<size_t> m_cell2arg;
+	const std::size_t m_register_count;
+	const std::vector<std::size_t> m_cell2arg;
 
 	// code object public attributes
 	// number of arguments (not including keyword only arguments, * or ** args)
-	const size_t m_arg_count;
+	const std::size_t m_arg_count;
 	// string of raw compiled bytecode
 	// const std::string m_code;
 	// tuple of names of cell variables (referenced by containing scopes)
@@ -24,7 +31,7 @@ class PyCode : public PyBaseObject
 	// name of file in which this code object was created
 	const std::string m_filename;
 	// number of first line in Python source code
-	const size_t m_first_line_number;
+	const std::size_t m_first_line_number;
 	// bitmap of CO_* flags
 	CodeFlags m_flags;
 	// encoded mapping of line numbers to bytecode indices
@@ -32,17 +39,17 @@ class PyCode : public PyBaseObject
 	// tuple of names of free variables (referenced via a function’s closure)
 	const std::vector<std::string> m_freevars;
 	// number of positional only arguments
-	const size_t m_positional_only_arg_count;
+	const std::size_t m_positional_only_arg_count;
 	// number of keyword only arguments (not including ** arg)
-	const size_t m_kwonly_arg_count;
+	const std::size_t m_kwonly_arg_count;
 	// name with which this code object was defined
 	const std::string m_name;
 	// tuple of names other than arguments and function locals
 	const std::vector<std::string> m_names;
 	// number of local variables
-	const size_t m_nlocals;
+	const std::size_t m_nlocals;
 	// virtual machine stack space required
-	const size_t m_stack_size;
+	const std::size_t m_stack_size;
 	// tuple of names of arguments and local variables
 	const std::vector<std::string> m_varnames;
 
@@ -51,40 +58,40 @@ class PyCode : public PyBaseObject
 	PyCode(PyType *);
 
 	PyCode(std::unique_ptr<Function> &&function,
-		std::vector<size_t> &&cell2arg,
-		size_t arg_count,
+		std::vector<std::size_t> &&cell2arg,
+		std::size_t arg_count,
 		std::vector<std::string> &&cellvars,
 		PyTuple *consts,
 		std::string &&filename,
-		size_t first_line_number,
+		std::size_t first_line_number,
 		CodeFlags flags,
 		std::vector<std::string> &&freevars,
-		size_t positional_arg_count,
-		size_t kwonly_arg_count,
-		size_t stack_size,
+		std::size_t positional_arg_count,
+		std::size_t kwonly_arg_count,
+		std::size_t stack_size,
 		std::string &&name,
 		std::vector<std::string> &&names,
-		size_t nlocals,
+		std::size_t nlocals,
 		std::vector<std::string> &&varnames);
 
   public:
 	~PyCode();
 
 	static PyResult<PyCode *> create(std::unique_ptr<Function> &&function,
-		std::vector<size_t> cell2arg,
-		size_t arg_count,
+		std::vector<std::size_t> cell2arg,
+		std::size_t arg_count,
 		std::vector<std::string> cellvars,
 		PyTuple *consts,
 		std::string filename,
-		size_t first_line_number,
+		std::size_t first_line_number,
 		CodeFlags flags,
 		std::vector<std::string> freevars,
-		size_t positional_arg_count,
-		size_t kwonly_arg_count,
-		size_t stack_size,
+		std::size_t positional_arg_count,
+		std::size_t kwonly_arg_count,
+		std::size_t stack_size,
 		std::string name,
 		std::vector<std::string> names,
-		size_t nlocals,
+		std::size_t nlocals,
 		std::vector<std::string> varnames);
 
 	static PyResult<PyCode *> create(std::shared_ptr<Program> program);
@@ -96,13 +103,13 @@ class PyCode : public PyBaseObject
 
 	PyResult<PyObject *> __repr__() const;
 
-	size_t register_count() const;
-	size_t freevars_count() const;
-	size_t cellvars_count() const;
-	size_t arg_count() const;
-	size_t kwonly_arg_count() const;
+	std::size_t register_count() const;
+	std::size_t freevars_count() const;
+	std::size_t cellvars_count() const;
+	std::size_t arg_count() const;
+	std::size_t kwonly_arg_count() const;
 	CodeFlags flags() const;
-	const std::vector<size_t> &cell2arg() const;
+	const std::vector<std::size_t> &cell2arg() const;
 	const PyTuple *consts() const;
 
 	const std::string &name() const { return m_name; }
@@ -117,7 +124,7 @@ class PyCode : public PyBaseObject
 
 	void visit_graph(Visitor &) override;
 
-	std::vector<uint8_t> serialize() const;
+	std::vector<std::uint8_t> serialize() const;
 
 	PyResult<PyObject *> eval(PyObject *globals,
 		PyObject *locals,
@@ -133,7 +140,7 @@ class PyCode : public PyBaseObject
 		const std::vector<py::Value> &kw_default_values,
 		PyTuple *closure) const;
 
-	static std::pair<PyResult<PyCode *>, size_t> deserialize(std::span<const uint8_t> &,
+	static std::pair<PyResult<PyCode *>, std::size_t> deserialize(std::span<const std::uint8_t> &,
 		std::shared_ptr<Program>);
 };
 
diff --git a/src/runtime/PyComplex.cpp b/src/runtime/PyComplex.cpp
index 7310dee7..f02f2bd9 100644
--- a/src/runtime/PyComplex.cpp
+++ b/src/runtime/PyComplex.cpp
@@ -1,7 +1,8 @@
-#include "PyComplex.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/types/api.hpp"
+module;
+
+module py.runtime;
+import py.types;
+
 
 using namespace py;
 
diff --git a/src/runtime/PyComplex.hpp b/src/runtime/PyComplex.cppm
similarity index 66%
rename from src/runtime/PyComplex.hpp
rename to src/runtime/PyComplex.cppm
index 93a5fb80..2b1226fe 100644
--- a/src/runtime/PyComplex.hpp
+++ b/src/runtime/PyComplex.cppm
@@ -1,17 +1,18 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "forward.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/Value.hpp"
+export module py.runtime:complex;
+import :object;
+import py.memory;
+import std;
 
-#include <complex>
-
-namespace py {
+export namespace py {
+class PyType;
 
 class PyComplex : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	std::complex<BigIntType> m_complex;
 
diff --git a/src/runtime/PyCoroutine.cpp b/src/runtime/PyCoroutine.cpp
index 8debee36..983fbbad 100644
--- a/src/runtime/PyCoroutine.cpp
+++ b/src/runtime/PyCoroutine.cpp
@@ -1,9 +1,9 @@
-#include "PyCoroutine.hpp"
-#include "MemoryError.hpp"
-#include "PyCode.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
diff --git a/src/runtime/PyCoroutine.hpp b/src/runtime/PyCoroutine.cppm
similarity index 72%
rename from src/runtime/PyCoroutine.hpp
rename to src/runtime/PyCoroutine.cppm
index 37b55a86..6c7068c6 100644
--- a/src/runtime/PyCoroutine.hpp
+++ b/src/runtime/PyCoroutine.cppm
@@ -1,11 +1,21 @@
-#pragma once
+module;
 
-#include "GeneratorInterface.hpp"
+#include "memory/allocate.hpp"
+
+export module py.runtime:coroutine;
+import :detail;
+import py.memory;
+import std;
+
+export struct StackFrame;
+
+export namespace py {
+class PyType;
 
-namespace py {
 class PyCoroutine : public GeneratorInterface<PyCoroutine>
 {
-	friend ::Heap;
+	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	PyCoroutine(PyType *);
 
diff --git a/src/runtime/PyDict.cpp b/src/runtime/PyDict.cpp
index 2675e202..6e3f1ffc 100644
--- a/src/runtime/PyDict.cpp
+++ b/src/runtime/PyDict.cpp
@@ -1,21 +1,11 @@
-#include "PyDict.hpp"
-#include "KeyError.hpp"
-#include "MemoryError.hpp"
-#include "PyArgParser.hpp"
-#include "PyBool.hpp"
-#include "PyNone.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "StopIteration.hpp"
-#include "ValueError.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/Value.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
-
-#include <unordered_set>
-#include <variant>
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
@@ -804,7 +794,7 @@ void PyDictItemsIterator::visit_graph(Visitor &visitor)
 
 std::string PyDictItemsIterator::to_string() const
 {
-	return fmt::format("<dict_itemiterator at {}>", static_cast<const void *>(this));
+	return std::format("<dict_itemiterator at {}>", static_cast<const void *>(this));
 }
 
 PyResult<PyObject *> PyDictItemsIterator::__repr__() const { return PyString::create(to_string()); }
@@ -901,7 +891,7 @@ void PyDictKeyIterator::visit_graph(Visitor &visitor)
 
 std::string PyDictKeyIterator::to_string() const
 {
-	return fmt::format("<dict_keyiterator at {}>", static_cast<const void *>(this));
+	return std::format("<dict_keyiterator at {}>", static_cast<const void *>(this));
 }
 
 PyResult<PyObject *> PyDictKeyIterator::__repr__() const { return PyString::create(to_string()); }
@@ -997,7 +987,7 @@ void PyDictValueIterator::visit_graph(Visitor &visitor)
 
 std::string PyDictValueIterator::to_string() const
 {
-	return fmt::format("<dict_valueiterator at {}>", static_cast<const void *>(this));
+	return std::format("<dict_valueiterator at {}>", static_cast<const void *>(this));
 }
 
 PyResult<PyObject *> PyDictValueIterator::__repr__() const { return PyString::create(to_string()); }
diff --git a/src/runtime/PyDict.hpp b/src/runtime/PyDict.cppm
similarity index 89%
rename from src/runtime/PyDict.hpp
rename to src/runtime/PyDict.cppm
index 9ab0516c..a36fb3d3 100644
--- a/src/runtime/PyDict.hpp
+++ b/src/runtime/PyDict.cppm
@@ -1,13 +1,15 @@
-#pragma once
-
-#include "PyObject.hpp"
-#include "runtime/Value.hpp"
+module;
 
+#include "memory/allocate.hpp"
 #include <tsl/ordered_map.h>
 
-#include <variant>
+export module py.runtime:dict;
+import :object;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+class PyType;
 
 class PyDictItems;
 class PyDictItemsIterator;
@@ -25,6 +27,7 @@ class PyDict : public PyBaseObject
 
   private:
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	friend PyDictItems;
 	friend PyDictItemsIterator;
 
@@ -43,7 +46,7 @@ class PyDict : public PyBaseObject
 
 	PyDictItems *items() const;
 
-	size_t size() const { return m_map.size(); }
+	std::size_t size() const { return m_map.size(); }
 
 	std::string to_string() const override;
 	PyResult<PyObject *> __repr__() const;
@@ -52,7 +55,7 @@ class PyDict : public PyBaseObject
 	PyResult<std::monostate> __setitem__(PyObject *key, PyObject *value);
 	PyResult<std::monostate> __delitem__(PyObject *key);
 	PyResult<PyObject *> __eq__(const PyObject *other) const;
-	PyResult<size_t> __len__() const;
+	PyResult<std::size_t> __len__() const;
 
 	const MapType &map() const { return m_map; }
 
@@ -86,6 +89,7 @@ class PyDict : public PyBaseObject
 class PyDictItems : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	friend PyDict;
 	friend PyDictItemsIterator;
 
@@ -114,6 +118,7 @@ class PyDictItems : public PyBaseObject
 class PyDictKeys : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	friend PyDict;
 	friend PyDictKeyIterator;
 
@@ -142,6 +147,7 @@ class PyDictKeys : public PyBaseObject
 class PyDictValues : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	friend PyDict;
 	friend PyDictValueIterator;
 
@@ -170,6 +176,7 @@ class PyDictValues : public PyBaseObject
 class PyDictItemsIterator : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	friend PyDictItems;
 
 	const std::optional<std::reference_wrapper<const PyDictItems>> m_pydictitems;
@@ -178,7 +185,7 @@ class PyDictItemsIterator : public PyBaseObject
 	PyDictItemsIterator(PyType *);
 
 	PyDictItemsIterator(const PyDictItems &pydict_items);
-	PyDictItemsIterator(const PyDictItems &pydict_items, size_t position);
+	PyDictItemsIterator(const PyDictItems &pydict_items, std::size_t position);
 
   public:
 	using difference_type = PyDict::MapType::difference_type;
@@ -188,7 +195,8 @@ class PyDictItemsIterator : public PyBaseObject
 	using iterator_category = std::forward_iterator_tag;
 
 	static PyResult<PyDictItemsIterator *> create(const PyDictItems &pydict_items);
-	static PyResult<PyDictItemsIterator *> create(const PyDictItems &pydict_items, size_t position);
+	static PyResult<PyDictItemsIterator *> create(const PyDictItems &pydict_items,
+		std::size_t position);
 
 	std::string to_string() const override;
 
@@ -209,6 +217,7 @@ class PyDictItemsIterator : public PyBaseObject
 class PyDictKeyIterator : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	friend PyDictItems;
 	friend PyDictKeys;
 
@@ -218,7 +227,7 @@ class PyDictKeyIterator : public PyBaseObject
 	PyDictKeyIterator(PyType *);
 
 	PyDictKeyIterator(const PyDictKeys &pydict_keys);
-	PyDictKeyIterator(const PyDictKeys &pydict_keys, size_t position);
+	PyDictKeyIterator(const PyDictKeys &pydict_keys, std::size_t position);
 
   public:
 	using difference_type = PyDict::MapType::difference_type;
@@ -228,7 +237,8 @@ class PyDictKeyIterator : public PyBaseObject
 	using iterator_category = std::forward_iterator_tag;
 
 	static PyResult<PyDictKeyIterator *> create(const PyDictKeys &pydict_keys);
-	static PyResult<PyDictKeyIterator *> create(const PyDictKeys &pydict_keys, size_t position);
+	static PyResult<PyDictKeyIterator *> create(const PyDictKeys &pydict_keys,
+		std::size_t position);
 
 	std::string to_string() const override;
 
@@ -248,6 +258,7 @@ class PyDictKeyIterator : public PyBaseObject
 class PyDictValueIterator : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	friend PyDictItems;
 	friend PyDictValues;
 
@@ -257,7 +268,7 @@ class PyDictValueIterator : public PyBaseObject
 	PyDictValueIterator(PyType *);
 
 	PyDictValueIterator(const PyDictValues &pydict_values);
-	PyDictValueIterator(const PyDictValues &pydict_values, size_t position);
+	PyDictValueIterator(const PyDictValues &pydict_values, std::size_t position);
 
   public:
 	using difference_type = PyDict::MapType::difference_type;
@@ -268,7 +279,7 @@ class PyDictValueIterator : public PyBaseObject
 
 	static PyResult<PyDictValueIterator *> create(const PyDictValues &pydict_values);
 	static PyResult<PyDictValueIterator *> create(const PyDictValues &pydict_values,
-		size_t position);
+		std::size_t position);
 
 	std::string to_string() const override;
 
diff --git a/src/runtime/PyDict_tests.cpp b/src/runtime/PyDict_tests.cpp
index 7f85112d..4788abe5 100644
--- a/src/runtime/PyDict_tests.cpp
+++ b/src/runtime/PyDict_tests.cpp
@@ -1,9 +1,7 @@
-#include "PyDict.hpp"
-#include "PyNone.hpp"
-#include "PyString.hpp"
-
 #include <gtest/gtest.h>
 
+import py.runtime;
+
 using namespace py;
 
 TEST(PyDict, StringLookup)
@@ -18,4 +16,4 @@ TEST(PyDict, StringLookup)
 	ASSERT_TRUE(foo_.is_ok());
 	auto *foo = foo_.unwrap();
 	ASSERT_TRUE(dict->map().contains(foo));
-}
\ No newline at end of file
+}
diff --git a/src/runtime/PyEllipsis.cpp b/src/runtime/PyEllipsis.cpp
index cd71abe9..c9609c24 100644
--- a/src/runtime/PyEllipsis.cpp
+++ b/src/runtime/PyEllipsis.cpp
@@ -1,11 +1,14 @@
-#include "PyEllipsis.hpp"
-#include "MemoryError.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
+
+std::string PyEllipsis::to_string() const { return "PyEllipsis"; }
 PyEllipsis::PyEllipsis(PyType *type) : PyBaseObject(type) {}
 
 PyEllipsis::PyEllipsis() : PyBaseObject(types::BuiltinTypes::the().ellipsis()) {}
diff --git a/src/runtime/PyEllipsis.hpp b/src/runtime/PyEllipsis.cppm
similarity index 68%
rename from src/runtime/PyEllipsis.hpp
rename to src/runtime/PyEllipsis.cppm
index 912a2094..159ff923 100644
--- a/src/runtime/PyEllipsis.hpp
+++ b/src/runtime/PyEllipsis.cppm
@@ -1,12 +1,19 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
+export module py.runtime:ellipsis;
+import :object;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+struct Number;
+class PyType;
 
 class PyEllipsis : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	friend PyObject *py_ellipsis();
 
 	static constexpr Ellipsis m_value{};
@@ -14,7 +21,7 @@ class PyEllipsis : public PyBaseObject
 	PyEllipsis(PyType *);
 
   public:
-	std::string to_string() const override { return fmt::format("PyEllipsis"); }
+	std::string to_string() const override;
 
 	PyResult<PyObject *> __add__(const PyObject *obj) const;
 	PyResult<PyObject *> __repr__() const;
diff --git a/src/runtime/PyEnumerate.cpp b/src/runtime/PyEnumerate.cpp
index 1be11029..1449ad9e 100644
--- a/src/runtime/PyEnumerate.cpp
+++ b/src/runtime/PyEnumerate.cpp
@@ -1,7 +1,12 @@
-#include "PyEnumerate.hpp"
-#include "MemoryError.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 PyEnumerate::PyEnumerate(PyType *type) : PyBaseObject(type) {}
diff --git a/src/runtime/PyEnumerate.hpp b/src/runtime/PyEnumerate.cppm
similarity index 53%
rename from src/runtime/PyEnumerate.hpp
rename to src/runtime/PyEnumerate.cppm
index 30b57e50..83bbd7f1 100644
--- a/src/runtime/PyEnumerate.hpp
+++ b/src/runtime/PyEnumerate.cppm
@@ -1,22 +1,31 @@
-#pragma once
-
-#include "PyObject.hpp"
-
-namespace py {
+module;
+#include "memory/allocate.hpp"
+
+export module py.runtime:enumerate;
+import :object;
+import py.memory;
+import std;
+
+export namespace py {
+struct Number;
+class PyTuple;
+class PyDict;
+class PyType;
 class PyEnumerate : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
-	int64_t m_current_index{ 0 };
+	std::int64_t m_current_index{ 0 };
 	PyObject *m_iterator{ nullptr };
 
   private:
 	PyEnumerate(PyType *);
 
-	PyEnumerate(int64_t current_index, PyObject *iterator);
+	PyEnumerate(std::int64_t current_index, PyObject *iterator);
 
   public:
-	static PyResult<PyObject *> create(int64_t current_index, PyObject *iterable);
+	static PyResult<PyObject *> create(std::int64_t current_index, PyObject *iterable);
 	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
 
 	PyResult<PyObject *> __iter__() const;
diff --git a/src/runtime/PyFloat.cpp b/src/runtime/PyFloat.cpp
index c8f925a5..16fc2eec 100644
--- a/src/runtime/PyFloat.cpp
+++ b/src/runtime/PyFloat.cpp
@@ -1,14 +1,12 @@
-#include "PyFloat.hpp"
-#include "MemoryError.hpp"
-#include "runtime/PyArgParser.hpp"
-#include "runtime/PyNumber.hpp"
-#include "runtime/Value.hpp"
-#include "runtime/forward.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
-
-#include <cmath>
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+#include <gmpxx.h>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
diff --git a/src/runtime/PyFloat.hpp b/src/runtime/PyFloat.cppm
similarity index 70%
rename from src/runtime/PyFloat.hpp
rename to src/runtime/PyFloat.cppm
index e3fbd540..62c73ee1 100644
--- a/src/runtime/PyFloat.hpp
+++ b/src/runtime/PyFloat.cppm
@@ -1,10 +1,19 @@
-#include "PyNumber.hpp"
+module;
 
-namespace py {
+#include "memory/allocate.hpp"
+
+export module py.runtime:float_;
+import :number;
+import std;
+import py.memory;
+
+export namespace py {
+class PyType;
 
 class PyFloat final : public PyNumber
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	PyFloat(double);
 
diff --git a/src/runtime/PyFrame.cpp b/src/runtime/PyFrame.cpp
index c81ccafe..4cd9efae 100644
--- a/src/runtime/PyFrame.cpp
+++ b/src/runtime/PyFrame.cpp
@@ -1,17 +1,12 @@
-#include "PyFrame.hpp"
-#include "BaseException.hpp"
-#include "KeyError.hpp"
-#include "PyCell.hpp"
-#include "PyCode.hpp"
-#include "PyDict.hpp"
-#include "PyModule.hpp"
-#include "PyNone.hpp"
-#include "PyObject.hpp"
-#include "PyTraceback.hpp"
-#include "PyType.hpp"
-#include "executable/Function.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+#include "executable/CodeFlags.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
@@ -93,26 +88,36 @@ PyFrame *PyFrame::create(PyFrame *parent,
 void PyFrame::push_exception(BaseException *exception)
 {
 	ASSERT(exception);
-	spdlog::debug("PyFrame::push_exception: current exception count {}", m_exception_stack->size());
+	::detail::log_debug(std::format(
+		"PyFrame::push_exception: current exception count {}", m_exception_stack->size())
+			.c_str());
 	m_exception_stack->push_back(ExceptionStackItem{ .exception = exception,
 		.exception_type = exception->type(),
 		.traceback = exception->traceback() });
-	spdlog::debug("PyFrame::push_exception: pushed exception {}",
-		m_exception_stack->back().exception->to_string());
-	spdlog::debug("PyFrame::push_exception: added exception, stack has now {} exceptions",
-		m_exception_stack->size());
+	::detail::log_debug(std::format("PyFrame::push_exception: pushed exception {}",
+		m_exception_stack->back().exception->to_string())
+			.c_str());
+	::detail::log_debug(
+		std::format("PyFrame::push_exception: added exception, stack has now {} exceptions",
+			m_exception_stack->size())
+			.c_str());
 }
 
 BaseException *PyFrame::pop_exception()
 {
 	ASSERT(!m_exception_stack->empty());
 	auto *exception = m_exception_stack->back().exception;
-	spdlog::debug("PyFrame::pop_exception: @{}", static_cast<void *>(this));
-	spdlog::debug("PyFrame::pop_exception: current exception count {}", m_exception_stack->size());
-	spdlog::debug("PyFrame::pop_exception: Popped exception {}", exception->to_string());
+	::detail::log_debug(
+		std::format("PyFrame::pop_exception: @{}", static_cast<void *>(this)).c_str());
+	::detail::log_debug(
+		std::format("PyFrame::pop_exception: current exception count {}", m_exception_stack->size())
+			.c_str());
+	::detail::log_debug(
+		std::format("PyFrame::pop_exception: Popped exception {}", exception->to_string()).c_str());
 	m_exception_stack->pop_back();
-	spdlog::debug(
-		"PyFrame::pop_exception: cleared exception, {} exceptions left", m_exception_stack->size());
+	::detail::log_debug(std::format(
+		"PyFrame::pop_exception: cleared exception, {} exceptions left", m_exception_stack->size())
+			.c_str());
 	return exception;
 }
 
@@ -203,9 +208,10 @@ std::vector<PyCell *> &PyFrame::freevars() { return m_freevars; }
 
 PyFrame *PyFrame::exit()
 {
-	spdlog::debug("Leaving PyFrame '{}' and entering PyFrame '{}'",
+	::detail::log_debug(std::format("Leaving PyFrame '{}' and entering PyFrame '{}'",
 		m_f_code->function()->function_name(),
-		m_f_back->m_f_code->function()->function_name());
+		m_f_back->m_f_code->function()->function_name())
+			.c_str());
 
 	return m_f_back;
 }
@@ -217,7 +223,7 @@ std::string PyFrame::to_string() const
 	const auto builtins = m_builtins ? m_builtins->to_string() : "";
 	const void *parent = m_f_back ? &m_f_back : nullptr;
 
-	return fmt::format("PyFrame(locals={}, globals={}, builtins={}, parent={})",
+	return std::format("PyFrame(locals={}, globals={}, builtins={}, parent={})",
 		locals,
 		globals,
 		builtins,
@@ -249,7 +255,7 @@ void PyFrame::visit_graph(Visitor &visitor)
 Value PyFrame::consts(size_t index) const
 {
 	ASSERT(index < m_consts->size());
-	spdlog::debug("m_consts: {}", (void *)m_consts);
+	::detail::log_debug(std::format("m_consts: {}", (void *)m_consts).c_str());
 	return m_consts->elements()[index];
 }
 
diff --git a/src/runtime/PyFrame.hpp b/src/runtime/PyFrame.cppm
similarity index 80%
rename from src/runtime/PyFrame.hpp
rename to src/runtime/PyFrame.cppm
index 831f8de5..e9ef8aec 100644
--- a/src/runtime/PyFrame.hpp
+++ b/src/runtime/PyFrame.cppm
@@ -1,18 +1,30 @@
-#pragma once
+module;
 
-#include "forward.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/Value.hpp"
-#include "vm/VM.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
 
-#include <memory>
-#include <unordered_map>
+export module py.runtime:frame;
+import std;
+import :object;
+import py.memory;
 
-namespace py {
+export namespace py {
+class PyType;
+}
+
+export class Interpreter;
+
+export namespace py {
+
+class PyModule;
+class PyCell;
+class PyCode;
+class PyTraceback;
 
 class PyFrame : public PyBaseObject
 {
-	friend Heap;
+	friend class ::Heap;
+	friend class py::detail::Allocator;
 	friend Interpreter;
 	template<typename T> friend class GeneratorInterface;
 
@@ -43,7 +55,7 @@ class PyFrame : public PyBaseObject
 	// generator object
 	PyObject *m_generator{ nullptr };
 
-	size_t m_register_count;
+	std::size_t m_register_count;
 	const std::vector<std::string> m_names;
 	const PyTuple *m_consts;
 	std::vector<PyCell *> m_freevars;
@@ -51,8 +63,8 @@ class PyFrame : public PyBaseObject
 
   public:
 	static PyFrame *create(PyFrame *parent,
-		size_t register_count,
-		size_t freevar_count,
+		std::size_t register_count,
+		std::size_t freevar_count,
 		PyCode *code,
 		PyObject *globals,
 		PyObject *locals,
@@ -85,8 +97,8 @@ class PyFrame : public PyBaseObject
 
 	const std::vector<PyCell *> &freevars() const;
 	std::vector<PyCell *> &freevars();
-	Value consts(size_t index) const;
-	const std::string &names(size_t index) const;
+	Value consts(std::size_t index) const;
+	const std::string &names(std::size_t index) const;
 
 	std::string to_string() const override;
 	void visit_graph(Visitor &) override;
diff --git a/src/runtime/PyFrozenSet.cpp b/src/runtime/PyFrozenSet.cpp
index 99cfad65..85851e36 100644
--- a/src/runtime/PyFrozenSet.cpp
+++ b/src/runtime/PyFrozenSet.cpp
@@ -1,11 +1,12 @@
-#include "PyFrozenSet.hpp"
-#include "MemoryError.hpp"
-#include "PyArgParser.hpp"
-#include "PySet.hpp"
-#include "StopIteration.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
diff --git a/src/runtime/PyFrozenSet.hpp b/src/runtime/PyFrozenSet.cppm
similarity index 76%
rename from src/runtime/PyFrozenSet.hpp
rename to src/runtime/PyFrozenSet.cppm
index d93b6215..2b4e60a3 100644
--- a/src/runtime/PyFrozenSet.hpp
+++ b/src/runtime/PyFrozenSet.cppm
@@ -1,13 +1,19 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
-#include <unordered_set>
 
-namespace py {
+export module py.runtime:frozenset;
+import :object;
+import std;
+import py.memory;
+
+export namespace py {
+class PyType;
 
 class PyFrozenSet : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
   public:
 	using SetType = std::unordered_set<Value, ValueHash>;
@@ -24,11 +30,11 @@ class PyFrozenSet : public PyBaseObject
 	std::string to_string() const override;
 
 	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs);
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs);
 
 	PyResult<PyObject *> __repr__() const;
 	PyResult<PyObject *> __iter__() const;
-	PyResult<size_t> __len__() const;
+	PyResult<std::size_t> __len__() const;
 	PyResult<PyObject *> __eq__(const PyObject *other) const;
 	PyResult<bool> __contains__(const PyObject *value) const;
 
diff --git a/src/runtime/PyFunction.cpp b/src/runtime/PyFunction.cpp
index 1329d764..6c9fc6d5 100644
--- a/src/runtime/PyFunction.cpp
+++ b/src/runtime/PyFunction.cpp
@@ -1,18 +1,10 @@
-#include "PyFunction.hpp"
-#include "PyBoundMethod.hpp"
-#include "PyCode.hpp"
-#include "PyDict.hpp"
-#include "PyNone.hpp"
-#include "PyString.hpp"
-#include "executable/Program.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyObject.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-
-#include "vm/VM.hpp"
-
-#include <variant>
+module;
+#include "core.hpp"
+
+module py.runtime;
+import std;
+import py.types;
+
 
 namespace py {
 
@@ -85,7 +77,7 @@ PyResult<PyObject *> PyFunction::__repr__() const
 {
 	return PyString::create(m_qualname).and_then([this](PyString *qualname) {
 		return PyString::create(
-			fmt::format("<function {} at {}>", qualname->value(), static_cast<const void *>(this)));
+			std::format("<function {} at {}>", qualname->value(), static_cast<const void *>(this)));
 	});
 }
 
@@ -116,7 +108,7 @@ PyResult<PyObject *> PyFunction::__call__(PyTuple *args, PyDict *kwargs)
 
 std::string PyFunction::to_string() const
 {
-	return fmt::format("<function {} at {}>", m_name->value(), (void *)this);
+	return std::format("<function {} at {}>", m_name->value(), (void *)this);
 }
 
 namespace {
@@ -169,12 +161,12 @@ PyNativeFunction::PyNativeFunction(std::string &&name, FunctionType &&function)
 std::string PyNativeFunction::to_string() const
 {
 	if (is_method()) {
-		return fmt::format("<built-in method {} of {} object at {}>",
+		return std::format("<built-in method {} of {} object at {}>",
 			m_name,
 			m_self->type()->name(),
 			(void *)this);
 	} else {
-		return fmt::format("<built-in function {} at {}>", m_name, (void *)this);
+		return std::format("<built-in function {} at {}>", m_name, (void *)this);
 	}
 }
 
diff --git a/src/runtime/PyFunction.hpp b/src/runtime/PyFunction.cppm
similarity index 92%
rename from src/runtime/PyFunction.hpp
rename to src/runtime/PyFunction.cppm
index 7fae2dc7..c9f8d581 100644
--- a/src/runtime/PyFunction.hpp
+++ b/src/runtime/PyFunction.cppm
@@ -1,15 +1,20 @@
-#pragma once
+module;
 
-#include "MemoryError.hpp"
-#include "PyObject.hpp"
-#include "PyTuple.hpp"
-#include "executable/Program.hpp"
-#include "vm/VM.hpp"
+#include "core.hpp"
+#include "memory/allocate.hpp"
 
-namespace py {
+export module py.runtime:function;
+import :object;
+import :code;
+import py.memory;
+import std;
+
+export namespace py {
+class PyType;
 class PyFunction : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	PyString *m_name{ nullptr };
 	PyObject *m_doc{ nullptr };
@@ -58,6 +63,7 @@ class PyFunction : public PyBaseObject
 class PyNativeFunction : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	using FreeFunctionSignature = PyResult<PyObject *>(PyTuple *, PyDict *);
 	using MethodSignature = PyResult<PyObject *>(PyObject *, PyTuple *, PyDict *);
 	using FreeFunctionType = std::function<FreeFunctionSignature>;
@@ -90,7 +96,7 @@ class PyNativeFunction : public PyBaseObject
 	static PyResult<PyNativeFunction *>
 		create(std::string name, FreeFunctionType function, Args &&...args)
 	{
-		auto *result = VirtualMachine::the().heap().allocate<PyNativeFunction>(
+		auto *result = detail::allocate<PyNativeFunction>(
 			std::move(name), std::move(function), nullptr, std::forward<Args>(args)...);
 		if (!result) { return Err(memory_error(sizeof(PyNativeFunction))); }
 		return Ok(result);
@@ -100,7 +106,7 @@ class PyNativeFunction : public PyBaseObject
 	static PyResult<PyNativeFunction *>
 		create(std::string name, MethodType function, PyObject *self, Args &&...args)
 	{
-		auto *result = VirtualMachine::the().heap().allocate<PyNativeFunction>(
+		auto *result = detail::allocate<PyNativeFunction>(
 			std::move(name), std::move(function), self, std::forward<Args>(args)...);
 		if (!result) { return Err(memory_error(sizeof(PyNativeFunction))); }
 		return Ok(result);
diff --git a/src/runtime/PyGenerator.cpp b/src/runtime/PyGenerator.cpp
index 349c8be1..9e37b791 100644
--- a/src/runtime/PyGenerator.cpp
+++ b/src/runtime/PyGenerator.cpp
@@ -1,9 +1,9 @@
-#include "PyGenerator.hpp"
-#include "MemoryError.hpp"
-#include "PyCode.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
diff --git a/src/runtime/PyGenerator.hpp b/src/runtime/PyGenerator.cppm
similarity index 72%
rename from src/runtime/PyGenerator.hpp
rename to src/runtime/PyGenerator.cppm
index addb3be3..9b3657f4 100644
--- a/src/runtime/PyGenerator.hpp
+++ b/src/runtime/PyGenerator.cppm
@@ -1,11 +1,21 @@
-#pragma once
+module;
 
-#include "GeneratorInterface.hpp"
+#include "memory/allocate.hpp"
 
-namespace py {
+export module py.runtime:generator;
+import :detail;
+import std;
+import py.memory;
+
+
+export struct StackFrame;
+
+export namespace py {
+class PyType;
 class PyGenerator : public GeneratorInterface<PyGenerator>
 {
-	friend ::Heap;
+	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	PyGenerator(PyType *);
 
diff --git a/src/runtime/PyGenericAlias.cpp b/src/runtime/PyGenericAlias.cpp
index 31f28183..7c84f086 100644
--- a/src/runtime/PyGenericAlias.cpp
+++ b/src/runtime/PyGenericAlias.cpp
@@ -1,11 +1,11 @@
-#include "PyGenericAlias.hpp"
-#include "MemoryError.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "RuntimeError.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
@@ -52,7 +52,7 @@ PyResult<PyGenericAlias *> PyGenericAlias::create(PyObject *origin, PyObject *ar
 
 std::string PyGenericAlias::to_string() const
 {
-	return fmt::format("<generic_alias object at {}>", static_cast<const void *>(this));
+	return std::format("<generic_alias object at {}>", static_cast<const void *>(this));
 }
 
 PyResult<PyObject *> PyGenericAlias::__repr__() const
@@ -69,7 +69,7 @@ PyResult<PyObject *> PyGenericAlias::__repr__() const
 		if (++i != m_args->elements().size()) { os << ", "; }
 	}
 	ASSERT(as<PyType>(m_origin));
-	return PyString::create(fmt::format("{}[{}]", as<PyType>(m_origin)->name(), os.str()));
+	return PyString::create(std::format("{}[{}]", as<PyType>(m_origin)->name(), os.str()));
 }
 
 namespace {
diff --git a/src/runtime/PyGenericAlias.hpp b/src/runtime/PyGenericAlias.cppm
similarity index 73%
rename from src/runtime/PyGenericAlias.hpp
rename to src/runtime/PyGenericAlias.cppm
index ad5ed21b..cab2a938 100644
--- a/src/runtime/PyGenericAlias.hpp
+++ b/src/runtime/PyGenericAlias.cppm
@@ -1,11 +1,19 @@
-#pragma once
-
-#include "PyObject.hpp"
-
-namespace py {
+module;
+#include "memory/allocate.hpp"
+
+export module py.runtime:generic_alias;
+import :object;
+import py.memory;
+import std;
+
+export namespace py {
+struct Number;
+class PyTuple;
+class PyType;
 class PyGenericAlias : public PyBaseObject
 {
-	friend ::Heap;
+	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	PyObject *m_origin{ nullptr };
 	PyTuple *m_args{ nullptr };
diff --git a/src/runtime/PyGetSetDescriptor.cpp b/src/runtime/PyGetSetDescriptor.cpp
index 890c2ce2..e6c25287 100644
--- a/src/runtime/PyGetSetDescriptor.cpp
+++ b/src/runtime/PyGetSetDescriptor.cpp
@@ -1,13 +1,10 @@
-#include "PyGetSetDescriptor.hpp"
-#include "AttributeError.hpp"
-#include "MemoryError.hpp"
-#include "PyString.hpp"
-#include "PyType.hpp"
-#include "TypeError.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
@@ -54,7 +51,7 @@ void PyGetSetDescriptor::visit_graph(Visitor &visitor)
 
 std::string PyGetSetDescriptor::to_string() const
 {
-	return fmt::format(
+	return std::format(
 		"<attribute '{}' of '{}' objects>", m_name->to_string(), m_underlying_type->name());
 }
 
diff --git a/src/runtime/PyGetSetDescriptor.hpp b/src/runtime/PyGetSetDescriptor.cppm
similarity index 78%
rename from src/runtime/PyGetSetDescriptor.hpp
rename to src/runtime/PyGetSetDescriptor.cppm
index 6568448e..46e25194 100644
--- a/src/runtime/PyGetSetDescriptor.hpp
+++ b/src/runtime/PyGetSetDescriptor.cppm
@@ -1,8 +1,15 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
+export module py.runtime:get_set_descriptor;
+import :object;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+struct Number;
+class PyString;
+class PyType;
 
 class PyGetSetDescriptor : public PyBaseObject
 {
@@ -11,6 +18,7 @@ class PyGetSetDescriptor : public PyBaseObject
 	std::optional<std::reference_wrapper<PropertyDefinition>> m_getset;
 
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	PyGetSetDescriptor(PyType *);
 
diff --git a/src/runtime/PyInteger.cpp b/src/runtime/PyInteger.cpp
index d1f3ec63..b25805ce 100644
--- a/src/runtime/PyInteger.cpp
+++ b/src/runtime/PyInteger.cpp
@@ -1,20 +1,14 @@
-#include "PyInteger.hpp"
-#include "MemoryError.hpp"
-#include "PyArgParser.hpp"
-#include "PyBytes.hpp"
-#include "PyFloat.hpp"
-#include "TypeError.hpp"
-#include "ValueError.hpp"
-#include "runtime/PyByteArray.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/Value.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
-
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+#include <cstdint>
 #include <gmpxx.h>
 
-#include <ranges>
+module py.runtime;
+import py.types;
+import std;
+
 
 namespace py {
 
diff --git a/src/runtime/PyInteger.hpp b/src/runtime/PyInteger.cppm
similarity index 74%
rename from src/runtime/PyInteger.hpp
rename to src/runtime/PyInteger.cppm
index 446b5358..8c63df6c 100644
--- a/src/runtime/PyInteger.hpp
+++ b/src/runtime/PyInteger.cppm
@@ -1,14 +1,23 @@
-#pragma once
+module;
 
-#include "PyNumber.hpp"
-#include "forward.hpp"
-#include "runtime/PyType.hpp"
+#include "memory/allocate.hpp"
 
-namespace py {
+#include <cstddef>
+#include <cstdint>
+
+export module py.runtime:integer;
+import std;
+import :object;
+import :number;
+import py.memory;
+
+export namespace py {
+class PyType;
 
 class PyInteger : public Interface<PyNumber, PyInteger>
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	PyInteger(BigIntType);
 
@@ -22,13 +31,13 @@ class PyInteger : public Interface<PyNumber, PyInteger>
 	static PyResult<PyInteger *> create(PyType *, BigIntType);
 
   public:
-	static PyResult<PyInteger *> create(int64_t);
+	static PyResult<PyInteger *> create(std::int64_t);
 
 	static PyResult<PyInteger *> create(BigIntType);
 
 	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
 
-	PyResult<int64_t> __hash__() const;
+	PyResult<std::int64_t> __hash__() const;
 
 	PyResult<PyObject *> __and__(PyObject *obj);
 	PyResult<PyObject *> __or__(PyObject *obj);
@@ -49,8 +58,8 @@ class PyInteger : public Interface<PyNumber, PyInteger>
 	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
 	PyType *static_type() const override;
 
-	int64_t as_i64() const;
-	size_t as_size_t() const;
+	std::int64_t as_i64() const;
+	std::size_t as_size_t() const;
 	BigIntType as_big_int() const;
 };
 
diff --git a/src/runtime/PyIterator.cpp b/src/runtime/PyIterator.cpp
index 8878fd81..5044e143 100644
--- a/src/runtime/PyIterator.cpp
+++ b/src/runtime/PyIterator.cpp
@@ -1,11 +1,9 @@
-#include "PyIterator.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/StopIteration.hpp"
-#include "runtime/Value.hpp"
-#include "runtime/ValueError.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include <limits>
+module;
+#include "memory/allocate.hpp"
+#include <cstddef>
+
+module py.runtime;
+import py.types;
 
 
 using namespace py;
@@ -84,4 +82,4 @@ std::function<std::unique_ptr<TypePrototype>()> PyIterator::type_factory()
 		std::call_once(iterator_flag, []() { type = register_iterator(); });
 		return std::move(type);
 	};
-}
\ No newline at end of file
+}
diff --git a/src/runtime/PyIterator.hpp b/src/runtime/PyIterator.cppm
similarity index 63%
rename from src/runtime/PyIterator.hpp
rename to src/runtime/PyIterator.cppm
index 7588fb6f..521cc45a 100644
--- a/src/runtime/PyIterator.hpp
+++ b/src/runtime/PyIterator.cppm
@@ -1,15 +1,22 @@
-#pragma once
-
-#include "PyObject.hpp"
+module;
+#include "memory/allocate.hpp"
 #include <cstddef>
 
-namespace py {
+export module py.runtime:iterator;
+import :object;
+import py.memory;
+import std;
+
+export namespace py {
+struct Number;
+class PyType;
 
 class PyIterator : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
-	size_t m_index{ 0 };
+	std::size_t m_index{ 0 };
 	PyObject *m_iterator{ nullptr };
 
 	PyIterator(PyObject *iterator);
@@ -21,7 +28,7 @@ class PyIterator : public PyBaseObject
 	PyResult<PyObject *> __iter__() const;
 	PyResult<PyObject *> __next__();
 
-	PyResult<size_t> __len__() const;
+	PyResult<std::size_t> __len__() const;
 
 	PyType *static_type() const override;
 
diff --git a/src/runtime/PyLLVMFunction.cpp b/src/runtime/PyLLVMFunction.cpp
index 289ffb57..187c054b 100644
--- a/src/runtime/PyLLVMFunction.cpp
+++ b/src/runtime/PyLLVMFunction.cpp
@@ -1,7 +1,8 @@
-#include "PyLLVMFunction.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
@@ -14,7 +15,7 @@ PyLLVMFunction::PyLLVMFunction(std::string &&name, FunctionType &&function)
 
 std::string PyLLVMFunction::to_string() const
 {
-	return fmt::format("LLVM JIT function {} at {}", m_name, (void *)this);
+	return std::format("LLVM JIT function {} at {}", m_name, (void *)this);
 }
 
 PyResult<PyObject *> PyLLVMFunction::__call__(PyTuple *args, PyDict *kwargs)
diff --git a/src/runtime/PyLLVMFunction.hpp b/src/runtime/PyLLVMFunction.cppm
similarity index 86%
rename from src/runtime/PyLLVMFunction.hpp
rename to src/runtime/PyLLVMFunction.cppm
index 83c8dd12..09494e77 100644
--- a/src/runtime/PyLLVMFunction.hpp
+++ b/src/runtime/PyLLVMFunction.cppm
@@ -1,10 +1,18 @@
-#pragma once
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
 
-#include "MemoryError.hpp"
-#include "PyObject.hpp"
-#include "vm/VM.hpp"
+export module py.runtime:l_l_v_m_function;
+import :vm;
+import :dict;
+import :object;
+import :tuple;
+import :value;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+class PyType;
 
 // Essentially the same as PyNativeFunction, but wraps around a std::function
 // with return type PyObject*, instead of PyResult. This makes it easier to interop
@@ -13,6 +21,7 @@ namespace py {
 class PyLLVMFunction : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	using FunctionType = std::function<PyObject *(PyTuple *, PyDict *)>;
 
 	std::string m_name;
diff --git a/src/runtime/PyList.cpp b/src/runtime/PyList.cpp
index 8f776609..878def91 100644
--- a/src/runtime/PyList.cpp
+++ b/src/runtime/PyList.cpp
@@ -1,36 +1,12 @@
-#include "PyList.hpp"
-#include "IndexError.hpp"
-#include "MemoryError.hpp"
-#include "PyArgParser.hpp"
-#include "PyBool.hpp"
-#include "PyDict.hpp"
-#include "PyFunction.hpp"
-#include "PyGenericAlias.hpp"
-#include "PyInteger.hpp"
-#include "PyNone.hpp"
-#include "PyNumber.hpp"
-#include "PySlice.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "StopIteration.hpp"
-#include "ValueError.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/TypeError.hpp"
-#include "runtime/Value.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
-
-#include <algorithm>
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
 #include <cstddef>
 #include <cstdint>
-#include <limits>
-#include <numeric>
-#include <ranges>
-#include <unordered_set>
-#include <variant>
+#include <gmpxx.h>
 
+module py.runtime;
+import py.types;
 
 namespace py {
 
@@ -704,7 +680,7 @@ PyListIterator::PyListIterator(const PyList &pylist)
 
 std::string PyListIterator::to_string() const
 {
-	return fmt::format("<list_iterator at {}>", static_cast<const void *>(this));
+	return std::format("<list_iterator at {}>", static_cast<const void *>(this));
 }
 
 void PyListIterator::visit_graph(Visitor &visitor)
diff --git a/src/runtime/PyList.hpp b/src/runtime/PyList.cppm
similarity index 79%
rename from src/runtime/PyList.hpp
rename to src/runtime/PyList.cppm
index 73aea996..7748b366 100644
--- a/src/runtime/PyList.hpp
+++ b/src/runtime/PyList.cppm
@@ -1,14 +1,22 @@
-#pragma once
+module;
 
-#include "PyObject.hpp"
+#include "memory/allocate.hpp"
 
-namespace py {
+export module py.runtime:list;
+
+import :object;
+import std;
+import py.memory;
+
+export namespace py {
+class PyType;
 
 class PyList
 	: public PyBaseObject
 	, PySequence
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	std::vector<Value> m_elements;
 
@@ -27,14 +35,14 @@ class PyList
 	PyResult<PyObject *> __iter__() const;
 	PyResult<PyObject *> __getitem__(PyObject *index);
 	PyResult<std::monostate> __setitem__(PyObject *index, PyObject *value);
-	PyResult<size_t> __len__() const;
+	PyResult<std::size_t> __len__() const;
 
-	PyResult<PyObject *> __getitem__(int64_t index);
-	PyResult<std::monostate> __setitem__(int64_t index, PyObject *value);
+	PyResult<PyObject *> __getitem__(std::int64_t index);
+	PyResult<std::monostate> __setitem__(std::int64_t index, PyObject *value);
 	PyResult<std::monostate> __delitem__(PyObject *key);
 
 	PyResult<PyObject *> __add__(const PyObject *other) const;
-	PyResult<PyObject *> __mul__(size_t count) const;
+	PyResult<PyObject *> __mul__(std::size_t count) const;
 	PyResult<PyObject *> __eq__(const PyObject *other) const;
 
 	const std::vector<Value> &elements() const { return m_elements; }
@@ -64,9 +72,10 @@ class PyList
 class PyListIterator : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	const PyList &m_pylist;
-	size_t m_current_index{ 0 };
+	std::size_t m_current_index{ 0 };
 
   public:
 	PyListIterator(const PyList &pylist);
@@ -85,14 +94,15 @@ class PyListIterator : public PyBaseObject
 class PyListReverseIterator : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	std::optional<std::reference_wrapper<PyList>> m_pylist;
-	size_t m_current_index{ 0 };
+	std::size_t m_current_index{ 0 };
 
   private:
 	PyListReverseIterator(PyType *);
 
-	PyListReverseIterator(PyList &pylist, size_t start_index);
+	PyListReverseIterator(PyList &pylist, std::size_t start_index);
 
   public:
 	static PyResult<PyListReverseIterator *> create(PyList &);
diff --git a/src/runtime/PyMap.cpp b/src/runtime/PyMap.cpp
index 646f9dda..fd45e851 100644
--- a/src/runtime/PyMap.cpp
+++ b/src/runtime/PyMap.cpp
@@ -1,7 +1,11 @@
-#include "PyMap.hpp"
-#include "PyList.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
@@ -13,7 +17,7 @@ PyMap::PyMap(PyType *type, PyObject *func, PyTuple *iters)
 
 std::string PyMap::to_string() const
 {
-	return fmt::format("<map object at {}>", static_cast<const void *>(this));
+	return std::format("<map object at {}>", static_cast<const void *>(this));
 }
 
 
diff --git a/src/runtime/PyMap.hpp b/src/runtime/PyMap.cppm
similarity index 72%
rename from src/runtime/PyMap.hpp
rename to src/runtime/PyMap.cppm
index 241952d4..c4002f04 100644
--- a/src/runtime/PyMap.hpp
+++ b/src/runtime/PyMap.cppm
@@ -1,12 +1,21 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
+export module py.runtime:map;
+import :object;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+struct Number;
+class PyTuple;
+class PyDict;
+class PyType;
 
 class PyMap : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	PyObject *m_func{ nullptr };
 	PyTuple *m_iters{ nullptr };
diff --git a/src/runtime/PyMappingProxy.cpp b/src/runtime/PyMappingProxy.cpp
index f2498dfa..2b8b125f 100644
--- a/src/runtime/PyMappingProxy.cpp
+++ b/src/runtime/PyMappingProxy.cpp
@@ -1,7 +1,11 @@
-#include "PyMappingProxy.hpp"
-#include "MemoryError.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 PyMappingProxy::PyMappingProxy(PyType *type) : PyBaseObject(type) {}
@@ -36,7 +40,7 @@ PyResult<PyObject *> PyMappingProxy::__new__(const PyType *type, PyTuple *args,
 PyResult<PyObject *> PyMappingProxy::__repr__() const
 {
 	if (auto r = m_mapping->repr(); r.is_ok()) {
-		return PyString::create(fmt::format("mappingproxy({})", r.unwrap()->to_string()));
+		return PyString::create(std::format("mappingproxy({})", r.unwrap()->to_string()));
 	} else {
 		return r;
 	}
diff --git a/src/runtime/PyMappingProxy.hpp b/src/runtime/PyMappingProxy.cppm
similarity index 77%
rename from src/runtime/PyMappingProxy.hpp
rename to src/runtime/PyMappingProxy.cppm
index 0e4000b8..b84f6ef9 100644
--- a/src/runtime/PyMappingProxy.hpp
+++ b/src/runtime/PyMappingProxy.cppm
@@ -1,11 +1,20 @@
-#pragma once
-
-#include "PyObject.hpp"
-
-namespace py {
+module;
+#include "memory/allocate.hpp"
+
+export module py.runtime:mapping_proxy;
+import :object;
+import py.memory;
+import std;
+
+export namespace py {
+struct Number;
+class PyTuple;
+class PyDict;
+class PyType;
 class PyMappingProxy : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	PyObject *m_mapping{ nullptr };
 
diff --git a/src/runtime/PyMemberDescriptor.cpp b/src/runtime/PyMemberDescriptor.cpp
index e159b136..57c79a5d 100644
--- a/src/runtime/PyMemberDescriptor.cpp
+++ b/src/runtime/PyMemberDescriptor.cpp
@@ -1,12 +1,9 @@
-#include "PyMemberDescriptor.hpp"
-#include "MemoryError.hpp"
-#include "PyString.hpp"
-#include "PyType.hpp"
-#include "TypeError.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
@@ -57,7 +54,7 @@ void PyMemberDescriptor::visit_graph(Visitor &visitor)
 
 std::string PyMemberDescriptor::to_string() const
 {
-	return fmt::format(
+	return std::format(
 		"<member '{}' of '{}' objects>", m_name->to_string(), m_underlying_type->name());
 }
 
diff --git a/src/runtime/PyMemberDescriptor.hpp b/src/runtime/PyMemberDescriptor.cppm
similarity index 83%
rename from src/runtime/PyMemberDescriptor.hpp
rename to src/runtime/PyMemberDescriptor.cppm
index e813cae8..5c6b1625 100644
--- a/src/runtime/PyMemberDescriptor.hpp
+++ b/src/runtime/PyMemberDescriptor.cppm
@@ -1,9 +1,15 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
-#include "vm/VM.hpp"
+export module py.runtime:member_descriptor;
+import :object;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+struct Number;
+class PyString;
+class PyType;
 
 class PyMemberDescriptor : public PyBaseObject
 {
@@ -13,6 +19,7 @@ class PyMemberDescriptor : public PyBaseObject
 	std::function<PyResult<std::monostate>(PyObject *, PyObject *)> m_member_setter;
 
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	PyMemberDescriptor(PyType *);
 
diff --git a/src/runtime/PyMemoryView.cpp b/src/runtime/PyMemoryView.cpp
index 07133190..bc1f76d5 100644
--- a/src/runtime/PyMemoryView.cpp
+++ b/src/runtime/PyMemoryView.cpp
@@ -1,29 +1,13 @@
-#include "PyMemoryView.hpp"
-#include "runtime/NotImplementedError.hpp"
-#include "runtime/PyBool.hpp"
-#include "runtime/PyBytes.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFloat.hpp"
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/TypeError.hpp"
-#include "runtime/Value.hpp"
-#include "runtime/ValueError.hpp"
-#include "runtime/forward.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "utilities.hpp"
-#include <algorithm>
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
 #include <cstddef>
 #include <cstdint>
-#include <functional>
-#include <iterator>
-#include <memory>
-#include <string_view>
+#include <sys/types.h>
+
+module py.runtime;
+import py.types;
 
 namespace py {
 
@@ -102,60 +86,60 @@ namespace {
 		case 'c': {
 			Bytes b;
 			b.b.reserve(1);
-			b.b.push_back(static_cast<std::byte>(*bit_cast<char *>(ptr)));
+			b.b.push_back(static_cast<std::byte>(*std::bit_cast<char *>(ptr)));
 			return PyBytes::create(std::move(b));
 		} break;
 		case 'b': {
-			return PyInteger::create(*bit_cast<char *>(ptr));
+			return PyInteger::create(*std::bit_cast<char *>(ptr));
 		} break;
 		case 'B': {
-			return PyInteger::create(*bit_cast<unsigned char *>(ptr));
+			return PyInteger::create(*std::bit_cast<unsigned char *>(ptr));
 		} break;
 		case 'h': {
-			return PyInteger::create(*bit_cast<short *>(ptr));
+			return PyInteger::create(*std::bit_cast<short *>(ptr));
 		} break;
 		case 'H': {
-			return PyInteger::create(*bit_cast<unsigned short *>(ptr));
+			return PyInteger::create(*std::bit_cast<unsigned short *>(ptr));
 		} break;
 		case 'i': {
-			return PyInteger::create(*bit_cast<int32_t *>(ptr));
+			return PyInteger::create(*std::bit_cast<int32_t *>(ptr));
 		} break;
 		case 'I': {
-			return PyInteger::create(*bit_cast<uint32_t *>(ptr));
+			return PyInteger::create(*std::bit_cast<uint32_t *>(ptr));
 		} break;
 		case 'l': {
-			return PyInteger::create(*bit_cast<int32_t *>(ptr));
+			return PyInteger::create(*std::bit_cast<int32_t *>(ptr));
 		} break;
 		case 'L': {
-			return PyInteger::create(*bit_cast<uint32_t *>(ptr));
+			return PyInteger::create(*std::bit_cast<uint32_t *>(ptr));
 		} break;
 		case 'q': {
-			return PyInteger::create(*bit_cast<int64_t *>(ptr));
+			return PyInteger::create(*std::bit_cast<int64_t *>(ptr));
 		} break;
 		case 'Q': {
-			return PyInteger::create(*bit_cast<uint64_t *>(ptr));
+			return PyInteger::create(*std::bit_cast<uint64_t *>(ptr));
 		} break;
 		case 'n': {
-			return PyInteger::create(*bit_cast<ssize_t *>(ptr));
+			return PyInteger::create(*std::bit_cast<ssize_t *>(ptr));
 		} break;
 		case 'N': {
-			return PyInteger::create(*bit_cast<size_t *>(ptr));
+			return PyInteger::create(*std::bit_cast<size_t *>(ptr));
 		} break;
 		case 'f': {
-			return PyFloat::create(static_cast<double>(*bit_cast<float *>(ptr)));
+			return PyFloat::create(static_cast<double>(*std::bit_cast<float *>(ptr)));
 		} break;
 		case 'd': {
-			return PyFloat::create(*bit_cast<double *>(ptr));
+			return PyFloat::create(*std::bit_cast<double *>(ptr));
 		} break;
 		case '?': {
-			if (*bit_cast<bool *>(ptr)) {
+			if (*std::bit_cast<bool *>(ptr)) {
 				return Ok(py_true());
 			} else {
 				return Ok(py_false());
 			}
 		} break;
 		case 'P': {
-			return PyInteger::create(*bit_cast<size_t *>(ptr));
+			return PyInteger::create(*std::bit_cast<size_t *>(ptr));
 		} break;
 		}
 
@@ -396,16 +380,21 @@ PyType *PyMemoryView::static_type() const { return types::memoryview(); }
 void PyMemoryView::visit_graph(Visitor &visitor)
 {
 	PyObject::visit_graph(visitor);
-	if (m_view.obj && !m_view.readonly) { visitor.visit(*m_view.obj); }
-	if (m_managed_buffer && m_managed_buffer->m_main_view.obj
-		&& !m_managed_buffer->m_main_view.readonly) {
+	// A view must root its backing object whether or not it is readonly: readonly
+	// governs writing *through* the view, not whether the view holds a reference.
+	// Because a memoryview over immutable bytes is always readonly, skipping those
+	// left BufferedWriter::raw_write's PyBytes unrooted - it was collected during
+	// the allocations that follow, and the raw stream then copied recycled memory.
+	// Reproduces with --gc-frequency 1.
+	if (m_view.obj) { visitor.visit(*m_view.obj); }
+	if (m_managed_buffer && m_managed_buffer->m_main_view.obj) {
 		visitor.visit(*m_managed_buffer->m_main_view.obj);
 	}
 }
 
 std::string PyMemoryView::to_string() const
 {
-	return fmt::format("<memory at {}>", static_cast<const void *>(this));
+	return std::format("<memory at {}>", static_cast<const void *>(this));
 }
 
 }// namespace py
diff --git a/src/runtime/PyMemoryView.hpp b/src/runtime/PyMemoryView.cppm
similarity index 74%
rename from src/runtime/PyMemoryView.hpp
rename to src/runtime/PyMemoryView.cppm
index 1d5c6972..de93158b 100644
--- a/src/runtime/PyMemoryView.hpp
+++ b/src/runtime/PyMemoryView.cppm
@@ -1,15 +1,21 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/Value.hpp"
+export module py.runtime:memory_view;
+import :object;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+struct Number;
+class PyTuple;
+class PyDict;
+class PyType;
 
 class PyMemoryView : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	struct ManagedBuffer
 	{
@@ -29,7 +35,7 @@ class PyMemoryView : public PyBaseObject
 	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
 	PyResult<PyObject *> __repr__() const;
 
-	PyResult<size_t> __len__() const;
+	PyResult<std::size_t> __len__() const;
 
 	PyResult<PyObject *> cast(PyTuple *args, PyDict *kwargs);
 	PyResult<PyObject *> tolist();
@@ -40,11 +46,10 @@ class PyMemoryView : public PyBaseObject
 	void visit_graph(Visitor &) override;
 	std::string to_string() const override;
 
-	size_t itemsize() const { return m_view.itemsize; }
+	std::size_t itemsize() const { return m_view.itemsize; }
 
 	PyResult<std::monostate> __getbuffer__(PyBuffer &view, int /*flags*/);
 
-
   private:
 	static PyResult<PyBuffer> create_view(PyBuffer &main_view);
 };
diff --git a/src/runtime/PyMethodDescriptor.cpp b/src/runtime/PyMethodDescriptor.cpp
index e290740c..a46e6d84 100644
--- a/src/runtime/PyMethodDescriptor.cpp
+++ b/src/runtime/PyMethodDescriptor.cpp
@@ -1,11 +1,11 @@
-#include "PyMethodDescriptor.hpp"
-#include "PyFunction.hpp"
-#include "PyString.hpp"
-#include "PyType.hpp"
-#include "TypeError.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
@@ -55,7 +55,7 @@ void PyMethodDescriptor::visit_graph(Visitor &visitor)
 
 std::string PyMethodDescriptor::to_string() const
 {
-	return fmt::format(
+	return std::format(
 		"<method '{}' of '{}' objects>", m_name->to_string(), m_underlying_type->name());
 }
 
diff --git a/src/runtime/PyMethodDescriptor.hpp b/src/runtime/PyMethodDescriptor.cppm
similarity index 83%
rename from src/runtime/PyMethodDescriptor.hpp
rename to src/runtime/PyMethodDescriptor.cppm
index b0aa781c..7ed9ff1b 100644
--- a/src/runtime/PyMethodDescriptor.hpp
+++ b/src/runtime/PyMethodDescriptor.cppm
@@ -1,10 +1,18 @@
-#pragma once
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
 
-#include "MemoryError.hpp"
-#include "PyObject.hpp"
-#include "vm/VM.hpp"
+export module py.runtime:method_descriptor;
+import :object;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+struct Number;
+class PyTuple;
+class PyString;
+class PyDict;
+class PyType;
 
 class PyMethodDescriptor : public PyBaseObject
 {
@@ -14,6 +22,7 @@ class PyMethodDescriptor : public PyBaseObject
 	std::vector<PyObject *> m_captures;
 
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	PyMethodDescriptor(PyType *);
 
diff --git a/src/runtime/PyModule.cpp b/src/runtime/PyModule.cpp
index 3b291c00..1b122b94 100644
--- a/src/runtime/PyModule.cpp
+++ b/src/runtime/PyModule.cpp
@@ -1,21 +1,13 @@
-#include "PyModule.hpp"
-#include "MemoryError.hpp"
-#include "PyArgParser.hpp"
-#include "PyDict.hpp"
-#include "PyList.hpp"
-#include "PyString.hpp"
-#include "ValueError.hpp"
-#include "executable/Program.hpp"
-#include "executable/bytecode/codegen/BytecodeGenerator.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "modules/Modules.hpp"
-#include "parser/Parser.hpp"
-#include "runtime/AttributeError.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
-
-#include <filesystem>
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import py.types;
+import py.codegen;
+
 
 namespace py {
 
@@ -46,7 +38,7 @@ PyResult<PyObject *> PyModule::__repr__() const
 			return obj->call(PyTuple::create(const_cast<PyModule *>(this)).unwrap(), nullptr);
 		});
 	} else {
-		return PyString::create(fmt::format("<module {}>", m_module_name->value()));
+		return PyString::create(std::format("<module {}>", m_module_name->value()));
 	}
 }
 
@@ -165,7 +157,7 @@ void PyModule::visit_graph(Visitor &visitor)
 
 std::string PyModule::to_string() const
 {
-	return fmt::format("<module '{}'>", m_module_name->to_string());
+	return std::format("<module '{}'>", m_module_name->to_string());
 }
 
 PyResult<PyModule *> PyModule::create(PyDict *symbol_table, PyString *module_name, PyObject *doc)
diff --git a/src/runtime/PyModule.hpp b/src/runtime/PyModule.cppm
similarity index 83%
rename from src/runtime/PyModule.hpp
rename to src/runtime/PyModule.cppm
index 3b2fa7aa..05bd1c99 100644
--- a/src/runtime/PyModule.hpp
+++ b/src/runtime/PyModule.cppm
@@ -1,9 +1,14 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
-#include "PyString.hpp"
+export module py.runtime:pymodule;
+import :object;
+import py.memory;
 
-namespace py {
+export class Program;
+
+export namespace py {
+class PyType;
 
 class PyModule : public PyBaseObject
 {
@@ -18,9 +23,9 @@ class PyModule : public PyBaseObject
   private:
 	PyObject *m_module_context{ nullptr };
 
-
   private:
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	friend class VM;
 
 	std::shared_ptr<Program> m_program;
@@ -32,7 +37,7 @@ class PyModule : public PyBaseObject
 
 	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
 
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs);
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs);
 
 	static PyResult<PyModule *> create(PyDict *symbol_table, PyString *module_name, PyObject *doc);
 
diff --git a/src/runtime/PyNamespace.cpp b/src/runtime/PyNamespace.cpp
index c69fe09c..b41c50b7 100644
--- a/src/runtime/PyNamespace.cpp
+++ b/src/runtime/PyNamespace.cpp
@@ -1,10 +1,12 @@
-#include "PyNamespace.hpp"
-#include "MemoryError.hpp"
-#include "NotImplemented.hpp"
-#include "PyDict.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import py.types;
 
 namespace py {
 
@@ -52,7 +54,7 @@ PyResult<PyObject *> PyNamespace::__new__(const PyType *type, PyTuple *, PyDict
 
 PyResult<int32_t> PyNamespace::__init__(PyTuple *args, PyDict *kwargs)
 {
-	if (args || args->size() > 0) { return Err(type_error("no positional arguments expected")); }
+	if (!args || args->size() > 0) { return Err(type_error("no positional arguments expected")); }
 	if (kwargs) {
 		for (const auto &[key, value] : kwargs->map()) {
 			if (std::holds_alternative<PyObject *>(key)) {
@@ -121,7 +123,7 @@ std::string PyNamespace::to_string() const
 		i++;
 		if (i != m_dict->map().size()) { ss << ", "; }
 	}
-	return fmt::format("namespace({})", ss.str());
+	return std::format("namespace({})", ss.str());
 }
 
 
diff --git a/src/runtime/PyNamespace.hpp b/src/runtime/PyNamespace.cppm
similarity index 70%
rename from src/runtime/PyNamespace.hpp
rename to src/runtime/PyNamespace.cppm
index 5035e496..3cb0ee33 100644
--- a/src/runtime/PyNamespace.hpp
+++ b/src/runtime/PyNamespace.cppm
@@ -1,12 +1,21 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
+export module py.runtime:pynamespace;
+import :object;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+struct Number;
+class PyTuple;
+class PyDict;
+class PyType;
 
 class PyNamespace : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
   public:
 	PyDict *m_dict{ nullptr };
@@ -24,7 +33,7 @@ class PyNamespace : public PyBaseObject
 	static PyResult<PyNamespace *> create(PyDict *dict);
 
 	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs);
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs);
 
 	PyResult<PyObject *> __repr__() const;
 	PyResult<PyObject *> __eq__(const PyObject *obj) const;
diff --git a/src/runtime/PyNone.cpp b/src/runtime/PyNone.cpp
index 9c7a4e66..56b423be 100644
--- a/src/runtime/PyNone.cpp
+++ b/src/runtime/PyNone.cpp
@@ -1,8 +1,9 @@
-#include "PyNone.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
diff --git a/src/runtime/PyNone.hpp b/src/runtime/PyNone.cppm
similarity index 76%
rename from src/runtime/PyNone.hpp
rename to src/runtime/PyNone.cppm
index 1d45a505..6c182837 100644
--- a/src/runtime/PyNone.hpp
+++ b/src/runtime/PyNone.cppm
@@ -1,12 +1,18 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
+export module py.runtime:none;
+import :object;
+import std;
+import py.memory;
 
-namespace py {
+export namespace py {
+class PyType;
 
 class PyNone : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	friend PyObject *py_none();
 
 	bool m_value;
diff --git a/src/runtime/PyNumber.cpp b/src/runtime/PyNumber.cpp
index 39f45e9c..2acdb2b3 100644
--- a/src/runtime/PyNumber.cpp
+++ b/src/runtime/PyNumber.cpp
@@ -1,19 +1,12 @@
-#include "PyNumber.hpp"
-#include "NotImplemented.hpp"
-#include "PyFloat.hpp"
-#include "PyInteger.hpp"
-#include "PyNone.hpp"
-#include "PyObject.hpp"
-#include "PyString.hpp"
-#include "PyType.hpp"
-#include "TypeError.hpp"
-#include "Value.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/ValueError.hpp"
-#include "types/builtin.hpp"
-
+module;
+#include "core.hpp"
 #include <cmath>
-#include <variant>
+#include <gmpxx.h>
+
+module py.runtime;
+import py.types;
+import std;
+
 
 namespace py {
 
diff --git a/src/runtime/PyNumber.hpp b/src/runtime/PyNumber.cppm
similarity index 88%
rename from src/runtime/PyNumber.hpp
rename to src/runtime/PyNumber.cppm
index 02d04b41..a75aa3f3 100644
--- a/src/runtime/PyNumber.hpp
+++ b/src/runtime/PyNumber.cppm
@@ -1,13 +1,20 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
-#include "runtime/Value.hpp"
+export module py.runtime:number;
 
-namespace py {
+import :object;
+import std;
+import py.memory;
+
+export namespace py {
+class PyType;
+class PyInteger;
 
 class PyNumber : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	friend Interface<PyNumber, PyInteger>;
 	friend class PyFloat;
 
diff --git a/src/runtime/PyNumber_tests.cpp b/src/runtime/PyNumber_tests.cpp
index b49d6bb9..9cfa100c 100644
--- a/src/runtime/PyNumber_tests.cpp
+++ b/src/runtime/PyNumber_tests.cpp
@@ -1,7 +1,7 @@
-#include "PyNumber.hpp"
-
 #include "gtest/gtest.h"
 
+import py.runtime;
+
 using namespace py;
 using namespace py::concepts;
 
@@ -9,4 +9,4 @@ TEST(PyNumber, SatisfiesRelevantConcepts)
 {
 	// ASSERT_TRUE(HasAdd<PyNumber>);
 	// ASSERT_TRUE(HasRepr<PyNumber>);
-}
\ No newline at end of file
+}
diff --git a/src/runtime/PyObject.cpp b/src/runtime/PyObject.cpp
index a80657e1..40e71e2a 100644
--- a/src/runtime/PyObject.cpp
+++ b/src/runtime/PyObject.cpp
@@ -1,30 +1,18 @@
-#include "PyObject.hpp"
-
-#include "AttributeError.hpp"
-#include "NotImplemented.hpp"
-#include "NotImplementedError.hpp"
-#include "PyBool.hpp"
-#include "PyBytes.hpp"
-#include "PyDict.hpp"
-#include "PyEllipsis.hpp"
-#include "PyGenericAlias.hpp"
-#include "PyInteger.hpp"
-#include "PyIterator.hpp"
-#include "PyNone.hpp"
-#include "PyNumber.hpp"
-#include "PySlotWrapper.hpp"
-#include "PyStaticMethod.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "PyType.hpp"
-#include "StopIteration.hpp"
-#include "TypeError.hpp"
-#include "runtime/Value.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-
-#include "vm/VM.hpp"
-#include <variant>
+module;
+#include "core.hpp"
+
+// The global-namespace C names (size_t, the intN_t family): `import std;` below
+// exports only the std:: spellings, and this file uses the unqualified ones.
+#include <cstddef>
+#include <cstdint>
+
+// mpz_class comparison operators (BigIntType)
+#include <gmpxx.h>
+
+module py.runtime;
+import py.types;
+import std;
+
 
 namespace py {
 
@@ -71,18 +59,18 @@ size_t ValueHash::operator()(const Value &value) const
 				   },
 			[](const String &s) -> size_t { return std::hash<std::string>{}(s.s); },
 			[](const Bytes &b) -> size_t {
-				std::string_view sv{ bit_cast<char *>(b.b.data()), b.b.size() };
+				std::string_view sv{ std::bit_cast<char *>(b.b.data()), b.b.size() };
 				return static_cast<int64_t>(std::hash<std::string_view>{}(sv));
 			},
-			[](const Ellipsis &) -> size_t { return ::bit_cast<size_t>(py_ellipsis()); },
+			[](const Ellipsis &) -> size_t { return std::bit_cast<size_t>(py_ellipsis()); },
 			[](const NameConstant &c) -> size_t {
 				if (std::holds_alternative<bool>(c.value)) {
 					return std::get<bool>(c.value) ? 0 : 1;
 				} else {
-					return bit_cast<size_t>(py_none()) >> 4;
+					return std::bit_cast<size_t>(py_none()) >> 4;
 				}
 			},
-			[](const Tuple &t) -> size_t { return ::bit_cast<size_t>(t.elements.data()); },
+			[](const Tuple &t) -> size_t { return std::bit_cast<size_t>(t.elements.data()); },
 			[](PyObject *obj) -> size_t {
 				auto val = obj->hash();
 				ASSERT(val.is_ok());
@@ -424,7 +412,7 @@ void PyObject::visit_graph(Visitor &visitor)
 	if (m_attributes) { visitor.visit(*m_attributes); }
 	for (size_t i = 0, offset = type()->underlying_type().basicsize; i < type()->__slots__.size();
 		++i, offset += sizeof(PyObject *)) {
-		auto *slot = *bit_cast<PyObject **>(bit_cast<uint8_t *>(this) + offset);
+		auto *slot = *std::bit_cast<PyObject **>(std::bit_cast<uint8_t *>(this) + offset);
 		if (slot) { visitor.visit(*slot); }
 	}
 	if (std::holds_alternative<PyType *>(m_type)) {
@@ -474,7 +462,7 @@ PyResult<std::monostate> PyObject::get_buffer(PyBuffer &buffer, int flags)
 
 PyResult<PyObject *> PyObject::__repr__() const
 {
-	return PyString::create(fmt::format(
+	return PyString::create(std::format(
 		"<{} object at {}>", type_prototype().__name__, static_cast<const void *>(this)));
 }
 
@@ -1364,7 +1352,7 @@ PyResult<std::monostate> PyObject::__delattribute__(PyObject *attribute)
 	return Ok(std::monostate{});
 }
 
-PyResult<int64_t> PyObject::__hash__() const { return Ok(bit_cast<size_t>(this) >> 4); }
+PyResult<int64_t> PyObject::__hash__() const { return Ok(std::bit_cast<size_t>(this) >> 4); }
 
 bool PyObject::is_callable() const { return type_prototype().__call__.has_value(); }
 
@@ -1440,7 +1428,7 @@ PyResult<int32_t> PyObject::__init__(PyTuple *args, PyDict *kwargs)
 
 std::string PyObject::to_string() const
 {
-	return fmt::format("PyObject at {}", static_cast<const void *>(this));
+	return std::format("PyObject at {}", static_cast<const void *>(this));
 }
 
 PyType *PyObject::type() const
diff --git a/src/runtime/PyObject.hpp b/src/runtime/PyObject.cppm
similarity index 90%
rename from src/runtime/PyObject.hpp
rename to src/runtime/PyObject.cppm
index 4d16e027..da8a4a4e 100644
--- a/src/runtime/PyObject.hpp
+++ b/src/runtime/PyObject.cppm
@@ -1,22 +1,23 @@
-#pragma once
+module;
 
-#include "../utilities.hpp"
-#include "Value.hpp"
-#include "concepts.hpp"
-#include "forward.hpp"
-#include "memory/GarbageCollector.hpp"
-#include "runtime/forward.hpp"
-#include "vm/VM.hpp"
+#include "core.hpp"
+#include "memory/allocate.hpp"
 
 #include <cstddef>
-#include <functional>
-#include <memory>
-#include <optional>
-#include <string>
+#include <cstdint>
 
-#include <spdlog/fmt/fmt.h>
+export module py.runtime:object;
 
-namespace py {
+import std;
+import :concepts;
+import py.memory;
+
+export namespace py {
+struct Number;
+
+template<typename T> struct klass;
+
+class PyString;
 
 enum class RichCompare {
 	Py_LT = 0,// <
@@ -27,8 +28,6 @@ enum class RichCompare {
 	Py_GE = 5,// >=
 };
 
-class PyObject;
-
 class MethodFlags
 {
 	std::bitset<10> m_flags;
@@ -51,11 +50,11 @@ class MethodFlags
 	template<typename... Args> static MethodFlags create(Args... args)
 	{
 		MethodFlags f;
-		(f.m_flags.set(static_cast<uint8_t>(args)), ...);
+		(f.m_flags.set(static_cast<std::uint8_t>(args)), ...);
 		return f;
 	}
 
-	bool is_set(Flag f) const { return m_flags.test(static_cast<size_t>(f)); }
+	bool is_set(Flag f) const { return m_flags.test(static_cast<std::size_t>(f)); }
 
 	const std::bitset<10> &flags() const { return m_flags; }
 };
@@ -89,7 +88,7 @@ using CallSlotFunctionType = std::function<PyResult<PyObject *>(PyObject *, PyTu
 using StrSlotFunctionType = std::function<PyResult<PyObject *>(PyObject *)>;
 using NewSlotFunctionType =
 	std::function<PyResult<PyObject *>(const PyType *, PyTuple *, PyDict *)>;
-using InitSlotFunctionType = std::function<PyResult<int32_t>(PyObject *, PyTuple *, PyDict *)>;
+using InitSlotFunctionType = std::function<PyResult<std::int32_t>(PyObject *, PyTuple *, PyDict *)>;
 
 using GetAttroFunctionType = std::function<PyResult<PyObject *>(const PyObject *, PyObject *)>;
 using SetAttroFunctionType =
@@ -107,14 +106,15 @@ using SetItemSlotFunctionType =
 	std::function<PyResult<std::monostate>(PyObject *, PyObject *, PyObject *)>;
 using DelItemSlotFunctionType = std::function<PyResult<std::monostate>(PyObject *, PyObject *)>;
 
-using RepeatSequenceSlotFunctionType = std::function<PyResult<PyObject *>(PyObject *, size_t)>;
-using GetItemSequenceSlotFunctionType = std::function<PyResult<PyObject *>(PyObject *, int64_t)>;
+using RepeatSequenceSlotFunctionType = std::function<PyResult<PyObject *>(PyObject *, std::size_t)>;
+using GetItemSequenceSlotFunctionType =
+	std::function<PyResult<PyObject *>(PyObject *, std::int64_t)>;
 using SetItemSequenceSlotFunctionType =
-	std::function<PyResult<std::monostate>(PyObject *, int64_t, PyObject *)>;
+	std::function<PyResult<std::monostate>(PyObject *, std::int64_t, PyObject *)>;
 using DelItemSequenceSlotFunctionType =
-	std::function<PyResult<std::monostate>(PyObject *, int64_t)>;
+	std::function<PyResult<std::monostate>(PyObject *, std::int64_t)>;
 
-using LenSlotFunctionType = std::function<PyResult<size_t>(const PyObject *)>;
+using LenSlotFunctionType = std::function<PyResult<std::size_t>(const PyObject *)>;
 using BoolSlotFunctionType = std::function<PyResult<bool>(const PyObject *)>;
 using ContainsSlotFunctionType = std::function<PyResult<bool>(PyObject *, PyObject *)>;
 using ReprSlotFunctionType = std::function<PyResult<PyObject *>(const PyObject *)>;
@@ -146,7 +146,7 @@ using AndSlotFunctionType = std::function<PyResult<PyObject *>(PyObject *, PyObj
 using OrSlotFunctionType = std::function<PyResult<PyObject *>(PyObject *, PyObject *)>;
 using XorSlotFunctionType = std::function<PyResult<PyObject *>(PyObject *, PyObject *)>;
 
-using HashSlotFunctionType = std::function<PyResult<int64_t>(const PyObject *)>;
+using HashSlotFunctionType = std::function<PyResult<std::int64_t>(const PyObject *)>;
 using CompareSlotFunctionType =
 	std::function<PyResult<PyObject *>(const PyObject *, const PyObject *)>;
 
@@ -230,14 +230,14 @@ struct PyBuffer
 {
 	std::unique_ptr<Storage> buf;
 	PyObject *obj;
-	int64_t len;
-	int64_t itemsize;
+	std::int64_t len;
+	std::int64_t itemsize;
 	int readonly;
 	int ndim;
 	std::string format;
-	std::vector<int64_t> shape;
-	std::vector<int64_t> strides;
-	std::vector<int64_t> suboffsets;
+	std::vector<std::int64_t> shape;
+	std::vector<std::int64_t> strides;
+	std::vector<std::int64_t> suboffsets;
 	void *internal;
 
 	bool is_ccontiguous() const { return len == 0 || strides.empty(); }
@@ -276,7 +276,7 @@ struct TypePrototype
 
   public:
 	std::string __name__;
-	size_t basicsize;
+	std::size_t basicsize;
 
 	PyType *__base__{ nullptr };
 	std::vector<PyType *> __bases__{ nullptr };
@@ -358,16 +358,16 @@ struct TypePrototype
 };
 
 template<typename T, typename... U>
-size_t get_address(const std::variant<std::function<T(U...)>, PyObject *> &f)
+std::size_t get_address(const std::variant<std::function<T(U...)>, PyObject *> &f)
 {
 	// adapted from https://stackoverflow.com/a/35920804
 	if (std::holds_alternative<std::function<T(U...)>>(f)) {
 		using FunctionType = T (*)(U...);
 		auto fn_ptr = std::get<std::function<T(U...)>>(f).template target<FunctionType>();
-		return bit_cast<size_t>(*fn_ptr);
+		return std::bit_cast<std::size_t>(*fn_ptr);
 	} else {
 		// FIXME: is it valid to take this path? Is there use case?
-		return bit_cast<size_t>(std::get<PyObject *>(f));
+		return std::bit_cast<std::size_t>(std::get<PyObject *>(f));
 	}
 }
 
@@ -379,7 +379,7 @@ class PyMappingWrapper
 
   public:
 	PyMappingWrapper(PyObject *object) : m_object(object) {}
-	PyResult<size_t> len();
+	PyResult<std::size_t> len();
 	PyResult<PyObject *> getitem(PyObject *);// mp_subscript
 	PyResult<std::monostate> setitem(PyObject *, PyObject *);// mp_ass_subscript
 	PyResult<std::monostate> delitem(PyObject *);// mp_ass_subscript
@@ -395,11 +395,11 @@ class PySequenceWrapper
 
   public:
 	PySequenceWrapper(PyObject *object) : m_object(object) {}
-	PyResult<size_t> len();
+	PyResult<std::size_t> len();
 	PyResult<PyObject *> concat(PyObject *other);
-	PyResult<PyObject *> getitem(int64_t);// sq_item
-	PyResult<std::monostate> setitem(int64_t, PyObject *);// sq_ass_item
-	PyResult<std::monostate> delitem(int64_t);// sq_ass_item
+	PyResult<PyObject *> getitem(std::int64_t);// sq_item
+	PyResult<std::monostate> setitem(std::int64_t, PyObject *);// sq_ass_item
+	PyResult<std::monostate> delitem(std::int64_t);// sq_ass_item
 	PyResult<bool> contains(PyObject *);
 	PyResult<PyObject *> repeat(const PyObject *);
 };
@@ -407,6 +407,7 @@ class PySequenceWrapper
 class PyObject : public Cell
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	friend PyMappingWrapper;
 	friend PySequenceWrapper;
 	friend class PyType;
@@ -466,7 +467,7 @@ class PyObject : public Cell
 	PyResult<PyString *> repr() const;
 	PyResult<PyString *> str();
 
-	PyResult<int64_t> hash() const;
+	PyResult<std::int64_t> hash() const;
 
 	PyResult<PyObject *> richcompare(const PyObject *other, RichCompare) const;
 	PyResult<PyObject *> eq(const PyObject *other) const;
@@ -482,15 +483,15 @@ class PyObject : public Cell
 
 	PyResult<PyObject *> call(PyTuple *args, PyDict *kwargs);
 	virtual PyResult<PyObject *> new_(PyTuple *args, PyDict *kwargs) const;
-	PyResult<int32_t> init(PyTuple *args, PyDict *kwargs);
+	PyResult<std::int32_t> init(PyTuple *args, PyDict *kwargs);
 
 	PyResult<PyObject *> getitem(PyObject *key);
-	PyResult<PyObject *> getitem(size_t index);
+	PyResult<PyObject *> getitem(std::size_t index);
 	PyResult<std::monostate> setitem(PyObject *key, PyObject *value);
 	PyResult<std::monostate> delitem(PyObject *key);
 
 	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs);
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs);
 
 	PyResult<PyObject *> __getattribute__(PyObject *attribute) const;
 	PyResult<std::monostate> __setattribute__(PyObject *attribute, PyObject *value);
@@ -498,7 +499,7 @@ class PyObject : public Cell
 	PyResult<PyObject *> __eq__(const PyObject *other) const;
 	PyResult<PyObject *> __ne__(const PyObject *other) const;
 	PyResult<PyObject *> __repr__() const;
-	PyResult<int64_t> __hash__() const;
+	PyResult<std::int64_t> __hash__() const;
 	PyResult<PyObject *> __str__();
 
 	bool is_pyobject() const override { return true; }
@@ -519,7 +520,7 @@ class PyObject : public Cell
 // avoid explicit specialization after instantiations
 template<> PyResult<PyObject *> PyObject::from(PyObject *const &value);
 template<> PyResult<PyObject *> PyObject::from(const Number &value);
-template<> PyResult<PyObject *> PyObject::from(const int64_t &value);
+template<> PyResult<PyObject *> PyObject::from(const std::int64_t &value);
 template<> PyResult<PyObject *> PyObject::from(const String &value);
 template<> PyResult<PyObject *> PyObject::from(const Bytes &value);
 template<> PyResult<PyObject *> PyObject::from(const Ellipsis &value);
@@ -531,10 +532,10 @@ template<> PyResult<PyObject *> PyObject::from(const Value &value);
 // repr/str so str(["a"]) and str(("a",)) both render 'a' with quotes.
 PyResult<PyString *> repr_value(const Value &value);
 
-BaseException *memory_error(size_t failed_allocation_size);
+BaseException *memory_error(std::size_t failed_allocation_size);
 
 namespace detail {
-	size_t slot_count(PyType *);
+	std::size_t slot_count(PyType *);
 }
 
 namespace detail {
@@ -600,15 +601,16 @@ std::unique_ptr<TypePrototype> TypePrototype::create(std::string_view name, Args
 	type_prototype->__bases__ = std::vector<PyType *>{ args... };
 	type_prototype->basicsize = sizeof(Type);
 	type_prototype->__alloc__ = [](PyType *t) -> PyResult<PyObject *> {
-		auto *obj = [t]() -> Type * {
-			if (const auto nslots = py::detail::slot_count(t); nslots > 0) {
-				return VirtualMachine::the().heap().allocate_with_extra_bytes<Type>(
-					nslots * sizeof(PyObject *), t);
-			} else {
-				return VirtualMachine::the().heap().allocate<Type>(t);
-			};
-		}();
-		if (!obj) { return Err(memory_error(sizeof(Type))); }
+		const auto nslots = py::detail::slot_count(t);
+		// Allocator, not std::construct_at: the concrete types keep their
+		// constructors private and befriend ::Heap and detail::Allocator, and
+		// construct_at cannot reach a private constructor the way the placement
+		// new inside Allocator can.
+		auto *obj =
+			detail::Allocator::allocate_with_extra_bytes<Type>(nslots * sizeof(PyObject *), t);
+		// FIXME: this should call Err(memory_error(sizeof(Type))), but would cause circular
+		// dependency
+		if (!obj) { TODO(); }
 		return Ok(obj);
 	};
 
@@ -653,13 +655,13 @@ std::unique_ptr<TypePrototype> TypePrototype::create(std::string_view name, Args
 	}
 	if constexpr (concepts::HasInit<Type>) {
 		type_prototype->__init__ =
-			+[](PyObject *self, PyTuple *args, PyDict *kwargs) -> PyResult<int32_t> {
+			+[](PyObject *self, PyTuple *args, PyDict *kwargs) -> PyResult<std::int32_t> {
 			return static_cast<Type *>(self)->__init__(args, kwargs);
 		};
 	}
 	if constexpr (concepts::HasDoc<Type>) { type_prototype->__doc__ = Type::__doc__; }
 	if constexpr (concepts::HasHash<Type>) {
-		type_prototype->__hash__ = +[](const PyObject *self) -> PyResult<int64_t> {
+		type_prototype->__hash__ = +[](const PyObject *self) -> PyResult<std::int64_t> {
 			return static_cast<const Type *>(self)->__hash__();
 		};
 	}
@@ -715,7 +717,7 @@ std::unique_ptr<TypePrototype> TypePrototype::create(std::string_view name, Args
 	// mapping_type_protocol slots — the protocol struct is created lazily.
 	if constexpr (concepts::HasLength<Type>) {
 		detail::ensure_mapping_proto(*type_prototype).__len__ =
-			+[](const PyObject *self) -> PyResult<size_t> {
+			+[](const PyObject *self) -> PyResult<std::size_t> {
 			return static_cast<const Type *>(self)->__len__();
 		};
 	}
@@ -747,19 +749,19 @@ std::unique_ptr<TypePrototype> TypePrototype::create(std::string_view name, Args
 	}
 	if constexpr (concepts::HasSequenceGetItem<Type>) {
 		detail::ensure_sequence_proto(*type_prototype).__getitem__ =
-			+[](PyObject *self, int64_t index) -> PyResult<PyObject *> {
+			+[](PyObject *self, std::int64_t index) -> PyResult<PyObject *> {
 			return static_cast<Type *>(self)->__getitem__(index);
 		};
 	}
 	if constexpr (concepts::HasSequenceSetItem<Type>) {
 		detail::ensure_sequence_proto(*type_prototype).__setitem__ =
-			+[](PyObject *self, int64_t index, PyObject *value) -> PyResult<std::monostate> {
+			+[](PyObject *self, std::int64_t index, PyObject *value) -> PyResult<std::monostate> {
 			return static_cast<Type *>(self)->__setitem__(index, value);
 		};
 	}
 	if constexpr (concepts::HasSequenceDelItem<Type>) {
 		detail::ensure_sequence_proto(*type_prototype).__delitem__ =
-			+[](PyObject *self, int64_t index) -> PyResult<std::monostate> {
+			+[](PyObject *self, std::int64_t index) -> PyResult<std::monostate> {
 			return static_cast<Type *>(self)->__delitem__(index);
 		};
 	}
@@ -779,7 +781,7 @@ std::unique_ptr<TypePrototype> TypePrototype::create(std::string_view name, Args
 	}
 	if constexpr (std::is_base_of_v<PySequence, Type> && concepts::HasRepeat<Type>) {
 		detail::ensure_sequence_proto(*type_prototype).__repeat__ =
-			+[](const PyObject *self, size_t count) -> PyResult<PyObject *> {
+			+[](const PyObject *self, std::size_t count) -> PyResult<PyObject *> {
 			return static_cast<const Type *>(self)->__mul__(count);
 		};
 	} else if constexpr (concepts::HasMul<Type>) {
@@ -824,7 +826,7 @@ class PyBaseObject : public PyObject
 
 struct ValueHash
 {
-	size_t operator()(const Value &value) const;
+	std::size_t operator()(const Value &value) const;
 };
 
 struct ValueEq
@@ -832,4 +834,7 @@ struct ValueEq
 	bool operator()(const Value &lhs, const Value &rhs) const;
 };
 
+template<typename T> T *as(PyObject *node);
+template<typename T> const T *as(const PyObject *node);
+
 }// namespace py
diff --git a/src/runtime/PyProperty.cpp b/src/runtime/PyProperty.cpp
index 78e0088f..b4e79ad4 100644
--- a/src/runtime/PyProperty.cpp
+++ b/src/runtime/PyProperty.cpp
@@ -1,15 +1,11 @@
-#include "PyProperty.hpp"
-#include "AttributeError.hpp"
-#include "PyArgParser.hpp"
-#include "PyDict.hpp"
-#include "PyFunction.hpp"
-#include "PyNone.hpp"
-#include "PyString.hpp"
-#include "PyType.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
@@ -77,7 +73,7 @@ PyProperty::PyProperty(PyObject *fget, PyObject *fset, PyObject *fdel, PyObject
 
 std::string PyProperty::to_string() const
 {
-	return fmt::format("<property object at {}>", static_cast<const void *>(this));
+	return std::format("<property object at {}>", static_cast<const void *>(this));
 }
 
 PyResult<PyProperty *>
diff --git a/src/runtime/PyProperty.hpp b/src/runtime/PyProperty.cppm
similarity index 82%
rename from src/runtime/PyProperty.hpp
rename to src/runtime/PyProperty.cppm
index acfbf6a0..35e728e9 100644
--- a/src/runtime/PyProperty.hpp
+++ b/src/runtime/PyProperty.cppm
@@ -1,8 +1,16 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
+export module py.runtime:property;
+import :object;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+struct Number;
+class PyTuple;
+class PyDict;
+class PyType;
 
 class PyProperty : public PyBaseObject
 {
@@ -15,6 +23,7 @@ class PyProperty : public PyBaseObject
 	PyObject *m_property_name{ nullptr };
 
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	PyProperty(PyType *);
 
diff --git a/src/runtime/PyRange.cpp b/src/runtime/PyRange.cpp
index 986aa221..e40eb244 100644
--- a/src/runtime/PyRange.cpp
+++ b/src/runtime/PyRange.cpp
@@ -1,19 +1,13 @@
-#include "PyRange.hpp"
-#include "MemoryError.hpp"
-#include "PyArgParser.hpp"
-#include "PyDict.hpp"
-#include "PyInteger.hpp"
-#include "PyString.hpp"
-#include "StopIteration.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/IndexError.hpp"
-#include "runtime/PySlice.hpp"
-#include "runtime/TypeError.hpp"
-#include "runtime/Value.hpp"
-#include "runtime/ValueError.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+#include <cstdint>
+#include <gmpxx.h>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
@@ -89,9 +83,9 @@ PyRange::PyRange(PyInteger *start, PyInteger *stop, PyInteger *step)
 std::string PyRange::to_string() const
 {
 	if (m_step == 1) {
-		return fmt::format("range({}, {})", m_start, m_stop);
+		return std::format("range({}, {})", m_start, m_stop);
 	} else {
-		return fmt::format("range({}, {}, {})", m_start, m_stop, m_step);
+		return std::format("range({}, {}, {})", m_start, m_stop, m_step);
 	}
 }
 
@@ -189,7 +183,7 @@ PyRangeIterator::PyRangeIterator(const PyRange &pyrange)
 
 std::string PyRangeIterator::to_string() const
 {
-	return fmt::format("<range_iterator at {}>", static_cast<const void *>(this));
+	return std::format("<range_iterator at {}>", static_cast<const void *>(this));
 }
 
 PyResult<PyObject *> PyRangeIterator::__repr__() const { return PyString::create(to_string()); }
diff --git a/src/runtime/PyRange.hpp b/src/runtime/PyRange.cppm
similarity index 80%
rename from src/runtime/PyRange.hpp
rename to src/runtime/PyRange.cppm
index 01b11b4e..9b1c0634 100644
--- a/src/runtime/PyRange.hpp
+++ b/src/runtime/PyRange.cppm
@@ -1,12 +1,22 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
+export module py.runtime:range;
+import :dict;
+import :integer;
+import :object;
+import :tuple;
+import :value;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+class PyType;
 
 class PyRange : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	const BigIntType m_start{ 0 };
 	const BigIntType m_stop;
@@ -20,7 +30,7 @@ class PyRange : public PyBaseObject
 	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
 	PyResult<PyObject *> __repr__() const;
 	PyResult<PyObject *> __iter__() const;
-	PyResult<PyObject *> __getitem__(int64_t index) const;
+	PyResult<PyObject *> __getitem__(std::int64_t index) const;
 	PyResult<PyObject *> __getitem__(PyObject *key) const;
 
 	const BigIntType &start() const { return m_start; }
@@ -39,10 +49,10 @@ class PyRange : public PyBaseObject
 	PyRange(PyInteger *start, PyInteger *stop, PyInteger *step);
 };
 
-
 class PyRangeIterator : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	const PyRange &m_pyrange;
 	BigIntType m_current_index;
diff --git a/src/runtime/PyReversed.cpp b/src/runtime/PyReversed.cpp
index f6218e90..967e375b 100644
--- a/src/runtime/PyReversed.cpp
+++ b/src/runtime/PyReversed.cpp
@@ -1,7 +1,10 @@
-#include "PyReversed.hpp"
-#include "PyArgParser.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+#include <cstddef>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 PyReversed::PyReversed(PyType *type) : PyBaseObject(type) {}
diff --git a/src/runtime/PyReversed.hpp b/src/runtime/PyReversed.cppm
similarity index 73%
rename from src/runtime/PyReversed.hpp
rename to src/runtime/PyReversed.cppm
index 77d36aab..aa54a59e 100644
--- a/src/runtime/PyReversed.hpp
+++ b/src/runtime/PyReversed.cppm
@@ -1,11 +1,20 @@
-#pragma once
-
-#include "PyObject.hpp"
-
-namespace py {
+module;
+#include "memory/allocate.hpp"
+
+export module py.runtime:reversed;
+import :object;
+import py.memory;
+import std;
+
+export namespace py {
+struct Number;
+class PyTuple;
+class PyDict;
+class PyType;
 class PyReversed : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	PyObject *m_sequence{ nullptr };
 
diff --git a/src/runtime/PySet.cpp b/src/runtime/PySet.cpp
index 3a2a6ce3..a392dd7a 100644
--- a/src/runtime/PySet.cpp
+++ b/src/runtime/PySet.cpp
@@ -1,28 +1,12 @@
-#include "PySet.hpp"
-#include "KeyError.hpp"
-#include "MemoryError.hpp"
-#include "PyArgParser.hpp"
-#include "PyBool.hpp"
-#include "PyDict.hpp"
-#include "PyFrozenSet.hpp"
-#include "PyFunction.hpp"
-#include "PyInteger.hpp"
-#include "PyNone.hpp"
-#include "PyNumber.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "StopIteration.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/NotImplementedError.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/TypeError.hpp"
-#include "runtime/Value.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "utilities.hpp"
-#include "vm/VM.hpp"
-
-#include <algorithm>
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
@@ -395,7 +379,7 @@ PySetIterator::PySetIterator(const PyFrozenSet &pyset)
 
 std::string PySetIterator::to_string() const
 {
-	return fmt::format("<set_iterator at {}>", static_cast<const void *>(this));
+	return std::format("<set_iterator at {}>", static_cast<const void *>(this));
 }
 
 void PySetIterator::visit_graph(Visitor &visitor)
diff --git a/src/runtime/PySet.hpp b/src/runtime/PySet.cppm
similarity index 84%
rename from src/runtime/PySet.hpp
rename to src/runtime/PySet.cppm
index 0f637b65..256de4b1 100644
--- a/src/runtime/PySet.hpp
+++ b/src/runtime/PySet.cppm
@@ -1,13 +1,22 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
-#include <unordered_set>
+export module py.runtime:set;
+import :object;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+struct Number;
+class PyTuple;
+class PyDict;
+class PyFrozenSet;
+class PyType;
 
 class PySet : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
   public:
 	using SetType = std::unordered_set<Value, ValueHash>;
@@ -24,11 +33,11 @@ class PySet : public PyBaseObject
 	std::string to_string() const override;
 
 	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs);
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs);
 
 	PyResult<PyObject *> __repr__() const;
 	PyResult<PyObject *> __iter__() const;
-	PyResult<size_t> __len__() const;
+	PyResult<std::size_t> __len__() const;
 	PyResult<PyObject *> __eq__(const PyObject *other) const;
 	PyResult<PyObject *> __le__(const PyObject *other) const;
 	PyResult<PyObject *> __lt__(const PyObject *other) const;
@@ -62,16 +71,16 @@ class PySet : public PyBaseObject
 	PySet(SetType elements);
 };
 
-
 class PySetIterator : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	const std::variant<std::monostate,
 		std::reference_wrapper<const PySet>,
 		std::reference_wrapper<const PyFrozenSet>>
 		m_pyset;
-	size_t m_current_index{ 0 };
+	std::size_t m_current_index{ 0 };
 
 	PySetIterator(PyType *);
 
diff --git a/src/runtime/PySlice.cpp b/src/runtime/PySlice.cpp
index 23bbaaff..843eeb49 100644
--- a/src/runtime/PySlice.cpp
+++ b/src/runtime/PySlice.cpp
@@ -1,15 +1,12 @@
-#include "PySlice.hpp"
-#include "MemoryError.hpp"
-#include "PyArgParser.hpp"
-#include "PyBool.hpp"
-#include "PyInteger.hpp"
-#include "PyNone.hpp"
-#include "PyType.hpp"
-#include "TypeError.hpp"
-#include "ValueError.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
@@ -111,7 +108,7 @@ std::string PySlice::to_string() const
 	ASSERT(m_start);
 	ASSERT(m_stop);
 	ASSERT(m_step);
-	return fmt::format(
+	return std::format(
 		"slice({}, {}, {})", m_start->to_string(), m_stop->to_string(), m_step->to_string());
 }
 
diff --git a/src/runtime/PySlice.hpp b/src/runtime/PySlice.cppm
similarity index 52%
rename from src/runtime/PySlice.hpp
rename to src/runtime/PySlice.cppm
index 1c97fcb0..dafc0871 100644
--- a/src/runtime/PySlice.hpp
+++ b/src/runtime/PySlice.cppm
@@ -1,12 +1,21 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
+export module py.runtime:slice;
+import :object;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+struct Number;
+class PyTuple;
+class PyDict;
+class PyType;
 
 class PySlice : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
   public:
 	PyObject *m_start{ nullptr };
@@ -24,25 +33,28 @@ class PySlice : public PyBaseObject
 	void visit_graph(Visitor &) override;
 
   public:
-	static PyResult<PySlice *> create(int64_t stop);
-	static PyResult<PySlice *> create(int64_t start, int64_t stop, int64_t end);
+	static PyResult<PySlice *> create(std::int64_t stop);
+	static PyResult<PySlice *> create(std::int64_t start, std::int64_t stop, std::int64_t end);
 
 	static PyResult<PySlice *> create(PyObject *stop);
 	static PyResult<PySlice *> create(PyObject *start, PyObject *stop, PyObject *end);
 
 	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs);
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs);
 
 	PyResult<PyObject *> __repr__() const;
-	PyResult<int64_t> __hash__() const;
+	PyResult<std::int64_t> __hash__() const;
 	PyResult<PyObject *> __eq__(const PyObject *obj) const;
 	PyResult<PyObject *> __lt__(const PyObject *obj) const;
 
-	PyResult<std::tuple<int64_t, int64_t, int64_t>> get_indices(int64_t length) const;
+	PyResult<std::tuple<std::int64_t, std::int64_t, std::int64_t>> get_indices(
+		std::int64_t length) const;
 
-	PyResult<std::tuple<int64_t, int64_t, int64_t>> unpack() const;
-	static std::tuple<int64_t, int64_t, int64_t>
-		adjust_indices(int64_t start, int64_t stop, int64_t step, int64_t length);
+	PyResult<std::tuple<std::int64_t, std::int64_t, std::int64_t>> unpack() const;
+	static std::tuple<std::int64_t, std::int64_t, std::int64_t> adjust_indices(std::int64_t start,
+		std::int64_t stop,
+		std::int64_t step,
+		std::int64_t length);
 
 	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
 	PyType *static_type() const override;
diff --git a/src/runtime/PySlotWrapper.cpp b/src/runtime/PySlotWrapper.cpp
index b0fb57e0..5fc91ea2 100644
--- a/src/runtime/PySlotWrapper.cpp
+++ b/src/runtime/PySlotWrapper.cpp
@@ -1,12 +1,11 @@
-#include "PySlotWrapper.hpp"
-#include "PyFunction.hpp"
-#include "PyString.hpp"
-#include "PyType.hpp"
-#include "TypeError.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
@@ -14,7 +13,7 @@ PySlotWrapper::PySlotWrapper(PyType *type) : PyBaseObject(type) {}
 
 std::string PySlotWrapper::to_string() const
 {
-	return fmt::format("<slot wrapper '{}' of '{}' objects>", m_name->to_string(), m_type->name());
+	return std::format("<slot wrapper '{}' of '{}' objects>", m_name->to_string(), m_type->name());
 }
 
 void PySlotWrapper::visit_graph(Visitor &visitor)
diff --git a/src/runtime/PySlotWrapper.hpp b/src/runtime/PySlotWrapper.cppm
similarity index 94%
rename from src/runtime/PySlotWrapper.hpp
rename to src/runtime/PySlotWrapper.cppm
index d4298c73..cd55f885 100644
--- a/src/runtime/PySlotWrapper.hpp
+++ b/src/runtime/PySlotWrapper.cppm
@@ -1,13 +1,24 @@
-#pragma once
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
 
-#include "PyBool.hpp"
-#include "PyInteger.hpp"
-#include "PyNone.hpp"
-#include "PyString.hpp"
-#include "PyType.hpp"
-#include "TypeError.hpp"
+export module py.runtime:slot_wrapper;
+import :type;
+import :bool_;
+import :none;
+import :type_error;
+import :dict;
+import :integer;
+import :object;
+import :string;
+import :tuple;
+import :value;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+
+class PySlotWrapper;
 
 class Slot
 {
@@ -35,8 +46,8 @@ class Slot
 
 	template<typename R, typename... Args> struct arity<std::function<R(Args...)>>
 	{
-		static constexpr size_t value = sizeof...(Args);
-		template<size_t Idx>
+		static constexpr std::size_t value = sizeof...(Args);
+		template<std::size_t Idx>
 		using arg_type = typename std::tuple_element_t<Idx, std::tuple<Args...>>;
 	};
 
@@ -95,6 +106,7 @@ class PySlotWrapper : public PyBaseObject
 	FunctionType m_slot;
 
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	PySlotWrapper(PyType *type);
 
@@ -229,11 +241,11 @@ constexpr void Slot::initialize(
 						}();
 					}
 				};
-				auto get_parameter = [&args]<typename T, size_t Idx>() -> PyResult<T> {
+				auto get_parameter = [&args]<typename T, std::size_t Idx>() -> PyResult<T> {
 					using ArgType = typename std::remove_cv_t<std::remove_pointer_t<T>>;
 					if constexpr (std::is_same_v<ArgType, PyObject>) {
 						return PyObject::from(args->elements()[Idx]);
-					} else if constexpr (std::is_same_v<ArgType, int64_t>) {
+					} else if constexpr (std::is_same_v<ArgType, std::int64_t>) {
 						const auto &el = args->elements()[Idx];
 						if (std::holds_alternative<PyObject *>(el)) {
 							auto obj = std::get<PyObject *>(el);
@@ -289,5 +301,4 @@ constexpr void Slot::initialize(
 	};
 }
 
-
 }// namespace py
diff --git a/src/runtime/PyStaticMethod.cpp b/src/runtime/PyStaticMethod.cpp
index 303dad0e..ffef6312 100644
--- a/src/runtime/PyStaticMethod.cpp
+++ b/src/runtime/PyStaticMethod.cpp
@@ -1,13 +1,11 @@
-#include "PyStaticMethod.hpp"
-#include "PyArgParser.hpp"
-#include "PyFunction.hpp"
-#include "PyString.hpp"
-#include "PyType.hpp"
-#include "RuntimeError.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
diff --git a/src/runtime/PyStaticMethod.hpp b/src/runtime/PyStaticMethod.cppm
similarity index 76%
rename from src/runtime/PyStaticMethod.hpp
rename to src/runtime/PyStaticMethod.cppm
index f44657c0..ef79da4e 100644
--- a/src/runtime/PyStaticMethod.hpp
+++ b/src/runtime/PyStaticMethod.cppm
@@ -1,8 +1,16 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
+export module py.runtime:static_method;
+import :object;
+import py.memory;
+import std;
 
-namespace py {
+export namespace py {
+struct Number;
+class PyTuple;
+class PyDict;
+class PyType;
 
 class PyStaticMethod : public PyBaseObject
 {
@@ -10,6 +18,7 @@ class PyStaticMethod : public PyBaseObject
 	PyObject *m_static_method{ nullptr };
 
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	PyStaticMethod(PyType *);
 
diff --git a/src/runtime/PyString.cpp b/src/runtime/PyString.cpp
index e932ae87..8c060da5 100644
--- a/src/runtime/PyString.cpp
+++ b/src/runtime/PyString.cpp
@@ -1,38 +1,22 @@
-#include "PyString.hpp"
-#include "IndexError.hpp"
-#include "KeyError.hpp"
-#include "MemoryError.hpp"
-#include "NotImplementedError.hpp"
-#include "PyArgParser.hpp"
-#include "PyBool.hpp"
-#include "PyDict.hpp"
-#include "PyFloat.hpp"
-#include "PyInteger.hpp"
-#include "PyList.hpp"
-#include "PyNone.hpp"
-#include "PySlice.hpp"
-#include "StopIteration.hpp"
-#include "TypeError.hpp"
-#include "ValueError.hpp"
-#include "runtime/PyBytes.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/Value.hpp"
-#include "runtime/forward.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "utilities.hpp"
-
-#include <algorithm>
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
 #include <cstddef>
-#include <limits>
-#include <optional>
-#include <span>
+#include <cstdint>
+#include <cstdio>
 
+#include <gmpxx.h>
 #include <unicode/stringpiece.h>
 #include <unicode/uchar.h>
 #include <unicode/umachine.h>
 #include <unicode/unistr.h>
 
+module py.runtime;
+import py.types;
+import std;
+
+
 namespace py {
 
 template<> PyString *as(PyObject *obj)
@@ -166,21 +150,21 @@ PyResult<PyString *> PyString::create(const Bytes &bytes, const std::string &enc
 			if (*it > std::byte{ 127 }) {
 				return Err(value_error(
 					"'utf-8' codec can't decode byte {} in position {}: invalid start byte",
-					*it,
+					std::to_integer<int>(*it),
 					std::distance(bytes.b.begin(), it)));
 			}
 			auto length = utf8::codepoint_length(static_cast<char>(*it));
-			if (!utf8::codepoint(bit_cast<const char *>(it.base()), length).has_value()) {
+			if (!utf8::codepoint(std::bit_cast<const char *>(it.base()), length).has_value()) {
 				return Err(value_error(
 					"'utf-8' codec can't decode byte {} in position {}: invalidutf8 codepoint ",
-					*it,
+					std::to_integer<int>(*it),
 					std::distance(bytes.b.begin(), it)));
 			}
 			for (size_t i = 0; i < length; ++i) {
 				if (it == bytes.b.end()) {
 					return Err(value_error(
 						"'utf-8' codec can't decode byte {} in position {}: invalidutf8 codepoint ",
-						*it,
+						std::to_integer<int>(*it),
 						std::distance(bytes.b.begin(), it)));
 				}
 				result.push_back(static_cast<char>(*it));
@@ -243,7 +227,7 @@ PyResult<int64_t> PyString::__hash__() const
 
 PyResult<PyObject *> PyString::__repr__() const
 {
-	return PyString::create(fmt::format("'{}'", m_value));
+	return PyString::create(std::format("'{}'", m_value));
 }
 
 PyResult<PyObject *> PyString::__str__() const { return Ok(const_cast<PyString *>(this)); }
@@ -1374,7 +1358,8 @@ namespace {
 			if (conversion.has_value()) {
 				replacement_field.conversion = *conversion;
 			} else {
-				return Err(value_error("Invalid conversion specifier '{}'", *conversion));
+				return Err(value_error(
+					"Invalid conversion specifier '{}'", static_cast<int>(*conversion)));
 			}
 			str = end == std::string_view::npos ? "" : str.substr(end);
 		}
@@ -1573,7 +1558,7 @@ PyResult<PyString *> PyString::convert_to_ascii(PyObject *obj)
 			if (cp <= 128) {
 				new_string.push_back(static_cast<char>(cp));
 			} else {
-				new_string += fmt::format("\\U{:08x}", cp);
+				new_string += std::format("\\U{:08x}", cp);
 			}
 		}
 
@@ -1868,7 +1853,7 @@ PyStringIterator::PyStringIterator(const PyString &pystring)
 
 std::string PyStringIterator::to_string() const
 {
-	return fmt::format("<str_iterator at {}>", static_cast<const void *>(this));
+	return std::format("<str_iterator at {}>", static_cast<const void *>(this));
 }
 
 void PyStringIterator::visit_graph(Visitor &visitor)
diff --git a/src/runtime/PyString.hpp b/src/runtime/PyString.cppm
similarity index 83%
rename from src/runtime/PyString.hpp
rename to src/runtime/PyString.cppm
index d2377398..d960a0d3 100644
--- a/src/runtime/PyString.hpp
+++ b/src/runtime/PyString.cppm
@@ -1,18 +1,26 @@
-#pragma once
+module;
 
-#include "PyObject.hpp"
-#include "PyTuple.hpp"
-#include "runtime/Value.hpp"
+#include "core.hpp"
 
-#include <optional>
+#include "memory/allocate.hpp"
+#include <cstddef>
 
-namespace py {
+export module py.runtime:string;
+import std;
+import :tuple;
+import py.memory;
+
+export namespace py {
+class PyList;
+class PyDict;
+class PyType;
 
 class PyString
 	: public PyBaseObject
 	, public PySequence
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	std::string m_value;
 
 	PyString(PyType *);
@@ -20,12 +28,12 @@ class PyString
   public:
 	struct FormatSpec
 	{
-		size_t start;
-		size_t end;
+		std::size_t start;
+		std::size_t end;
 		std::optional<std::string> mapping;
 		std::optional<char> conversion_flag;
-		std::optional<uint32_t> minimum_width;
-		std::optional<uint32_t> precision;
+		std::optional<std::uint32_t> minimum_width;
+		std::optional<std::uint32_t> precision;
 		std::optional<char> conversion_type;
 
 		PyResult<std::string> apply(PyObject *obj) const;
@@ -41,8 +49,8 @@ class PyString
 		std::optional<std::string> field_name;
 		std::optional<Conversion> conversion;
 		std::optional<FormatSpec> format_spec;
-		size_t start;
-		size_t end;
+		std::size_t start;
+		std::size_t end;
 		bool display_expression{ false };
 
 		static std::optional<Conversion> get_conversion(char);
@@ -66,16 +74,16 @@ class PyString
 	}
 
 	const std::string &value() const { return m_value; }
-	std::vector<uint32_t> codepoints() const;
-	std::optional<uint32_t> codepoint() const;
+	std::vector<std::uint32_t> codepoints() const;
+	std::optional<std::uint32_t> codepoint() const;
 
 	std::string to_string() const override { return m_value; }
-	size_t size() const;
+	std::size_t size() const;
 
 	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
 	PyResult<PyObject *> __repr__() const;
 	PyResult<PyObject *> __str__() const;
-	PyResult<int64_t> __hash__() const;
+	PyResult<std::int64_t> __hash__() const;
 	PyResult<PyObject *> __eq__(const PyObject *obj) const;
 	PyResult<PyObject *> __ne__(const PyObject *obj) const;
 	PyResult<PyObject *> __lt__(const PyObject *obj) const;
@@ -83,9 +91,9 @@ class PyString
 	PyResult<PyObject *> __iter__() const;
 	PyResult<PyObject *> __getitem__(PyObject *index);
 
-	PyResult<size_t> __len__() const;
+	PyResult<std::size_t> __len__() const;
 	PyResult<PyObject *> __add__(const PyObject *obj) const;
-	PyResult<PyObject *> __mul__(size_t count) const;
+	PyResult<PyObject *> __mul__(std::size_t count) const;
 	PyResult<PyObject *> __mod__(const PyObject *obj) const;
 
 	PyResult<PyObject *> isalpha() const;
@@ -131,14 +139,14 @@ class PyString
 	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
 	PyType *static_type() const override;
 
-	PyResult<PyObject *> operator[](int64_t) const;
+	PyResult<PyObject *> operator[](std::int64_t) const;
 
 	static PyResult<PyString *> chr(BigIntType cp);
 
   private:
 	PyString(std::string s);
 
-	size_t get_position_from_slice(int64_t) const;
+	std::size_t get_position_from_slice(std::int64_t) const;
 
 	PyResult<PyString *> printf(const PyObject *values) const;
 };
@@ -146,9 +154,10 @@ class PyString
 class PyStringIterator : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	const PyString &m_pystring;
-	size_t m_current_index{ 0 };
+	std::size_t m_current_index{ 0 };
 
   public:
 	PyStringIterator(const PyString &pystring);
diff --git a/src/runtime/PyString_tests.cpp b/src/runtime/PyString_tests.cpp
index 490e7a79..4b17b67d 100644
--- a/src/runtime/PyString_tests.cpp
+++ b/src/runtime/PyString_tests.cpp
@@ -1,7 +1,7 @@
-#include "PyString.hpp"
-
 #include <gtest/gtest.h>
 
+import py.runtime;
+
 using namespace py;
 
 TEST(PyString, hash)
@@ -12,4 +12,4 @@ TEST(PyString, hash)
 	auto object_hash = foo_obj_.unwrap()->hash();
 	ASSERT_TRUE(object_hash.is_ok());
 	ASSERT_EQ(ValueHash{}(foo), object_hash.unwrap());
-}
\ No newline at end of file
+}
diff --git a/src/runtime/PySuper.cpp b/src/runtime/PySuper.cpp
index 0f0ae75d..5e6f8ee8 100644
--- a/src/runtime/PySuper.cpp
+++ b/src/runtime/PySuper.cpp
@@ -1,16 +1,12 @@
-#include "PySuper.hpp"
-#include "MemoryError.hpp"
-#include "PyArgParser.hpp"
-#include "PyCell.hpp"
-#include "PyCode.hpp"
-#include "PyFrame.hpp"
-#include "PyList.hpp"
-#include "PyString.hpp"
-#include "PyType.hpp"
-#include "RuntimeError.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
@@ -210,11 +206,11 @@ PyResult<PyType *> PySuper::infer_type(PyFrame *frame, PyCode *code)
 std::string PySuper::to_string() const
 {
 	if (m_object_type) {
-		return fmt::format("<super: <class '{}'>, <{} object>>",
+		return std::format("<super: <class '{}'>, <{} object>>",
 			m_type ? m_type->name() : "NULL",
 			m_object_type->name());
 	} else {
-		return fmt::format("<super: <class '{}'>, NULL>", m_type ? m_type->name() : "NULL");
+		return std::format("<super: <class '{}'>, NULL>", m_type ? m_type->name() : "NULL");
 	}
 }
 
diff --git a/src/runtime/PySuper.hpp b/src/runtime/PySuper.cppm
similarity index 72%
rename from src/runtime/PySuper.hpp
rename to src/runtime/PySuper.cppm
index d001fc5f..7321ee5e 100644
--- a/src/runtime/PySuper.hpp
+++ b/src/runtime/PySuper.cppm
@@ -1,12 +1,23 @@
-#pragma once
-
-#include "PyObject.hpp"
-
-namespace py {
+module;
+#include "memory/allocate.hpp"
+
+export module py.runtime:super;
+import :code;
+import :dict;
+import :frame;
+import :object;
+import :tuple;
+import :value;
+import py.memory;
+import std;
+
+export namespace py {
+class PyType;
 
 class PySuper : public PyBaseObject
 {
-	friend ::Heap;
+	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	PyType *m_type{ nullptr };
 	PyObject *m_object{ nullptr };
@@ -19,7 +30,7 @@ class PySuper : public PyBaseObject
 
   public:
 	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs);
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs);
 
 	PyResult<PyObject *> __repr__() const;
 	PyResult<PyObject *> __getattribute__(PyObject *name) const;
diff --git a/src/runtime/PyTraceback.cpp b/src/runtime/PyTraceback.cpp
index b205f9b6..803fc9e7 100644
--- a/src/runtime/PyTraceback.cpp
+++ b/src/runtime/PyTraceback.cpp
@@ -1,10 +1,13 @@
-#include "PyTraceback.hpp"
-#include "MemoryError.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyInteger.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "memory/allocate.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import py.types;
+
+
+import :traceback;
 
 namespace py {
 
@@ -12,7 +15,7 @@ PyTraceback::PyTraceback(PyType *type) : PyBaseObject(type) {}
 
 std::string PyTraceback::to_string() const
 {
-	return fmt::format("<traceback object at {}>", static_cast<const void *>(this));
+	return std::format("<traceback object at {}>", static_cast<const void *>(this));
 }
 
 void PyTraceback::visit_graph(Visitor &visitor)
diff --git a/src/runtime/PyTraceback.hpp b/src/runtime/PyTraceback.cppm
similarity index 55%
rename from src/runtime/PyTraceback.hpp
rename to src/runtime/PyTraceback.cppm
index 8fb37a47..28a55cae 100644
--- a/src/runtime/PyTraceback.hpp
+++ b/src/runtime/PyTraceback.cppm
@@ -1,8 +1,19 @@
-#pragma once
+module;
 
-#include "PyObject.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
 
-namespace py {
+export module py.runtime:traceback;
+
+import std;
+import :object;
+import py.memory;
+
+export namespace py {
+class PyType;
+
+
+class PyFrame;
 
 class PyTraceback : public PyBaseObject
 {
@@ -10,22 +21,28 @@ class PyTraceback : public PyBaseObject
 	// frame object at this level
 	PyFrame *m_tb_frame = nullptr;
 	// index of last attempted instruction in bytecode
-	size_t m_tb_lasti;
+	std::size_t m_tb_lasti;
 	// current line number in Python source code
-	size_t m_tb_lineno;
+	std::size_t m_tb_lineno;
 	// next inner traceback object (called by this level)
 	PyTraceback *m_tb_next = nullptr;
 
   private:
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	PyTraceback(PyType *);
 
-	PyTraceback(PyFrame *tb_frame, size_t tb_lasti, size_t tb_lineno, PyTraceback *tb_next);
+	PyTraceback(PyFrame *tb_frame,
+		std::size_t tb_lasti,
+		std::size_t tb_lineno,
+		PyTraceback *tb_next);
 
   public:
-	static PyResult<PyTraceback *>
-		create(PyFrame *tb_frame, size_t tb_lasti, size_t tb_lineno, PyTraceback *tb_next);
+	static PyResult<PyTraceback *> create(PyFrame *tb_frame,
+		std::size_t tb_lasti,
+		std::size_t tb_lineno,
+		PyTraceback *tb_next);
 
 	std::string to_string() const override;
 
diff --git a/src/runtime/PyTuple.cpp b/src/runtime/PyTuple.cpp
index 8c670e3e..969dd20b 100644
--- a/src/runtime/PyTuple.cpp
+++ b/src/runtime/PyTuple.cpp
@@ -1,18 +1,12 @@
-#include "PyTuple.hpp"
-#include "IndexError.hpp"
-#include "MemoryError.hpp"
-#include "PyBool.hpp"
-#include "PyInteger.hpp"
-#include "PyList.hpp"
-#include "PySlice.hpp"
-#include "PyString.hpp"
-#include "StopIteration.hpp"
-#include "TypeError.hpp"
-#include "ValueError.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
@@ -337,7 +331,7 @@ PyResult<PyTupleIterator *> PyTupleIterator::create(const PyTuple &pytuple)
 
 std::string PyTupleIterator::to_string() const
 {
-	return fmt::format("<tuple_iterator at {}>", static_cast<const void *>(this));
+	return std::format("<tuple_iterator at {}>", static_cast<const void *>(this));
 }
 
 PyResult<PyObject *> PyTupleIterator::__repr__() const { return PyString::create(to_string()); }
diff --git a/src/runtime/PyTuple.hpp b/src/runtime/PyTuple.cppm
similarity index 82%
rename from src/runtime/PyTuple.hpp
rename to src/runtime/PyTuple.cppm
index 5cd89014..6eb00989 100644
--- a/src/runtime/PyTuple.hpp
+++ b/src/runtime/PyTuple.cppm
@@ -1,15 +1,24 @@
-#pragma once
+module;
 
-#include "PyObject.hpp"
+#include "memory/allocate.hpp"
 
-namespace py {
+export module py.runtime:tuple;
+import :object;
+import std;
+import py.memory;
+
+export namespace py {
+class PyType;
+
+class PyTupleIterator;
 
 class PyTuple
 	: public PyBaseObject
 	, PySequence
 {
 	friend class ::Heap;
-	friend class PyTupleIterator;
+	friend class py::detail::Allocator;
+	friend PyTupleIterator;
 
 	const std::vector<Value> m_elements;
 
@@ -43,12 +52,12 @@ class PyTuple
 
 	PyResult<PyObject *> __repr__() const;
 	PyResult<PyObject *> __iter__() const;
-	PyResult<size_t> __len__() const;
+	PyResult<std::size_t> __len__() const;
 	PyResult<PyObject *> __add__(const PyObject *other) const;
 	PyResult<PyObject *> __eq__(const PyObject *other) const;
 	PyResult<PyObject *> __getitem__(PyObject *key);
 
-	PyResult<PyObject *> __getitem__(int64_t index);
+	PyResult<PyObject *> __getitem__(std::int64_t index);
 
 	PyTupleIterator begin() const;
 	PyTupleIterator end() const;
@@ -57,8 +66,8 @@ class PyTuple
 	// std::shared_ptr<PyTupleIterator> cend() const;
 
 	const std::vector<Value> &elements() const { return m_elements; }
-	size_t size() const { return m_elements.size(); }
-	PyResult<PyObject *> operator[](size_t idx) const;
+	std::size_t size() const { return m_elements.size(); }
+	PyResult<PyObject *> operator[](std::size_t idx) const;
 
 	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
 	PyType *static_type() const override;
@@ -70,13 +79,14 @@ template<> const PyTuple *as(const PyObject *obj);
 class PyTupleIterator : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	friend PyTuple;
 
 	const PyTuple &m_pytuple;
-	size_t m_current_index{ 0 };
+	std::size_t m_current_index{ 0 };
 
 	PyTupleIterator(const PyTuple &pytuple);
-	PyTupleIterator(const PyTuple &pytuple, size_t position);
+	PyTupleIterator(const PyTuple &pytuple, std::size_t position);
 
   protected:
 	void visit_graph(Visitor &) override;
diff --git a/src/runtime/PyType.cpp b/src/runtime/PyType.cpp
index f9782d70..f0a9d71d 100644
--- a/src/runtime/PyType.cpp
+++ b/src/runtime/PyType.cpp
@@ -1,36 +1,13 @@
-#include "PyType.hpp"
-#include "AttributeError.hpp"
-#include "PyArgParser.hpp"
-#include "PyBool.hpp"
-#include "PyBoundMethod.hpp"
-#include "PyBuiltInMethod.hpp"
-#include "PyCell.hpp"
-#include "PyClassMethodDescriptor.hpp"
-#include "PyDict.hpp"
-#include "PyFrame.hpp"
-#include "PyFunction.hpp"
-#include "PyGetSetDescriptor.hpp"
-#include "PyInteger.hpp"
-#include "PyList.hpp"
-#include "PyMappingProxy.hpp"
-#include "PyMemberDescriptor.hpp"
-#include "PyMethodDescriptor.hpp"
-#include "PyNone.hpp"
-#include "PySlotWrapper.hpp"
-#include "PyStaticMethod.hpp"
-#include "PyString.hpp"
-#include "StopIteration.hpp"
-#include "TypeError.hpp"
-#include "ValueError.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/PyTuple.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
-
-#include <algorithm>
-#include <string_view>
-#include <unordered_set>
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import py.types;
+import std;
+
 
 namespace py {
 template<> PyType *as(PyObject *obj)
@@ -571,7 +548,8 @@ PyResult<std::monostate> PyType::initialize(const std::string &name,
 									   PyObject *self) -> PyResult<PyObject *> {
 					const auto object_offset =
 						self->type()->underlying_type().basicsize + additional_offset;
-					auto *obj = *bit_cast<PyObject **>(bit_cast<uint8_t *>(self) + object_offset);
+					auto *obj =
+						*std::bit_cast<PyObject **>(std::bit_cast<uint8_t *>(self) + object_offset);
 					if (!obj) { return Err(attribute_error(name)); }
 					return Ok(obj);
 				},
@@ -579,9 +557,9 @@ PyResult<std::monostate> PyType::initialize(const std::string &name,
 									 PyObject *self, PyObject *value) -> PyResult<std::monostate> {
 					const auto offset =
 						self->type()->underlying_type().basicsize + additional_offset;
-					uint8_t *self_address = bit_cast<uint8_t *>(self);
+					uint8_t *self_address = std::bit_cast<uint8_t *>(self);
 					uint8_t *slot_address = self_address + offset;
-					*bit_cast<PyObject **>(slot_address) = value;
+					*std::bit_cast<PyObject **>(slot_address) = value;
 					return Ok(std::monostate{});
 				},
 			});
@@ -1539,7 +1517,8 @@ PyResult<PyType *> PyType::build_type(const PyType *metatype,
 				return Err(r.unwrap_err());
 			}
 
-			spdlog::trace("Created type@{} #{}", (void *)type, type->name());
+			::detail::log_trace(
+				std::format("Created type@{} #{}", (void *)type, type->name()).c_str());
 
 			return Ok(type);
 		});
@@ -1600,7 +1579,7 @@ PyResult<PyObject *> PyType::__call__(PyTuple *args, PyDict *kwargs) const
 
 std::string PyType::to_string() const
 {
-	return fmt::format("<class '{}'>", underlying_type().__name__);
+	return std::format("<class '{}'>", underlying_type().__name__);
 }
 
 PyResult<PyObject *> PyType::__repr__() const { return PyString::create(to_string()); }
diff --git a/src/runtime/PyType.hpp b/src/runtime/PyType.cppm
similarity index 94%
rename from src/runtime/PyType.hpp
rename to src/runtime/PyType.cppm
index 08b81ade..ead7e175 100644
--- a/src/runtime/PyType.hpp
+++ b/src/runtime/PyType.cppm
@@ -1,13 +1,20 @@
-#pragma once
+module;
+#include "memory/allocate.hpp"
 
-#include "PyObject.hpp"
+export module py.runtime:type;
 
-namespace py {
+import :object;
+import std;
+import py.memory;
+
+export namespace py {
+class PyList;
 
 class PyType : public PyBaseObject
 {
 	template<typename T> friend struct klass;
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	friend class PyObject;
 
   private:
diff --git a/src/runtime/PyType_tests.cpp b/src/runtime/PyType_tests.cpp
index d178b577..3a345472 100644
--- a/src/runtime/PyType_tests.cpp
+++ b/src/runtime/PyType_tests.cpp
@@ -1,11 +1,8 @@
-#include "PyList.hpp"
-#include "PyTuple.hpp"
-#include "PyType.hpp"
-#include "types/builtin.hpp"
-#include "vm/VM.hpp"
-
 #include "gtest/gtest.h"
 
+import py.runtime;
+import py.types;
+
 using namespace py;
 
 TEST(PyType, ObjectClassParent)
diff --git a/src/runtime/PyZip.cpp b/src/runtime/PyZip.cpp
index 8bdaa9e6..216eb016 100644
--- a/src/runtime/PyZip.cpp
+++ b/src/runtime/PyZip.cpp
@@ -1,9 +1,10 @@
-#include "PyZip.hpp"
-#include "MemoryError.hpp"
-#include "PyList.hpp"
-#include "StopIteration.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
diff --git a/src/runtime/PyZip.hpp b/src/runtime/PyZip.cppm
similarity index 71%
rename from src/runtime/PyZip.hpp
rename to src/runtime/PyZip.cppm
index 97edad71..6cbbe9b6 100644
--- a/src/runtime/PyZip.hpp
+++ b/src/runtime/PyZip.cppm
@@ -1,11 +1,20 @@
-#pragma once
-
-#include "PyObject.hpp"
-
-namespace py {
+module;
+#include "memory/allocate.hpp"
+
+export module py.runtime:zip;
+import :object;
+import py.memory;
+import std;
+
+export namespace py {
+struct Number;
+class PyTuple;
+class PyDict;
+class PyType;
 class PyZip : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	std::vector<PyObject *> m_iterators;
 
diff --git a/src/runtime/RuntimeError.cpp b/src/runtime/RuntimeError.cpp
index c8c4432c..d83132c8 100644
--- a/src/runtime/RuntimeError.cpp
+++ b/src/runtime/RuntimeError.cpp
@@ -1,11 +1,22 @@
-#include "RuntimeError.hpp"
-#include "MemoryError.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
+BaseException *make_runtime_error(std::string &&message)
+{
+	auto msg = PyString::create(std::move(message));
+	ASSERT(msg.is_ok());
+	auto args_tuple = PyTuple::create(msg.unwrap());
+	ASSERT(args_tuple.is_ok());
+	return RuntimeError::create(args_tuple.unwrap()).unwrap();
+}
+
 template<> RuntimeError *as(PyObject *obj)
 {
 	ASSERT(types::runtime_error());
diff --git a/src/runtime/RuntimeError.cppm b/src/runtime/RuntimeError.cppm
new file mode 100644
index 00000000..fd9bb2de
--- /dev/null
+++ b/src/runtime/RuntimeError.cppm
@@ -0,0 +1,51 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+export module py.runtime:runtime_error;
+import :baseexception;
+import :dict;
+import :exception;
+import :object;
+import :string;
+import :tuple;
+import :value;
+import py.memory;
+import std;
+
+export namespace py {
+class PyType;
+
+class RuntimeError : public Exception
+{
+	friend class ::Heap;
+	friend class py::detail::Allocator;
+	friend BaseException *make_runtime_error(std::string &&);
+
+  private:
+	RuntimeError(PyType *);
+
+	RuntimeError(PyTuple *args);
+
+	static PyResult<RuntimeError *> create(PyTuple *args);
+
+  public:
+	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
+
+	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
+
+	PyType *static_type() const override;
+};
+
+// Defined in RuntimeError.cpp. Keeping the PyString/PyTuple construction and the
+// heap allocation out of the interface means this partition no longer has
+// to materialise those types just to declare one exception class.
+BaseException *make_runtime_error(std::string &&message);
+
+template<typename... Args>
+inline BaseException *runtime_error(const std::string &message, Args &&...args)
+{
+	return make_runtime_error(std::vformat(message, std::make_format_args(args...)));
+}
+
+}// namespace py
diff --git a/src/runtime/RuntimeError.hpp b/src/runtime/RuntimeError.hpp
deleted file mode 100644
index 3006f9dd..00000000
--- a/src/runtime/RuntimeError.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#pragma once
-
-#include "Exception.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
-
-class RuntimeError : public Exception
-{
-	friend class ::Heap;
-	template<typename... Args>
-	friend BaseException *runtime_error(const std::string &message, Args &&...args);
-
-  private:
-	RuntimeError(PyType *);
-
-	RuntimeError(PyTuple *args);
-
-	static PyResult<RuntimeError *> create(PyTuple *args);
-
-  public:
-	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-
-	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
-
-	PyType *static_type() const override;
-};
-
-template<typename... Args>
-inline BaseException *runtime_error(const std::string &message, Args &&...args)
-{
-	auto msg = PyString::create(fmt::format(message, std::forward<Args>(args)...));
-	ASSERT(msg.is_ok());
-	auto args_tuple = PyTuple::create(msg.unwrap());
-	ASSERT(args_tuple.is_ok());
-	auto obj = RuntimeError::create(args_tuple.unwrap());
-	ASSERT(obj.is_ok());
-	return obj.unwrap();
-}
-
-}// namespace py
diff --git a/src/runtime/SourceManager.cpp b/src/runtime/SourceManager.cpp
index 84b09b71..77ee6fb0 100644
--- a/src/runtime/SourceManager.cpp
+++ b/src/runtime/SourceManager.cpp
@@ -1,6 +1,6 @@
 #include "SourceManager.hpp"
+import std;
 
-#include <fstream>
 
 namespace py {
 
diff --git a/src/runtime/SourceManager_tests.cpp b/src/runtime/SourceManager_tests.cpp
index 6ba80432..e9dbb902 100644
--- a/src/runtime/SourceManager_tests.cpp
+++ b/src/runtime/SourceManager_tests.cpp
@@ -3,8 +3,7 @@
 #include "gtest/gtest.h"
 
 #include <cstdio>
-#include <filesystem>
-#include <fstream>
+import std;
 
 namespace {
 std::filesystem::path write_temp(std::string_view name, std::string_view contents)
diff --git a/src/runtime/StopIteration.cpp b/src/runtime/StopIteration.cpp
index c46b4eac..dcb8cc22 100644
--- a/src/runtime/StopIteration.cpp
+++ b/src/runtime/StopIteration.cpp
@@ -1,10 +1,18 @@
-#include "StopIteration.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
+StopIteration *StopIteration::create(PyTuple *args)
+{
+	auto &heap = VirtualMachine::the().heap();
+	return heap.allocate<StopIteration>(args);
+}
+
 template<> StopIteration *as(PyObject *obj)
 {
 	ASSERT(types::stop_iteration());
diff --git a/src/runtime/StopIteration.hpp b/src/runtime/StopIteration.cppm
similarity index 67%
rename from src/runtime/StopIteration.hpp
rename to src/runtime/StopIteration.cppm
index b3e2f037..aa8dcfa9 100644
--- a/src/runtime/StopIteration.hpp
+++ b/src/runtime/StopIteration.cppm
@@ -1,15 +1,24 @@
-#pragma once
-
-#include "Exception.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+export module py.runtime:stop_iteration;
+import :baseexception;
+import :dict;
+import :exception;
+import :object;
+import :tuple;
+import :value;
+import py.memory;
+import std;
+
+export namespace py {
+class PyType;
 
 class StopIteration : public Exception
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	template<typename... Args> friend BaseException *stop_iteration(Args &&...args);
 
   private:
@@ -18,11 +27,7 @@ class StopIteration : public Exception
 	StopIteration(PyTuple *args);
 
   public:
-	static StopIteration *create(PyTuple *args)
-	{
-		auto &heap = VirtualMachine::the().heap();
-		return heap.allocate<StopIteration>(args);
-	}
+	static StopIteration *create(PyTuple *args);
 
 	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
 
diff --git a/src/runtime/SyntaxError.cpp b/src/runtime/SyntaxError.cpp
index e01b757c..bfab0202 100644
--- a/src/runtime/SyntaxError.cpp
+++ b/src/runtime/SyntaxError.cpp
@@ -1,10 +1,27 @@
-#include "SyntaxError.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
+SyntaxError *SyntaxError::create(PyTuple *args)
+{
+	auto &heap = VirtualMachine::the().heap();
+	return heap.allocate<SyntaxError>(args);
+}
+
+BaseException *make_syntax_error(std::string &&message)
+{
+	auto msg = PyString::create(std::move(message));
+	ASSERT(msg.is_ok());
+	auto args_tuple = PyTuple::create(msg.unwrap());
+	ASSERT(args_tuple.is_ok());
+	return SyntaxError::create(args_tuple.unwrap());
+}
+
 SyntaxError::SyntaxError(PyType *type) : Exception(type) {}
 
 SyntaxError::SyntaxError(PyTuple *args) : Exception(types::BuiltinTypes::the().syntax_error(), args)
diff --git a/src/runtime/SyntaxError.cppm b/src/runtime/SyntaxError.cppm
new file mode 100644
index 00000000..7b0b3538
--- /dev/null
+++ b/src/runtime/SyntaxError.cppm
@@ -0,0 +1,51 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+export module py.runtime:syntax_error;
+import :baseexception;
+import :dict;
+import :exception;
+import :object;
+import :string;
+import :tuple;
+import :value;
+import py.memory;
+import std;
+
+export namespace py {
+class PyType;
+
+class SyntaxError : public Exception
+{
+	friend class ::Heap;
+	friend class py::detail::Allocator;
+	friend BaseException *make_syntax_error(std::string &&);
+
+  private:
+	SyntaxError(PyType *type);
+
+	SyntaxError(PyTuple *args);
+
+	static SyntaxError *create(PyTuple *args);
+
+  public:
+	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
+
+	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
+
+	PyType *static_type() const override;
+};
+
+// Defined in SyntaxError.cpp. Keeping the PyString/PyTuple construction and the
+// heap allocation out of the interface means this partition no longer has
+// to materialise those types just to declare one exception class.
+BaseException *make_syntax_error(std::string &&message);
+
+template<typename... Args>
+inline BaseException *syntax_error(const std::string &message, Args &&...args)
+{
+	return make_syntax_error(std::vformat(message, std::make_format_args(args...)));
+}
+
+}// namespace py
diff --git a/src/runtime/SyntaxError.hpp b/src/runtime/SyntaxError.hpp
deleted file mode 100644
index 1bfb30ab..00000000
--- a/src/runtime/SyntaxError.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#pragma once
-
-#include "Exception.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
-
-class SyntaxError : public Exception
-{
-	friend class ::Heap;
-	template<typename... Args>
-	friend BaseException *syntax_error(const std::string &message, Args &&...args);
-
-  private:
-	SyntaxError(PyType *type);
-
-	SyntaxError(PyTuple *args);
-
-	static SyntaxError *create(PyTuple *args)
-	{
-		auto &heap = VirtualMachine::the().heap();
-		return heap.allocate<SyntaxError>(args);
-	}
-
-  public:
-	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-
-	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
-
-	PyType *static_type() const override;
-};
-
-template<typename... Args>
-inline BaseException *syntax_error(const std::string &message, Args &&...args)
-{
-	auto msg = PyString::create(fmt::format(message, std::forward<Args>(args)...));
-	ASSERT(msg.is_ok());
-	auto args_tuple = PyTuple::create(msg.unwrap());
-	ASSERT(args_tuple.is_ok());
-	return SyntaxError::create(args_tuple.unwrap());
-}
-
-}// namespace py
diff --git a/src/runtime/TypeError.cpp b/src/runtime/TypeError.cpp
index 431cb95d..8e68f7de 100644
--- a/src/runtime/TypeError.cpp
+++ b/src/runtime/TypeError.cpp
@@ -1,10 +1,27 @@
-#include "TypeError.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
+TypeError *TypeError::create(PyTuple *args)
+{
+	auto &heap = VirtualMachine::the().heap();
+	return heap.allocate<TypeError>(args);
+}
+
+BaseException *make_type_error(std::string &&message)
+{
+	auto msg = PyString::create(std::move(message));
+	ASSERT(msg.is_ok());
+	auto args_tuple = PyTuple::create(msg.unwrap());
+	ASSERT(args_tuple.is_ok());
+	return TypeError::create(args_tuple.unwrap());
+}
+
 TypeError::TypeError(PyType *type) : Exception(type) {}
 
 TypeError::TypeError(PyTuple *args) : Exception(types::BuiltinTypes::the().type_error(), args) {}
diff --git a/src/runtime/TypeError.cppm b/src/runtime/TypeError.cppm
new file mode 100644
index 00000000..0553b91c
--- /dev/null
+++ b/src/runtime/TypeError.cppm
@@ -0,0 +1,50 @@
+module;
+#include "memory/allocate.hpp"
+
+export module py.runtime:type_error;
+import :baseexception;
+import :dict;
+import :exception;
+import :object;
+import :string;
+import :tuple;
+import :value;
+import py.memory;
+import std;
+
+export namespace py {
+class PyType;
+
+class TypeError : public Exception
+{
+	friend class ::Heap;
+	friend class py::detail::Allocator;
+	friend BaseException *make_type_error(std::string &&);
+
+  private:
+	TypeError(PyType *type);
+
+	TypeError(PyTuple *args);
+
+	static TypeError *create(PyTuple *args);
+
+  public:
+	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
+
+	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
+
+	PyType *static_type() const override;
+};
+
+// Defined in TypeError.cpp. Keeping the PyString/PyTuple construction and the
+// heap allocation out of the interface means this partition no longer has
+// to materialise those types just to declare one exception class.
+BaseException *make_type_error(std::string &&message);
+
+template<typename... Args>
+inline BaseException *type_error(const std::string &message, Args &&...args)
+{
+	return make_type_error(std::vformat(message, std::make_format_args(args...)));
+}
+
+}// namespace py
diff --git a/src/runtime/TypeError.hpp b/src/runtime/TypeError.hpp
deleted file mode 100644
index 138fb835..00000000
--- a/src/runtime/TypeError.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#pragma once
-
-#include "Exception.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
-
-class TypeError : public Exception
-{
-	friend class ::Heap;
-	template<typename... Args>
-	friend BaseException *type_error(const std::string &message, Args &&...args);
-
-  private:
-	TypeError(PyType *type);
-
-	TypeError(PyTuple *args);
-
-	static TypeError *create(PyTuple *args)
-	{
-		auto &heap = VirtualMachine::the().heap();
-		return heap.allocate<TypeError>(args);
-	}
-
-  public:
-	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-
-	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
-
-	PyType *static_type() const override;
-};
-
-template<typename... Args>
-inline BaseException *type_error(const std::string &message, Args &&...args)
-{
-	auto msg = PyString::create(fmt::format(message, std::forward<Args>(args)...));
-	ASSERT(msg.is_ok());
-	auto args_tuple = PyTuple::create(msg.unwrap());
-	ASSERT(args_tuple.is_ok());
-	return TypeError::create(args_tuple.unwrap());
-}
-
-}// namespace py
diff --git a/src/runtime/UnboundLocalError.cpp b/src/runtime/UnboundLocalError.cpp
index 1a57095f..c77a2726 100644
--- a/src/runtime/UnboundLocalError.cpp
+++ b/src/runtime/UnboundLocalError.cpp
@@ -1,10 +1,27 @@
-#include "UnboundLocalError.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
+UnboundLocalError *UnboundLocalError::create(PyTuple *args)
+{
+	auto &heap = VirtualMachine::the().heap();
+	return heap.allocate<UnboundLocalError>(args);
+}
+
+BaseException *make_unbound_local_error(std::string &&message)
+{
+	auto msg = PyString::create(std::move(message));
+	ASSERT(msg.is_ok());
+	auto args_tuple = PyTuple::create(msg.unwrap());
+	ASSERT(args_tuple.is_ok());
+	return UnboundLocalError::create(args_tuple.unwrap());
+}
+
 UnboundLocalError::UnboundLocalError(PyType *type) : Exception(type) {}
 
 UnboundLocalError::UnboundLocalError(PyTuple *args)
diff --git a/src/runtime/UnboundLocalError.cppm b/src/runtime/UnboundLocalError.cppm
new file mode 100644
index 00000000..44580fbc
--- /dev/null
+++ b/src/runtime/UnboundLocalError.cppm
@@ -0,0 +1,51 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+export module py.runtime:unbound_local_error;
+import :baseexception;
+import :dict;
+import :exception;
+import :object;
+import :string;
+import :tuple;
+import :value;
+import py.memory;
+import std;
+
+export namespace py {
+class PyType;
+
+class UnboundLocalError : public Exception
+{
+	friend class ::Heap;
+	friend class py::detail::Allocator;
+	friend BaseException *make_unbound_local_error(std::string &&);
+
+  private:
+	UnboundLocalError(PyType *type);
+
+	UnboundLocalError(PyTuple *args);
+
+	static UnboundLocalError *create(PyTuple *args);
+
+  public:
+	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
+
+	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
+
+	PyType *static_type() const override;
+};
+
+// Defined in UnboundLocalError.cpp. Keeping the PyString/PyTuple construction and the
+// heap allocation out of the interface means this partition no longer has
+// to materialise those types just to declare one exception class.
+BaseException *make_unbound_local_error(std::string &&message);
+
+template<typename... Args>
+inline BaseException *unbound_local_error(const std::string &message, Args &&...args)
+{
+	return make_unbound_local_error(std::vformat(message, std::make_format_args(args...)));
+}
+
+}// namespace py
diff --git a/src/runtime/UnboundLocalError.hpp b/src/runtime/UnboundLocalError.hpp
deleted file mode 100644
index 6aedaca0..00000000
--- a/src/runtime/UnboundLocalError.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#pragma once
-
-#include "Exception.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
-
-class UnboundLocalError : public Exception
-{
-	friend class ::Heap;
-	template<typename... Args>
-	friend BaseException *unbound_local_error(const std::string &message, Args &&...args);
-
-  private:
-	UnboundLocalError(PyType *type);
-
-	UnboundLocalError(PyTuple *args);
-
-	static UnboundLocalError *create(PyTuple *args)
-	{
-		auto &heap = VirtualMachine::the().heap();
-		return heap.allocate<UnboundLocalError>(args);
-	}
-
-  public:
-	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-
-	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
-
-	PyType *static_type() const override;
-};
-
-template<typename... Args>
-inline BaseException *unbound_local_error(const std::string &message, Args &&...args)
-{
-	auto msg = PyString::create(fmt::format(message, std::forward<Args>(args)...));
-	ASSERT(msg.is_ok());
-	auto args_tuple = PyTuple::create(msg.unwrap());
-	ASSERT(args_tuple.is_ok());
-	return UnboundLocalError::create(args_tuple.unwrap());
-}
-
-}// namespace py
diff --git a/src/runtime/Value.cpp b/src/runtime/Value.cpp
index d0b09b26..bda82564 100644
--- a/src/runtime/Value.cpp
+++ b/src/runtime/Value.cpp
@@ -1,33 +1,20 @@
-#include "Value.hpp"
-#include "PyBool.hpp"
-#include "PyBytes.hpp"
-#include "PyEllipsis.hpp"
-#include "PyFloat.hpp"
-#include "PyInteger.hpp"
-#include "PyNone.hpp"
-#include "PyNumber.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "PyType.hpp"
-#include "TypeError.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "vm/VM.hpp"
-
-#include <cstdlib>
-#include <iostream>
-#include <locale>
-#include <ranges>
-
+module;
+#include "core.hpp"
+#include <cstdint>
+#include <gmpxx.h>
 #include <unicode/uchar.h>
 #include <unicode/unistr.h>
 #include <unicode/urename.h>
 #include <unicode/utypes.h>
 
+module py.runtime;
+
+
 using namespace py;
 
 std::string Number::to_string() const
 {
-	return std::visit([](const auto &value) { return fmt::format("{}", value); }, value);
+	return std::visit([](const auto &value) { return std::format("{}", value); }, value);
 }
 
 Number Number::exp(const Number &rhs) const
@@ -534,7 +521,8 @@ Bytes Bytes::from_unescaped_string(const std::string &str)
 				const auto c = static_cast<unsigned char>((digit1 << 4) + digit2);
 				bytes.push_back(std::byte{ c });
 			}
-			auto &f = std::use_facet<std::ctype<char>>(std::locale());
+			const std::locale loc;
+			const auto &f = std::use_facet<std::ctype<char>>(loc);
 			/* skip \x */
 			if (it < end && f.is(std::ctype<char>::xdigit, *it)) {
 				it++;// and a hexdigit
diff --git a/src/runtime/Value.hpp b/src/runtime/Value.cppm
similarity index 93%
rename from src/runtime/Value.hpp
rename to src/runtime/Value.cppm
index 8e7c817e..acfc9396 100644
--- a/src/runtime/Value.hpp
+++ b/src/runtime/Value.cppm
@@ -1,31 +1,38 @@
-#pragma once
+module;
 
-#include "../forward.hpp"
-#include "../utilities.hpp"
-#include "forward.hpp"
+#include "core.hpp"
 
 #include <gmpxx.h>
-#include <spdlog/fmt/bundled/format.h>
 
-#include <algorithm>
-#include <cmath>
-#include <cstddef>
-#include <expected>
-#include <sstream>
-#include <variant>
-#include <vector>
+export module py.runtime:value;
+import std;
 
-template<> struct fmt::formatter<mpz_class> : fmt::formatter<std::string>
+export class Interpreter;
+
+// std::formatter rather than std::formatter: spdlog is built with
+// SPDLOG_USE_STD_FORMAT, so nothing here needs spdlog/fmt/fmt.h - which would
+// otherwise pull 231 libstdc++ headers into this leaf partition's BMI.
+template<> struct std::formatter<mpz_class> : std::formatter<std::string>
 {
-	template<typename FormatContext> auto format(const mpz_class &number, FormatContext &ctx)
+	template<typename FormatContext> auto format(const mpz_class &number, FormatContext &ctx) const
 	{
 		std::ostringstream os;
 		os << number;
-		return fmt::formatter<std::string>::format(os.str(), ctx);
+		return std::formatter<std::string>::format(os.str(), ctx);
 	}
 };
 
-namespace py {
+export namespace py {
+
+struct Number;
+struct String;
+struct Bytes;
+struct Ellipsis;
+struct NoneType;
+struct NameConstant;
+struct Tuple;
+class PyObject;
+using Value = std::variant<Number, String, Bytes, Ellipsis, NameConstant, Tuple, PyObject *>;
 
 using BigIntType = mpz_class;
 
diff --git a/src/runtime/ValueError.cpp b/src/runtime/ValueError.cpp
index 0ca25d08..e0c89e34 100644
--- a/src/runtime/ValueError.cpp
+++ b/src/runtime/ValueError.cpp
@@ -1,11 +1,22 @@
-#include "ValueError.hpp"
-#include "MemoryError.hpp"
-#include "PyString.hpp"
-#include "types/api.hpp"
-#include "types/builtin.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
+BaseException *make_value_error(std::string &&message)
+{
+	auto msg = PyString::create(std::move(message));
+	ASSERT(msg.is_ok());
+	auto args_tuple = PyTuple::create(msg.unwrap());
+	ASSERT(args_tuple.is_ok());
+	return ValueError::create(args_tuple.unwrap()).unwrap();
+}
+
 template<> ValueError *as(PyObject *obj)
 {
 	ASSERT(types::value_error());
diff --git a/src/runtime/ValueError.cppm b/src/runtime/ValueError.cppm
new file mode 100644
index 00000000..5ad3cf12
--- /dev/null
+++ b/src/runtime/ValueError.cppm
@@ -0,0 +1,52 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+export module py.runtime:value_error;
+import :baseexception;
+import :dict;
+import :exception;
+import :object;
+import :string;
+import :tuple;
+import :value;
+import py.memory;
+import std;
+
+export namespace py {
+class PyType;
+
+class ValueError : public Exception
+{
+	friend class ::Heap;
+	friend class py::detail::Allocator;
+	friend BaseException *make_value_error(std::string &&);
+
+  private:
+	ValueError(PyType *type);
+
+	ValueError(PyTuple *args);
+
+  public:
+	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
+	static PyResult<ValueError *> create(PyTuple *args);
+
+	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
+
+	PyType *static_type() const override;
+
+	static PyType *class_type();
+};
+
+// Defined in ValueError.cpp. Keeping the PyString/PyTuple construction and the
+// heap allocation out of the interface means this partition no longer has
+// to materialise those types just to declare one exception class.
+BaseException *make_value_error(std::string &&message);
+
+template<typename... Args>
+inline BaseException *value_error(const std::string &message, Args &&...args)
+{
+	return make_value_error(std::vformat(message, std::make_format_args(args...)));
+}
+
+}// namespace py
diff --git a/src/runtime/ValueError.hpp b/src/runtime/ValueError.hpp
deleted file mode 100644
index e05ad352..00000000
--- a/src/runtime/ValueError.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#pragma once
-
-#include "Exception.hpp"
-#include "PyString.hpp"
-#include "PyTuple.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
-
-class ValueError : public Exception
-{
-	friend class ::Heap;
-	template<typename... Args>
-	friend BaseException *value_error(const std::string &message, Args &&...args);
-
-  private:
-	ValueError(PyType *type);
-
-	ValueError(PyTuple *args);
-
-  public:
-	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-	static PyResult<ValueError *> create(PyTuple *args);
-
-	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
-
-	PyType *static_type() const override;
-
-	static PyType *class_type();
-};
-
-template<typename... Args>
-inline BaseException *value_error(const std::string &message, Args &&...args)
-{
-	auto msg = PyString::create(fmt::format(message, std::forward<Args>(args)...));
-	ASSERT(msg.is_ok());
-	auto args_tuple = PyTuple::create(msg.unwrap());
-	ASSERT(args_tuple.is_ok());
-	return ValueError::create(args_tuple.unwrap()).unwrap();
-}
-
-}// namespace py
diff --git a/src/runtime/concepts.hpp b/src/runtime/concepts.cppm
similarity index 93%
rename from src/runtime/concepts.hpp
rename to src/runtime/concepts.cppm
index 1b4e578e..46815add 100644
--- a/src/runtime/concepts.hpp
+++ b/src/runtime/concepts.cppm
@@ -1,10 +1,17 @@
-#pragma once
+module;
 
-#include "runtime/forward.hpp"
+export module py.runtime:concepts;
 
-#include <concepts>
+import :value;
+import std;
 
-namespace py {
+export namespace py {
+
+class PyObject;
+class PyDict;
+class PyTuple;
+class PyType;
+class PyBuffer;
 
 template<typename _Interface, typename _Interfacing> struct Interface : public _Interface
 {
@@ -97,12 +104,12 @@ namespace concepts {
 	concept HasContains = requires(T *obj, PyObject *value) { obj->__contains__(value); };
 
 	template<typename T>
-	concept HasSequenceGetItem = requires(T *obj, int64_t index) { obj->__getitem__(index); };
+	concept HasSequenceGetItem = requires(T *obj, std::int64_t index) { obj->__getitem__(index); };
 	template<typename T>
 	concept HasSequenceSetItem =
-		requires(T *obj, int64_t index, PyObject *value) { obj->__setitem__(index, value); };
+		requires(T *obj, std::int64_t index, PyObject *value) { obj->__setitem__(index, value); };
 	template<typename T>
-	concept HasSequenceDelItem = requires(T *obj, int64_t index) { obj->__delitem__(index); };
+	concept HasSequenceDelItem = requires(T *obj, std::int64_t index) { obj->__delitem__(index); };
 
 	template<typename T>
 	concept HasLt = requires(const T *obj, const PyObject *other) { obj->__lt__(other); };
diff --git a/src/runtime/forward.hpp b/src/runtime/forward.hpp
deleted file mode 100644
index f8f9b21c..00000000
--- a/src/runtime/forward.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#pragma once
-
-namespace py {
-
-class PyAsyncGenerator;
-class PyCell;
-class PyCode;
-class PyCoroutine;
-class PyDict;
-class PyFloat;
-class PyFrozenSet;
-class PyFunction;
-class PyFrame;
-class PyGenerator;
-class PyInteger;
-class PyList;
-class PyNativeFunction;
-class PyNone;
-class PyNumber;
-class PyMethodDescriptor;
-class PyModule;
-class PyObject;
-class PySet;
-class PySlice;
-class PySlotWrapper;
-class PyString;
-class PyTraceback;
-class PyTuple;
-class PyTupleIterator;
-class PyType;
-struct TypePrototype;
-struct PyBuffer;
-
-template<typename T> T *as(PyObject *node);
-template<typename T> const T *as(const PyObject *node);
-
-}// namespace py
diff --git a/src/runtime/modules/BuiltinsModule.cpp b/src/runtime/modules/BuiltinsModule.cpp
index 5732f41d..15154ad5 100644
--- a/src/runtime/modules/BuiltinsModule.cpp
+++ b/src/runtime/modules/BuiltinsModule.cpp
@@ -1,65 +1,17 @@
-#include "Modules.hpp"
-#include "runtime/AssertionError.hpp"
-#include "runtime/AttributeError.hpp"
-#include "runtime/Import.hpp"
-#include "runtime/ImportError.hpp"
-#include "runtime/IndexError.hpp"
-#include "runtime/KeyError.hpp"
-#include "runtime/LookupError.hpp"
-#include "runtime/ModuleNotFoundError.hpp"
-#include "runtime/NameError.hpp"
-#include "runtime/NotImplementedError.hpp"
-#include "runtime/OSError.hpp"
-#include "runtime/PyArgParser.hpp"
-#include "runtime/PyBool.hpp"
-#include "runtime/PyBytes.hpp"
-#include "runtime/PyCell.hpp"
-#include "runtime/PyCode.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyFunction.hpp"
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/PyModule.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyNumber.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyRange.hpp"
-#include "runtime/PyStaticMethod.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/RuntimeError.hpp"
-#include "runtime/StopIteration.hpp"
-#include "runtime/SyntaxError.hpp"
-#include "runtime/TypeError.hpp"
-#include "runtime/UnboundLocalError.hpp"
-#include "runtime/Value.hpp"
-#include "runtime/ValueError.hpp"
-#include "runtime/modules/Modules.hpp"
-#include "runtime/types/builtin.hpp"
-#include "runtime/warnings/ImportWarning.hpp"
-#include "runtime/warnings/Warning.hpp"
-
-#include "executable/Mangler.hpp"
-#include "executable/Program.hpp"
-#include "executable/bytecode/Bytecode.hpp"
-#include "executable/bytecode/codegen/BytecodeGenerator.hpp"
-#include "executable/bytecode/instructions/FunctionCall.hpp"
-
-#include "interpreter/Interpreter.hpp"
-
-#include "lexer/Lexer.hpp"
-
-#include "memory/GarbageCollector.hpp"
-
-#include "parser/Parser.hpp"
-
-#include "vm/VM.hpp"
-
-#include "utilities.hpp"
-#include <algorithm>
-#include <variant>
+module;
+#include "core.hpp"
+#include "executable/common.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <gmpxx.h>
+
+module py.runtime;
+import py.lexer;
+import py.types;
+import std;
+
 
 using namespace py;
 
@@ -154,11 +106,12 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
 	--arg_it_end;
 
 	while (arg_it != arg_it_end) {
-		spdlog::debug("arg function ptr: {}", static_cast<void *>((*arg_it).unwrap()));
+		::detail::log_debug(
+			std::format("arg function ptr: {}", static_cast<void *>((*arg_it).unwrap())).c_str());
 		auto reprobj_ = strfunc(*arg_it);
 		if (reprobj_.is_err()) { return reprobj_; }
 		auto reprobj = reprobj_.unwrap();
-		spdlog::debug("repr result: {}", reprobj->value());
+		::detail::log_debug(std::format("repr result: {}", reprobj->value()).c_str());
 		if (auto result = file_write->call(PyTuple::create(reprobj).unwrap(), nullptr);
 			result.is_err()) {
 			return result;
@@ -170,11 +123,12 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
 		std::advance(arg_it, 1);
 	}
 
-	spdlog::debug("arg function ptr: {}", static_cast<void *>((*arg_it).unwrap()));
+	::detail::log_debug(
+		std::format("arg function ptr: {}", static_cast<void *>((*arg_it).unwrap())).c_str());
 	auto reprobj_ = strfunc(*arg_it);
 	if (reprobj_.is_err()) { return reprobj_; }
 	auto reprobj = reprobj_.unwrap();
-	spdlog::debug("repr result: {}", reprobj->value());
+	::detail::log_debug(std::format("repr result: {}", reprobj->value()).c_str());
 	if (auto result = file_write->call(PyTuple::create(reprobj).unwrap(), nullptr);
 		result.is_err()) {
 		return result;
@@ -199,8 +153,8 @@ PyResult<PyObject *> iter(PyTuple *args, PyDict *kwargs, Interpreter &)
 	auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 		kwargs,
 		"iter",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 1>{});
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 1>{});
 	if (result.is_err()) return Err(result.unwrap_err());
 	return std::get<0>(result.unwrap())->iter();
 }
@@ -210,10 +164,10 @@ PyResult<PyObject *> hash(PyTuple *args, PyDict *kwargs, Interpreter &)
 	auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 		kwargs,
 		"hash",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 1>{});
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 1>{});
 	if (result.is_err()) return Err(result.unwrap_err());
-	return std::get<0>(result.unwrap())->hash().and_then([](const size_t h) {
+	return std::get<0>(result.unwrap())->hash().and_then([](const std::size_t h) {
 		return PyInteger::create(h);
 	});
 }
@@ -223,8 +177,8 @@ PyResult<PyObject *> next(PyTuple *args, PyDict *kwargs, Interpreter &)
 	auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 		kwargs,
 		"next",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 1>{});
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 1>{});
 	if (result.is_err()) return Err(result.unwrap_err());
 	return std::get<0>(result.unwrap())->next();
 }
@@ -257,9 +211,10 @@ PyResult<PyObject *>
 	auto mangled_class_name_ = args->operator[](1);
 	if (mangled_class_name_.is_err()) return mangled_class_name_;
 	auto *mangled_class_name = mangled_class_name_.unwrap();
-	spdlog::debug("__build_class__({}, {})",
+	::detail::log_debug(std::format("__build_class__({}, {})",
 		mangled_class_name->to_string(),
-		maybe_function_location->to_string());
+		maybe_function_location->to_string())
+			.c_str());
 
 	if (!as<PyString>(mangled_class_name)) {
 		return Err(type_error("__build_class__: name is not a string"));
@@ -432,8 +387,8 @@ PyResult<PyObject *> len(PyTuple *args, PyDict *kwargs, Interpreter &)
 	auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 		kwargs,
 		"len",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 1>{});
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 1>{});
 	if (result.is_err()) return Err(result.unwrap_err());
 
 	auto *o = std::get<0>(result.unwrap());
@@ -451,7 +406,7 @@ PyResult<PyObject *> id(const PyTuple *args, const PyDict *, Interpreter &)
 	ASSERT(args->size() == 1);
 	auto obj = args->operator[](0);
 	if (obj.is_err()) return obj;
-	return PyInteger::create(bit_cast<intptr_t>(obj.unwrap()));
+	return PyInteger::create(std::bit_cast<std::intptr_t>(obj.unwrap()));
 }
 
 PyResult<PyObject *> import(const PyTuple *args, const PyDict *, Interpreter &)
@@ -534,7 +489,7 @@ PyResult<PyObject *> import(const PyTuple *args, const PyDict *, Interpreter &)
 		as<PyDict>(globals),
 		locals,
 		fromlist,
-		static_cast<uint32_t>(as<PyInteger>(level)->as_size_t()));
+		static_cast<std::uint32_t>(as<PyInteger>(level)->as_size_t()));
 }
 
 PyResult<PyObject *> hasattr(PyTuple *args, PyDict *kwargs, Interpreter &)
@@ -542,8 +497,8 @@ PyResult<PyObject *> hasattr(PyTuple *args, PyDict *kwargs, Interpreter &)
 	auto result = PyArgsParser<PyObject *, PyObject *>::unpack_tuple(args,
 		kwargs,
 		"hasattr",
-		std::integral_constant<size_t, 2>{},
-		std::integral_constant<size_t, 2>{});
+		std::integral_constant<std::size_t, 2>{},
+		std::integral_constant<std::size_t, 2>{});
 	if (result.is_err()) return Err(result.unwrap_err());
 	auto [obj, name] = result.unwrap();
 	if (!as<PyString>(name)) { return Err(type_error("hasattr(): attribute name must be string")); }
@@ -563,8 +518,8 @@ PyResult<PyObject *> getattr(PyTuple *args, PyDict *kwargs, Interpreter &)
 	auto result = PyArgsParser<PyObject *, PyObject *, PyObject *>::unpack_tuple(args,
 		kwargs,
 		"getattr",
-		std::integral_constant<size_t, 2>{},
-		std::integral_constant<size_t, 3>{},
+		std::integral_constant<std::size_t, 2>{},
+		std::integral_constant<std::size_t, 3>{},
 		nullptr /* default */);
 	if (result.is_err()) return Err(result.unwrap_err());
 	auto [obj, name, default_value] = result.unwrap();
@@ -594,8 +549,8 @@ PyResult<PyObject *> setattr(PyTuple *args, PyDict *kwargs, Interpreter &)
 	auto result = PyArgsParser<PyObject *, PyObject *, PyObject *>::unpack_tuple(args,
 		kwargs,
 		"setattr",
-		std::integral_constant<size_t, 3>{},
-		std::integral_constant<size_t, 3>{});
+		std::integral_constant<std::size_t, 3>{},
+		std::integral_constant<std::size_t, 3>{});
 	if (result.is_err()) return Err(result.unwrap_err());
 	auto [obj, name, value] = result.unwrap();
 
@@ -613,8 +568,8 @@ PyResult<PyObject *> hex(PyTuple *args, PyDict *kwargs, Interpreter &)
 	auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 		kwargs,
 		"hex",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 1>{});
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 1>{});
 	if (result.is_err()) return Err(result.unwrap_err());
 	auto *obj = std::get<0>(result.unwrap());
 	if (auto pynumber = PyNumber::as_number(obj)) {
@@ -638,13 +593,13 @@ PyResult<PyObject *> ord(PyTuple *args, PyDict *kwargs, Interpreter &)
 	auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 		kwargs,
 		"ord",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 1>{});
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 1>{});
 	if (result.is_err()) return Err(result.unwrap_err());
 	auto *obj = std::get<0>(result.unwrap());
 	if (auto pystr = as<PyString>(obj)) {
 		if (auto codepoint = pystr->codepoint()) {
-			return PyObject::from(Number{ static_cast<int64_t>(*codepoint) });
+			return PyObject::from(Number{ static_cast<std::int64_t>(*codepoint) });
 		} else {
 			auto mapping = pystr->as_mapping();
 			if (mapping.is_err()) { return Err(mapping.unwrap_err()); }
@@ -664,8 +619,8 @@ PyResult<PyObject *> chr(PyTuple *args, PyDict *kwargs, Interpreter &)
 	auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 		kwargs,
 		"chr",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 1>{});
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 1>{});
 	if (result.is_err()) return Err(result.unwrap_err());
 	auto *obj = std::get<0>(result.unwrap());
 
@@ -729,8 +684,8 @@ PyResult<PyObject *> repr(PyTuple *args, PyDict *kwargs, Interpreter &)
 	auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 		kwargs,
 		"repr",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 1>{});
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 1>{});
 	if (result.is_err()) return Err(result.unwrap_err());
 	return std::get<0>(result.unwrap())->repr();
 }
@@ -740,8 +695,8 @@ PyResult<PyObject *> abs(PyTuple *args, PyDict *kwargs, Interpreter &)
 	auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 		kwargs,
 		"abs",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 1>{});
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 1>{});
 	if (result.is_err()) return Err(result.unwrap_err());
 	return std::get<0>(result.unwrap())->abs();
 }
@@ -849,8 +804,8 @@ PyResult<PyObject *> isinstance(PyTuple *args, PyDict *kwargs, Interpreter &)
 	auto result = PyArgsParser<PyObject *, PyObject *>::unpack_tuple(args,
 		kwargs,
 		"isinstance",
-		std::integral_constant<size_t, 2>{},
-		std::integral_constant<size_t, 2>{});
+		std::integral_constant<std::size_t, 2>{},
+		std::integral_constant<std::size_t, 2>{});
 	if (result.is_err()) return Err(result.unwrap_err());
 	auto [object, classinfo] = result.unwrap();
 
@@ -883,8 +838,8 @@ PyResult<PyObject *> issubclass(PyTuple *args, PyDict *kwargs, Interpreter &)
 	auto result = PyArgsParser<PyObject *, PyObject *>::unpack_tuple(args,
 		kwargs,
 		"issubclass",
-		std::integral_constant<size_t, 2>{},
-		std::integral_constant<size_t, 2>{});
+		std::integral_constant<std::size_t, 2>{},
+		std::integral_constant<std::size_t, 2>{});
 	if (result.is_err()) return Err(result.unwrap_err());
 	auto [class_, classinfo] = result.unwrap();
 
@@ -906,8 +861,8 @@ PyResult<PyObject *> all(PyTuple *args, PyDict *kwargs, Interpreter &)
 	auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 		kwargs,
 		"all",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 1>{});
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 1>{});
 	if (result.is_err()) return Err(result.unwrap_err());
 	auto *iterable = std::get<0>(result.unwrap());
 
@@ -934,8 +889,8 @@ PyResult<PyObject *> any(PyTuple *args, PyDict *kwargs, Interpreter &)
 	auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 		kwargs,
 		"any",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 1>{});
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 1>{});
 	if (result.is_err()) return Err(result.unwrap_err());
 	auto *iterable = std::get<0>(result.unwrap());
 
@@ -961,8 +916,8 @@ PyResult<PyObject *> exec(PyTuple *args, PyDict *kwargs, Interpreter &interprete
 	auto result = PyArgsParser<PyObject *, PyObject *, PyObject *>::unpack_tuple(args,
 		kwargs,
 		"exec",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 3>{},
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 3>{},
 		py_none() /* globals */,
 		py_none() /* locals */);
 	if (result.is_err()) return Err(result.unwrap_err());
@@ -1009,8 +964,8 @@ PyResult<PyObject *> eval(PyTuple *args, PyDict *kwargs, Interpreter &interprete
 	auto result = PyArgsParser<PyObject *, PyObject *, PyObject *>::unpack_tuple(args,
 		kwargs,
 		"eval",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 3>{},
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 3>{},
 		py_none() /* globals */,
 		py_none() /* locals */);
 
@@ -1166,8 +1121,8 @@ PyResult<PyObject *> callable(PyTuple *args, PyDict *kwargs, Interpreter &)
 	auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 		kwargs,
 		"callable",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 1>{});
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 1>{});
 	if (result.is_err()) return Err(result.unwrap_err());
 	auto *obj = std::get<0>(result.unwrap());
 	return obj->type_prototype().__call__.has_value() ? Ok(py_true()) : Ok(py_false());
@@ -1178,8 +1133,8 @@ PyResult<PyObject *> ascii(PyTuple *args, PyDict *kwargs, Interpreter &)
 	auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 		kwargs,
 		"ascii",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 1>{});
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 1>{});
 
 	if (result.is_err()) { return Err(result.unwrap_err()); }
 	auto [obj] = result.unwrap();
@@ -1271,11 +1226,11 @@ PyResult<PyObject *> sorted(PyTuple *args, PyDict *kwargs, Interpreter &interpre
 		if (err.is_err()) { return err; }
 	} else {
 		PyResult<PyObject *> err = Ok(py_none());
-		std::vector<size_t> indices(cmp_list->elements().size());
+		std::vector<std::size_t> indices(cmp_list->elements().size());
 		std::iota(indices.begin(), indices.end(), 0);
 		// FIXME: should throw exception when comparing, as returning true is
 		// probably messing up the C++ Compare requirment
-		auto cmp = [&err, cmp_list](size_t lhs_index, size_t rhs_index) -> bool {
+		auto cmp = [&err, cmp_list](std::size_t lhs_index, std::size_t rhs_index) -> bool {
 			const auto &lhs = cmp_list->elements()[lhs_index];
 			const auto &rhs = cmp_list->elements()[rhs_index];
 			if (auto cmp = less_than(lhs, rhs, VirtualMachine::the().interpreter()); cmp.is_ok()) {
@@ -1312,8 +1267,8 @@ PyResult<PyObject *> vars(PyTuple *args, PyDict *kwargs, Interpreter &interprete
 	auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 		kwargs,
 		"vars",
-		std::integral_constant<size_t, 0>{},
-		std::integral_constant<size_t, 1>{},
+		std::integral_constant<std::size_t, 0>{},
+		std::integral_constant<std::size_t, 1>{},
 		nullptr);
 
 	if (result.is_err()) { return Err(result.unwrap_err()); }
@@ -1334,8 +1289,8 @@ PyResult<PyObject *> divmod(PyTuple *args, PyDict *kwargs, Interpreter &)
 	auto result = PyArgsParser<PyObject *, PyObject *>::unpack_tuple(args,
 		kwargs,
 		"divmod",
-		std::integral_constant<size_t, 2>{},
-		std::integral_constant<size_t, 2>{});
+		std::integral_constant<std::size_t, 2>{},
+		std::integral_constant<std::size_t, 2>{});
 
 	if (result.is_err()) { return Err(result.unwrap_err()); }
 	auto [lhs, rhs] = result.unwrap();
@@ -1348,8 +1303,8 @@ PyResult<PyObject *> round(PyTuple *args, PyDict *kwargs, Interpreter &)
 	auto result = PyArgsParser<PyObject *, PyObject *>::unpack_tuple(args,
 		kwargs,
 		"round",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 2>{},
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 2>{},
 		nullptr);
 
 	if (result.is_err()) { return Err(result.unwrap_err()); }
@@ -1442,7 +1397,8 @@ PyModule *builtins_module(Interpreter &interpreter)
 	// FIXME: second check (check address is valid) is only needed for unittests since each test
 	// 		  clears the heap but is still the same executable (so it still uses the same static
 	// 		  address)
-	if (s_builtin_module && heap.slab().has_address(bit_cast<uint8_t *>(s_builtin_module))) {
+	if (s_builtin_module
+		&& heap.slab().has_address(std::bit_cast<std::uint8_t *>(s_builtin_module))) {
 		return s_builtin_module;
 	}
 
diff --git a/src/runtime/modules/CodecsModule.cpp b/src/runtime/modules/CodecsModule.cpp
index c312a6d7..a1eac76b 100644
--- a/src/runtime/modules/CodecsModule.cpp
+++ b/src/runtime/modules/CodecsModule.cpp
@@ -1,22 +1,9 @@
-#include "Modules.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/LookupError.hpp"
-#include "runtime/PyArgParser.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFunction.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/PyModule.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/TypeError.hpp"
-#include "runtime/Value.hpp"
-#include "runtime/types/builtin.hpp"
-#include "vm/VM.hpp"
-
-#include <algorithm>
+module;
 #include <cctype>
 
+module py.runtime;
+import py.types;
+
 
 namespace py {
 namespace detail {
@@ -26,8 +13,8 @@ namespace detail {
 			auto result = PyArgsParser<PyString *>::unpack_tuple(args,
 				kwargs,
 				"lookup_errors",
-				std::integral_constant<size_t, 1>{},
-				std::integral_constant<size_t, 1>{});
+				std::integral_constant<std::size_t, 1>{},
+				std::integral_constant<std::size_t, 1>{});
 
 			if (result.is_err()) { return Err(result.unwrap_err()); }
 			auto [error] = result.unwrap();
@@ -46,8 +33,8 @@ namespace detail {
 			auto parse_result = PyArgsParser<PyString *>::unpack_tuple(args,
 				kwargs,
 				"lookup",
-				std::integral_constant<size_t, 1>{},
-				std::integral_constant<size_t, 1>{});
+				std::integral_constant<std::size_t, 1>{},
+				std::integral_constant<std::size_t, 1>{});
 
 			if (parse_result.is_err()) { return Err(parse_result.unwrap_err()); }
 			auto [encoding] = parse_result.unwrap();
@@ -117,4 +104,4 @@ PyModule *codecs_module()
 
 	return s_codecs_module;
 }
-}// namespace py
\ No newline at end of file
+}// namespace py
diff --git a/src/runtime/modules/GcModule.cpp b/src/runtime/modules/GcModule.cpp
index fd2ff58d..4721dae4 100644
--- a/src/runtime/modules/GcModule.cpp
+++ b/src/runtime/modules/GcModule.cpp
@@ -1,12 +1,8 @@
-#include "Modules.hpp"
-#include "memory/GarbageCollector.hpp"
-#include "memory/Heap.hpp"
-#include "runtime/PyBool.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFunction.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyString.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+
+module py.runtime;
+
 
 namespace py {
 
diff --git a/src/runtime/modules/IOChecks.hpp b/src/runtime/modules/IOChecks.hpp
index 640c4f84..b50ba94c 100644
--- a/src/runtime/modules/IOChecks.hpp
+++ b/src/runtime/modules/IOChecks.hpp
@@ -1,9 +1,5 @@
 #pragma once
 
-#include "runtime/Value.hpp"
-#include "runtime/ValueError.hpp"
-
-#include <variant>
 
 namespace py {
 
diff --git a/src/runtime/modules/IOModule.cpp b/src/runtime/modules/IOModule.cpp
index 6a721968..fa0780c2 100644
--- a/src/runtime/modules/IOModule.cpp
+++ b/src/runtime/modules/IOModule.cpp
@@ -1,41 +1,23 @@
-#include "IOChecks.hpp"
-#include "Modules.hpp"
-#include "runtime/MemoryError.hpp"
-#include "runtime/NotImplementedError.hpp"
-#include "runtime/OSError.hpp"
-#include "runtime/PyArgParser.hpp"
-#include "runtime/PyBool.hpp"
-#include "runtime/PyBytes.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFunction.hpp"
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/PyMemoryView.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/StopIteration.hpp"
-#include "runtime/Value.hpp"
-#include "runtime/ValueError.hpp"
-#include "runtime/types/api.hpp"
-#include "runtime/types/builtin.hpp"
-#include "utilities.hpp"
-#include "vm/VM.hpp"
-#include <cstddef>
-#include <cstdint>
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cerrno>
 #include <cstdio>
-#include <limits>
-#include <optional>
+#include <ext/stdio_filebuf.h>
+#include <fcntl.h>
+#include <gmpxx.h>
 #include <unistd.h>
-#include <variant>
+
+module py.runtime;
+import py.types;
+import std;
+
+#include "IOChecks.hpp"
+
 
 #if defined(__GLIBCXX__) || defined(__GLIBCPP__)
-#include <ext/stdio_filebuf.h>
 #endif
-#include <filesystem>
-#include <fstream>
+
 
 namespace fs = std::filesystem;
 
@@ -60,7 +42,7 @@ namespace {
 	PyType *s_unsupported_operation_type = nullptr;
 }// namespace
 
-static constexpr size_t s_default_buffer_size = 8192;
+static constexpr std::size_t s_default_buffer_size = 8192;
 
 Exception *unsupported_operation(PyTuple *args, PyDict *kwargs)
 {
@@ -73,6 +55,7 @@ Exception *unsupported_operation(PyTuple *args, PyDict *kwargs)
 class IOBase : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
   private:
 	IOBase() : IOBase(s_io_base->type()) {}
@@ -211,15 +194,15 @@ class IOBase : public PyBaseObject
 		return check_closed().and_then([](auto) { return Ok(py_false()); });
 	}
 
-	PyResult<PyObject *> readline(int64_t limit) const
+	PyResult<PyObject *> readline(std::int64_t limit) const
 	{
 		auto peek = lookup_attribute(PyString::create("peek").unwrap());
 		if (std::get<0>(peek).is_err()) return std::get<0>(peek);
 		const bool peakable = std::get<1>(peek) == LookupAttrResult::FOUND;
 		std::vector<std::byte> buffer;
 
-		while (limit < 0 || static_cast<int64_t>(buffer.size()) < limit) {
-			int64_t nreadahead = 1;
+		while (limit < 0 || static_cast<std::int64_t>(buffer.size()) < limit) {
+			std::int64_t nreadahead = 1;
 			if (peakable) {
 				auto readahead = std::get<0>(peek).unwrap()->call(
 					PyTuple::create(Number{ 1 }).unwrap(), PyDict::create().unwrap());
@@ -232,9 +215,9 @@ class IOBase : public PyBaseObject
 				auto readahead_bytes = as<PyBytes>(readahead.unwrap());
 				if (!readahead_bytes->value().b.empty()) {
 					const auto &bytes = readahead_bytes->value().b;
-					const auto upper = limit == -1
-										   ? bytes.size()
-										   : std::min(static_cast<int64_t>(bytes.size()), limit);
+					const auto upper =
+						limit == -1 ? bytes.size()
+									: std::min(static_cast<std::int64_t>(bytes.size()), limit);
 					auto it = std::find(bytes.begin(), bytes.begin() + upper, std::byte{ '\n' });
 					nreadahead = std::distance(bytes.begin(), it);
 				}
@@ -260,7 +243,7 @@ class IOBase : public PyBaseObject
 		return PyBytes::create(Bytes{ std::move(buffer) });
 	}
 
-	PyResult<PyObject *> readlines(int64_t hint) const
+	PyResult<PyObject *> readlines(std::int64_t hint) const
 	{
 		auto result_ = PyList::create();
 		if (result_.is_err()) return result_;
@@ -270,7 +253,7 @@ class IOBase : public PyBaseObject
 		if (it_.is_err()) return it_;
 		auto *it = it_.unwrap();
 
-		size_t length = 0;
+		std::size_t length = 0;
 
 		while (true) {
 			auto line = it->next();
@@ -289,7 +272,7 @@ class IOBase : public PyBaseObject
 						return Err(size.unwrap_err());
 					} else {
 						length += size.unwrap();
-						if (static_cast<int64_t>(length) > hint) { break; }
+						if (static_cast<std::int64_t>(length) > hint) { break; }
 					}
 				} else {
 					return Err(m.unwrap_err());
@@ -508,6 +491,7 @@ class IOBase : public PyBaseObject
 class RawIOBase : public IOBase
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
   private:
 	RawIOBase() : RawIOBase(s_io_raw_iobase->type()) {}
@@ -533,7 +517,7 @@ class RawIOBase : public IOBase
 
 	PyType *static_type() const override { return s_io_raw_iobase; }
 
-	PyResult<PyObject *> read(int64_t n)
+	PyResult<PyObject *> read(std::int64_t n)
 	{
 		if (n < 0) {
 			return get_method(PyString::create("readall").unwrap()).and_then([](PyObject *readall) {
@@ -549,14 +533,14 @@ class RawIOBase : public IOBase
 			.and_then([bytes](PyObject *readinto) {
 				return readinto->call(PyTuple::create(bytes).unwrap(), PyDict::create().unwrap());
 			})
-			.and_then([](PyObject *res) -> PyResult<int64_t> {
+			.and_then([](PyObject *res) -> PyResult<std::int64_t> {
 				if (!as<PyInteger>(res)) {
 					return Err(type_error(
 						"expected readinto to return an int, got '{}'", res->type()->name()));
 				}
 				return Ok(as<PyInteger>(res)->as_i64());
 			})
-			.and_then([bytes](const int64_t &n) {
+			.and_then([bytes](const std::int64_t &n) {
 				const auto &b = bytes->value().b;
 				std::vector<std::byte> result{ b.begin(), b.begin() + n };
 				return PyBytes::create(Bytes{ std::move(result) });
@@ -581,7 +565,7 @@ class RawIOBase : public IOBase
 					.def("read",
 						[](RawIOBase *self, PyTuple *args, PyDict *kwargs) -> PyResult<PyObject *> {
 							ASSERT(!kwargs || kwargs->map().empty());
-							int64_t n = -1;
+							std::int64_t n = -1;
 							if (args && args->elements().size() > 1) {
 								return Err(value_error(
 									"_RawIOBase.read expected at most one argument (got {})",
@@ -613,6 +597,7 @@ class RawIOBase : public IOBase
 class BufferedIOBase : public IOBase
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	BufferedIOBase() : BufferedIOBase(s_io_buffered_io_base) {}
 
@@ -678,7 +663,7 @@ class BufferedIOBase : public IOBase
 
 		const auto len = data_bytes.size();
 
-		if (static_cast<int64_t>(len) > buffer.len) {
+		if (static_cast<std::int64_t>(len) > buffer.len) {
 			return Err(
 				value_error("read() returned too much data: "
 							"{} bytes requested, {} returned",
@@ -690,7 +675,7 @@ class BufferedIOBase : public IOBase
 			data_bytes.size(),
 			static_cast<std::byte *>(buffer.buf->get_buffer()));
 
-		return PyInteger::create(static_cast<int64_t>(len));
+		return PyInteger::create(static_cast<std::int64_t>(len));
 	}
 
 	PyResult<PyObject *> readinto(PyBuffer &buffer) const
@@ -813,7 +798,7 @@ struct Buffered : IOChecks<Buffered<T>>
 
 	bool valid_readbuffer() const { return readable_ && buffer && buffer->in_avail() != -1; }
 
-	int64_t readahead() const { return valid_readbuffer() ? buffer->in_avail() : 0; }
+	std::int64_t readahead() const { return valid_readbuffer() ? buffer->in_avail() : 0; }
 
 	bool is_initialized() const { return ok && raw; }
 
@@ -964,7 +949,7 @@ struct Buffered : IOChecks<Buffered<T>>
 		}
 	}
 
-	PyResult<PyObject *> read(int64_t n)
+	PyResult<PyObject *> read(std::int64_t n)
 	{
 		if (auto err = this->check_initialized(); err.is_err()) return Err(err.unwrap_err());
 
@@ -981,7 +966,7 @@ struct Buffered : IOChecks<Buffered<T>>
 		}
 	}
 
-	PyResult<PyObject *> read1(int64_t n)
+	PyResult<PyObject *> read1(std::int64_t n)
 	{
 		if (auto err = this->check_initialized(); err.is_err()) return Err(err.unwrap_err());
 
@@ -995,7 +980,7 @@ struct Buffered : IOChecks<Buffered<T>>
 		if (n == 0) { return PyBytes::create(); }
 
 		const auto have = readahead();
-		if (have > 0) { return static_cast<T *>(this)->readfast(std::min<int64_t>(n, have)); }
+		if (have > 0) { return static_cast<T *>(this)->readfast(std::min<std::int64_t>(n, have)); }
 		Bytes b;
 		b.b.resize(n);
 		auto result = static_cast<T *>(this)->raw_read(std::span{ b.b.begin(), b.b.end() });
@@ -1015,6 +1000,7 @@ class BufferedReader
 	, public Buffered<BufferedReader>
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	BufferedReader(PyType *type, PyObject *raw, int buffer_size) : BufferedIOBase(type)
 	{
@@ -1065,7 +1051,7 @@ class BufferedReader
 		return BufferedReader::create(const_cast<PyType *>(type));
 	}
 
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs)
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs)
 	{
 		ASSERT(!kwargs || kwargs->map().empty());
 		if (!args || args->elements().empty()) {
@@ -1073,7 +1059,7 @@ class BufferedReader
 		}
 		if (args->elements().size() > 1) { TODO(); }
 		return PyObject::from(args->elements()[0])
-			.and_then([this](PyObject *raw) -> PyResult<int32_t> {
+			.and_then([this](PyObject *raw) -> PyResult<std::int32_t> {
 				this->raw = raw;
 				this->readable_ = true;
 				this->writable_ = false;
@@ -1093,7 +1079,7 @@ class BufferedReader
 		if (current_size > 0) {
 			ASSERT(buffer);
 			data.resize(current_size);
-			buffer->sgetn(::bit_cast<char *>(data.begin().base()), current_size);
+			buffer->sgetn(std::bit_cast<char *>(data.begin().base()), current_size);
 		}
 
 		auto readall_ = raw->lookup_attribute(PyString::create("readall").unwrap());
@@ -1145,25 +1131,25 @@ class BufferedReader
 		}
 	}
 
-	PyResult<PyObject *> readfast(size_t n)
+	PyResult<PyObject *> readfast(std::size_t n)
 	{
 		const auto current_size = readahead();
-		if (static_cast<int64_t>(n) <= current_size) {
+		if (static_cast<std::int64_t>(n) <= current_size) {
 			ASSERT(buffer);
 			std::vector<std::byte> data;
 			data.resize(n);
-			buffer->sgetn(::bit_cast<char *>(data.begin().base()), n);
+			buffer->sgetn(std::bit_cast<char *>(data.begin().base()), n);
 			return PyBytes::create(Bytes{ std::move(data) });
 		}
 		return Ok(py_none());
 	}
 
-	PyResult<size_t> raw_read(std::span<std::byte> data)
+	PyResult<std::size_t> raw_read(std::span<std::byte> data)
 	{
 		PyBuffer buffer{
 			.buf = std::make_unique<NonOwningStorage<std::byte>>(data.data()),
 			.obj = nullptr,
-			.len = static_cast<int64_t>(data.size()),
+			.len = static_cast<std::int64_t>(data.size()),
 			.itemsize = 1,
 			.readonly = false,
 			.ndim = 1,
@@ -1174,7 +1160,7 @@ class BufferedReader
 			.and_then([memobj](PyObject *read_into) {
 				return read_into->call(PyTuple::create(memobj).unwrap(), nullptr);
 			})
-			.and_then([](PyObject *n) -> PyResult<size_t> {
+			.and_then([](PyObject *n) -> PyResult<std::size_t> {
 				if (!as<PyInteger>(n)) {
 					return Err(value_error("expected 'int' got '{}'", n->type()->name()));
 				}
@@ -1182,7 +1168,7 @@ class BufferedReader
 			});
 	}
 
-	PyResult<PyObject *> readgeneric(size_t n)
+	PyResult<PyObject *> readgeneric(std::size_t n)
 	{
 		if (auto result = readfast(n); result.is_ok() && result.unwrap() != py_none()) {
 			return result;
@@ -1191,9 +1177,9 @@ class BufferedReader
 		bytes.b.resize(n);
 		const auto current_size = readahead();
 		auto remaining = n;
-		size_t written = 0;
+		std::size_t written = 0;
 		if (current_size > 0) {
-			buffer->sgetn(bit_cast<char *>(bytes.b.data()), current_size);
+			buffer->sgetn(std::bit_cast<char *>(bytes.b.data()), current_size);
 			remaining -= current_size;
 			written += current_size;
 		}
@@ -1224,12 +1210,12 @@ class BufferedReader
 			return std::get<0>(attr);
 		}
 		if (std::get<1>(attr) == LookupAttrResult::NOT_FOUND) {
-			return PyString::create(fmt::format("<{}>", type_prototype().__name__));
+			return PyString::create(std::format("<{}>", type_prototype().__name__));
 		}
 		auto *nameobj = std::get<0>(attr).unwrap();
 		return nameobj->repr().and_then([this](PyObject *nameobj_repr) {
 			return PyString::create(
-				fmt::format("<{} name={}>", type_prototype().__name__, nameobj_repr->to_string()));
+				std::format("<{} name={}>", type_prototype().__name__, nameobj_repr->to_string()));
 		});
 	}
 
@@ -1266,7 +1252,7 @@ class BufferedReader
 							PyTuple *args,
 							PyDict *kwargs) -> PyResult<PyObject *> {
 							ASSERT(!kwargs || kwargs->map().empty());
-							int64_t n = -1;
+							std::int64_t n = -1;
 							if (args && args->elements().size() > 1) {
 								return Err(
 									value_error("read expected at most one argument (got {})",
@@ -1290,7 +1276,7 @@ class BufferedReader
 							PyTuple *args,
 							PyDict *kwargs) -> PyResult<PyObject *> {
 							ASSERT(!kwargs || kwargs->map().empty());
-							int64_t n = -1;
+							std::int64_t n = -1;
 							if (args && args->elements().size() > 1) {
 								return Err(value_error("read1 at most one argument (got {})",
 									args->elements().size()));
@@ -1350,11 +1336,12 @@ class BufferedWriter
 	, public Buffered<BufferedWriter>
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	BufferedWriter(PyType *type, PyObject *raw, int buffer_size) : BufferedIOBase(type)
 	{
 		this->raw = raw;
-		if (buffer_size > 0) { m_buffer_size = static_cast<size_t>(buffer_size); }
+		if (buffer_size > 0) { m_buffer_size = static_cast<std::size_t>(buffer_size); }
 		this->readable_ = false;
 		this->writable_ = true;
 		this->fast_closed_checks = false;
@@ -1405,14 +1392,14 @@ class BufferedWriter
 		return BufferedWriter::create(const_cast<PyType *>(type));
 	}
 
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs)
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs)
 	{
-		auto parse_result = PyArgsParser<PyObject *, int64_t>::unpack_tuple(args,
+		auto parse_result = PyArgsParser<PyObject *, std::int64_t>::unpack_tuple(args,
 			kwargs,
 			"BufferedWriter",
-			std::integral_constant<size_t, 1>{},
-			std::integral_constant<size_t, 2>{},
-			static_cast<int64_t>(s_default_buffer_size));
+			std::integral_constant<std::size_t, 1>{},
+			std::integral_constant<std::size_t, 2>{},
+			static_cast<std::int64_t>(s_default_buffer_size));
 		if (parse_result.is_err()) { return Err(parse_result.unwrap_err()); }
 		auto [raw, buffer_size] = parse_result.unwrap();
 		if (buffer_size <= 0) { return Err(value_error("buffer size must be strictly positive")); }
@@ -1422,7 +1409,7 @@ class BufferedWriter
 		this->fast_closed_checks = false;
 		this->ok = true;
 		this->buffer = std::make_unique<std::stringbuf>();
-		m_buffer_size = static_cast<size_t>(buffer_size);
+		m_buffer_size = static_cast<std::size_t>(buffer_size);
 		m_buffered_bytes = 0;
 		return Ok(0);
 	}
@@ -1435,18 +1422,18 @@ class BufferedWriter
 			return std::get<0>(attr);
 		}
 		if (std::get<1>(attr) == LookupAttrResult::NOT_FOUND) {
-			return PyString::create(fmt::format("<{}>", type_prototype().__name__));
+			return PyString::create(std::format("<{}>", type_prototype().__name__));
 		}
 		auto *nameobj = std::get<0>(attr).unwrap();
 		return nameobj->repr().and_then([this](PyObject *nameobj_repr) {
 			return PyString::create(
-				fmt::format("<{} name={}>", type_prototype().__name__, nameobj_repr->to_string()));
+				std::format("<{} name={}>", type_prototype().__name__, nameobj_repr->to_string()));
 		});
 	}
 
-	PyResult<PyObject *> raw_write(const char *data, size_t len)
+	PyResult<PyObject *> raw_write(const char *data, std::size_t len)
 	{
-		auto *raw_bytes = bit_cast<std::byte *>(data);
+		auto *raw_bytes = std::bit_cast<std::byte *>(data);
 		auto bytes = PyBytes::create(Bytes{ .b = { raw_bytes, raw_bytes + len } });
 		auto memobj = PyMemoryView::create(bytes.unwrap());
 		if (memobj.is_err()) { return memobj; }
@@ -1461,8 +1448,8 @@ class BufferedWriter
 		auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 			kwargs,
 			"write",
-			std::integral_constant<size_t, 1>{},
-			std::integral_constant<size_t, 1>{});
+			std::integral_constant<std::size_t, 1>{},
+			std::integral_constant<std::size_t, 1>{});
 		if (result.is_err()) { return Err(result.unwrap_err()); }
 		auto [arg] = result.unwrap();
 		PyBuffer buffer;
@@ -1479,13 +1466,13 @@ class BufferedWriter
 		}
 
 		const char *start = static_cast<char *>(buffer.buf->get_buffer());
-		const auto len = static_cast<size_t>(buffer.len);
+		const auto len = static_cast<std::size_t>(buffer.len);
 
 		// fast path: the data fits in the buffer's free space, so it is only buffered and does
 		// not reach the raw stream
 		if (m_buffered_bytes + len <= m_buffer_size) {
 			const auto written = this->buffer->sputn(start, len);
-			ASSERT(static_cast<size_t>(written) == len);
+			ASSERT(static_cast<std::size_t>(written) == len);
 			m_buffered_bytes += len;
 			return PyInteger::create(len);
 		}
@@ -1500,8 +1487,8 @@ class BufferedWriter
 		if (auto r = flush(); r.is_err()) { return r; }
 
 		// write oversized data directly to raw, bypassing the buffer
-		size_t written = 0;
-		size_t remaining = len;
+		std::size_t written = 0;
+		std::size_t remaining = len;
 		while (remaining > m_buffer_size) {
 			auto r = raw_write(payload.data() + written, remaining);
 			if (r.is_err()) { return r; }
@@ -1534,7 +1521,7 @@ class BufferedWriter
 		// buffer the tail, which is now guaranteed to fit
 		if (remaining > 0) {
 			const auto count = this->buffer->sputn(payload.data() + written, remaining);
-			ASSERT(static_cast<size_t>(count) == remaining);
+			ASSERT(static_cast<std::size_t>(count) == remaining);
 			m_buffered_bytes += remaining;
 			written += remaining;
 		}
@@ -1570,8 +1557,8 @@ class BufferedWriter
 	}
 
   private:
-	size_t m_buffer_size{ s_default_buffer_size };
-	size_t m_buffered_bytes{ 0 };
+	std::size_t m_buffer_size{ s_default_buffer_size };
+	std::size_t m_buffered_bytes{ 0 };
 };
 
 template<> PyResult<PyObject *> Buffered<BufferedWriter>::flush_and_rewind()
@@ -1591,7 +1578,7 @@ PyResult<PyObject *> BufferedWriter::flush()
 		// bytes buffer copy just to then get a view of it.
 		auto written = buffer->sgetn(to_write.data(), BUFSIZ);
 		if (written <= 0) { break; }
-		auto *raw_bytes = bit_cast<std::byte *>(to_write.data());
+		auto *raw_bytes = std::bit_cast<std::byte *>(to_write.data());
 		auto bytes = PyBytes::create(Bytes{ .b = { raw_bytes, raw_bytes + written } });
 		auto memobj = PyMemoryView::create(bytes.unwrap());
 		if (memobj.is_err()) { return memobj; }
@@ -1638,9 +1625,10 @@ template<> const BufferedWriter *as(const PyObject *obj)
 class BufferedRWPair : public BufferedIOBase
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	BufferedReader *m_reader;
 	BufferedWriter *m_writer;
-	size_t m_buffer_size;
+	std::size_t m_buffer_size;
 
 	BufferedRWPair(PyType *type) : BufferedIOBase(type) {}
 
@@ -1672,7 +1660,7 @@ class BufferedRWPair : public BufferedIOBase
 		return BufferedRWPair::create(const_cast<PyType *>(type));
 	}
 
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs)
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs)
 	{
 		if (this->type() != s_io_buffered_rwpair && kwargs && !kwargs->map().empty()) {
 			return Err(type_error("BufferedRWPair() takes no keyword arguments"));
@@ -1681,8 +1669,8 @@ class BufferedRWPair : public BufferedIOBase
 		auto parse_result = PyArgsParser<PyObject *, PyObject *, PyInteger *>::unpack_tuple(args,
 			kwargs,
 			"BufferedRWPair",
-			std::integral_constant<size_t, 2>{},
-			std::integral_constant<size_t, 3>{},
+			std::integral_constant<std::size_t, 2>{},
+			std::integral_constant<std::size_t, 3>{},
 			PyInteger::create(8 * 1024).unwrap());
 
 		if (parse_result.is_err()) return Err(parse_result.unwrap_err());
@@ -1822,6 +1810,7 @@ class BufferedRandom
 	, public Buffered<BufferedRandom>
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	BufferedRandom(PyType *type, PyObject *raw, int buffer_size) : BufferedIOBase(type)
 	{
@@ -1876,13 +1865,13 @@ class BufferedRandom
 		return BufferedRandom::create(const_cast<PyType *>(type));
 	}
 
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs)
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs)
 	{
 		auto parse_result = PyArgsParser<PyObject *, PyInteger *>::unpack_tuple(args,
 			kwargs,
 			"BufferedRandom",
-			std::integral_constant<size_t, 1>{},
-			std::integral_constant<size_t, 2>{},
+			std::integral_constant<std::size_t, 1>{},
+			std::integral_constant<std::size_t, 2>{},
 			PyInteger::create(8 * 1024).unwrap());
 
 		if (parse_result.is_err()) return Err(parse_result.unwrap_err());
@@ -1918,12 +1907,12 @@ class BufferedRandom
 			return std::get<0>(attr);
 		}
 		if (std::get<1>(attr) == LookupAttrResult::NOT_FOUND) {
-			return PyString::create(fmt::format("<{}>", type_prototype().__name__));
+			return PyString::create(std::format("<{}>", type_prototype().__name__));
 		}
 		auto *nameobj = std::get<0>(attr).unwrap();
 		return nameobj->repr().and_then([this](PyObject *nameobj_repr) {
 			return PyString::create(
-				fmt::format("<{} name={}>", type_prototype().__name__, nameobj_repr->to_string()));
+				std::format("<{} name={}>", type_prototype().__name__, nameobj_repr->to_string()));
 		});
 	}
 
@@ -1958,10 +1947,11 @@ class BufferedRandom
 
 class BytesIO : public BufferedIOBase
 {
-	friend ::Heap;
+	friend class ::Heap;
+	friend class py::detail::Allocator;
 	PyObject *m_buf;
-	int64_t m_pos;
-	int64_t m_string_size;
+	std::int64_t m_pos;
+	std::int64_t m_string_size;
 
 	BytesIO(PyType *type) : BufferedIOBase(type) {}
 
@@ -1984,7 +1974,7 @@ class BytesIO : public BufferedIOBase
 		return BytesIO::create(const_cast<PyType *>(type));
 	}
 
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs)
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs)
 	{
 		ASSERT(!kwargs || kwargs->map().empty());
 		m_pos = 0;
@@ -2003,10 +1993,11 @@ class BytesIO : public BufferedIOBase
 			});
 		}
 
-		return PyBytes::create(Bytes{}).and_then([this](auto *initial_bytes) -> PyResult<int32_t> {
-			m_buf = initial_bytes;
-			return Ok(0);
-		});
+		return PyBytes::create(Bytes{}).and_then(
+			[this](auto *initial_bytes) -> PyResult<std::int32_t> {
+				m_buf = initial_bytes;
+				return Ok(0);
+			});
 	}
 
 	PyResult<std::monostate> check_closed() const
@@ -2015,7 +2006,7 @@ class BytesIO : public BufferedIOBase
 		return Ok(std::monostate{});
 	}
 
-	PyResult<PyObject *> read(int64_t n)
+	PyResult<PyObject *> read(std::int64_t n)
 	{
 		ASSERT(m_buf);
 		ASSERT(as<PyBytes>(m_buf));
@@ -2025,10 +2016,10 @@ class BytesIO : public BufferedIOBase
 		const auto size = m_string_size - m_pos;
 
 		n = n < 0 ? size : n;
-		n = std::clamp(n, int64_t{ 0 }, size);
+		n = std::clamp(n, std::int64_t{ 0 }, size);
 
 		if (n > 1 && m_pos == 0
-			&& n == static_cast<int64_t>(as<PyBytes>(m_buf)->value().b.size())) {
+			&& n == static_cast<std::int64_t>(as<PyBytes>(m_buf)->value().b.size())) {
 			m_pos += n;
 			return Ok(m_buf);
 		}
@@ -2040,7 +2031,7 @@ class BytesIO : public BufferedIOBase
 		return PyBytes::create(Bytes{ std::move(output) });
 	}
 
-	PyResult<PyObject *> read1(int64_t n) { return read(n); }
+	PyResult<PyObject *> read1(std::int64_t n) { return read(n); }
 
 	PyType *static_type() const override { return s_io_bytesio; }
 
@@ -2052,7 +2043,7 @@ class BytesIO : public BufferedIOBase
 					.def("read",
 						[](BytesIO *self, PyTuple *args, PyDict *kwargs) -> PyResult<PyObject *> {
 							ASSERT(!kwargs || kwargs->map().empty());
-							int64_t n = -1;
+							std::int64_t n = -1;
 							if (args && args->elements().size() > 1) {
 								return Err(value_error(
 									"BytesIO.readlines expected at most one argument (got {})",
@@ -2074,7 +2065,7 @@ class BytesIO : public BufferedIOBase
 					.def("read1",
 						[](BytesIO *self, PyTuple *args, PyDict *kwargs) -> PyResult<PyObject *> {
 							ASSERT(!kwargs || kwargs->map().empty());
-							int64_t n = -1;
+							std::int64_t n = -1;
 							if (args && args->elements().size() > 1) {
 								return Err(value_error(
 									"BytesIO.readlines expected at most one argument (got {})",
@@ -2129,7 +2120,7 @@ PyResult<std::bitset<8>> read_flags(const std::string &mode)
 {
 	std::bitset<8> flag;
 
-	for (size_t i = 0; const auto c : mode) {
+	for (std::size_t i = 0; const auto c : mode) {
 		if (std::string_view{ mode }.substr(0, i).find(c) != std::string::npos) {
 			// duplicate mode
 			return Err(value_error("invalid mode: '{}'", mode));
@@ -2163,7 +2154,8 @@ PyResult<std::bitset<8>> read_flags(const std::string &mode)
 
 class FileIO : public RawIOBase
 {
-	friend ::Heap;
+	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	int m_file_descriptor{ -1 };
 	__gnu_cxx::stdio_filebuf<char> m_filebuffer;
@@ -2174,7 +2166,7 @@ class FileIO : public RawIOBase
 	std::optional<bool> m_seekable;
 	bool m_close_file_descriptor{ true };
 	bool m_finalizing;
-	uint32_t m_bulksize{ 0 };
+	std::uint32_t m_bulksize{ 0 };
 
 	FileIO(const PyType *type) : RawIOBase(type) {}
 
@@ -2219,7 +2211,7 @@ class FileIO : public RawIOBase
 	}
 
 
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs)
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs)
 	{
 		ASSERT(!kwargs || kwargs->map().empty());
 		if (args->elements().empty()) { TODO(); }
@@ -2239,7 +2231,7 @@ class FileIO : public RawIOBase
 	std::string to_string() const override
 	{
 		if (!m_filebuffer.is_open()) { return "<_io.FileIO [closed]>"; }
-		return fmt::format("<_io.FileIO fd={} mode={}>", m_file_descriptor, mode_string());
+		return std::format("<_io.FileIO fd={} mode={}>", m_file_descriptor, mode_string());
 	}
 
 	PyResult<PyObject *> __repr__() const { return PyString::create(to_string()); }
@@ -2267,12 +2259,12 @@ class FileIO : public RawIOBase
 		}
 		std::vector<std::byte> result;
 		result.resize(file_size);
-		int64_t bytes_read = 0;
+		std::int64_t bytes_read = 0;
 		const auto buffer_size = file_size;
 
 		do {
 			if (std::ferror(m_filebuffer.file())) { TODO(); }
-			const auto got = m_filebuffer.sgetn(::bit_cast<char *>(result.data()), buffer_size);
+			const auto got = m_filebuffer.sgetn(std::bit_cast<char *>(result.data()), buffer_size);
 			if (got <= 0) { break; }
 			bytes_read += got;
 		} while (true);
@@ -2353,7 +2345,7 @@ class FileIO : public RawIOBase
 	}
 
   private:
-	PyResult<int32_t> init(PyObject *name, const std::bitset<8> &rawmode)
+	PyResult<std::int32_t> init(PyObject *name, const std::bitset<8> &rawmode)
 	{
 		auto mode_result = get_mode(rawmode);
 		if (mode_result.is_err()) return Err(mode_result.unwrap_err());
@@ -2502,6 +2494,7 @@ class FileIO : public RawIOBase
 class TextIOBase : public IOBase
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	TextIOBase() : TextIOBase(s_io_textiobase) {}
 
@@ -2573,6 +2566,7 @@ class TextIOBase : public IOBase
 class IncrementalNewlineDecoder : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	PyObject *m_decoder{ nullptr };
 	PyObject *m_errors{ nullptr };
 	bool m_translate{ false };
@@ -2609,7 +2603,7 @@ class IncrementalNewlineDecoder : public PyBaseObject
 		return IncrementalNewlineDecoder::create(type);
 	}
 
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs)
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs)
 	{
 		(void)args;
 		(void)kwargs;
@@ -2641,7 +2635,9 @@ class StringIO
 {
 	friend class IOChecks<StringIO>;
 
-	friend ::Heap;
+	friend class ::Heap;
+
+	friend class py::detail::Allocator;
 
 	std::stringstream m_stringstream;
 	std::string m_newline;
@@ -2678,7 +2674,7 @@ class StringIO
 		return Err(memory_error(sizeof(StringIO)));
 	}
 
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs)
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs)
 	{
 		ASSERT(!kwargs || kwargs->map().empty());
 
@@ -2771,11 +2767,11 @@ class StringIO
 
 		if (auto result = check_usable(); result.is_err()) { return Err(result.unwrap_err()); }
 
-		auto size_ = [args, this]() -> PyResult<size_t> {
+		auto size_ = [args, this]() -> PyResult<std::size_t> {
 			const auto initial_pos = m_stringstream.tellg();
 			m_stringstream.seekg(0, std::ios_base::end);
 			ASSERT(m_stringstream.tellg() >= initial_pos);
-			const size_t str_size = m_stringstream.tellg() - initial_pos;
+			const std::size_t str_size = m_stringstream.tellg() - initial_pos;
 			m_stringstream.seekg(initial_pos);
 			if (args->size() == 0) {
 				return Ok(str_size);
@@ -2787,7 +2783,7 @@ class StringIO
 						obj.unwrap()->type()->to_string()));
 				}
 				auto size = as<PyInteger>(obj.unwrap())->as_size_t();
-				return Ok(std::clamp(size, size_t{ 0 }, str_size));
+				return Ok(std::clamp(size, std::size_t{ 0 }, str_size));
 			} else {
 				return Err(type_error("read expected at most 1 argument, got {}", args->size()));
 			}
@@ -2807,11 +2803,11 @@ class StringIO
 
 		if (auto result = check_usable(); result.is_err()) { return Err(result.unwrap_err()); }
 
-		auto limit_ = [args, this]() -> PyResult<size_t> {
+		auto limit_ = [args, this]() -> PyResult<std::size_t> {
 			const auto initial_pos = m_stringstream.tellg();
 			m_stringstream.seekg(0, std::ios_base::end);
 			ASSERT(m_stringstream.tellg() >= initial_pos);
-			const size_t str_size = m_stringstream.tellg() - initial_pos;
+			const std::size_t str_size = m_stringstream.tellg() - initial_pos;
 			m_stringstream.seekg(initial_pos);
 			if (args->size() == 0) {
 				return Ok(str_size);
@@ -2823,7 +2819,7 @@ class StringIO
 						obj.unwrap()->type()->to_string()));
 				}
 				auto size = as<PyInteger>(obj.unwrap())->as_size_t();
-				return Ok(std::clamp(size, size_t{ 0 }, str_size));
+				return Ok(std::clamp(size, std::size_t{ 0 }, str_size));
 			} else {
 				return Err(type_error("read expected at most 1 argument, got {}", args->size()));
 			}
@@ -2854,8 +2850,8 @@ class StringIO
 		auto parse_result = PyArgsParser<PyString *>::unpack_tuple(args,
 			kwargs,
 			"write",
-			std::integral_constant<size_t, 1>{},
-			std::integral_constant<size_t, 1>{});
+			std::integral_constant<std::size_t, 1>{},
+			std::integral_constant<std::size_t, 1>{});
 
 		if (parse_result.is_err()) return Err(parse_result.unwrap_err());
 
@@ -2879,8 +2875,8 @@ class StringIO
 		auto parse_result = PyArgsParser<PyInteger *, PyInteger *>::unpack_tuple(args,
 			kwargs,
 			"seek",
-			std::integral_constant<size_t, 1>{},
-			std::integral_constant<size_t, 2>{},
+			std::integral_constant<std::size_t, 1>{},
+			std::integral_constant<std::size_t, 2>{},
 			PyInteger::create(0).unwrap());
 
 		if (parse_result.is_err()) return Err(parse_result.unwrap_err());
@@ -2939,7 +2935,7 @@ class StringIO
 
 
   private:
-	PyResult<int32_t> init(PyString *initial_value, PyString *newline)
+	PyResult<std::int32_t> init(PyString *initial_value, PyString *newline)
 	{
 		(void)initial_value;
 		if (!newline->value().empty() && newline->value() != "\n" && newline->value() != "\r"
@@ -2969,7 +2965,8 @@ class TextIOWrapper
 	: public TextIOBase
 	, public IOChecks<TextIOWrapper>
 {
-	friend ::Heap;
+	friend class ::Heap;
+	friend class py::detail::Allocator;
 	friend class IOChecks<TextIOWrapper>;
 
 	PyObject *m_buffer{ nullptr };
@@ -2980,10 +2977,10 @@ class TextIOWrapper
 	bool m_write_through;
 
 	std::optional<Bytes> m_buffer_bytes;
-	size_t m_position{ 0 };
+	std::size_t m_position{ 0 };
 	Bytes m_pending_bytes;
 
-	size_t m_chunk_size{ 8192 };
+	std::size_t m_chunk_size{ 8192 };
 
 	// line terminators recognised by readline; universal newlines for now
 	// TODO: derive the set from the newline constructor argument
@@ -3053,15 +3050,15 @@ class TextIOWrapper
 		return Err(memory_error(sizeof(TextIOWrapper)));
 	}
 
-	PyResult<int32_t> __init__(PyTuple *args, PyDict *kwargs)
+	PyResult<std::int32_t> __init__(PyTuple *args, PyDict *kwargs)
 	{
 		auto parse_result =
 			PyArgsParser<PyObject *, PyObject *, PyObject *, PyObject *, PyBool *, PyBool *>::
 				unpack_tuple(args,
 					kwargs,
 					"TextIOWrapper",
-					std::integral_constant<size_t, 1>{},
-					std::integral_constant<size_t, 6>{},
+					std::integral_constant<std::size_t, 1>{},
+					std::integral_constant<std::size_t, 6>{},
 					py_none(),
 					py_none(),
 					py_none(),
@@ -3120,7 +3117,7 @@ class TextIOWrapper
 			write_through == py_true());
 	}
 
-	PyResult<bool> read_chunk(size_t size_hint)
+	PyResult<bool> read_chunk(std::size_t size_hint)
 	{
 		// TODO: handle decoding
 		const auto chunk_size = std::max(size_hint, m_chunk_size);
@@ -3148,24 +3145,24 @@ class TextIOWrapper
 
 	PyResult<PyObject *> readline(PyTuple *args, PyDict *kwargs)
 	{
-		auto result = PyArgsParser<size_t>::unpack_tuple(args,
+		auto result = PyArgsParser<std::size_t>::unpack_tuple(args,
 			kwargs,
 			"readline",
-			std::integral_constant<size_t, 0>{},
-			std::integral_constant<size_t, 1>{},
-			std::numeric_limits<size_t>::max());
+			std::integral_constant<std::size_t, 0>{},
+			std::integral_constant<std::size_t, 1>{},
+			std::numeric_limits<std::size_t>::max());
 		if (result.is_err()) { return Err(result.unwrap_err()); }
 		auto [limit] = result.unwrap();
 		return readline_impl(limit);
 	}
 
-	PyResult<PyObject *> readline_impl(size_t limit)
+	PyResult<PyObject *> readline_impl(std::size_t limit)
 	{
 		if (auto result = writeflush(); result.is_err()) { return Err(result.unwrap_err()); }
 
 		// length of the longest line delimiter at the start of text, 0 if none
-		auto match_delimiter = [this](std::string_view text) -> size_t {
-			size_t longest = 0;
+		auto match_delimiter = [this](std::string_view text) -> std::size_t {
+			std::size_t longest = 0;
 			for (const auto &delimiter : m_line_delimiters) {
 				if (delimiter.size() > longest && text.starts_with(delimiter)) {
 					longest = delimiter.size();
@@ -3197,15 +3194,15 @@ class TextIOWrapper
 				if (eof && (!m_buffer_bytes.has_value() || m_buffer_bytes->b.empty())) { break; }
 			}
 
-			std::string_view remaining{ bit_cast<const char *>(m_buffer_bytes->b.data())
+			std::string_view remaining{ std::bit_cast<const char *>(m_buffer_bytes->b.data())
 											+ m_position,
 				m_buffer_bytes->b.size() - m_position };
 
 			// TODO: use utf8 codepoints
 			const char *start = remaining.data();
-			size_t len = 0;
-			const size_t budget = limit - line.size();
-			const size_t scan_limit = std::min(budget, remaining.size());
+			std::size_t len = 0;
+			const std::size_t budget = limit - line.size();
+			const std::size_t scan_limit = std::min(budget, remaining.size());
 			for (; len < scan_limit; ++len) {
 				// the rest of the buffer may hold an incomplete delimiter (e.g. the
 				// '\r' of a "\r\n" straddling the chunk boundary); fetch more input
@@ -3239,7 +3236,7 @@ class TextIOWrapper
 		if (result_.is_err()) { return result_; }
 		auto *result = result_.unwrap();
 		while (true) {
-			auto line = readline_impl(std::numeric_limits<size_t>::max());
+			auto line = readline_impl(std::numeric_limits<std::size_t>::max());
 			if (line.is_err()) { return line; }
 			// readline only returns an empty string at EOF
 			if (as<PyString>(line.unwrap())->value().empty()) { break; }
@@ -3341,7 +3338,7 @@ class TextIOWrapper
 	}
 
   private:
-	PyResult<int32_t> init(PyObject *buffer,
+	PyResult<std::int32_t> init(PyObject *buffer,
 		const std::optional<std::string> &encoding,
 		const std::optional<std::string> &errors,
 		const std::optional<std::string> &newline,
@@ -3400,6 +3397,7 @@ PyResult<PyObject *> open(PyObject *file, const std::string &mode)
 class BlockingIOError : public OSError
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
   private:
 	BlockingIOError(PyType *t) : OSError(t) {}
@@ -3488,7 +3486,7 @@ PyModule *io_module()
 			}));
 
 	s_io_module->add_symbol(PyString::create("DEFAULT_BUFFER_SIZE").unwrap(),
-		Number{ static_cast<int64_t>(s_default_buffer_size) });
+		Number{ static_cast<std::int64_t>(s_default_buffer_size) });
 
 	// >> type("UnsupportedOperation", (_io.OSError, ValueError), {})
 	auto unsupported_operation_type = types::type()->call(
diff --git a/src/runtime/modules/ImpModule.cpp b/src/runtime/modules/ImpModule.cpp
index 861c4104..8e11810e 100644
--- a/src/runtime/modules/ImpModule.cpp
+++ b/src/runtime/modules/ImpModule.cpp
@@ -1,19 +1,7 @@
-#include "Modules.hpp"
-#include "config.hpp"
-#include "executable/bytecode/BytecodeProgram.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "runtime/Import.hpp"
-#include "runtime/ImportError.hpp"
-#include "runtime/PyArgParser.hpp"
-#include "runtime/PyBool.hpp"
-#include "runtime/PyCode.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFunction.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/TypeError.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+
+module py.runtime;
 
 namespace py {
 namespace {
@@ -36,8 +24,8 @@ PyModule *imp_module()
 				auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 					kwargs,
 					"is_frozen",
-					std::integral_constant<size_t, 1>{},
-					std::integral_constant<size_t, 1>{});
+					std::integral_constant<std::size_t, 1>{},
+					std::integral_constant<std::size_t, 1>{});
 				if (result.is_err()) return Err(result.unwrap_err());
 				auto *name = std::get<0>(result.unwrap());
 
@@ -56,8 +44,8 @@ PyModule *imp_module()
 				auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 					kwargs,
 					"is_frozen_package",
-					std::integral_constant<size_t, 1>{},
-					std::integral_constant<size_t, 1>{});
+					std::integral_constant<std::size_t, 1>{},
+					std::integral_constant<std::size_t, 1>{});
 				if (result.is_err()) return Err(result.unwrap_err());
 				auto *name = std::get<0>(result.unwrap());
 
@@ -81,8 +69,8 @@ PyModule *imp_module()
 				auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 					kwargs,
 					"get_frozen_object",
-					std::integral_constant<size_t, 1>{},
-					std::integral_constant<size_t, 1>{});
+					std::integral_constant<std::size_t, 1>{},
+					std::integral_constant<std::size_t, 1>{});
 				if (result.is_err()) return Err(result.unwrap_err());
 				auto *name = std::get<0>(result.unwrap());
 
@@ -126,8 +114,8 @@ PyModule *imp_module()
 				auto result = PyArgsParser<PyString *>::unpack_tuple(args,
 					kwargs,
 					"is_builtin",
-					std::integral_constant<size_t, 1>{},
-					std::integral_constant<size_t, 1>{});
+					std::integral_constant<std::size_t, 1>{},
+					std::integral_constant<std::size_t, 1>{});
 				if (result.is_err()) return Err(result.unwrap_err());
 				auto *name = std::get<0>(result.unwrap());
 
@@ -141,8 +129,8 @@ PyModule *imp_module()
 				auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 					kwargs,
 					"create_builtin",
-					std::integral_constant<size_t, 1>{},
-					std::integral_constant<size_t, 1>{});
+					std::integral_constant<std::size_t, 1>{},
+					std::integral_constant<std::size_t, 1>{});
 				if (result.is_err()) return Err(result.unwrap_err());
 
 				return create_builtin(std::get<0>(result.unwrap()));
@@ -155,8 +143,8 @@ PyModule *imp_module()
 				auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 					kwargs,
 					"exec_builtin",
-					std::integral_constant<size_t, 1>{},
-					std::integral_constant<size_t, 1>{});
+					std::integral_constant<std::size_t, 1>{},
+					std::integral_constant<std::size_t, 1>{});
 				if (result.is_err()) return Err(result.unwrap_err());
 				return exec_builtin(std::get<0>(result.unwrap()));
 			})
@@ -168,8 +156,8 @@ PyModule *imp_module()
 				auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 					kwargs,
 					"exec_dynamic",
-					std::integral_constant<size_t, 1>{},
-					std::integral_constant<size_t, 1>{});
+					std::integral_constant<std::size_t, 1>{},
+					std::integral_constant<std::size_t, 1>{});
 				if (result.is_err()) return Err(result.unwrap_err());
 				return exec_builtin(std::get<0>(result.unwrap()));
 			})
@@ -186,4 +174,4 @@ PyModule *imp_module()
 
 	return s_imp_module;
 }
-}// namespace py
\ No newline at end of file
+}// namespace py
diff --git a/src/runtime/modules/MarshalModule.cpp b/src/runtime/modules/MarshalModule.cpp
index aa7b84a2..7eea3c22 100644
--- a/src/runtime/modules/MarshalModule.cpp
+++ b/src/runtime/modules/MarshalModule.cpp
@@ -1,5 +1,7 @@
-#include "Modules.hpp"
-#include "runtime/PyDict.hpp"
+module;
+
+module py.runtime;
+
 
 namespace py {
 PyModule *marshal_module()
diff --git a/src/runtime/modules/config.hpp b/src/runtime/modules/Modules.cppm
similarity index 67%
rename from src/runtime/modules/config.hpp
rename to src/runtime/modules/Modules.cppm
index 2d5584db..bb2f5d17 100644
--- a/src/runtime/modules/config.hpp
+++ b/src/runtime/modules/Modules.cppm
@@ -1,10 +1,34 @@
-#pragma once
+export module py.runtime:modules;
 
-#include "Modules.hpp"
-#include <array>
+import std;
 
-namespace py {
-static constexpr std::array builtin_modules{
+export class Interpreter;// global scope, like its definition in :interpreter
+
+export namespace py {
+
+class PyModule;
+
+PyModule *builtins_module(Interpreter &interpreter);
+PyModule *codecs_module();
+PyModule *collections_module();
+PyModule *errno_module();
+PyModule *gc_module();
+PyModule *imp_module();
+PyModule *io_module();
+PyModule *math_module();
+PyModule *marshal_module();
+PyModule *posix_module();
+PyModule *thread_module();
+PyModule *weakref_module();
+PyModule *warnings_module();
+PyModule *itertools_module();
+PyModule *signal_module();
+PyModule *sre_module();
+PyModule *struct_module();
+PyModule *sys_module(Interpreter &interpreter);
+PyModule *time_module();
+
+constexpr std::array builtin_modules{
 	std::tuple<std::string_view, PyModule *(*)()>{ "builtin", nullptr },
 	std::tuple<std::string_view, PyModule *(*)()>{ "sys", nullptr },
 	std::tuple<std::string_view, PyModule *(*)()>{ "_codecs", codecs_module },
diff --git a/src/runtime/modules/Modules.hpp b/src/runtime/modules/Modules.hpp
deleted file mode 100644
index dfab2d67..00000000
--- a/src/runtime/modules/Modules.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "runtime/PyModule.hpp"
-
-namespace py {
-
-PyModule *builtins_module(Interpreter &interpreter);
-PyModule *codecs_module();
-PyModule *collections_module();
-PyModule *errno_module();
-PyModule *gc_module();
-PyModule *imp_module();
-PyModule *io_module();
-PyModule *math_module();
-PyModule *marshal_module();
-PyModule *posix_module();
-PyModule *thread_module();
-PyModule *weakref_module();
-PyModule *warnings_module();
-PyModule *itertools_module();
-PyModule *signal_module();
-PyModule *sre_module();
-PyModule *struct_module();
-PyModule *sys_module(Interpreter &interpreter);
-PyModule *time_module();
-}// namespace py
diff --git a/src/runtime/modules/PosixModule.cpp b/src/runtime/modules/PosixModule.cpp
index 6532ddb1..e0711611 100644
--- a/src/runtime/modules/PosixModule.cpp
+++ b/src/runtime/modules/PosixModule.cpp
@@ -1,24 +1,14 @@
-#include "Modules.hpp"
-#include "runtime/PyArgParser.hpp"
-#include "runtime/PyBytes.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFunction.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/TypeError.hpp"
-#include "runtime/Value.hpp"
-#include "runtime/ValueError.hpp"
-#include "runtime/types/api.hpp"
-
-#include <cstddef>
-#include <filesystem>
-#include <string_view>
-
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cerrno>
+#include <fcntl.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
+module py.runtime;
+
+
 namespace fs = std::filesystem;
 
 namespace py {
@@ -29,6 +19,9 @@ namespace {
 	class PyStatResult : public PyBaseObject
 	{
 		friend class ::Heap;
+		friend class py::detail::Allocator;
+
+		friend class ::Heap;
 
 	  public:
 		mode_t m_st_mode;
@@ -87,7 +80,7 @@ namespace {
 
 		std::string to_string() const final
 		{
-			return fmt::format(
+			return std::format(
 				"os.stat_result(st_mode={}, st_ino={}, std_dev={}, st_nlink={}, st_uid={} "
 				"st_gid={}, st_size={}. st_atime={}, st_mtime={}, st_ctime={})",
 				m_st_mode,
@@ -136,7 +129,7 @@ namespace {
 
 	PyResult<PyObject *> convertenviron()
 	{
-		size_t i = 0;
+		std::size_t i = 0;
 		PyDict::MapType environ_dict;
 		while (environ[i]) {
 			auto env_pair = std::string_view{ environ[i++] };
@@ -190,8 +183,8 @@ PyModule *posix_module()
 				auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 					kwargs,
 					"posix.stat",
-					std::integral_constant<size_t, 1>{},
-					std::integral_constant<size_t, 1>{});
+					std::integral_constant<std::size_t, 1>{},
+					std::integral_constant<std::size_t, 1>{});
 				if (result.is_err()) return Err(result.unwrap_err());
 				auto *path_obj = std::get<0>(result.unwrap());
 				if (!as<PyString>(path_obj)) {
@@ -213,8 +206,8 @@ PyModule *posix_module()
 				auto parsed = PyArgsParser<PyObject *>::unpack_tuple(args,
 					kwargs,
 					"posix.listdir",
-					std::integral_constant<size_t, 0>{},
-					std::integral_constant<size_t, 1>{},
+					std::integral_constant<std::size_t, 0>{},
+					std::integral_constant<std::size_t, 1>{},
 					nullptr);
 				if (parsed.is_err()) return Err(parsed.unwrap_err());
 				auto *path_obj = std::get<0>(parsed.unwrap());
@@ -262,8 +255,8 @@ PyModule *posix_module()
 				auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 					kwargs,
 					"posix.fspath",
-					std::integral_constant<size_t, 1>{},
-					std::integral_constant<size_t, 1>{});
+					std::integral_constant<std::size_t, 1>{},
+					std::integral_constant<std::size_t, 1>{});
 				if (result.is_err()) return Err(result.unwrap_err());
 				auto *path_obj = std::get<0>(result.unwrap());
 				if (!as<PyString>(path_obj) && !as<PyBytes>(path_obj)) {
diff --git a/src/runtime/modules/SysModule.cpp b/src/runtime/modules/SysModule.cpp
index 44e3b890..2af7b9f3 100644
--- a/src/runtime/modules/SysModule.cpp
+++ b/src/runtime/modules/SysModule.cpp
@@ -1,26 +1,18 @@
-#include "runtime/BaseException.hpp"
-#include "runtime/MemoryError.hpp"
-#include "runtime/PyBool.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyFunction.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/PyModule.hpp"
-#include "runtime/PyNamespace.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/PyTraceback.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/types/api.hpp"
-
-#include "config.hpp"
-#include "interpreter/Interpreter.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
 #include "runtime/modules/paths.hpp"
-#include "vm/VM.hpp"
 
-#include <bit>
-#include <filesystem>
-#include <format>
+#include <cstddef>
+#include <cstdint>
+
+// py::sys_module is declared in Modules.cppm, attached to py.runtime, so its
+// definition has to be attached to py.runtime too - hence an implementation
+// unit rather than an ordinary TU that imports the module.
+module py.runtime;
+import py.memory;
+import py.types;
+import std;
 
 using namespace py;
 
@@ -91,6 +83,7 @@ static PyType *s_sys_version = nullptr;
 class Flags : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
   public:
 	uint8_t m_debug;
@@ -173,7 +166,7 @@ class Flags : public PyBaseObject
 
 	std::string to_string() const final
 	{
-		return fmt::format(
+		return std::format(
 			"sys.flags(debug={}, inspect={}, interactive={}, optimize={}, dont_write_bytecode={}, "
 			"no_user_site={}, no_site={}, ignore_environment={}, verbose={}, bytes_warning={}, "
 			"quiet={}, hash_randomization={}, isolated={}, dev_mode={}, utf8_mode={})",
@@ -231,6 +224,7 @@ class Flags : public PyBaseObject
 class Version : public PyTuple
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
   public:
 	PyInteger *m_major{ nullptr };
@@ -274,7 +268,7 @@ class Version : public PyTuple
 
 	std::string to_string() const final
 	{
-		return fmt::format(
+		return std::format(
 			"sys.version_info(major={}, minor={}, micro={}, releaselevel={}, serial={})",
 			m_major ? m_major->as_i64() : 0,
 			m_minor ? m_minor->as_i64() : 0,
@@ -335,7 +329,7 @@ PyModule *sys_module(Interpreter &interpreter)
 {
 	auto &heap = VirtualMachine::the().heap();
 
-	if (s_sys_module && heap.slab().has_address(bit_cast<uint8_t *>(s_sys_module))) {
+	if (s_sys_module && heap.slab().has_address(std::bit_cast<uint8_t *>(s_sys_module))) {
 		return s_sys_module;
 	}
 
diff --git a/src/runtime/modules/WarningsModule.cpp b/src/runtime/modules/WarningsModule.cpp
index d5f574e3..1b2a63da 100644
--- a/src/runtime/modules/WarningsModule.cpp
+++ b/src/runtime/modules/WarningsModule.cpp
@@ -1,10 +1,8 @@
-#include "Modules.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFunction.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/types/builtin.hpp"
+module;
+#include "core.hpp"
+
+module py.runtime;
+
 
 namespace py {
 PyModule *warnings_module()
diff --git a/src/runtime/modules/collections/DefaultDict.cpp b/src/runtime/modules/collections/DefaultDict.cpp
index a721d5b5..ea664a4c 100644
--- a/src/runtime/modules/collections/DefaultDict.cpp
+++ b/src/runtime/modules/collections/DefaultDict.cpp
@@ -1,18 +1,20 @@
-#include "DefaultDict.hpp"
-#include "runtime/KeyError.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/Value.hpp"
-#include "runtime/types/api.hpp"
-#include "runtime/types/builtin.hpp"
-#include <variant>
+module;
+#include "memory/allocate.hpp"
+
+#include <cstddef>
+#include <cstdint>
 
-using namespace py;
-using namespace py::collections;
+module py.runtime;
+import py.memory;
+import py.types;
+import std;
 
+// After the import: these name module-owned types.
+#include "DefaultDict.hpp"
+
+namespace py::collections {
 namespace {
-PyType *s_collections_defaultdict = nullptr;
+	PyType *s_collections_defaultdict = nullptr;
 }
 
 DefaultDict::DefaultDict(PyType *type) : PyDict(type) {}
@@ -61,4 +63,5 @@ PyType *DefaultDict::register_type(PyModule *module)
 				.finalize();
 	}
 	return s_collections_defaultdict;
-}
\ No newline at end of file
+}
+}// namespace py::collections
diff --git a/src/runtime/modules/collections/DefaultDict.hpp b/src/runtime/modules/collections/DefaultDict.hpp
index eee729e2..508ba64f 100644
--- a/src/runtime/modules/collections/DefaultDict.hpp
+++ b/src/runtime/modules/collections/DefaultDict.hpp
@@ -1,14 +1,11 @@
 #pragma once
 
-#include "runtime/PyDict.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/Value.hpp"
-
 namespace py {
 namespace collections {
 	class DefaultDict : public PyDict
 	{
 		friend class ::Heap;
+		friend class py::detail::Allocator;
 
 		PyObject *m_default_factory;
 
diff --git a/src/runtime/modules/collections/Deque.cpp b/src/runtime/modules/collections/Deque.cpp
index ac1ff520..d6645e4c 100644
--- a/src/runtime/modules/collections/Deque.cpp
+++ b/src/runtime/modules/collections/Deque.cpp
@@ -1,21 +1,16 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+#include <gmpxx.h>
+
+module py.runtime;
+import py.memory;
+import py.types;
+import std;
+
+// After the import: these name module-owned types.
 #include "Deque.hpp"
-#include "runtime/IndexError.hpp"
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/TypeError.hpp"
-#include "runtime/Value.hpp"
-#include "runtime/ValueError.hpp"
-#include "runtime/types/api.hpp"
-#include "runtime/types/builtin.hpp"
-#include "utilities.hpp"
-#include "vm/VM.hpp"
-
-#include <algorithm>
-#include <cstdint>
-#include <deque>
-#include <sstream>
-#include <unordered_set>
-#include <variant>
 
 using namespace py;
 using namespace py::collections;
@@ -323,4 +318,4 @@ PyType *Deque::register_type(PyModule *module)
 								  .finalize();
 	}
 	return s_collections_deque;
-}
\ No newline at end of file
+}
diff --git a/src/runtime/modules/collections/Deque.hpp b/src/runtime/modules/collections/Deque.hpp
index d513678d..eead1925 100644
--- a/src/runtime/modules/collections/Deque.hpp
+++ b/src/runtime/modules/collections/Deque.hpp
@@ -1,16 +1,12 @@
 #pragma once
 
-#include "forward.hpp"
-#include "runtime/PyObject.hpp"
-#include <cstddef>
-#include <cstdint>
-#include <deque>
 
 namespace py {
 namespace collections {
 	class Deque : public PyBaseObject
 	{
 		friend class ::Heap;
+		friend class py::detail::Allocator;
 
 		std::deque<Value> m_deque;
 		std::optional<size_t> m_maxlength;
diff --git a/src/runtime/modules/collections/module.cpp b/src/runtime/modules/collections/module.cpp
index 1e3862e7..ceb74ff5 100644
--- a/src/runtime/modules/collections/module.cpp
+++ b/src/runtime/modules/collections/module.cpp
@@ -1,8 +1,15 @@
-#include "../Modules.hpp"
+module;
+#include "memory/allocate.hpp"
+
+#include <cstddef>
+#include <cstdint>
+
+module py.runtime;
+import std;
+
 #include "DefaultDict.hpp"
 #include "Deque.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyType.hpp"
+
 
 namespace py {
 
diff --git a/src/runtime/modules/errno/module.cpp b/src/runtime/modules/errno/module.cpp
index dc3e9713..d23ab986 100644
--- a/src/runtime/modules/errno/module.cpp
+++ b/src/runtime/modules/errno/module.cpp
@@ -1,8 +1,10 @@
-#include "../Modules.hpp"
-#include "runtime/PyDict.hpp"
-#include <array>
+module;
+#include "core.hpp"
 #include <cerrno>
 
+module py.runtime;
+
+
 namespace py {
 
 namespace {
diff --git a/src/runtime/modules/itertools/Chain.cpp b/src/runtime/modules/itertools/Chain.cpp
index a48b9193..491e6d0a 100644
--- a/src/runtime/modules/itertools/Chain.cpp
+++ b/src/runtime/modules/itertools/Chain.cpp
@@ -1,7 +1,14 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+
+module py.runtime;
+import py.memory;
+import std;
+
+// After the import: these name module-owned types.
 #include "Chain.hpp"
-#include "runtime/MemoryError.hpp"
-#include "runtime/StopIteration.hpp"
-#include "runtime/types/api.hpp"
 
 namespace py {
 namespace {
diff --git a/src/runtime/modules/itertools/Chain.hpp b/src/runtime/modules/itertools/Chain.hpp
index 3f2e0063..df793d75 100644
--- a/src/runtime/modules/itertools/Chain.hpp
+++ b/src/runtime/modules/itertools/Chain.hpp
@@ -1,10 +1,9 @@
-#include "runtime/PyObject.hpp"
-
 namespace py {
 namespace itertools {
 	class Chain : public PyBaseObject
 	{
 		friend class ::Heap;
+		friend class py::detail::Allocator;
 
 		PyObject *m_iterable_objects_iterator{ nullptr };
 		PyObject *m_current_iterator{ nullptr };
diff --git a/src/runtime/modules/itertools/Count.cpp b/src/runtime/modules/itertools/Count.cpp
index 0bbaab4e..7e8eac8c 100644
--- a/src/runtime/modules/itertools/Count.cpp
+++ b/src/runtime/modules/itertools/Count.cpp
@@ -1,18 +1,16 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+#include <cstddef>
+
+module py.runtime;
+import py.memory;
+import py.types;
+import std;
+
+// After the import: these name module-owned types.
 #include "Count.hpp"
-#include "runtime/MemoryError.hpp"
-#include "runtime/PyArgParser.hpp"
-#include "runtime/PyFloat.hpp"
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/StopIteration.hpp"
-#include "runtime/TypeError.hpp"
-#include "runtime/Value.hpp"
-#include "runtime/forward.hpp"
-#include "runtime/types/api.hpp"
-#include "runtime/types/builtin.hpp"
-#include "utilities.hpp"
-#include <variant>
 
 namespace py {
 namespace {
diff --git a/src/runtime/modules/itertools/Count.hpp b/src/runtime/modules/itertools/Count.hpp
index c4d35132..1d3e8e78 100644
--- a/src/runtime/modules/itertools/Count.hpp
+++ b/src/runtime/modules/itertools/Count.hpp
@@ -1,11 +1,9 @@
-#include "runtime/PyObject.hpp"
-#include "runtime/Value.hpp"
-
 namespace py {
 namespace itertools {
 	class Count : public PyBaseObject
 	{
 		friend class ::Heap;
+		friend class py::detail::Allocator;
 
 		Number m_start{ 0 };
 		Number m_step{ 1 };
diff --git a/src/runtime/modules/itertools/ISlice.cpp b/src/runtime/modules/itertools/ISlice.cpp
index 3f7bff5e..4fac2eba 100644
--- a/src/runtime/modules/itertools/ISlice.cpp
+++ b/src/runtime/modules/itertools/ISlice.cpp
@@ -1,10 +1,15 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+#include <gmpxx.h>
+
+module py.runtime;
+import py.memory;
+import std;
+
+// After the import: these name module-owned types.
 #include "ISlice.hpp"
-#include "runtime/MemoryError.hpp"
-#include "runtime/PyArgParser.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/StopIteration.hpp"
-#include "runtime/ValueError.hpp"
-#include "runtime/types/api.hpp"
 
 namespace py {
 namespace {
diff --git a/src/runtime/modules/itertools/ISlice.hpp b/src/runtime/modules/itertools/ISlice.hpp
index d35db683..9a1f7790 100644
--- a/src/runtime/modules/itertools/ISlice.hpp
+++ b/src/runtime/modules/itertools/ISlice.hpp
@@ -1,10 +1,9 @@
-#include "runtime/PyObject.hpp"
-
 namespace py {
 namespace itertools {
 	class ISlice : public PyBaseObject
 	{
 		friend class ::Heap;
+		friend class py::detail::Allocator;
 
 		PyObject *m_iterator{ nullptr };
 		BigIntType m_start{ 0 };
diff --git a/src/runtime/modules/itertools/Permutations.cpp b/src/runtime/modules/itertools/Permutations.cpp
index 58291d55..b0df6449 100644
--- a/src/runtime/modules/itertools/Permutations.cpp
+++ b/src/runtime/modules/itertools/Permutations.cpp
@@ -1,15 +1,16 @@
-#include "Permutations.hpp"
-#include "runtime/MemoryError.hpp"
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/StopIteration.hpp"
-#include "runtime/Value.hpp"
-#include "runtime/types/api.hpp"
-#include "runtime/types/builtin.hpp"
-
-#include <algorithm>
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
 #include <cstddef>
-#include <numeric>
+
+module py.runtime;
+import py.memory;
+import py.types;
+import std;
+
+// After the import: these name module-owned types.
+#include "Permutations.hpp"
 
 namespace py {
 namespace {
diff --git a/src/runtime/modules/itertools/Permutations.hpp b/src/runtime/modules/itertools/Permutations.hpp
index bb798f3d..cc2a6b9d 100644
--- a/src/runtime/modules/itertools/Permutations.hpp
+++ b/src/runtime/modules/itertools/Permutations.hpp
@@ -1,12 +1,12 @@
-#include "runtime/PyObject.hpp"
-#include "runtime/Value.hpp"
-#include <cstddef>
+#pragma once
+
 
 namespace py {
 namespace itertools {
 	class Permutations : public PyBaseObject
 	{
 		friend class ::Heap;
+		friend class py::detail::Allocator;
 
 		PyList *m_pool{ nullptr };
 		size_t m_length;
diff --git a/src/runtime/modules/itertools/Product.cpp b/src/runtime/modules/itertools/Product.cpp
index 4c00ec2b..a6784367 100644
--- a/src/runtime/modules/itertools/Product.cpp
+++ b/src/runtime/modules/itertools/Product.cpp
@@ -1,15 +1,18 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+#include <gmpxx.h>
+
+#include <cstddef>
+
+module py.runtime;
+import py.memory;
+import py.types;
+import std;
+
+// After the import: these name module-owned types.
 #include "Product.hpp"
-#include "runtime/MemoryError.hpp"
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/StopIteration.hpp"
-#include "runtime/TypeError.hpp"
-#include "runtime/Value.hpp"
-#include "runtime/types/api.hpp"
-#include "runtime/types/builtin.hpp"
-#include <variant>
 
 namespace py {
 namespace {
diff --git a/src/runtime/modules/itertools/Product.hpp b/src/runtime/modules/itertools/Product.hpp
index 31597555..f96b35cb 100644
--- a/src/runtime/modules/itertools/Product.hpp
+++ b/src/runtime/modules/itertools/Product.hpp
@@ -1,13 +1,11 @@
 #pragma once
 
-#include "runtime/PyObject.hpp"
-#include "runtime/Value.hpp"
-
 namespace py {
 namespace itertools {
 	class Product : public PyBaseObject
 	{
 		friend class ::Heap;
+		friend class py::detail::Allocator;
 
 		PyList *m_pools{ nullptr };
 		size_t m_repeat;
diff --git a/src/runtime/modules/itertools/Repeat.cpp b/src/runtime/modules/itertools/Repeat.cpp
index 4263dc4f..269a05a4 100644
--- a/src/runtime/modules/itertools/Repeat.cpp
+++ b/src/runtime/modules/itertools/Repeat.cpp
@@ -1,9 +1,18 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+#include <gmpxx.h>
+
+#include <cstddef>
+
+module py.runtime;
+import py.memory;
+import std;
+
+// After the import: these name module-owned types.
 #include "Repeat.hpp"
-#include "runtime/MemoryError.hpp"
-#include "runtime/PyArgParser.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/StopIteration.hpp"
-#include "runtime/types/api.hpp"
+
 
 namespace py {
 namespace {
diff --git a/src/runtime/modules/itertools/Repeat.hpp b/src/runtime/modules/itertools/Repeat.hpp
index 18b7cece..acadf83c 100644
--- a/src/runtime/modules/itertools/Repeat.hpp
+++ b/src/runtime/modules/itertools/Repeat.hpp
@@ -1,10 +1,9 @@
-#include "runtime/PyObject.hpp"
-
 namespace py {
 namespace itertools {
 	class Repeat : public PyBaseObject
 	{
 		friend class ::Heap;
+		friend class py::detail::Allocator;
 
 		PyObject *m_object{ nullptr };
 		std::optional<BigIntType> m_times_remaining;
diff --git a/src/runtime/modules/itertools/StarMap.cpp b/src/runtime/modules/itertools/StarMap.cpp
index e397077f..33a4e46a 100644
--- a/src/runtime/modules/itertools/StarMap.cpp
+++ b/src/runtime/modules/itertools/StarMap.cpp
@@ -1,8 +1,15 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstddef>
+
+module py.runtime;
+import py.memory;
+import std;
+
+// After the import: these name module-owned types.
 #include "StarMap.hpp"
-#include "runtime/MemoryError.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/StopIteration.hpp"
-#include "runtime/types/api.hpp"
+
 
 namespace py {
 namespace {
diff --git a/src/runtime/modules/itertools/StarMap.hpp b/src/runtime/modules/itertools/StarMap.hpp
index 6cff602b..44f26c78 100644
--- a/src/runtime/modules/itertools/StarMap.hpp
+++ b/src/runtime/modules/itertools/StarMap.hpp
@@ -1,10 +1,9 @@
-#include "runtime/PyObject.hpp"
-
 namespace py {
 namespace itertools {
 	class StarMap : public PyBaseObject
 	{
 		friend class ::Heap;
+		friend class py::detail::Allocator;
 
 		PyObject *m_function{ nullptr };
 		PyObject *m_iterator{ nullptr };
diff --git a/src/runtime/modules/itertools/module.cpp b/src/runtime/modules/itertools/module.cpp
index a678bcec..2420e90b 100644
--- a/src/runtime/modules/itertools/module.cpp
+++ b/src/runtime/modules/itertools/module.cpp
@@ -1,4 +1,9 @@
-#include "../Modules.hpp"
+module;
+#include "memory/allocate.hpp"
+#include <cstddef>
+
+module py.runtime;
+
 #include "Chain.hpp"
 #include "Count.hpp"
 #include "ISlice.hpp"
@@ -6,8 +11,7 @@
 #include "Product.hpp"
 #include "Repeat.hpp"
 #include "StarMap.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyType.hpp"
+
 
 namespace py {
 
diff --git a/src/runtime/modules/math/module.cpp b/src/runtime/modules/math/module.cpp
index 2a542a40..b7b5fe72 100644
--- a/src/runtime/modules/math/module.cpp
+++ b/src/runtime/modules/math/module.cpp
@@ -1,5 +1,7 @@
-#include "../Modules.hpp"
-#include "runtime/PyDict.hpp"
+module;
+
+module py.runtime;
+
 
 namespace py {
 
diff --git a/src/runtime/modules/signal/module.cpp b/src/runtime/modules/signal/module.cpp
index 8672aec8..c10f47d1 100644
--- a/src/runtime/modules/signal/module.cpp
+++ b/src/runtime/modules/signal/module.cpp
@@ -1,18 +1,9 @@
-#include "../Modules.hpp"
-#include "runtime/PyArgParser.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFunction.hpp"
-#include "runtime/PyModule.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/Value.hpp"
-#include "runtime/ValueError.hpp"
-
+module;
+#include "core.hpp"
 #include <csignal>
-#include <cstdint>
-#include <limits>
-#include <variant>
+
+module py.runtime;
+
 
 namespace py {
 
@@ -59,11 +50,11 @@ static PyDict *handlers = nullptr;
 
 PyResult<PyObject *> signal(PyTuple *args, PyDict *kwargs)
 {
-	auto result = PyArgsParser<int64_t, PyObject *>::unpack_tuple(args,
+	auto result = PyArgsParser<std::int64_t, PyObject *>::unpack_tuple(args,
 		kwargs,
 		"signal",
-		std::integral_constant<size_t, 2>{},
-		std::integral_constant<size_t, 2>{});
+		std::integral_constant<std::size_t, 2>{},
+		std::integral_constant<std::size_t, 2>{});
 
 	if (result.is_err()) { return Err(result.unwrap_err()); }
 
@@ -100,11 +91,11 @@ PyResult<PyObject *> signal(PyTuple *args, PyDict *kwargs)
 
 PyResult<PyObject *> getsignal(PyTuple *args, PyDict *kwargs)
 {
-	auto result = PyArgsParser<int64_t>::unpack_tuple(args,
+	auto result = PyArgsParser<std::int64_t>::unpack_tuple(args,
 		kwargs,
 		"getsignal",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 1>{});
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 1>{});
 
 	if (result.is_err()) { return Err(result.unwrap_err()); }
 
diff --git a/src/runtime/modules/sre/Match.cpp b/src/runtime/modules/sre/Match.cpp
index 0ddc1525..cf672cf0 100644
--- a/src/runtime/modules/sre/Match.cpp
+++ b/src/runtime/modules/sre/Match.cpp
@@ -1,15 +1,12 @@
+module;
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.memory;
+import std;
+
+// After the import: these name module-owned types.
 #include "Match.hpp"
-#include "memory/Heap.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/PyMappingProxy.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/types/api.hpp"
-#include "runtime/types/builtin.hpp"
-#include "utilities.hpp"
-#include "vm/VM.hpp"
 
 using namespace py;
 using namespace py::sre;
@@ -35,4 +32,4 @@ PyType *Match::register_type(PyModule *module)
 {
 	if (!s_sre_match) { s_sre_match = klass<Match>(module, "_sre.Match").finalize(); }
 	return s_sre_match;
-}
\ No newline at end of file
+}
diff --git a/src/runtime/modules/sre/Match.hpp b/src/runtime/modules/sre/Match.hpp
index 9696b86e..471b3009 100644
--- a/src/runtime/modules/sre/Match.hpp
+++ b/src/runtime/modules/sre/Match.hpp
@@ -1,12 +1,11 @@
 #pragma once
 
-#include "runtime/PyObject.hpp"
-
 namespace py {
 namespace sre {
 	class Match : public PyBaseObject
 	{
 		friend class ::Heap;
+		friend class py::detail::Allocator;
 
 		Match();
 		Match(PyType *);
diff --git a/src/runtime/modules/sre/Pattern.cpp b/src/runtime/modules/sre/Pattern.cpp
index 3a23d9ec..6a23221a 100644
--- a/src/runtime/modules/sre/Pattern.cpp
+++ b/src/runtime/modules/sre/Pattern.cpp
@@ -1,20 +1,17 @@
-#include "Pattern.hpp"
-#include "Match.hpp"
-#include "memory/Heap.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/PyMappingProxy.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/TypeError.hpp"
-#include "runtime/ValueError.hpp"
-#include "runtime/types/api.hpp"
-#include "runtime/types/builtin.hpp"
-#include "utilities.hpp"
-#include "vm/VM.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+#include <cstddef>
 #include <cstdint>
-#include <limits>
+
+module py.runtime;
+import py.memory;
+import py.types;
+import std;
+
+#include "Match.hpp"
+#include "Pattern.hpp"
 
 using namespace py;
 using namespace py::sre;
@@ -110,4 +107,4 @@ PyType *Pattern::register_type(PyModule *module)
 							.finalize();
 	}
 	return s_sre_pattern;
-}
\ No newline at end of file
+}
diff --git a/src/runtime/modules/sre/Pattern.hpp b/src/runtime/modules/sre/Pattern.hpp
index 5ca93f5c..e791f19c 100644
--- a/src/runtime/modules/sre/Pattern.hpp
+++ b/src/runtime/modules/sre/Pattern.hpp
@@ -1,16 +1,12 @@
 #pragma once
 
-#include "runtime/PyDict.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/Value.hpp"
-#include <cstdint>
 
 namespace py {
 namespace sre {
 	class Pattern : public PyBaseObject
 	{
 		friend class ::Heap;
+		friend class py::detail::Allocator;
 
 		size_t m_groups;
 		PyDict *m_groupindex{ nullptr };
@@ -45,4 +41,4 @@ namespace sre {
 		static PyType *register_type(PyModule *module);
 	};
 }// namespace sre
-}// namespace py
\ No newline at end of file
+}// namespace py
diff --git a/src/runtime/modules/sre/module.cpp b/src/runtime/modules/sre/module.cpp
index 29395541..3410b009 100644
--- a/src/runtime/modules/sre/module.cpp
+++ b/src/runtime/modules/sre/module.cpp
@@ -1,34 +1,25 @@
-#include "Match.hpp"
-#include "Pattern.hpp"
-#include "runtime/PyArgParser.hpp"
-#include "runtime/PyBool.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFunction.hpp"
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/PyModule.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/Value.hpp"
-#include "runtime/modules/Modules.hpp"
-
-#include <cctype>
-#include <unicode/uchar.h>
-
+module;
+#include "memory/allocate.hpp"
 #include <cstdint>
-#include <limits>
+#include <unicode/uchar.h>
 #include <unicode/unistr.h>
 
+module py.runtime;
+
+#include "Match.hpp"
+#include "Pattern.hpp"
+
 
 namespace py {
 PyResult<PyObject *> compile(PyTuple *args, PyDict *kwargs)
 {
 	auto result =
-		PyArgsParser<PyObject *, int32_t, PyList *, size_t, PyDict *, PyTuple *>::unpack_tuple(args,
-			kwargs,
-			"_sre.compile",
-			std::integral_constant<size_t, 6>{},
-			std::integral_constant<size_t, 6>{});
+		PyArgsParser<PyObject *, std::int32_t, PyList *, std::size_t, PyDict *, PyTuple *>::
+			unpack_tuple(args,
+				kwargs,
+				"_sre.compile",
+				std::integral_constant<std::size_t, 6>{},
+				std::integral_constant<std::size_t, 6>{});
 	if (result.is_err()) { return Err(result.unwrap_err()); }
 
 	auto [pattern, flags, code, groups, groupindex, indexgroup] = result.unwrap();
@@ -43,15 +34,15 @@ PyResult<PyObject *> unicode_iscased(PyTuple *args, PyDict *kwargs)
 	auto result = PyArgsParser<PyInteger *>::unpack_tuple(args,
 		kwargs,
 		"_sre.unicode_iscased",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 1>{});
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 1>{});
 	if (result.is_err()) { return Err(result.unwrap_err()); }
 
 	auto [character] = result.unwrap();
 
 	if (!character->as_big_int().fits_sint_p()) { return Ok(py_false()); }
 
-	icu::UnicodeString original{ UChar32{ static_cast<int32_t>(character->as_i64()) } };
+	icu::UnicodeString original{ UChar32{ static_cast<std::int32_t>(character->as_i64()) } };
 	auto other = original;
 	other.toUpper();
 	if (original != other) { return Ok(py_true()); }
@@ -66,15 +57,15 @@ PyResult<PyObject *> unicode_tolower(PyTuple *args, PyDict *kwargs)
 	auto result = PyArgsParser<PyInteger *>::unpack_tuple(args,
 		kwargs,
 		"_sre.unicode_tolower",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 1>{});
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 1>{});
 	if (result.is_err()) { return Err(result.unwrap_err()); }
 
 	auto [character] = result.unwrap();
 
 	if (!character->as_big_int().fits_sint_p()) { return Ok(py_false()); }
 
-	icu::UnicodeString original{ UChar32{ static_cast<int32_t>(character->as_i64()) } };
+	icu::UnicodeString original{ UChar32{ static_cast<std::int32_t>(character->as_i64()) } };
 	original.toLower();
 
 	return PyInteger::create(original.char32At(0));
@@ -85,8 +76,8 @@ PyResult<PyObject *> ascii_iscased(PyTuple *args, PyDict *kwargs)
 	auto result = PyArgsParser<PyInteger *>::unpack_tuple(args,
 		kwargs,
 		"_sre.ascii_iscased",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 1>{});
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 1>{});
 	if (result.is_err()) { return Err(result.unwrap_err()); }
 
 	auto [character] = result.unwrap();
@@ -103,8 +94,8 @@ PyResult<PyObject *> ascii_tolower(PyTuple *args, PyDict *kwargs)
 	auto result = PyArgsParser<PyInteger *>::unpack_tuple(args,
 		kwargs,
 		"_sre.ascii_tolower",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 1>{});
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 1>{});
 	if (result.is_err()) { return Err(result.unwrap_err()); }
 
 	auto [character] = result.unwrap();
@@ -126,10 +117,10 @@ PyModule *sre_module()
 	module_->add_symbol(PyString::create("MAGIC").unwrap(), Number{ BigIntType{ 20171005 } });
 
 	module_->add_symbol(PyString::create("MAXREPEAT").unwrap(),
-		Number{ BigIntType{ std::numeric_limits<uint32_t>::max() } });
+		Number{ BigIntType{ std::numeric_limits<std::uint32_t>::max() } });
 
 	module_->add_symbol(PyString::create("MAXGROUPS").unwrap(),
-		Number{ BigIntType{ std::numeric_limits<uint32_t>::max() / 2 } });
+		Number{ BigIntType{ std::numeric_limits<std::uint32_t>::max() / 2 } });
 
 	module_->add_symbol(PyString::create("compile").unwrap(),
 		PyNativeFunction::create("compile", &compile).unwrap());
@@ -151,4 +142,4 @@ PyModule *sre_module()
 
 	return module_;
 }
-}// namespace py
\ No newline at end of file
+}// namespace py
diff --git a/src/runtime/modules/struct/module.cpp b/src/runtime/modules/struct/module.cpp
index b59d7938..03b28467 100644
--- a/src/runtime/modules/struct/module.cpp
+++ b/src/runtime/modules/struct/module.cpp
@@ -1,8 +1,7 @@
-#include "../Modules.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFunction.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyString.hpp"
+module;
+
+module py.runtime;
+
 
 namespace py {
 
diff --git a/src/runtime/modules/thread/Lock.hpp b/src/runtime/modules/thread/Lock.hpp
index a0e48b5f..667f3786 100644
--- a/src/runtime/modules/thread/Lock.hpp
+++ b/src/runtime/modules/thread/Lock.hpp
@@ -1,14 +1,4 @@
-#include "runtime/MemoryError.hpp"
-#include "runtime/PyBool.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFunction.hpp"
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/TypeError.hpp"
-#include "runtime/ValueError.hpp"
-#include "runtime/types/api.hpp"
-#include "vm/VM.hpp"
+
 
 namespace py {
 
@@ -19,6 +9,7 @@ namespace {
 class Lock : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	std::timed_mutex m_mutex;
 	bool m_locked{ false };
diff --git a/src/runtime/modules/thread/RLock.hpp b/src/runtime/modules/thread/RLock.hpp
index 3b214492..94e93474 100644
--- a/src/runtime/modules/thread/RLock.hpp
+++ b/src/runtime/modules/thread/RLock.hpp
@@ -1,14 +1,4 @@
-#include "runtime/MemoryError.hpp"
-#include "runtime/PyBool.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFunction.hpp"
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/TypeError.hpp"
-#include "runtime/ValueError.hpp"
-#include "runtime/types/api.hpp"
-#include "vm/VM.hpp"
+
 
 namespace py {
 
@@ -19,6 +9,7 @@ namespace {
 class RLock : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 
 	std::recursive_timed_mutex m_mutex;
 	bool m_locked{ false };
diff --git a/src/runtime/modules/thread/module.cpp b/src/runtime/modules/thread/module.cpp
index 5f25f596..1c4e58b1 100644
--- a/src/runtime/modules/thread/module.cpp
+++ b/src/runtime/modules/thread/module.cpp
@@ -1,13 +1,17 @@
-#include "../Modules.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <climits>
+#include <cstddef>
+#include <cstdint>
+#include <pthread.h>
+
+module py.runtime;
+import py.types;
+
 #include "Lock.hpp"
 #include "RLock.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/TypeError.hpp"
-#include "runtime/types/builtin.hpp"
 
-#include <thread>
 
 namespace py {
 
@@ -16,8 +20,8 @@ PyResult<PyObject *> start_new_thread(PyTuple *args, PyDict *kwargs)
 	auto result = PyArgsParser<PyObject *, PyObject *>::unpack_tuple(args,
 		kwargs,
 		"start_new_thread",
-		std::integral_constant<size_t, 2>{},
-		std::integral_constant<size_t, 2>{});
+		std::integral_constant<std::size_t, 2>{},
+		std::integral_constant<std::size_t, 2>{});
 
 	if (result.is_err()) { return Ok(result.unwrap_err()); }
 
@@ -67,7 +71,7 @@ PyModule *thread_module()
 		PyString::create("TIMEOUT_MAX").unwrap(), PyInteger::create(LLONG_MAX).unwrap());
 
 	pthread_attr_t attr;
-	size_t stacksize;
+	std::size_t stacksize;
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &stacksize);
 
diff --git a/src/runtime/modules/time/module.cpp b/src/runtime/modules/time/module.cpp
index 386a142d..40a81613 100644
--- a/src/runtime/modules/time/module.cpp
+++ b/src/runtime/modules/time/module.cpp
@@ -1,14 +1,8 @@
-#include "../Modules.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFloat.hpp"
-#include "runtime/PyFunction.hpp"
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/PyType.hpp"
+module;
+#include <ctime>
+
+module py.runtime;
 
-#include <chrono>
-#include <ratio>
 
 namespace py {
 
diff --git a/src/runtime/modules/weakref/PyCallableProxyType.cpp b/src/runtime/modules/weakref/PyCallableProxyType.cpp
index 81f483df..0ddc9e1d 100644
--- a/src/runtime/modules/weakref/PyCallableProxyType.cpp
+++ b/src/runtime/modules/weakref/PyCallableProxyType.cpp
@@ -1,11 +1,15 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstdint>
+
+module py.runtime;
+import py.memory;
+import std;
+
+// After the import: these name module-owned types.
 #include "PyCallableProxyType.hpp"
-#include "runtime/MemoryError.hpp"
-#include "runtime/PyModule.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/ValueError.hpp"
-#include "runtime/types/api.hpp"
-#include "vm/VM.hpp"
+
 
 namespace py {
 
@@ -22,7 +26,7 @@ PyCallableProxyType::PyCallableProxyType(PyObject *object, PyObject *callback)
 PyCallableProxyType::~PyCallableProxyType()
 {
 	if (m_object && m_object != py_none()) {
-		VirtualMachine::the().heap().unregister_weakref(bit_cast<uint8_t *>(m_object), this);
+		VirtualMachine::the().heap().unregister_weakref(std::bit_cast<uint8_t *>(m_object), this);
 	}
 }
 
@@ -43,9 +47,9 @@ void PyCallableProxyType::visit_graph(Visitor &visitor)
 std::string PyCallableProxyType::to_string() const
 {
 	if (!m_object) {
-		return fmt::format("<weakproxy at {} empty", static_cast<const void *>(this));
+		return std::format("<weakproxy at {} empty", static_cast<const void *>(this));
 	}
-	return fmt::format("<weakproxy at {} to {} at {}>",
+	return std::format("<weakproxy at {} to {} at {}>",
 		static_cast<const void *>(this),
 		m_object->type()->name(),
 		static_cast<const void *>(m_object));
@@ -138,7 +142,7 @@ PyType *PyCallableProxyType::register_type(PyModule *module, std::string_view na
 bool PyCallableProxyType::is_alive() const
 {
 	if (m_object
-		&& !VirtualMachine::the().heap().has_weakref_object(bit_cast<uint8_t *>(m_object))) {
+		&& !VirtualMachine::the().heap().has_weakref_object(std::bit_cast<uint8_t *>(m_object))) {
 		m_object = nullptr;
 	}
 	return m_object != nullptr;
diff --git a/src/runtime/modules/weakref/PyCallableProxyType.hpp b/src/runtime/modules/weakref/PyCallableProxyType.hpp
index cc667a68..7ab84329 100644
--- a/src/runtime/modules/weakref/PyCallableProxyType.hpp
+++ b/src/runtime/modules/weakref/PyCallableProxyType.hpp
@@ -1,12 +1,11 @@
 #pragma once
 
-#include "runtime/PyObject.hpp"
-
 namespace py {
 
 class PyCallableProxyType : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	mutable PyObject *m_object{ nullptr };
 	PyObject *m_callback{ nullptr };
 
diff --git a/src/runtime/modules/weakref/PyWeakProxy.cpp b/src/runtime/modules/weakref/PyWeakProxy.cpp
index 61e607b2..898f128b 100644
--- a/src/runtime/modules/weakref/PyWeakProxy.cpp
+++ b/src/runtime/modules/weakref/PyWeakProxy.cpp
@@ -1,11 +1,15 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstdint>
+
+module py.runtime;
+import py.memory;
+import std;
+
+// After the import: these name module-owned types.
 #include "PyWeakProxy.hpp"
-#include "runtime/MemoryError.hpp"
-#include "runtime/PyModule.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/ValueError.hpp"
-#include "runtime/types/api.hpp"
-#include "vm/VM.hpp"
+
 
 namespace py {
 
@@ -22,7 +26,7 @@ PyWeakProxy::PyWeakProxy(PyObject *object, PyObject *callback)
 PyWeakProxy::~PyWeakProxy()
 {
 	if (m_object && m_object != py_none()) {
-		VirtualMachine::the().heap().unregister_weakref(bit_cast<uint8_t *>(m_object), this);
+		VirtualMachine::the().heap().unregister_weakref(std::bit_cast<uint8_t *>(m_object), this);
 	}
 }
 
@@ -42,9 +46,9 @@ void PyWeakProxy::visit_graph(Visitor &visitor)
 std::string PyWeakProxy::to_string() const
 {
 	if (!m_object) {
-		return fmt::format("<weakproxy at {} empty", static_cast<const void *>(this));
+		return std::format("<weakproxy at {} empty", static_cast<const void *>(this));
 	}
-	return fmt::format("<weakproxy at {} to {} at {}>",
+	return std::format("<weakproxy at {} to {} at {}>",
 		static_cast<const void *>(this),
 		m_object->type()->name(),
 		static_cast<const void *>(m_object));
@@ -128,10 +132,12 @@ PyType *PyWeakProxy::register_type(PyModule *module, std::string_view name)
 bool PyWeakProxy::is_alive() const
 {
 	if (m_object
-		&& !VirtualMachine::the().heap().has_weakref_object(bit_cast<uint8_t *>(m_object))) {
+		&& !VirtualMachine::the().heap().has_weakref_object(std::bit_cast<uint8_t *>(m_object))) {
 		m_object = py_none();
 	}
 	return m_object != py_none();
 }
 
+PyObject *PyWeakProxy::get_object() const { return m_object; }
+
 }// namespace py
diff --git a/src/runtime/modules/weakref/PyWeakProxy.hpp b/src/runtime/modules/weakref/PyWeakProxy.hpp
index b7e861ab..6d6775db 100644
--- a/src/runtime/modules/weakref/PyWeakProxy.hpp
+++ b/src/runtime/modules/weakref/PyWeakProxy.hpp
@@ -1,12 +1,11 @@
 #pragma once
 
-#include "runtime/PyObject.hpp"
-
 namespace py {
 
 class PyWeakProxy : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	mutable PyObject *m_object{ nullptr };
 	PyObject *m_callback{ nullptr };
 
@@ -32,7 +31,7 @@ class PyWeakProxy : public PyBaseObject
 	static PyType *register_type(PyModule *module, std::string_view name);
 
   public:
-	PyObject *get_object() const { return m_object; }
+	PyObject *get_object() const;
 
   private:
 	bool is_alive() const;
diff --git a/src/runtime/modules/weakref/PyWeakRef.cpp b/src/runtime/modules/weakref/PyWeakRef.cpp
index 850893a0..9d0d3829 100644
--- a/src/runtime/modules/weakref/PyWeakRef.cpp
+++ b/src/runtime/modules/weakref/PyWeakRef.cpp
@@ -1,10 +1,15 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+#include <cstdint>
+
+module py.runtime;
+import py.memory;
+import std;
+
+// After the import: these name module-owned types.
 #include "PyWeakRef.hpp"
-#include "runtime/MemoryError.hpp"
-#include "runtime/PyModule.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/types/api.hpp"
-#include "vm/VM.hpp"
+
 
 namespace py {
 
@@ -26,7 +31,7 @@ PyWeakRef::~PyWeakRef()
 	// switched m_object to py_none() or the entry was erased by sweep —
 	// either way, unregister_weakref is a safe no-op.
 	if (m_object && m_object != py_none()) {
-		VirtualMachine::the().heap().unregister_weakref(bit_cast<uint8_t *>(m_object), this);
+		VirtualMachine::the().heap().unregister_weakref(std::bit_cast<uint8_t *>(m_object), this);
 	}
 }
 
@@ -45,10 +50,10 @@ void PyWeakRef::visit_graph(Visitor &visitor)
 
 std::string PyWeakRef::to_string() const
 {
-	return fmt::format("<weakref at {}; {}>",
+	return std::format("<weakref at {}; {}>",
 		static_cast<const void *>(this),
 		is_alive()
-			? fmt::format("to '{}' at {}", m_object->type()->name(), static_cast<void *>(m_object))
+			? std::format("to '{}' at {}", m_object->type()->name(), static_cast<void *>(m_object))
 			: "dead");
 }
 
@@ -100,10 +105,12 @@ PyType *PyWeakRef::register_type(PyModule *module, std::string_view name)
 bool PyWeakRef::is_alive() const
 {
 	if (m_object
-		&& !VirtualMachine::the().heap().has_weakref_object(bit_cast<uint8_t *>(m_object))) {
+		&& !VirtualMachine::the().heap().has_weakref_object(std::bit_cast<uint8_t *>(m_object))) {
 		m_object = py_none();
 	}
 	return m_object != py_none();
 }
 
+PyObject *PyWeakRef::get_object() const { return m_object; }
+
 }// namespace py
diff --git a/src/runtime/modules/weakref/PyWeakRef.hpp b/src/runtime/modules/weakref/PyWeakRef.hpp
index 0ac575dd..647b0a56 100644
--- a/src/runtime/modules/weakref/PyWeakRef.hpp
+++ b/src/runtime/modules/weakref/PyWeakRef.hpp
@@ -1,12 +1,11 @@
 #pragma once
 
-#include "runtime/PyObject.hpp"
-
 namespace py {
 
 class PyWeakRef : public PyBaseObject
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	mutable PyObject *m_object{ nullptr };
 	PyObject *m_callback{ nullptr };
 
@@ -31,7 +30,7 @@ class PyWeakRef : public PyBaseObject
 	static PyType *register_type(PyModule *module, std::string_view name);
 
   public:
-	PyObject *get_object() const { return m_object; }
+	PyObject *get_object() const;
 
   private:
 	bool is_alive() const;
diff --git a/src/runtime/modules/weakref/module.cpp b/src/runtime/modules/weakref/module.cpp
index e2df7c2f..9089848d 100644
--- a/src/runtime/modules/weakref/module.cpp
+++ b/src/runtime/modules/weakref/module.cpp
@@ -1,20 +1,17 @@
-#include "../Modules.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.memory;
+import py.types;
+
+// These name py:: types, so they belong in the purview where the implicit
+// import of py.runtime has already happened.
 #include "PyCallableProxyType.hpp"
 #include "PyWeakProxy.hpp"
 #include "PyWeakRef.hpp"
-#include "runtime/PyArgParser.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyFunction.hpp"
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/TypeError.hpp"
-#include "runtime/ValueError.hpp"
-#include "runtime/types/builtin.hpp"
-#include "vm/VM.hpp"
-#include <bit>
-#include <cstdint>
+
 
 namespace py {
 
@@ -28,15 +25,15 @@ PyResult<PyObject *> getweakrefcount(PyTuple *args, PyDict *kwargs)
 	auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 		kwargs,
 		"getweakrefcount",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 1>{});
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 1>{});
 
 	if (result.is_err()) { return Err(result.unwrap_err()); }
 
 	auto [object] = result.unwrap();
 
 	return PyInteger::create(
-		VirtualMachine::the().heap().weakref_count(std::bit_cast<uint8_t *>(object)));
+		VirtualMachine::the().heap().weakref_count(std::bit_cast<std::uint8_t *>(object)));
 }
 
 PyResult<PyObject *> getweakrefs(PyTuple *args, PyDict *kwargs)
@@ -44,19 +41,24 @@ PyResult<PyObject *> getweakrefs(PyTuple *args, PyDict *kwargs)
 	auto result = PyArgsParser<PyObject *>::unpack_tuple(args,
 		kwargs,
 		"getweakrefs",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 1>{});
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 1>{});
 
 	if (result.is_err()) { return Err(result.unwrap_err()); }
 
 	auto [object] = result.unwrap();
 
-	auto weakrefs = VirtualMachine::the().heap().get_weakrefs(std::bit_cast<uint8_t *>(object));
+	auto weakrefs =
+		VirtualMachine::the().heap().get_weakrefs(std::bit_cast<std::uint8_t *>(object));
 
 	auto weakref_list = PyList::create();
 	if (result.is_err()) { return weakref_list; }
-	weakref_list.unwrap()->elements().insert(
-		weakref_list.unwrap()->elements().end(), weakrefs.begin(), weakrefs.end());
+	// Heap::get_weakrefs returns Cell* so that memory/ does not have to name
+	// py::PyObject (that dependency closed a module cycle); every weakref stored
+	// there is a PyObject, so the downcast is safe.
+	auto &elements = weakref_list.unwrap()->elements();
+	elements.reserve(elements.size() + weakrefs.size());
+	for (auto *cell : weakrefs) { elements.push_back(static_cast<PyObject *>(cell)); }
 
 	return weakref_list;
 }
@@ -66,8 +68,8 @@ PyResult<PyObject *> proxy(PyTuple *args, PyDict *kwargs)
 	auto result = PyArgsParser<PyObject *, PyObject *>::unpack_tuple(args,
 		kwargs,
 		"proxy",
-		std::integral_constant<size_t, 1>{},
-		std::integral_constant<size_t, 2>{},
+		std::integral_constant<std::size_t, 1>{},
+		std::integral_constant<std::size_t, 2>{},
 		nullptr);
 
 	if (result.is_err()) { return Err(result.unwrap_err()); }
@@ -84,8 +86,8 @@ PyResult<PyObject *> remove_dead_weakref(PyTuple *args, PyDict *kwargs)
 	auto result = PyArgsParser<PyObject *, PyObject *>::unpack_tuple(args,
 		kwargs,
 		"remove_dead_weakref",
-		std::integral_constant<size_t, 2>{},
-		std::integral_constant<size_t, 2>{});
+		std::integral_constant<std::size_t, 2>{},
+		std::integral_constant<std::size_t, 2>{});
 
 	if (result.is_err()) { return Err(result.unwrap_err()); }
 
diff --git a/src/runtime/runtime.cppm b/src/runtime/runtime.cppm
new file mode 100644
index 00000000..30414d32
--- /dev/null
+++ b/src/runtime/runtime.cppm
@@ -0,0 +1,95 @@
+export module py.runtime;
+
+export import :arg_parser;
+export import :assertion_error;
+export import :asyncgenerator;
+export import :attribute_error;
+export import :baseexception;
+export import :bool_;
+export import :bound_method;
+export import :built_in_method;
+export import :byte_array;
+export import :bytecode;
+export import :bytecode_program;
+export import :bytes;
+export import :cell;
+export import :class_method;
+export import :class_method_descriptor;
+export import :code;
+export import :complex;
+export import :concepts;
+export import :coroutine;
+export import :deprecation_warning;
+export import :detail;
+export import :dict;
+export import :ellipsis;
+export import :enumerate;
+export import :exception;
+export import :executable_function;
+export import :executable_functionblock;
+export import :executable_program;
+export import :float_;
+export import :frame;
+export import :frozenset;
+export import :function;
+export import :generator;
+export import :generic_alias;
+export import :get_set_descriptor;
+export import :import;
+export import :import_error;
+export import :import_warning;
+export import :index_error;
+export import :instructions;
+export import :mangler;
+export import :parser;
+export import :integer;
+export import :interpreter;
+export import :interpreter_session;
+export import :iterator;
+export import :key_error;
+export import :klass;
+export import :l_l_v_m_function;
+export import :list;
+export import :lookup_error;
+export import :map;
+export import :mapping_proxy;
+export import :member_descriptor;
+export import :memory_error;
+export import :memory_view;
+export import :method_descriptor;
+export import :module_not_found_error;
+export import :modules;
+export import :name_error;
+export import :none;
+export import :not_implemented;
+export import :not_implemented_error;
+export import :number;
+export import :o_s_error;
+export import :object;
+export import :pending_deprecation_warning;
+export import :property;
+export import :pymodule;
+export import :pynamespace;
+export import :range;
+export import :resource_warning;
+export import :reversed;
+export import :runtime_error;
+export import :set;
+export import :slice;
+export import :slot_wrapper;
+export import :static_method;
+export import :stop_iteration;
+export import :string;
+export import :super;
+export import :syntax_error;
+export import :traceback;
+export import :tuple;
+export import :type;
+export import :type_error;
+export import :unbound_local_error;
+export import :utilities;
+export import :value;
+export import :value_error;
+export import :vm;
+export import :warning;
+export import :zip;
diff --git a/src/runtime/types/api.cppm b/src/runtime/types/api.cppm
new file mode 100644
index 00000000..c42a0581
--- /dev/null
+++ b/src/runtime/types/api.cppm
@@ -0,0 +1,5 @@
+module;
+
+export module py.types:api;
+import py.runtime;
+import std;
diff --git a/src/runtime/types/builtin.cpp b/src/runtime/types/builtin.cpp
index ee3ee768..d4e8ec8b 100644
--- a/src/runtime/types/builtin.cpp
+++ b/src/runtime/types/builtin.cpp
@@ -1,74 +1,10 @@
-#include "builtin.hpp"
-
-#include "runtime/AssertionError.hpp"
-#include "runtime/AttributeError.hpp"
-#include "runtime/ImportError.hpp"
-#include "runtime/IndexError.hpp"
-#include "runtime/KeyError.hpp"
-#include "runtime/LookupError.hpp"
-#include "runtime/MemoryError.hpp"
-#include "runtime/ModuleNotFoundError.hpp"
-#include "runtime/NameError.hpp"
-#include "runtime/NotImplemented.hpp"
-#include "runtime/NotImplementedError.hpp"
-#include "runtime/OSError.hpp"
-#include "runtime/PyAsyncGenerator.hpp"
-#include "runtime/PyBool.hpp"
-#include "runtime/PyBoundMethod.hpp"
-#include "runtime/PyBuiltInMethod.hpp"
-#include "runtime/PyByteArray.hpp"
-#include "runtime/PyBytes.hpp"
-#include "runtime/PyCell.hpp"
-#include "runtime/PyClassMethod.hpp"
-#include "runtime/PyClassMethodDescriptor.hpp"
-#include "runtime/PyCode.hpp"
-#include "runtime/PyComplex.hpp"
-#include "runtime/PyCoroutine.hpp"
-#include "runtime/PyDict.hpp"
-#include "runtime/PyEllipsis.hpp"
-#include "runtime/PyEnumerate.hpp"
-#include "runtime/PyFloat.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyFrozenSet.hpp"
-#include "runtime/PyFunction.hpp"
-#include "runtime/PyGenerator.hpp"
-#include "runtime/PyGenericAlias.hpp"
-#include "runtime/PyGetSetDescriptor.hpp"
-#include "runtime/PyInteger.hpp"
-#include "runtime/PyIterator.hpp"
-#include "runtime/PyLLVMFunction.hpp"
-#include "runtime/PyList.hpp"
-#include "runtime/PyMap.hpp"
-#include "runtime/PyMappingProxy.hpp"
-#include "runtime/PyMemberDescriptor.hpp"
-#include "runtime/PyMemoryView.hpp"
-#include "runtime/PyMethodDescriptor.hpp"
-#include "runtime/PyModule.hpp"
-#include "runtime/PyNamespace.hpp"
-#include "runtime/PyNone.hpp"
-#include "runtime/PyProperty.hpp"
-#include "runtime/PyRange.hpp"
-#include "runtime/PyReversed.hpp"
-#include "runtime/PySet.hpp"
-#include "runtime/PySlice.hpp"
-#include "runtime/PySlotWrapper.hpp"
-#include "runtime/PyStaticMethod.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/PySuper.hpp"
-#include "runtime/PyTraceback.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/PyType.hpp"
-#include "runtime/PyZip.hpp"
-#include "runtime/RuntimeError.hpp"
-#include "runtime/StopIteration.hpp"
-#include "runtime/SyntaxError.hpp"
-#include "runtime/UnboundLocalError.hpp"
-#include "runtime/ValueError.hpp"
-#include "runtime/warnings/DeprecationWarning.hpp"
-#include "runtime/warnings/ImportWarning.hpp"
-#include "runtime/warnings/PendingDeprecationWarning.hpp"
-#include "runtime/warnings/ResourceWarning.hpp"
-#include "runtime/warnings/Warning.hpp"
+module;
+#include "core.hpp"
+
+module py.types;
+import py.runtime;
+import std;
+
 
 namespace py::types {
 
@@ -131,16 +67,18 @@ BuiltinTypes::BuiltinTypes()
 	  m_unbound_local_error(UnboundLocalError::type_factory())
 {}
 
-#define INITIALIZE_TYPE(TYPENAME)                                                         \
-	PyType *TYPENAME()                                                                    \
-	{                                                                                     \
-		static PyType *type = nullptr;                                                    \
-		if (!type) {                                                                      \
-			auto &prototype = BuiltinTypes::the().TYPENAME();                             \
-			type = PyType::initialize(prototype);                                         \
-			spdlog::trace("Initialized builtin type {} @{}", type->name(), (void *)type); \
-		}                                                                                 \
-		return type;                                                                      \
+#define INITIALIZE_TYPE(TYPENAME)                                                          \
+	PyType *TYPENAME()                                                                     \
+	{                                                                                      \
+		static PyType *type = nullptr;                                                     \
+		if (!type) {                                                                       \
+			auto &prototype = BuiltinTypes::the().TYPENAME();                              \
+			type = PyType::initialize(prototype);                                          \
+			::detail::log_trace(                                                           \
+				std::format("Initialized builtin type {} @{}", type->name(), (void *)type) \
+					.c_str());                                                             \
+		}                                                                                  \
+		return type;                                                                       \
 	}
 
 INITIALIZE_TYPE(type)
diff --git a/src/runtime/types/builtin.hpp b/src/runtime/types/builtin.cppm
similarity index 98%
rename from src/runtime/types/builtin.hpp
rename to src/runtime/types/builtin.cppm
index 2d599388..e55f15da 100644
--- a/src/runtime/types/builtin.hpp
+++ b/src/runtime/types/builtin.cppm
@@ -1,13 +1,8 @@
-#pragma once
+export module py.types:builtin;
+import py.runtime;
+import std;
 
-#include "runtime/PyObject.hpp"
-#include "runtime/forward.hpp"
-
-#include <functional>
-#include <memory>
-#include <variant>
-
-namespace py {
+export namespace py {
 namespace types {
 	class BuiltinTypes
 	{
diff --git a/src/runtime/types/types.cppm b/src/runtime/types/types.cppm
new file mode 100644
index 00000000..06fbed03
--- /dev/null
+++ b/src/runtime/types/types.cppm
@@ -0,0 +1,5 @@
+export module py.types;
+
+export import :api;
+export import :builtin;
+import std;
diff --git a/src/runtime/utilities.hpp b/src/runtime/utilities.cppm
similarity index 91%
rename from src/runtime/utilities.hpp
rename to src/runtime/utilities.cppm
index 73920b68..07555f79 100644
--- a/src/runtime/utilities.hpp
+++ b/src/runtime/utilities.cppm
@@ -1,12 +1,14 @@
-#pragma once
+module;
+#include "core.hpp"
 
-#include "PyFrame.hpp"
-#include "PyObject.hpp"
-#include "StopIteration.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
+export module py.runtime:utilities;
+import :stop_iteration;
+import :baseexception;
+import :object;
+import :value;
+import py.memory;
+import std;
+export namespace py {
 
 namespace detail {
 	template<typename T>
diff --git a/src/runtime/warnings/DeprecationWarning.cpp b/src/runtime/warnings/DeprecationWarning.cpp
index 1c10553a..ba57a744 100644
--- a/src/runtime/warnings/DeprecationWarning.cpp
+++ b/src/runtime/warnings/DeprecationWarning.cpp
@@ -1,10 +1,27 @@
-#include "DeprecationWarning.hpp"
-#include "runtime/types/api.hpp"
-#include "runtime/types/builtin.hpp"
-#include "runtime/warnings/Warning.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.types;
+
 
 using namespace py;
 
+// Declared in DeprecationWarning.cppm. In namespace py rather than under the
+// using-directive above, which would define an unrelated function at global scope.
+namespace py {
+BaseException *make_deprecation_warning(std::string &&message)
+{
+	auto msg = PyString::create(std::move(message));
+	ASSERT(msg.is_ok());
+	auto args_tuple = PyTuple::create(msg.unwrap());
+	ASSERT(args_tuple.is_ok());
+	return DeprecationWarning::create(DeprecationWarning::class_type(), args_tuple.unwrap())
+		.unwrap();
+}
+}// namespace py
+
 DeprecationWarning::DeprecationWarning(PyType *type) : Warning(type) {}
 
 DeprecationWarning::DeprecationWarning(PyType *, PyTuple *args)
diff --git a/src/runtime/warnings/DeprecationWarning.cppm b/src/runtime/warnings/DeprecationWarning.cppm
new file mode 100644
index 00000000..04d26438
--- /dev/null
+++ b/src/runtime/warnings/DeprecationWarning.cppm
@@ -0,0 +1,53 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+export module py.runtime:deprecation_warning;
+import :warning;
+import :baseexception;
+import :dict;
+import :object;
+import :string;
+import :tuple;
+import :value;
+import py.memory;
+import std;
+
+export namespace py {
+class PyType;
+
+class DeprecationWarning : public Warning
+{
+	friend class ::Heap;
+	friend class py::detail::Allocator;
+	friend BaseException *make_deprecation_warning(std::string &&);
+
+  protected:
+	DeprecationWarning(PyType *type);
+
+	DeprecationWarning(PyType *, PyTuple *args);
+
+  private:
+	static PyResult<DeprecationWarning *> create(PyType *, PyTuple *args);
+
+  public:
+	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
+
+	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
+
+	PyType *static_type() const override;
+	static PyType *class_type();
+};
+
+// Defined in warnings/DeprecationWarning.cpp. Keeping the PyString/PyTuple construction and the
+// heap allocation out of the interface means this partition no longer has
+// to materialise those types just to declare one exception class.
+BaseException *make_deprecation_warning(std::string &&message);
+
+template<typename... Args>
+inline BaseException *deprecation_warning(const std::string &message, Args &&...args)
+{
+	return make_deprecation_warning(std::vformat(message, std::make_format_args(args...)));
+}
+
+}// namespace py
diff --git a/src/runtime/warnings/DeprecationWarning.hpp b/src/runtime/warnings/DeprecationWarning.hpp
deleted file mode 100644
index df6cd434..00000000
--- a/src/runtime/warnings/DeprecationWarning.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#pragma once
-
-#include "runtime/PyString.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/warnings/Warning.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
-
-class DeprecationWarning : public Warning
-{
-	friend class ::Heap;
-	template<typename... Args>
-	friend BaseException *deprecation_warning(const std::string &message, Args &&...args);
-
-  protected:
-	DeprecationWarning(PyType *type);
-
-	DeprecationWarning(PyType *, PyTuple *args);
-
-  private:
-	static PyResult<DeprecationWarning *> create(PyType *, PyTuple *args);
-
-  public:
-	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-
-	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
-
-	PyType *static_type() const override;
-	static PyType *class_type();
-};
-
-template<typename... Args>
-inline BaseException *deprecation_warning(const std::string &message, Args &&...args)
-{
-	auto msg = PyString::create(fmt::format(message, std::forward<Args>(args)...));
-	ASSERT(msg.is_ok());
-	auto args_tuple = PyTuple::create(msg.unwrap());
-	ASSERT(args_tuple.is_ok());
-	return DeprecationWarning::create(DeprecationWarning::class_type(), args_tuple.unwrap())
-		.unwrap();
-}
-
-}// namespace py
diff --git a/src/runtime/warnings/ImportWarning.cpp b/src/runtime/warnings/ImportWarning.cpp
index ba02d929..287cacb0 100644
--- a/src/runtime/warnings/ImportWarning.cpp
+++ b/src/runtime/warnings/ImportWarning.cpp
@@ -1,10 +1,22 @@
-#include "ImportWarning.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/types/api.hpp"
-#include "runtime/types/builtin.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
+BaseException *make_import_warning(std::string &&message)
+{
+	auto msg = PyString::create(std::move(message));
+	ASSERT(msg.is_ok());
+	auto args_tuple = PyTuple::create(msg.unwrap());
+	ASSERT(args_tuple.is_ok());
+	return ImportWarning::create(ImportWarning::class_type(), args_tuple.unwrap()).unwrap();
+}
+
 ImportWarning::ImportWarning(PyType *type) : Warning(type) {}
 
 ImportWarning::ImportWarning(PyType *type, PyTuple *args) : Warning(type, args) {}
diff --git a/src/runtime/warnings/ImportWarning.cppm b/src/runtime/warnings/ImportWarning.cppm
new file mode 100644
index 00000000..0e2d0edd
--- /dev/null
+++ b/src/runtime/warnings/ImportWarning.cppm
@@ -0,0 +1,52 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+export module py.runtime:import_warning;
+import :warning;
+import :baseexception;
+import :dict;
+import :object;
+import :string;
+import :tuple;
+import :value;
+import py.memory;
+import std;
+
+export namespace py {
+class PyType;
+
+class ImportWarning : public Warning
+{
+	friend class ::Heap;
+	friend class py::detail::Allocator;
+	friend BaseException *make_import_warning(std::string &&);
+
+  private:
+	ImportWarning(PyType *type);
+
+	ImportWarning(PyType *type, PyTuple *args);
+
+	static PyResult<ImportWarning *> create(PyType *type, PyTuple *args);
+
+  public:
+	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
+
+	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
+
+	PyType *static_type() const override;
+	static PyType *class_type();
+};
+
+// Defined in warnings/ImportWarning.cpp. Keeping the PyString/PyTuple construction and the
+// heap allocation out of the interface means this partition no longer has
+// to materialise those types just to declare one exception class.
+BaseException *make_import_warning(std::string &&message);
+
+template<typename... Args>
+inline BaseException *import_warning(const std::string &message, Args &&...args)
+{
+	return make_import_warning(std::vformat(message, std::make_format_args(args...)));
+}
+
+}// namespace py
diff --git a/src/runtime/warnings/ImportWarning.hpp b/src/runtime/warnings/ImportWarning.hpp
deleted file mode 100644
index a5516c11..00000000
--- a/src/runtime/warnings/ImportWarning.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-
-#include "Warning.hpp"
-
-namespace py {
-
-class ImportWarning : public Warning
-{
-	friend class ::Heap;
-	template<typename... Args>
-	friend BaseException *import_warning(const std::string &message, Args &&...args);
-
-  private:
-	ImportWarning(PyType *type);
-
-	ImportWarning(PyType *type, PyTuple *args);
-
-	static PyResult<ImportWarning *> create(PyType *type, PyTuple *args);
-
-  public:
-	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-
-	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
-
-	PyType *static_type() const override;
-	static PyType *class_type();
-};
-
-template<typename... Args>
-inline BaseException *import_warning(const std::string &message, Args &&...args)
-{
-	auto msg = PyString::create(fmt::format(message, std::forward<Args>(args)...));
-	ASSERT(msg.is_ok());
-	auto args_tuple = PyTuple::create(msg.unwrap());
-	ASSERT(args_tuple.is_ok());
-	return ImportWarning::create(ImportWarning::class_type(), args_tuple.unwrap()).unwrap();
-}
-
-}// namespace py
diff --git a/src/runtime/warnings/PendingDeprecationWarning.cpp b/src/runtime/warnings/PendingDeprecationWarning.cpp
index 19cb5f49..3fdb0e93 100644
--- a/src/runtime/warnings/PendingDeprecationWarning.cpp
+++ b/src/runtime/warnings/PendingDeprecationWarning.cpp
@@ -1,10 +1,28 @@
-#include "runtime/warnings/PendingDeprecationWarning.hpp"
-#include "runtime/types/api.hpp"
-#include "runtime/types/builtin.hpp"
-#include "runtime/warnings/Warning.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.types;
+
 
 using namespace py;
 
+// Declared in PendingDeprecationWarning.cppm. In namespace py rather than under the
+// using-directive above, which would define an unrelated function at global scope.
+namespace py {
+BaseException *make_pending_deprecation_warning(std::string &&message)
+{
+	auto msg = PyString::create(std::move(message));
+	ASSERT(msg.is_ok());
+	auto args_tuple = PyTuple::create(msg.unwrap());
+	ASSERT(args_tuple.is_ok());
+	return PendingDeprecationWarning::create(
+		PendingDeprecationWarning::class_type(), args_tuple.unwrap())
+		.unwrap();
+}
+}// namespace py
+
 PendingDeprecationWarning::PendingDeprecationWarning(PyType *type) : Warning(type) {}
 
 PendingDeprecationWarning::PendingDeprecationWarning(PyType *, PyTuple *args)
diff --git a/src/runtime/warnings/PendingDeprecationWarning.cppm b/src/runtime/warnings/PendingDeprecationWarning.cppm
new file mode 100644
index 00000000..f6178d64
--- /dev/null
+++ b/src/runtime/warnings/PendingDeprecationWarning.cppm
@@ -0,0 +1,53 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+export module py.runtime:pending_deprecation_warning;
+import :warning;
+import :baseexception;
+import :dict;
+import :object;
+import :string;
+import :tuple;
+import :value;
+import py.memory;
+import std;
+
+export namespace py {
+class PyType;
+
+class PendingDeprecationWarning : public Warning
+{
+	friend class ::Heap;
+	friend class py::detail::Allocator;
+	friend BaseException *make_pending_deprecation_warning(std::string &&);
+
+  protected:
+	PendingDeprecationWarning(PyType *type);
+
+	PendingDeprecationWarning(PyType *, PyTuple *args);
+
+  private:
+	static PyResult<PendingDeprecationWarning *> create(PyType *, PyTuple *args);
+
+  public:
+	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
+
+	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
+
+	PyType *static_type() const override;
+	static PyType *class_type();
+};
+
+// Defined in warnings/PendingDeprecationWarning.cpp. Keeping the PyString/PyTuple construction and
+// the heap allocation out of the interface means this partition no longer has to materialise those
+// types just to declare one exception class.
+BaseException *make_pending_deprecation_warning(std::string &&message);
+
+template<typename... Args>
+inline BaseException *pending_deprecation_warning(const std::string &message, Args &&...args)
+{
+	return make_pending_deprecation_warning(std::vformat(message, std::make_format_args(args...)));
+}
+
+}// namespace py
diff --git a/src/runtime/warnings/PendingDeprecationWarning.hpp b/src/runtime/warnings/PendingDeprecationWarning.hpp
deleted file mode 100644
index 4f5c13bf..00000000
--- a/src/runtime/warnings/PendingDeprecationWarning.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#pragma once
-
-#include "runtime/PyString.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/warnings/Warning.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
-
-class PendingDeprecationWarning : public Warning
-{
-	friend class ::Heap;
-	template<typename... Args>
-	friend BaseException *pending_deprecation_warning(const std::string &message, Args &&...args);
-
-  protected:
-	PendingDeprecationWarning(PyType *type);
-
-	PendingDeprecationWarning(PyType *, PyTuple *args);
-
-  private:
-	static PyResult<PendingDeprecationWarning *> create(PyType *, PyTuple *args);
-
-  public:
-	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-
-	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
-
-	PyType *static_type() const override;
-	static PyType *class_type();
-};
-
-template<typename... Args>
-inline BaseException *pending_deprecation_warning(const std::string &message, Args &&...args)
-{
-	auto msg = PyString::create(fmt::format(message, std::forward<Args>(args)...));
-	ASSERT(msg.is_ok());
-	auto args_tuple = PyTuple::create(msg.unwrap());
-	ASSERT(args_tuple.is_ok());
-	return PendingDeprecationWarning::create(
-		PendingDeprecationWarning::class_type(), args_tuple.unwrap())
-		.unwrap();
-}
-
-}// namespace py
diff --git a/src/runtime/warnings/ResourceWarning.cpp b/src/runtime/warnings/ResourceWarning.cpp
index 9475a533..0d0ade3f 100644
--- a/src/runtime/warnings/ResourceWarning.cpp
+++ b/src/runtime/warnings/ResourceWarning.cpp
@@ -1,10 +1,26 @@
-#include "runtime/warnings/ResourceWarning.hpp"
-#include "runtime/types/api.hpp"
-#include "runtime/types/builtin.hpp"
-#include "runtime/warnings/Warning.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.types;
+
 
 using namespace py;
 
+// Declared in ResourceWarning.cppm. In namespace py rather than under the
+// using-directive above, which would define an unrelated function at global scope.
+namespace py {
+BaseException *make_resource_warning(std::string &&message)
+{
+	auto msg = PyString::create(std::move(message));
+	ASSERT(msg.is_ok());
+	auto args_tuple = PyTuple::create(msg.unwrap());
+	ASSERT(args_tuple.is_ok());
+	return ResourceWarning::create(ResourceWarning::class_type(), args_tuple.unwrap()).unwrap();
+}
+}// namespace py
+
 ResourceWarning::ResourceWarning(PyType *type) : Warning(type) {}
 
 ResourceWarning::ResourceWarning(PyType *, PyTuple *args) : Warning(types::resource_warning(), args)
diff --git a/src/runtime/warnings/ResourceWarning.cppm b/src/runtime/warnings/ResourceWarning.cppm
new file mode 100644
index 00000000..ea00cbe9
--- /dev/null
+++ b/src/runtime/warnings/ResourceWarning.cppm
@@ -0,0 +1,53 @@
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+export module py.runtime:resource_warning;
+import :warning;
+import :baseexception;
+import :dict;
+import :object;
+import :string;
+import :tuple;
+import :value;
+import py.memory;
+import std;
+
+export namespace py {
+class PyType;
+
+class ResourceWarning : public Warning
+{
+	friend class ::Heap;
+	friend class py::detail::Allocator;
+	friend BaseException *make_resource_warning(std::string &&);
+
+  protected:
+	ResourceWarning(PyType *type);
+
+	ResourceWarning(PyType *, PyTuple *args);
+
+  private:
+	static PyResult<ResourceWarning *> create(PyType *, PyTuple *args);
+
+  public:
+	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
+
+	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
+
+	PyType *static_type() const override;
+	static PyType *class_type();
+};
+
+// Defined in warnings/ResourceWarning.cpp. Keeping the PyString/PyTuple construction and the
+// heap allocation out of the interface means this partition no longer has
+// to materialise those types just to declare one exception class.
+BaseException *make_resource_warning(std::string &&message);
+
+template<typename... Args>
+inline BaseException *resource_warning(const std::string &message, Args &&...args)
+{
+	return make_resource_warning(std::vformat(message, std::make_format_args(args...)));
+}
+
+}// namespace py
diff --git a/src/runtime/warnings/ResourceWarning.hpp b/src/runtime/warnings/ResourceWarning.hpp
deleted file mode 100644
index 3051685c..00000000
--- a/src/runtime/warnings/ResourceWarning.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#pragma once
-
-#include "runtime/PyString.hpp"
-#include "runtime/PyTuple.hpp"
-#include "runtime/warnings/Warning.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
-
-class ResourceWarning : public Warning
-{
-	friend class ::Heap;
-	template<typename... Args>
-	friend BaseException *resource_warning(const std::string &message, Args &&...args);
-
-  protected:
-	ResourceWarning(PyType *type);
-
-	ResourceWarning(PyType *, PyTuple *args);
-
-  private:
-	static PyResult<ResourceWarning *> create(PyType *, PyTuple *args);
-
-  public:
-	static PyResult<PyObject *> __new__(const PyType *type, PyTuple *args, PyDict *kwargs);
-
-	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
-
-	PyType *static_type() const override;
-	static PyType *class_type();
-};
-
-template<typename... Args>
-inline BaseException *resource_warning(const std::string &message, Args &&...args)
-{
-	auto msg = PyString::create(fmt::format(message, std::forward<Args>(args)...));
-	ASSERT(msg.is_ok());
-	auto args_tuple = PyTuple::create(msg.unwrap());
-	ASSERT(args_tuple.is_ok());
-	return ResourceWarning::create(ResourceWarning::class_type(), args_tuple.unwrap()).unwrap();
-}
-
-}// namespace py
diff --git a/src/runtime/warnings/Warning.cpp b/src/runtime/warnings/Warning.cpp
index 9a4734f1..0d324532 100644
--- a/src/runtime/warnings/Warning.cpp
+++ b/src/runtime/warnings/Warning.cpp
@@ -1,7 +1,10 @@
-#include "Warning.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/types/api.hpp"
-#include "runtime/types/builtin.hpp"
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+module py.runtime;
+import py.types;
+
 
 namespace py {
 
diff --git a/src/runtime/warnings/Warning.hpp b/src/runtime/warnings/Warning.cppm
similarity index 68%
rename from src/runtime/warnings/Warning.hpp
rename to src/runtime/warnings/Warning.cppm
index ae5b29f0..48a7456e 100644
--- a/src/runtime/warnings/Warning.hpp
+++ b/src/runtime/warnings/Warning.cppm
@@ -1,15 +1,25 @@
-#pragma once
-
-#include "runtime/Exception.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/PyTuple.hpp"
-#include "vm/VM.hpp"
-
-namespace py {
+module;
+#include "core.hpp"
+#include "memory/allocate.hpp"
+
+export module py.runtime:warning;
+import :baseexception;
+import :dict;
+import :exception;
+import :object;
+import :string;
+import :tuple;
+import :value;
+import py.memory;
+import std;
+
+export namespace py {
+class PyType;
 
 class Warning : public Exception
 {
 	friend class ::Heap;
+	friend class py::detail::Allocator;
 	template<typename... Args>
 	friend BaseException *warning(const std::string &message, Args &&...args);
 
@@ -32,7 +42,7 @@ class Warning : public Exception
 
 template<typename... Args> inline BaseException *warning(const std::string &message, Args &&...args)
 {
-	auto msg = PyString::create(fmt::format(message, std::forward<Args>(args)...));
+	auto msg = PyString::create(std::vformat(message, std::make_format_args(args...)));
 	ASSERT(msg.is_ok());
 	auto args_tuple = PyTuple::create(msg.unwrap());
 	ASSERT(args_tuple.is_ok());
diff --git a/src/runtime/warnings/Warnings_tests.cpp b/src/runtime/warnings/Warnings_tests.cpp
new file mode 100644
index 00000000..c6b6b553
--- /dev/null
+++ b/src/runtime/warnings/Warnings_tests.cpp
@@ -0,0 +1,58 @@
+#include "gtest/gtest.h"
+
+import py.runtime;
+import py.types;
+
+using namespace py;
+
+// Each warning header declares make_<name>_warning out of line and calls it from an inline
+// <name>_warning wrapper. Referencing the wrappers here is what pins the out-of-line
+// definitions down: three of them were declared but never defined, which nothing caught
+// because no call site existed.
+
+namespace {
+void assert_warning(BaseException *exc, PyType *expected_type, std::string_view message)
+{
+	ASSERT_TRUE(exc);
+	EXPECT_EQ(exc->type(), expected_type);
+	auto str = exc->str();
+	ASSERT_TRUE(str.is_ok());
+	EXPECT_EQ(str.unwrap()->value(), message);
+}
+}// namespace
+
+TEST(Warnings, DeprecationWarning)
+{
+	[[maybe_unused]] auto scope = VirtualMachine::the().heap().scoped_gc_pause();
+	assert_warning(deprecation_warning("spam is deprecated"),
+		types::deprecation_warning(),
+		"spam is deprecated");
+}
+
+TEST(Warnings, PendingDeprecationWarning)
+{
+	[[maybe_unused]] auto scope = VirtualMachine::the().heap().scoped_gc_pause();
+	assert_warning(pending_deprecation_warning("spam will be deprecated"),
+		types::pending_deprecation_warning(),
+		"spam will be deprecated");
+}
+
+TEST(Warnings, ResourceWarning)
+{
+	[[maybe_unused]] auto scope = VirtualMachine::the().heap().scoped_gc_pause();
+	assert_warning(resource_warning("unclosed file"), types::resource_warning(), "unclosed file");
+}
+
+TEST(Warnings, ImportWarning)
+{
+	[[maybe_unused]] auto scope = VirtualMachine::the().heap().scoped_gc_pause();
+	assert_warning(import_warning("bad import"), types::import_warning(), "bad import");
+}
+
+TEST(Warnings, FormatsArguments)
+{
+	[[maybe_unused]] auto scope = VirtualMachine::the().heap().scoped_gc_pause();
+	assert_warning(deprecation_warning("{} is deprecated, use {}", "spam", "eggs"),
+		types::deprecation_warning(),
+		"spam is deprecated, use eggs");
+}
diff --git a/src/testing/main.cpp b/src/testing/main.cpp
index 4574d47d..e6b4b4cc 100644
--- a/src/testing/main.cpp
+++ b/src/testing/main.cpp
@@ -1,9 +1,8 @@
-#include "interpreter/Interpreter.hpp"
-#include "vm/VM.hpp"
-
 #include "gtest/gtest.h"
-
 #include <cxxopts.hpp>
+#include <spdlog/spdlog.h>
+
+import py.runtime;
 
 #if defined(__SANITIZE_ADDRESS__)
 #define PYTHON_ASAN_ENABLED
@@ -32,7 +31,7 @@ class PythonVMEnvironment : public ::testing::Environment
 	void SetUp() override
 	{
 		auto &vm = VirtualMachine::the();
-		vm.heap().set_start_stack_pointer(bit_cast<uintptr_t *>(m_argv));
+		vm.heap().set_start_stack_pointer(std::bit_cast<uintptr_t *>(m_argv));
 		initialize_types();
 	}
 
diff --git a/src/utilities.hpp b/src/utilities.hpp
index 060f14cb..33d06960 100644
--- a/src/utilities.hpp
+++ b/src/utilities.hpp
@@ -1,48 +1,15 @@
 #pragma once
 
-#include "spdlog/spdlog.h"
-#include <bit>
-
-#define TODO()                                                      \
-	do {                                                            \
-		spdlog::error("Not implemented {}:{}", __FILE__, __LINE__); \
-		std::abort();                                               \
-	} while (0)
-
-#define ASSERT(condition)                                                               \
-	do {                                                                                \
-		if (!(condition)) {                                                             \
-			spdlog::error("Assertion failed {} {}:{}", #condition, __FILE__, __LINE__); \
-			std::abort();                                                               \
-		}                                                                               \
-	} while (0)
-
-#define ASSERT_NOT_REACHED()                                                \
-	do {                                                                    \
-		spdlog::error("Reached unexpected line {}:{}", __FILE__, __LINE__); \
-		__builtin_unreachable();                                            \
-		std::abort();                                                       \
-	} while (0)
-template<class... Ts> struct overloaded : Ts...
-{
-	using Ts::operator()...;
-};
-// explicit deduction guide (not needed as of C++20)
-template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
+// TODO/ASSERT/ASSERT_NOT_REACHED and NonCopyable/NonMoveable live in core.hpp,
+// which pulls in no libstdc++ and is therefore safe inside a module's global
+// module fragment. This header keeps the pieces that genuinely need spdlog.
 
-struct NonCopyable
-{
-	NonCopyable() = default;
-	NonCopyable(const NonCopyable &) = delete;
-	NonCopyable &operator=(const NonCopyable &) = delete;
-};
+#include "core.hpp"
 
-struct NonMoveable
-{
-	NonMoveable() = default;
-	NonMoveable(NonMoveable &&) = delete;
-	NonMoveable &operator=(NonMoveable &&) = delete;
-};
+#include "spdlog/spdlog.h"
+#include <bit>
+#include <cstring>
+#include <type_traits>
 
 
 namespace detail {
@@ -109,4 +76,4 @@ template<Integral Target, Integral Source> bool fits_in(Source value)
 		return value >= std::numeric_limits<Target>::min()
 			   && value <= std::numeric_limits<Target>::max();
 	}
-}
\ No newline at end of file
+}
diff --git a/src/utilities/freeze.cpp b/src/utilities/freeze.cpp
index d41fe25f..e2e0511d 100644
--- a/src/utilities/freeze.cpp
+++ b/src/utilities/freeze.cpp
@@ -1,21 +1,15 @@
-#include "ast/optimizers/ConstantFolding.hpp"
-#include "executable/Program.hpp"
-#include "executable/bytecode/Bytecode.hpp"
-#include "executable/bytecode/BytecodeProgram.hpp"
-#include "executable/bytecode/codegen/BytecodeGenerator.hpp"
-#include "executable/mlir/Conversion/Passes.hpp"
-#include "executable/mlir/Conversion/PythonToPythonBytecode/PythonToPythonBytecode.hpp"
-#include "executable/mlir/Dialect/Python/MLIRGenerator.hpp"
-#include "executable/mlir/Target/PythonBytecode/PythonBytecodeEmitter.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "parser/Parser.hpp"
-#include "runtime/types/builtin.hpp"
-#include "vm/VM.hpp"
+#include "core.hpp"
+#include "executable/common.hpp"
+#include <spdlog/spdlog.h>
+
 
 #include <cxxopts.hpp>
 
-#include <filesystem>
-#include <fstream>
+import py.ast;
+import py.lexer;
+import py.runtime;
+import py.codegen;
+import std;
 
 using namespace py;
 
diff --git a/src/vm/VM.cpp b/src/vm/VM.cpp
index 4ed9ca5a..5a94bada 100644
--- a/src/vm/VM.cpp
+++ b/src/vm/VM.cpp
@@ -1,20 +1,13 @@
-#include "VM.hpp"
-#include "executable/Program.hpp"
-#include "executable/bytecode/Bytecode.hpp"
-#include "executable/bytecode/BytecodeProgram.hpp"
-#include "executable/bytecode/instructions/Instructions.hpp"
-#include "interpreter/Interpreter.hpp"
-#include "interpreter/InterpreterSession.hpp"
-#include "runtime/BaseException.hpp"
-#include "runtime/PyFrame.hpp"
-#include "runtime/PyObject.hpp"
-#include "runtime/PyString.hpp"
-#include "runtime/PyTraceback.hpp"
-#include "utilities.hpp"
+module;
+
+#include "core.hpp"
+
 #include <cstddef>
-#include <iterator>
 #include <spdlog/spdlog.h>
 
+module py.runtime;
+import std;
+
 using namespace py;
 
 
@@ -184,21 +177,21 @@ void VirtualMachine::dump() const
 		std::visit(overloaded{ [](const auto &stack_value) {
 								  std::ostringstream os;
 								  os << stack_value;
-								  std::cout << fmt::format("@{}:  {}\n",
+								  std::cout << std::format("@{}:  {}\n",
 									  static_cast<const void *>(&stack_value),
 									  os.str());
 							  },
 					   [](const PyObject *&obj) {
 						   if (obj) {
-							   //    std::cout << fmt::format("[{}]  {} ({})\n",
+							   //    std::cout << std::format("[{}]  {} ({})\n",
 							   // 	   i++,
 							   // 	   static_cast<const void *>(obj),
 							   // 	   obj->to_string());
-							   std::cout << fmt::format("@{}:  {}\n",
+							   std::cout << std::format("@{}:  {}\n",
 								   static_cast<const void *>(&obj),
 								   static_cast<const void *>(obj));
 						   } else {
-							   std::cout << fmt::format(
+							   std::cout << std::format(
 								   "@{}:  (Empty)\n", static_cast<const void *>(&obj));
 						   }
 					   } },
@@ -211,14 +204,14 @@ void VirtualMachine::dump() const
 			overloaded{ [&i](const auto &register_value) {
 						   std::ostringstream os;
 						   os << register_value;
-						   std::cout << fmt::format("[{}]  {}\n", i, os.str());
+						   std::cout << std::format("[{}]  {}\n", i, os.str());
 					   },
 				[&i](PyObject *obj) {
 					if (obj) {
-						std::cout << fmt::format(
+						std::cout << std::format(
 							"[{}]  {} ({})\n", i, static_cast<const void *>(obj), obj->to_string());
 					} else {
-						std::cout << fmt::format("[{}]  (Empty)\n", i);
+						std::cout << std::format("[{}]  (Empty)\n", i);
 					}
 				} },
 			register_);
diff --git a/src/vm/VM.hpp b/src/vm/VM.cppm
similarity index 85%
rename from src/vm/VM.hpp
rename to src/vm/VM.cppm
index de242461..8e6c1823 100644
--- a/src/vm/VM.hpp
+++ b/src/vm/VM.cppm
@@ -1,22 +1,19 @@
-#pragma once
+module;
 
-#include "executable/FunctionBlock.hpp"
-#include "forward.hpp"
-#include "memory/Heap.hpp"
-#include "runtime/Value.hpp"
-#include "utilities.hpp"
+#include "core.hpp"
 
-#include <deque>
-#include <functional>
-#include <span>
-#include <stack>
-#include <vector>
+export module py.runtime:vm;
+import :value;
+import :executable_program;
+import :executable_functionblock;
+import std;
 
-class VirtualMachine;
+export class Interpreter;
+export class VirtualMachine;
 
-using Registers = std::vector<py::Value>;
+export using Registers = std::vector<py::Value>;
 
-struct State
+export struct State
 {
 	enum class CleanupLogic {
 		CATCH_EXCEPTION,
@@ -27,14 +24,14 @@ struct State
 	};
 };
 
-struct StackFrame : NonCopyable
+export struct StackFrame : NonCopyable
 {
   private:
 	StackFrame() = default;
 
-	StackFrame(size_t register_count,
-		size_t locals_count,
-		size_t stack_size,
+	StackFrame(std::size_t register_count,
+		std::size_t locals_count,
+		std::size_t stack_size,
 		std::optional<InstructionVector::const_iterator> return_address,
 		VirtualMachine *);
 
@@ -57,7 +54,7 @@ struct StackFrame : NonCopyable
 	InstructionVector::const_iterator last_instruction_pointer;
 	std::vector<py::Value>::const_iterator base_pointer;
 	std::vector<py::Value>::iterator stack_pointer;
-	size_t locals_count{ 0 };
+	std::size_t locals_count{ 0 };
 	VirtualMachine *vm{ nullptr };
 	std::unique_ptr<State> state;
 
@@ -69,7 +66,7 @@ struct StackFrame : NonCopyable
 	void leave();
 };
 
-class VirtualMachine
+export class VirtualMachine
 	: NonCopyable
 	, NonMoveable
 {
@@ -79,7 +76,7 @@ class VirtualMachine
 	// dangle every existing frame's locals span and the m_stack_pointer
 	// iterator. If the stack ever needs to grow, switch StackFrame::locals
 	// to an (offset, size) pair against m_stack first.
-	static constexpr size_t kStackSize = 10'000;
+	static constexpr std::size_t kStackSize = 10'000;
 	std::vector<py::Value> m_stack;
 	// m_stack_frames is a vector rather than a stack so callers can iterate
 	// over the frame chain (used by VirtualMachine::dump and the GC root
@@ -105,7 +102,7 @@ class VirtualMachine
 		return *vm;
 	}
 
-	py::Value &reg(size_t idx)
+	py::Value &reg(std::size_t idx)
 	{
 		auto r = registers();
 		ASSERT(r.has_value());
@@ -113,7 +110,7 @@ class VirtualMachine
 		return r->get()[idx];
 	}
 
-	const py::Value &reg(size_t idx) const
+	const py::Value &reg(std::size_t idx) const
 	{
 		auto r = registers();
 		ASSERT(r.has_value());
@@ -121,7 +118,7 @@ class VirtualMachine
 		return r->get()[idx];
 	}
 
-	py::Value &stack_local(size_t idx)
+	py::Value &stack_local(std::size_t idx)
 	{
 		auto local = stack_locals();
 		ASSERT(!local.empty());
@@ -129,7 +126,7 @@ class VirtualMachine
 		return local[idx];
 	}
 
-	const py::Value &stack_local(size_t idx) const
+	const py::Value &stack_local(std::size_t idx) const
 	{
 		auto local = stack_locals();
 		ASSERT(!local.empty());
@@ -189,8 +186,9 @@ class VirtualMachine
 
 	void dump() const;
 
-	[[nodiscard]] std::unique_ptr<StackFrame>
-		setup_call_stack(size_t register_count, size_t locals_count, size_t stack_size);
+	[[nodiscard]] std::unique_ptr<StackFrame> setup_call_stack(std::size_t register_count,
+		std::size_t locals_count,
+		std::size_t stack_size);
 
 	void ret();
 	void set_cleanup(State::CleanupLogic cleanup_type,
@@ -198,7 +196,7 @@ class VirtualMachine
 	void leave_cleanup_handling();
 
 	[[nodiscard]] std::unique_ptr<StackFrame>
-		push_frame(size_t register_count, size_t locals_count, size_t stack_size);
+		push_frame(std::size_t register_count, std::size_t locals_count, std::size_t stack_size);
 	void push_frame(StackFrame &frame);
 
 	void pop_frame(bool should_return_value);