diff --git a/.github/workflows/run-tests.yml b/.github/workflows/run-tests.yml
index 83154bbbd2b..5bb3aaee736 100644
--- a/.github/workflows/run-tests.yml
+++ b/.github/workflows/run-tests.yml
@@ -53,19 +53,18 @@ jobs:
         run: ./run-tests.py -j4 --print-failures
         if: failure()
         working-directory: tests
-    # Not working after MicroPython v1.23 merge.
-    # - name: Build native modules
-    #   if: matrix.test == 'all'
-    #   run: |
-    #     make -C examples/natmod/features1
-    #     make -C examples/natmod/features2
-    #     make -C examples/natmod/heapq
-    #     make -C examples/natmod/random
-    #     make -C examples/natmod/re
-    # - name: Test native modules
-    #   if: matrix.test == 'all'
-    #   run: ./run-natmodtests.py extmod/{heapq*,random*,re*}.py
-    #   working-directory: tests
+      - name: Build native modules
+        if: matrix.test == 'all'
+        run: |
+          make -C examples/natmod/features1
+          make -C examples/natmod/features2
+          make -C examples/natmod/heapq
+          make -C examples/natmod/random
+          make -C examples/natmod/re
+      - name: Test native modules
+        if: matrix.test == 'all'
+        run: ./run-natmodtests.py extmod/{heapq*,random*,re*}.py
+        working-directory: tests
 
   zephyr:
     runs-on: ubuntu-24.04
diff --git a/examples/natmod/.gitignore b/examples/natmod/.gitignore
new file mode 100644
index 00000000000..4815d20f06b
--- /dev/null
+++ b/examples/natmod/.gitignore
@@ -0,0 +1 @@
+*.mpy
diff --git a/examples/natmod/README.md b/examples/natmod/README.md
new file mode 100644
index 00000000000..ca6b887d034
--- /dev/null
+++ b/examples/natmod/README.md
@@ -0,0 +1,74 @@
+# Dynamic Native Modules
+
+Dynamic Native Modules are .mpy files that contain native machine code from a
+language other than Python. For more info see [the
+documentation](https://docs.micropython.org/en/latest/develop/natmod.html).
+
+This should not be confused with [User C
+Modules](https://docs.micropython.org/en/latest/develop/cmodules.html) which are
+a mechanism to add additional out-of-tree modules into the firmware build.
+
+## Examples
+
+This directory contains several examples of writing dynamic native modules, in
+two main categories:
+
+1.  Feature examples.
+
+    * `features0` - A module containing a single "factorial" function which
+      demonstrates working with integers.
+
+    * `features1` - A module that demonstrates some common tasks:
+        - defining simple functions exposed to Python
+        - defining local, helper C functions
+        - defining constant integers and strings exposed to Python
+        - getting and creating integer objects
+        - creating Python lists
+        - raising exceptions
+        - allocating memory
+        - BSS and constant data (rodata)
+        - relocated pointers in rodata
+
+    * `features2` - This is a hybrid module containing both Python and C code,
+      and additionally the C code is spread over multiple files. It also
+      demonstrates using floating point (only when the target supports
+      hardware floating point).
+
+    * `features3` - A module that shows how to use types, constant objects,
+      and creating dictionary instances.
+
+    * `features4` - A module that demonstrates how to define a class.
+
+2.  Dynamic version of existing built-ins.
+
+    This provides a way to add missing functionality to firmware that doesn't
+    include certain built-in modules. See the `heapq`, `random`, `re`,
+    `deflate`, `btree`, and `framebuf` directories.
+
+    So for example, if your firmware was compiled with `MICROPY_PY_FRAMEBUF`
+    disabled (e.g. to save flash space), then it would not include the
+    `framebuf` module. The `framebuf` native module provides a way to add the
+    `framebuf` module dynamically.
+
+    The way these work is they define a dynamic native module which
+    `#include`'s the original module and then does the necessary
+    initialisation of the module's globals dict.
+
+## Build instructions
+
+To compile an example, you need to have the same toolchain available as
+required for your target port. e.g. `arm-none-eabi-gcc` for any ARM Cortex M
+target. See the port instructions for details.
+
+You also need to have the `pyelftools` Python package available, either via
+your system package manager or installed from PyPI in a virtual environment
+with `pip`.
+
+Each example provides a Makefile. You should specify the `ARCH` argument to
+make (one of x86, x64, armv6m, armv7m, xtensa, xtensawin, rv32imc):
+
+```
+$ cd features0
+$ make ARCH=armv7m
+$ mpremote cp features0.mpy :
+```
diff --git a/examples/natmod/btree/Makefile b/examples/natmod/btree/Makefile
new file mode 100644
index 00000000000..ff130d61b37
--- /dev/null
+++ b/examples/natmod/btree/Makefile
@@ -0,0 +1,38 @@
+# Location of top-level MicroPython directory
+MPY_DIR = ../../..
+
+# Name of module (different to built-in btree so it can coexist)
+MOD = btree_$(ARCH)
+
+# Source files (.c or .py)
+SRC = btree_c.c
+
+# Architecture to build for (x86, x64, armv7m, xtensa, xtensawin, rv32imc)
+ARCH = x64
+
+BTREE_DIR = $(MPY_DIR)/lib/berkeley-db-1.xx
+BERKELEY_DB_CONFIG_FILE ?= \"extmod/berkeley-db/berkeley_db_config_port.h\"
+CFLAGS += -I$(BTREE_DIR)/include
+CFLAGS += -DBERKELEY_DB_CONFIG_FILE=$(BERKELEY_DB_CONFIG_FILE)
+CFLAGS += -Wno-old-style-definition -Wno-sign-compare -Wno-unused-parameter
+
+SRC += $(addprefix $(realpath $(BTREE_DIR))/,\
+	btree/bt_close.c \
+	btree/bt_conv.c \
+	btree/bt_delete.c \
+	btree/bt_get.c \
+	btree/bt_open.c \
+	btree/bt_overflow.c \
+	btree/bt_page.c \
+	btree/bt_put.c \
+	btree/bt_search.c \
+	btree/bt_seq.c \
+	btree/bt_split.c \
+	btree/bt_utils.c \
+	mpool/mpool.c \
+	)
+
+include $(MPY_DIR)/py/dynruntime.mk
+
+# btree needs gnu99 defined
+CFLAGS += -std=gnu99
diff --git a/examples/natmod/btree/btree_c.c b/examples/natmod/btree/btree_c.c
new file mode 100644
index 00000000000..4f494817e7b
--- /dev/null
+++ b/examples/natmod/btree/btree_c.c
@@ -0,0 +1,171 @@
+#define MICROPY_PY_BTREE (1)
+
+#include "py/dynruntime.h"
+
+#include <unistd.h>
+
+#if !defined(__linux__)
+void *memcpy(void *dst, const void *src, size_t n) {
+    return mp_fun_table.memmove_(dst, src, n);
+}
+void *memset(void *s, int c, size_t n) {
+    return mp_fun_table.memset_(s, c, n);
+}
+#endif
+
+void *memmove(void *dest, const void *src, size_t n) {
+    return mp_fun_table.memmove_(dest, src, n);
+}
+
+void *malloc(size_t n) {
+    void *ptr = m_malloc(n);
+    return ptr;
+}
+void *realloc(void *ptr, size_t n) {
+    mp_printf(&mp_plat_print, "UNDEF %d\n", __LINE__);
+    return NULL;
+}
+void *calloc(size_t n, size_t m) {
+    void *ptr = m_malloc(n * m);
+    // memory already cleared by conservative GC
+    return ptr;
+}
+
+void free(void *ptr) {
+    m_free(ptr);
+}
+
+void abort_(void) {
+    nlr_raise(mp_obj_new_exception(mp_load_global(MP_QSTR_RuntimeError)));
+}
+
+int puts(const char *s) {
+    return mp_printf(&mp_plat_print, "%s\n", s);
+}
+
+int native_errno;
+#if defined(__linux__)
+int *__errno_location (void)
+#else
+int *__errno (void)
+#endif
+{
+    return &native_errno;
+}
+
+ssize_t mp_stream_posix_write(void *stream, const void *buf, size_t len) {
+    mp_obj_base_t* o = stream;
+    const mp_stream_p_t *stream_p = MP_OBJ_TYPE_GET_SLOT(o->type, protocol);
+    mp_uint_t out_sz = stream_p->write(MP_OBJ_FROM_PTR(stream), buf, len, &native_errno);
+    if (out_sz == MP_STREAM_ERROR) {
+        return -1;
+    } else {
+        return out_sz;
+    }
+}
+
+ssize_t mp_stream_posix_read(void *stream, void *buf, size_t len) {
+    mp_obj_base_t* o = stream;
+    const mp_stream_p_t *stream_p = MP_OBJ_TYPE_GET_SLOT(o->type, protocol);
+    mp_uint_t out_sz = stream_p->read(MP_OBJ_FROM_PTR(stream), buf, len, &native_errno);
+    if (out_sz == MP_STREAM_ERROR) {
+        return -1;
+    } else {
+        return out_sz;
+    }
+}
+
+off_t mp_stream_posix_lseek(void *stream, off_t offset, int whence) {
+    const mp_obj_base_t* o = stream;
+    const mp_stream_p_t *stream_p = MP_OBJ_TYPE_GET_SLOT(o->type, protocol);
+    struct mp_stream_seek_t seek_s;
+    seek_s.offset = offset;
+    seek_s.whence = whence;
+    mp_uint_t res = stream_p->ioctl(MP_OBJ_FROM_PTR(stream), MP_STREAM_SEEK, (mp_uint_t)(uintptr_t)&seek_s, &native_errno);
+    if (res == MP_STREAM_ERROR) {
+        return -1;
+    }
+    return seek_s.offset;
+}
+
+int mp_stream_posix_fsync(void *stream) {
+    mp_obj_base_t* o = stream;
+    const mp_stream_p_t *stream_p = MP_OBJ_TYPE_GET_SLOT(o->type, protocol);
+    mp_uint_t res = stream_p->ioctl(MP_OBJ_FROM_PTR(stream), MP_STREAM_FLUSH, 0, &native_errno);
+    if (res == MP_STREAM_ERROR) {
+        return -1;
+    }
+    return res;
+}
+
+mp_obj_full_type_t btree_type;
+mp_getiter_iternext_custom_t btree_getiter_iternext;
+
+#include "extmod/modbtree.c"
+
+mp_map_elem_t btree_locals_dict_table[8];
+static MP_DEFINE_CONST_DICT(btree_locals_dict, btree_locals_dict_table);
+
+static mp_obj_t btree_open(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    // The allowed_args array must have its qstr's populated at runtime.
+    enum { ARG_flags, ARG_cachesize, ARG_pagesize, ARG_minkeypage };
+    mp_arg_t allowed_args[] = {
+        { MP_QSTR_, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
+    };
+    allowed_args[0].qst = MP_QSTR_flags;
+    allowed_args[1].qst = MP_QSTR_cachesize;
+    allowed_args[2].qst = MP_QSTR_pagesize;
+    allowed_args[3].qst = MP_QSTR_minkeypage;
+
+    // Make sure we got a stream object
+    mp_get_stream_raise(pos_args[0], MP_STREAM_OP_READ | MP_STREAM_OP_WRITE | MP_STREAM_OP_IOCTL);
+
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    BTREEINFO openinfo = {0};
+    openinfo.flags = args[ARG_flags].u_int;
+    openinfo.cachesize = args[ARG_cachesize].u_int;
+    openinfo.psize = args[ARG_pagesize].u_int;
+    openinfo.minkeypage = args[ARG_minkeypage].u_int;
+    DB *db = __bt_open(MP_OBJ_TO_PTR(pos_args[0]), &btree_stream_fvtable, &openinfo, 0);
+    if (db == NULL) {
+        mp_raise_OSError(native_errno);
+    }
+
+    return MP_OBJ_FROM_PTR(btree_new(db, pos_args[0]));
+}
+static MP_DEFINE_CONST_FUN_OBJ_KW(btree_open_obj, 1, btree_open);
+
+mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    MP_DYNRUNTIME_INIT_ENTRY
+
+    btree_getiter_iternext.getiter = btree_getiter;
+    btree_getiter_iternext.iternext = btree_iternext;
+
+    btree_type.base.type = (void*)&mp_fun_table.type_type;
+    btree_type.flags = MP_TYPE_FLAG_ITER_IS_CUSTOM;
+    btree_type.name = MP_QSTR_btree;
+    MP_OBJ_TYPE_SET_SLOT(&btree_type, print, btree_print, 0);
+    MP_OBJ_TYPE_SET_SLOT(&btree_type, iter, &btree_getiter_iternext, 1);
+    MP_OBJ_TYPE_SET_SLOT(&btree_type, binary_op, btree_binary_op, 2);
+    MP_OBJ_TYPE_SET_SLOT(&btree_type, subscr, btree_subscr, 3);
+    btree_locals_dict_table[0] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_close), MP_OBJ_FROM_PTR(&btree_close_obj) };
+    btree_locals_dict_table[1] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_flush), MP_OBJ_FROM_PTR(&btree_flush_obj) };
+    btree_locals_dict_table[2] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_get), MP_OBJ_FROM_PTR(&btree_get_obj) };
+    btree_locals_dict_table[3] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_put), MP_OBJ_FROM_PTR(&btree_put_obj) };
+    btree_locals_dict_table[4] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_seq), MP_OBJ_FROM_PTR(&btree_seq_obj) };
+    btree_locals_dict_table[5] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_keys), MP_OBJ_FROM_PTR(&btree_keys_obj) };
+    btree_locals_dict_table[6] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_values), MP_OBJ_FROM_PTR(&btree_values_obj) };
+    btree_locals_dict_table[7] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_items), MP_OBJ_FROM_PTR(&btree_items_obj) };
+    MP_OBJ_TYPE_SET_SLOT(&btree_type, locals_dict, (void*)&btree_locals_dict, 4);
+
+    mp_store_global(MP_QSTR_open, MP_OBJ_FROM_PTR(&btree_open_obj));
+    mp_store_global(MP_QSTR_INCL, MP_OBJ_NEW_SMALL_INT(FLAG_END_KEY_INCL));
+    mp_store_global(MP_QSTR_DESC, MP_OBJ_NEW_SMALL_INT(FLAG_DESC));
+
+    MP_DYNRUNTIME_INIT_EXIT
+}
diff --git a/examples/natmod/deflate/Makefile b/examples/natmod/deflate/Makefile
new file mode 100644
index 00000000000..504130d5723
--- /dev/null
+++ b/examples/natmod/deflate/Makefile
@@ -0,0 +1,13 @@
+# Location of top-level MicroPython directory
+MPY_DIR = ../../..
+
+# Name of module (different to built-in uzlib so it can coexist)
+MOD = deflate_$(ARCH)
+
+# Source files (.c or .py)
+SRC = deflate.c
+
+# Architecture to build for (x86, x64, armv7m, xtensa, xtensawin, rv32imc)
+ARCH = x64
+
+include $(MPY_DIR)/py/dynruntime.mk
diff --git a/examples/natmod/deflate/deflate.c b/examples/natmod/deflate/deflate.c
new file mode 100644
index 00000000000..9de7e101a76
--- /dev/null
+++ b/examples/natmod/deflate/deflate.c
@@ -0,0 +1,70 @@
+#define MICROPY_PY_DEFLATE (1)
+#define MICROPY_PY_DEFLATE_COMPRESS (1)
+
+#include "py/dynruntime.h"
+
+#if !defined(__linux__)
+void *memcpy(void *dst, const void *src, size_t n) {
+    return mp_fun_table.memmove_(dst, src, n);
+}
+void *memset(void *s, int c, size_t n) {
+    return mp_fun_table.memset_(s, c, n);
+}
+#endif
+
+mp_obj_full_type_t deflateio_type;
+
+#include "extmod/moddeflate.c"
+
+// Re-implemented from py/stream.c, not yet available in dynruntime.h.
+mp_obj_t mp_stream_close(mp_obj_t stream) {
+    const mp_stream_p_t *stream_p = mp_get_stream(stream);
+    int error;
+    mp_uint_t res = stream_p->ioctl(stream, MP_STREAM_CLOSE, 0, &error);
+    if (res == MP_STREAM_ERROR) {
+        mp_raise_OSError(error);
+    }
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_1(mp_stream_close_obj, mp_stream_close);
+
+// Re-implemented from py/stream.c, not yet available in dynruntime.h.
+static mp_obj_t mp_stream___exit__(size_t n_args, const mp_obj_t *args) {
+    (void)n_args;
+    return mp_stream_close(args[0]);
+}
+MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream___exit___obj, 4, 4, mp_stream___exit__);
+
+// Re-implemented from obj.c, not yet available in dynruntime.h.
+mp_obj_t mp_identity(mp_obj_t self) {
+    return self;
+}
+MP_DEFINE_CONST_FUN_OBJ_1(mp_identity_obj, mp_identity);
+
+mp_map_elem_t deflateio_locals_dict_table[7];
+static MP_DEFINE_CONST_DICT(deflateio_locals_dict, deflateio_locals_dict_table);
+
+mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    MP_DYNRUNTIME_INIT_ENTRY
+
+    deflateio_type.base.type = mp_fun_table.type_type;
+    deflateio_type.name = MP_QSTR_DeflateIO;
+    MP_OBJ_TYPE_SET_SLOT(&deflateio_type, make_new, &deflateio_make_new, 0);
+    MP_OBJ_TYPE_SET_SLOT(&deflateio_type, protocol, &deflateio_stream_p, 1);
+    deflateio_locals_dict_table[0] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_read), MP_OBJ_FROM_PTR(&mp_stream_read_obj) };
+    deflateio_locals_dict_table[1] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_readinto), MP_OBJ_FROM_PTR(&mp_stream_readinto_obj) };
+    deflateio_locals_dict_table[2] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_readline), MP_OBJ_FROM_PTR(&mp_stream_unbuffered_readline_obj) };
+    deflateio_locals_dict_table[3] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_write), MP_OBJ_FROM_PTR(&mp_stream_write_obj) };
+    deflateio_locals_dict_table[4] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_close), MP_OBJ_FROM_PTR(&mp_stream_close_obj) };
+    deflateio_locals_dict_table[5] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR___enter__), MP_OBJ_FROM_PTR(&mp_identity_obj) };
+    deflateio_locals_dict_table[6] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR___exit__), MP_OBJ_FROM_PTR(&mp_stream___exit___obj) };
+    MP_OBJ_TYPE_SET_SLOT(&deflateio_type, locals_dict, (void*)&deflateio_locals_dict, 2);
+
+    mp_store_global(MP_QSTR___name__, MP_OBJ_NEW_QSTR(MP_QSTR_deflate));
+    mp_store_global(MP_QSTR_DeflateIO, MP_OBJ_FROM_PTR(&deflateio_type));
+    mp_store_global(MP_QSTR_RAW, MP_OBJ_NEW_SMALL_INT(DEFLATEIO_FORMAT_RAW));
+    mp_store_global(MP_QSTR_ZLIB, MP_OBJ_NEW_SMALL_INT(DEFLATEIO_FORMAT_ZLIB));
+    mp_store_global(MP_QSTR_GZIP, MP_OBJ_NEW_SMALL_INT(DEFLATEIO_FORMAT_GZIP));
+
+    MP_DYNRUNTIME_INIT_EXIT
+}
diff --git a/examples/natmod/features0/Makefile b/examples/natmod/features0/Makefile
new file mode 100644
index 00000000000..9bc4bbf23b8
--- /dev/null
+++ b/examples/natmod/features0/Makefile
@@ -0,0 +1,14 @@
+# Location of top-level MicroPython directory
+MPY_DIR = ../../..
+
+# Name of module
+MOD = features0
+
+# Source files (.c or .py)
+SRC = features0.c
+
+# Architecture to build for (x86, x64, armv7m, xtensa, xtensawin, rv32imc)
+ARCH = x64
+
+# Include to get the rules for compiling and linking the module
+include $(MPY_DIR)/py/dynruntime.mk
diff --git a/examples/natmod/features0/features0.c b/examples/natmod/features0/features0.c
new file mode 100644
index 00000000000..c3d31afb79c
--- /dev/null
+++ b/examples/natmod/features0/features0.c
@@ -0,0 +1,40 @@
+/* This example demonstrates the following features in a native module:
+    - defining a simple function exposed to Python
+    - defining a local, helper C function
+    - getting and creating integer objects
+*/
+
+// Include the header file to get access to the MicroPython API
+#include "py/dynruntime.h"
+
+// Helper function to compute factorial
+static mp_int_t factorial_helper(mp_int_t x) {
+    if (x == 0) {
+        return 1;
+    }
+    return x * factorial_helper(x - 1);
+}
+
+// This is the function which will be called from Python, as factorial(x)
+static mp_obj_t factorial(mp_obj_t x_obj) {
+    // Extract the integer from the MicroPython input object
+    mp_int_t x = mp_obj_get_int(x_obj);
+    // Calculate the factorial
+    mp_int_t result = factorial_helper(x);
+    // Convert the result to a MicroPython integer object and return it
+    return mp_obj_new_int(result);
+}
+// Define a Python reference to the function above
+static MP_DEFINE_CONST_FUN_OBJ_1(factorial_obj, factorial);
+
+// This is the entry point and is called when the module is imported
+mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    // This must be first, it sets up the globals dict and other things
+    MP_DYNRUNTIME_INIT_ENTRY
+
+    // Make the function available in the module's namespace
+    mp_store_global(MP_QSTR_factorial, MP_OBJ_FROM_PTR(&factorial_obj));
+
+    // This must be last, it restores the globals dict
+    MP_DYNRUNTIME_INIT_EXIT
+}
diff --git a/examples/natmod/features1/Makefile b/examples/natmod/features1/Makefile
new file mode 100644
index 00000000000..49040511020
--- /dev/null
+++ b/examples/natmod/features1/Makefile
@@ -0,0 +1,14 @@
+# Location of top-level MicroPython directory
+MPY_DIR = ../../..
+
+# Name of module
+MOD = features1
+
+# Source files (.c or .py)
+SRC = features1.c
+
+# Architecture to build for (x86, x64, armv7m, xtensa, xtensawin, rv32imc)
+ARCH = x64
+
+# Include to get the rules for compiling and linking the module
+include $(MPY_DIR)/py/dynruntime.mk
diff --git a/examples/natmod/features1/features1.c b/examples/natmod/features1/features1.c
new file mode 100644
index 00000000000..92b96dbb183
--- /dev/null
+++ b/examples/natmod/features1/features1.c
@@ -0,0 +1,106 @@
+/* This example demonstrates the following features in a native module:
+    - defining simple functions exposed to Python
+    - defining local, helper C functions
+    - defining constant integers and strings exposed to Python
+    - getting and creating integer objects
+    - creating Python lists
+    - raising exceptions
+    - allocating memory
+    - BSS and constant data (rodata)
+    - relocated pointers in rodata
+*/
+
+// Include the header file to get access to the MicroPython API
+#include "py/dynruntime.h"
+
+// BSS (zero) data
+uint16_t data16[4];
+
+// Constant data (rodata)
+const uint8_t table8[] = { 0, 1, 1, 2, 3, 5, 8, 13 };
+const uint16_t table16[] = { 0x1000, 0x2000 };
+
+// Constant data pointing to BSS/constant data
+uint16_t *const table_ptr16a[] = { &data16[0], &data16[1], &data16[2], &data16[3] };
+const uint16_t *const table_ptr16b[] = { &table16[0], &table16[1] };
+
+// A simple function that adds its 2 arguments (must be integers)
+static mp_obj_t add(mp_obj_t x_in, mp_obj_t y_in) {
+    mp_int_t x = mp_obj_get_int(x_in);
+    mp_int_t y = mp_obj_get_int(y_in);
+    return mp_obj_new_int(x + y);
+}
+static MP_DEFINE_CONST_FUN_OBJ_2(add_obj, add);
+
+// A local helper function (not exposed to Python)
+static mp_int_t fibonacci_helper(mp_int_t x) {
+    if (x < MP_ARRAY_SIZE(table8)) {
+        return table8[x];
+    } else {
+        return fibonacci_helper(x - 1) + fibonacci_helper(x - 2);
+    }
+}
+
+// A function which computes Fibonacci numbers
+static mp_obj_t fibonacci(mp_obj_t x_in) {
+    mp_int_t x = mp_obj_get_int(x_in);
+    if (x < 0) {
+        mp_raise_ValueError(MP_ERROR_TEXT("can't compute negative Fibonacci number"));
+    }
+    return mp_obj_new_int(fibonacci_helper(x));
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(fibonacci_obj, fibonacci);
+
+// A function that accesses the BSS data
+static mp_obj_t access(size_t n_args, const mp_obj_t *args) {
+    if (n_args == 0) {
+        // Create a list holding all items from data16
+        mp_obj_list_t *lst = MP_OBJ_TO_PTR(mp_obj_new_list(MP_ARRAY_SIZE(data16), NULL));
+        for (int i = 0; i < MP_ARRAY_SIZE(data16); ++i) {
+            lst->items[i] = mp_obj_new_int(data16[i]);
+        }
+        return MP_OBJ_FROM_PTR(lst);
+    } else if (n_args == 1) {
+        // Get one item from data16
+        mp_int_t idx = mp_obj_get_int(args[0]) & 3;
+        return mp_obj_new_int(data16[idx]);
+    } else {
+        // Set one item in data16 (via table_ptr16a)
+        mp_int_t idx = mp_obj_get_int(args[0]) & 3;
+        *table_ptr16a[idx] = mp_obj_get_int(args[1]);
+        return mp_const_none;
+    }
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(access_obj, 0, 2, access);
+
+// A function that allocates memory and creates a bytearray
+static mp_obj_t make_array(void) {
+    uint16_t *ptr = m_new(uint16_t, MP_ARRAY_SIZE(table_ptr16b));
+    for (int i = 0; i < MP_ARRAY_SIZE(table_ptr16b); ++i) {
+        ptr[i] = *table_ptr16b[i];
+    }
+    return mp_obj_new_bytearray_by_ref(sizeof(uint16_t) * MP_ARRAY_SIZE(table_ptr16b), ptr);
+}
+static MP_DEFINE_CONST_FUN_OBJ_0(make_array_obj, make_array);
+
+// This is the entry point and is called when the module is imported
+mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    // This must be first, it sets up the globals dict and other things
+    MP_DYNRUNTIME_INIT_ENTRY
+
+    // Messages can be printed as usual
+    mp_printf(&mp_plat_print, "initialising module self=%p\n", self);
+
+    // Make the functions available in the module's namespace
+    mp_store_global(MP_QSTR_add, MP_OBJ_FROM_PTR(&add_obj));
+    mp_store_global(MP_QSTR_fibonacci, MP_OBJ_FROM_PTR(&fibonacci_obj));
+    mp_store_global(MP_QSTR_access, MP_OBJ_FROM_PTR(&access_obj));
+    mp_store_global(MP_QSTR_make_array, MP_OBJ_FROM_PTR(&make_array_obj));
+
+    // Add some constants to the module's namespace
+    mp_store_global(MP_QSTR_VAL, MP_OBJ_NEW_SMALL_INT(42));
+    mp_store_global(MP_QSTR_MSG, MP_OBJ_NEW_QSTR(MP_QSTR_HELLO_MICROPYTHON));
+
+    // This must be last, it restores the globals dict
+    MP_DYNRUNTIME_INIT_EXIT
+}
diff --git a/examples/natmod/features2/Makefile b/examples/natmod/features2/Makefile
new file mode 100644
index 00000000000..5ddb74087b7
--- /dev/null
+++ b/examples/natmod/features2/Makefile
@@ -0,0 +1,17 @@
+# Location of top-level MicroPython directory
+MPY_DIR = ../../..
+
+# Name of module
+MOD = features2
+
+# Source files (.c or .py)
+SRC = main.c prod.c test.py
+
+# Architecture to build for (x86, x64, armv7m, xtensa, xtensawin)
+ARCH = x64
+
+# Link with libm.a and libgcc.a from the toolchain
+LINK_RUNTIME = 1
+
+# Include to get the rules for compiling and linking the module
+include $(MPY_DIR)/py/dynruntime.mk
diff --git a/examples/natmod/features2/main.c b/examples/natmod/features2/main.c
new file mode 100644
index 00000000000..5ce8e7b0130
--- /dev/null
+++ b/examples/natmod/features2/main.c
@@ -0,0 +1,94 @@
+/* This example demonstrates the following features in a native module:
+    - using floats
+    - calling math functions from libm.a
+    - defining additional code in Python (see test.py)
+    - have extra C code in a separate file (see prod.c)
+*/
+
+// Include the header file to get access to the MicroPython API
+#include "py/dynruntime.h"
+
+// Include the header for auxiliary C code for this module
+#include "prod.h"
+
+// Include standard library header
+#include <math.h>
+
+// Automatically detect if this module should include double-precision code.
+// If double precision is supported by the target architecture then it can
+// be used in native module regardless of what float setting the target
+// MicroPython runtime uses (being none, float or double).
+#if defined(__i386__) || defined(__x86_64__) || (defined(__ARM_FP) && (__ARM_FP & 8))
+#define USE_DOUBLE 1
+#else
+#define USE_DOUBLE 0
+#endif
+
+// A function that uses the default float type configured for the current target
+// This default can be overridden by specifying MICROPY_FLOAT_IMPL at the make level
+static mp_obj_t add(mp_obj_t x, mp_obj_t y) {
+    return mp_obj_new_float(mp_obj_get_float(x) + mp_obj_get_float(y));
+}
+static MP_DEFINE_CONST_FUN_OBJ_2(add_obj, add);
+
+// A function that explicitly uses single precision floats
+static mp_obj_t add_f(mp_obj_t x, mp_obj_t y) {
+    return mp_obj_new_float_from_f(mp_obj_get_float_to_f(x) + mp_obj_get_float_to_f(y));
+}
+static MP_DEFINE_CONST_FUN_OBJ_2(add_f_obj, add_f);
+
+#if USE_DOUBLE
+// A function that explicitly uses double precision floats
+static mp_obj_t add_d(mp_obj_t x, mp_obj_t y) {
+    return mp_obj_new_float_from_d(mp_obj_get_float_to_d(x) + mp_obj_get_float_to_d(y));
+}
+static MP_DEFINE_CONST_FUN_OBJ_2(add_d_obj, add_d);
+#endif
+
+// A function that uses libm
+static mp_obj_t call_round(mp_obj_t x) {
+    return mp_obj_new_float_from_f(roundf(mp_obj_get_float_to_f(x)));
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(round_obj, call_round);
+
+// A function that computes the product of floats in an array.
+// This function uses the most general C argument interface, which is more difficult
+// to use but has access to the globals dict of the module via self->globals.
+static mp_obj_t productf(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    // Check number of arguments is valid
+    mp_arg_check_num(n_args, n_kw, 1, 1, false);
+
+    // Extract buffer pointer and verify typecode
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(args[0], &bufinfo, MP_BUFFER_RW);
+    if (bufinfo.typecode != 'f') {
+        mp_raise_ValueError(MP_ERROR_TEXT("expecting float array"));
+    }
+
+    // Compute product, store result back in first element of array
+    float *ptr = bufinfo.buf;
+    float prod = prod_array(bufinfo.len / sizeof(*ptr), ptr);
+    ptr[0] = prod;
+
+    return mp_const_none;
+}
+
+// This is the entry point and is called when the module is imported
+mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    // This must be first, it sets up the globals dict and other things
+    MP_DYNRUNTIME_INIT_ENTRY
+
+    // Make the functions available in the module's namespace
+    mp_store_global(MP_QSTR_add, MP_OBJ_FROM_PTR(&add_obj));
+    mp_store_global(MP_QSTR_add_f, MP_OBJ_FROM_PTR(&add_f_obj));
+    #if USE_DOUBLE
+    mp_store_global(MP_QSTR_add_d, MP_OBJ_FROM_PTR(&add_d_obj));
+    #endif
+    mp_store_global(MP_QSTR_round, MP_OBJ_FROM_PTR(&round_obj));
+
+    // The productf function uses the most general C argument interface
+    mp_store_global(MP_QSTR_productf, MP_DYNRUNTIME_MAKE_FUNCTION(productf));
+
+    // This must be last, it restores the globals dict
+    MP_DYNRUNTIME_INIT_EXIT
+}
diff --git a/examples/natmod/features2/prod.c b/examples/natmod/features2/prod.c
new file mode 100644
index 00000000000..7791dcad1d2
--- /dev/null
+++ b/examples/natmod/features2/prod.c
@@ -0,0 +1,9 @@
+#include "prod.h"
+
+float prod_array(int n, float *ar) {
+    float ans = 1;
+    for (int i = 0; i < n; ++i) {
+        ans *= ar[i];
+    }
+    return ans;
+}
diff --git a/examples/natmod/features2/prod.h b/examples/natmod/features2/prod.h
new file mode 100644
index 00000000000..f27dd8d0330
--- /dev/null
+++ b/examples/natmod/features2/prod.h
@@ -0,0 +1 @@
+float prod_array(int n, float *ar);
diff --git a/examples/natmod/features2/test.py b/examples/natmod/features2/test.py
new file mode 100644
index 00000000000..af79b9692c2
--- /dev/null
+++ b/examples/natmod/features2/test.py
@@ -0,0 +1,31 @@
+# This Python code will be merged with the C code in main.c
+
+# ruff: noqa: F821 - this file is evaluated with C-defined names in scope
+
+import array
+
+
+def isclose(a, b):
+    return abs(a - b) < 1e-3
+
+
+def test():
+    tests = [
+        isclose(add(0.1, 0.2), 0.3),
+        isclose(add_f(0.1, 0.2), 0.3),
+    ]
+
+    ar = array.array("f", [1, 2, 3.5])
+    productf(ar)
+    tests.append(isclose(ar[0], 7))
+
+    if "add_d" in globals():
+        tests.append(isclose(add_d(0.1, 0.2), 0.3))
+
+    print(tests)
+
+    if not all(tests):
+        raise SystemExit(1)
+
+
+test()
diff --git a/examples/natmod/features3/Makefile b/examples/natmod/features3/Makefile
new file mode 100644
index 00000000000..3573f41caca
--- /dev/null
+++ b/examples/natmod/features3/Makefile
@@ -0,0 +1,14 @@
+# Location of top-level MicroPython directory
+MPY_DIR = ../../..
+
+# Name of module
+MOD = features3
+
+# Source files (.c or .py)
+SRC = features3.c
+
+# Architecture to build for (x86, x64, armv7m, xtensa, xtensawin, rv32imc)
+ARCH = x64
+
+# Include to get the rules for compiling and linking the module
+include $(MPY_DIR)/py/dynruntime.mk
diff --git a/examples/natmod/features3/features3.c b/examples/natmod/features3/features3.c
new file mode 100644
index 00000000000..1d3bc51e609
--- /dev/null
+++ b/examples/natmod/features3/features3.c
@@ -0,0 +1,60 @@
+/* This example demonstrates the following features in a native module:
+    - using types
+    - using constant objects
+    - creating dictionaries
+*/
+
+// Include the header file to get access to the MicroPython API.
+#include "py/dynruntime.h"
+
+// A function that returns a tuple of object types.
+static mp_obj_t get_types(void) {
+    return mp_obj_new_tuple(9, ((mp_obj_t []) {
+        MP_OBJ_FROM_PTR(&mp_type_type),
+        MP_OBJ_FROM_PTR(&mp_type_NoneType),
+        MP_OBJ_FROM_PTR(&mp_type_bool),
+        MP_OBJ_FROM_PTR(&mp_type_int),
+        MP_OBJ_FROM_PTR(&mp_type_str),
+        MP_OBJ_FROM_PTR(&mp_type_bytes),
+        MP_OBJ_FROM_PTR(&mp_type_tuple),
+        MP_OBJ_FROM_PTR(&mp_type_list),
+        MP_OBJ_FROM_PTR(&mp_type_dict),
+    }));
+}
+static MP_DEFINE_CONST_FUN_OBJ_0(get_types_obj, get_types);
+
+// A function that returns a tuple of constant objects.
+static mp_obj_t get_const_objects(void) {
+    return mp_obj_new_tuple(5, ((mp_obj_t []) {
+        mp_const_none,
+        mp_const_false,
+        mp_const_true,
+        mp_const_empty_bytes,
+        mp_const_empty_tuple,
+    }));
+}
+static MP_DEFINE_CONST_FUN_OBJ_0(get_const_objects_obj, get_const_objects);
+
+// A function that creates a dictionary from the given arguments.
+static mp_obj_t make_dict(size_t n_args, const mp_obj_t *args) {
+    mp_obj_t dict = mp_obj_new_dict(n_args / 2);
+    for (; n_args >= 2; n_args -= 2, args += 2) {
+        mp_obj_dict_store(dict, args[0], args[1]);
+    }
+    return dict;
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(make_dict_obj, 0, MP_OBJ_FUN_ARGS_MAX, make_dict);
+
+// This is the entry point and is called when the module is imported.
+mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    // This must be first, it sets up the globals dict and other things.
+    MP_DYNRUNTIME_INIT_ENTRY
+
+    // Make the functions available in the module's namespace.
+    mp_store_global(MP_QSTR_make_dict, MP_OBJ_FROM_PTR(&make_dict_obj));
+    mp_store_global(MP_QSTR_get_types, MP_OBJ_FROM_PTR(&get_types_obj));
+    mp_store_global(MP_QSTR_get_const_objects, MP_OBJ_FROM_PTR(&get_const_objects_obj));
+
+    // This must be last, it restores the globals dict.
+    MP_DYNRUNTIME_INIT_EXIT
+}
diff --git a/examples/natmod/features4/Makefile b/examples/natmod/features4/Makefile
new file mode 100644
index 00000000000..34fc3a7ef7b
--- /dev/null
+++ b/examples/natmod/features4/Makefile
@@ -0,0 +1,14 @@
+# Location of top-level MicroPython directory
+MPY_DIR = ../../..
+
+# Name of module
+MOD = features4
+
+# Source files (.c or .py)
+SRC = features4.c
+
+# Architecture to build for (x86, x64, armv7m, xtensa, xtensawin, rv32imc)
+ARCH = x64
+
+# Include to get the rules for compiling and linking the module
+include $(MPY_DIR)/py/dynruntime.mk
diff --git a/examples/natmod/features4/features4.c b/examples/natmod/features4/features4.c
new file mode 100644
index 00000000000..e64c7f75921
--- /dev/null
+++ b/examples/natmod/features4/features4.c
@@ -0,0 +1,89 @@
+/*
+  This example extends on features0 but demonstrates how to define a class,
+  and a custom exception.
+
+  The Factorial class constructor takes an integer, and then the calculate
+  method can be called to get the factorial.
+
+  >>> import features4
+  >>> f = features4.Factorial(4)
+  >>> f.calculate()
+  24
+
+  If the argument to the Factorial class constructor is less than zero, a
+  FactorialError is raised.
+*/
+
+// Include the header file to get access to the MicroPython API
+#include "py/dynruntime.h"
+
+// This is type(Factorial)
+mp_obj_full_type_t mp_type_factorial;
+
+// This is the internal state of a Factorial instance.
+typedef struct {
+    mp_obj_base_t base;
+    mp_int_t n;
+} mp_obj_factorial_t;
+
+mp_obj_full_type_t mp_type_FactorialError;
+
+// Essentially Factorial.__new__ (but also kind of __init__).
+// Takes a single argument (the number to find the factorial of)
+static mp_obj_t factorial_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args_in) {
+    mp_arg_check_num(n_args, n_kw, 1, 1, false);
+
+    mp_obj_factorial_t *o = mp_obj_malloc(mp_obj_factorial_t, type);
+    o->n = mp_obj_get_int(args_in[0]);
+
+    if (o->n < 0) {
+        mp_raise_msg((mp_obj_type_t *)&mp_type_FactorialError, "argument must be zero or above");
+    }
+
+    return MP_OBJ_FROM_PTR(o);
+}
+
+static mp_int_t factorial_helper(mp_int_t x) {
+    if (x == 0) {
+        return 1;
+    }
+    return x * factorial_helper(x - 1);
+}
+
+// Implements Factorial.calculate()
+static mp_obj_t factorial_calculate(mp_obj_t self_in) {
+    mp_obj_factorial_t *self = MP_OBJ_TO_PTR(self_in);
+    return mp_obj_new_int(factorial_helper(self->n));
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(factorial_calculate_obj, factorial_calculate);
+
+// Locals dict for the Factorial type (will have a single method, calculate,
+// added in mpy_init).
+mp_map_elem_t factorial_locals_dict_table[1];
+static MP_DEFINE_CONST_DICT(factorial_locals_dict, factorial_locals_dict_table);
+
+// This is the entry point and is called when the module is imported
+mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    // This must be first, it sets up the globals dict and other things
+    MP_DYNRUNTIME_INIT_ENTRY
+
+    // Initialise the type.
+    mp_type_factorial.base.type = (void*)&mp_type_type;
+    mp_type_factorial.flags = MP_TYPE_FLAG_NONE;
+    mp_type_factorial.name = MP_QSTR_Factorial;
+    MP_OBJ_TYPE_SET_SLOT(&mp_type_factorial, make_new, factorial_make_new, 0);
+    factorial_locals_dict_table[0] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_calculate), MP_OBJ_FROM_PTR(&factorial_calculate_obj) };
+    MP_OBJ_TYPE_SET_SLOT(&mp_type_factorial, locals_dict, (void*)&factorial_locals_dict, 1);
+
+    // Make the Factorial type available on the module.
+    mp_store_global(MP_QSTR_Factorial, MP_OBJ_FROM_PTR(&mp_type_factorial));
+
+    // Initialise the exception type.
+    mp_obj_exception_init(&mp_type_FactorialError, MP_QSTR_FactorialError, &mp_type_Exception);
+
+    // Make the FactorialError type available on the module.
+    mp_store_global(MP_QSTR_FactorialError, MP_OBJ_FROM_PTR(&mp_type_FactorialError));
+
+    // This must be last, it restores the globals dict
+    MP_DYNRUNTIME_INIT_EXIT
+}
diff --git a/examples/natmod/framebuf/Makefile b/examples/natmod/framebuf/Makefile
new file mode 100644
index 00000000000..2e2b8159754
--- /dev/null
+++ b/examples/natmod/framebuf/Makefile
@@ -0,0 +1,13 @@
+# Location of top-level MicroPython directory
+MPY_DIR = ../../..
+
+# Name of module (different to built-in framebuf so it can coexist)
+MOD = framebuf_$(ARCH)
+
+# Source files (.c or .py)
+SRC = framebuf.c
+
+# Architecture to build for (x86, x64, armv7m, xtensa, xtensawin)
+ARCH = x64
+
+include $(MPY_DIR)/py/dynruntime.mk
diff --git a/examples/natmod/framebuf/framebuf.c b/examples/natmod/framebuf/framebuf.c
new file mode 100644
index 00000000000..1ba702e33d9
--- /dev/null
+++ b/examples/natmod/framebuf/framebuf.c
@@ -0,0 +1,51 @@
+#define MICROPY_PY_ARRAY (1)
+#define MICROPY_PY_FRAMEBUF (1)
+
+#include "py/dynruntime.h"
+
+#if !defined(__linux__)
+void *memset(void *s, int c, size_t n) {
+    return mp_fun_table.memset_(s, c, n);
+}
+#endif
+
+mp_obj_full_type_t mp_type_framebuf;
+
+#include "extmod/modframebuf.c"
+
+mp_map_elem_t framebuf_locals_dict_table[12];
+static MP_DEFINE_CONST_DICT(framebuf_locals_dict, framebuf_locals_dict_table);
+
+mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    MP_DYNRUNTIME_INIT_ENTRY
+
+    mp_type_framebuf.base.type = (void*)&mp_type_type;
+    mp_type_framebuf.name = MP_QSTR_FrameBuffer;
+    MP_OBJ_TYPE_SET_SLOT(&mp_type_framebuf, make_new, framebuf_make_new, 0);
+    MP_OBJ_TYPE_SET_SLOT(&mp_type_framebuf, buffer, framebuf_get_buffer, 1);
+    framebuf_locals_dict_table[0] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_fill), MP_OBJ_FROM_PTR(&framebuf_fill_obj) };
+    framebuf_locals_dict_table[1] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_fill_rect), MP_OBJ_FROM_PTR(&framebuf_fill_rect_obj) };
+    framebuf_locals_dict_table[2] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_pixel), MP_OBJ_FROM_PTR(&framebuf_pixel_obj) };
+    framebuf_locals_dict_table[3] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_hline), MP_OBJ_FROM_PTR(&framebuf_hline_obj) };
+    framebuf_locals_dict_table[4] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_vline), MP_OBJ_FROM_PTR(&framebuf_vline_obj) };
+    framebuf_locals_dict_table[5] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_rect), MP_OBJ_FROM_PTR(&framebuf_rect_obj) };
+    framebuf_locals_dict_table[6] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_line), MP_OBJ_FROM_PTR(&framebuf_line_obj) };
+    framebuf_locals_dict_table[7] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_ellipse), MP_OBJ_FROM_PTR(&framebuf_ellipse_obj) };
+    framebuf_locals_dict_table[8] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_poly), MP_OBJ_FROM_PTR(&framebuf_poly_obj) };
+    framebuf_locals_dict_table[9] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_blit), MP_OBJ_FROM_PTR(&framebuf_blit_obj) };
+    framebuf_locals_dict_table[10] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_scroll), MP_OBJ_FROM_PTR(&framebuf_scroll_obj) };
+    framebuf_locals_dict_table[11] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_text), MP_OBJ_FROM_PTR(&framebuf_text_obj) };
+    MP_OBJ_TYPE_SET_SLOT(&mp_type_framebuf, locals_dict, (void*)&framebuf_locals_dict, 2);
+
+    mp_store_global(MP_QSTR_FrameBuffer, MP_OBJ_FROM_PTR(&mp_type_framebuf));
+    mp_store_global(MP_QSTR_MVLSB, MP_OBJ_NEW_SMALL_INT(FRAMEBUF_MVLSB));
+    mp_store_global(MP_QSTR_MONO_VLSB, MP_OBJ_NEW_SMALL_INT(FRAMEBUF_MVLSB));
+    mp_store_global(MP_QSTR_RGB565, MP_OBJ_NEW_SMALL_INT(FRAMEBUF_RGB565));
+    mp_store_global(MP_QSTR_GS2_HMSB, MP_OBJ_NEW_SMALL_INT(FRAMEBUF_GS2_HMSB));
+    mp_store_global(MP_QSTR_GS4_HMSB, MP_OBJ_NEW_SMALL_INT(FRAMEBUF_GS4_HMSB));
+    mp_store_global(MP_QSTR_GS8, MP_OBJ_NEW_SMALL_INT(FRAMEBUF_GS8));
+    mp_store_global(MP_QSTR_MONO_HLSB, MP_OBJ_NEW_SMALL_INT(FRAMEBUF_MHLSB));
+    mp_store_global(MP_QSTR_MONO_HMSB, MP_OBJ_NEW_SMALL_INT(FRAMEBUF_MHMSB));
+
+    MP_DYNRUNTIME_INIT_EXIT
+}
diff --git a/examples/natmod/heapq/Makefile b/examples/natmod/heapq/Makefile
new file mode 100644
index 00000000000..61e2fc8fcc0
--- /dev/null
+++ b/examples/natmod/heapq/Makefile
@@ -0,0 +1,13 @@
+# Location of top-level MicroPython directory
+MPY_DIR = ../../..
+
+# Name of module (different to built-in heapq so it can coexist)
+MOD = heapq_$(ARCH)
+
+# Source files (.c or .py)
+SRC = heapq.c
+
+# Architecture to build for (x86, x64, armv7m, xtensa, xtensawin, rv32imc)
+ARCH = x64
+
+include $(MPY_DIR)/py/dynruntime.mk
diff --git a/examples/natmod/heapq/heapq.c b/examples/natmod/heapq/heapq.c
new file mode 100644
index 00000000000..ed19652a66b
--- /dev/null
+++ b/examples/natmod/heapq/heapq.c
@@ -0,0 +1,16 @@
+#define MICROPY_PY_HEAPQ (1)
+
+#include "py/dynruntime.h"
+
+#include "extmod/modheapq.c"
+
+mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    MP_DYNRUNTIME_INIT_ENTRY
+
+    mp_store_global(MP_QSTR___name__, MP_OBJ_NEW_QSTR(MP_QSTR_heapq));
+    mp_store_global(MP_QSTR_heappush, MP_OBJ_FROM_PTR(&mod_heapq_heappush_obj));
+    mp_store_global(MP_QSTR_heappop, MP_OBJ_FROM_PTR(&mod_heapq_heappop_obj));
+    mp_store_global(MP_QSTR_heapify, MP_OBJ_FROM_PTR(&mod_heapq_heapify_obj));
+
+    MP_DYNRUNTIME_INIT_EXIT
+}
diff --git a/examples/natmod/random/Makefile b/examples/natmod/random/Makefile
new file mode 100644
index 00000000000..8abdb66dc87
--- /dev/null
+++ b/examples/natmod/random/Makefile
@@ -0,0 +1,13 @@
+# Location of top-level MicroPython directory
+MPY_DIR = ../../..
+
+# Name of module (different to built-in random so it can coexist)
+MOD = random_$(ARCH)
+
+# Source files (.c or .py)
+SRC = random.c
+
+# Architecture to build for (x86, x64, armv7m, xtensa, xtensawin, rv32imc)
+ARCH = x64
+
+include $(MPY_DIR)/py/dynruntime.mk
diff --git a/examples/natmod/random/random.c b/examples/natmod/random/random.c
new file mode 100644
index 00000000000..92257b8bc68
--- /dev/null
+++ b/examples/natmod/random/random.c
@@ -0,0 +1,33 @@
+#define MICROPY_PY_RANDOM (1)
+#define MICROPY_PY_RANDOM_EXTRA_FUNCS (1)
+
+#include "py/dynruntime.h"
+
+// Dynamic native modules don't support a data section so these must go in the BSS
+uint32_t yasmarang_pad, yasmarang_n, yasmarang_d;
+uint8_t yasmarang_dat;
+
+#include "extmod/modrandom.c"
+
+mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    MP_DYNRUNTIME_INIT_ENTRY
+
+    yasmarang_pad = 0xeda4baba;
+    yasmarang_n = 69;
+    yasmarang_d = 233;
+
+    mp_store_global(MP_QSTR___name__, MP_OBJ_NEW_QSTR(MP_QSTR_random));
+    mp_store_global(MP_QSTR_getrandbits, MP_OBJ_FROM_PTR(&mod_random_getrandbits_obj));
+    mp_store_global(MP_QSTR_seed, MP_OBJ_FROM_PTR(&mod_random_seed_obj));
+    #if MICROPY_PY_RANDOM_EXTRA_FUNCS
+    mp_store_global(MP_QSTR_randrange, MP_OBJ_FROM_PTR(&mod_random_randrange_obj));
+    mp_store_global(MP_QSTR_randint, MP_OBJ_FROM_PTR(&mod_random_randint_obj));
+    mp_store_global(MP_QSTR_choice, MP_OBJ_FROM_PTR(&mod_random_choice_obj));
+    #if MICROPY_PY_BUILTINS_FLOAT
+    mp_store_global(MP_QSTR_random, MP_OBJ_FROM_PTR(&mod_random_random_obj));
+    mp_store_global(MP_QSTR_uniform, MP_OBJ_FROM_PTR(&mod_random_uniform_obj));
+    #endif
+    #endif
+
+    MP_DYNRUNTIME_INIT_EXIT
+}
diff --git a/examples/natmod/re/Makefile b/examples/natmod/re/Makefile
new file mode 100644
index 00000000000..56b08b98868
--- /dev/null
+++ b/examples/natmod/re/Makefile
@@ -0,0 +1,13 @@
+# Location of top-level MicroPython directory
+MPY_DIR = ../../..
+
+# Name of module (different to built-in re so it can coexist)
+MOD = re_$(ARCH)
+
+# Source files (.c or .py)
+SRC = re.c
+
+# Architecture to build for (x86, x64, armv7m, xtensa, xtensawin, rv32imc)
+ARCH = x64
+
+include $(MPY_DIR)/py/dynruntime.mk
diff --git a/examples/natmod/re/re.c b/examples/natmod/re/re.c
new file mode 100644
index 00000000000..c0279ee7e81
--- /dev/null
+++ b/examples/natmod/re/re.c
@@ -0,0 +1,91 @@
+#define MICROPY_STACK_CHECK (1)
+#define MICROPY_PY_RE (1)
+#define MICROPY_PY_RE_MATCH_GROUPS (1)
+#define MICROPY_PY_RE_MATCH_SPAN_START_END (1)
+#define MICROPY_PY_RE_SUB (0) // requires vstr interface
+
+#if defined __has_builtin
+#if __has_builtin(__builtin_alloca)
+#define alloca __builtin_alloca
+#endif
+#endif
+
+#if !defined(alloca)
+#if defined(_PICOLIBC__) && !defined(HAVE_BUILTIN_ALLOCA)
+#define alloca(n) m_malloc(n)
+#else
+#include <alloca.h>
+#endif
+#endif
+
+#include "py/dynruntime.h"
+
+#define STACK_LIMIT (2048)
+
+const char *stack_top;
+
+void mp_cstack_check(void) {
+    // Assumes descending stack on target
+    volatile char dummy;
+    if (stack_top - &dummy >= STACK_LIMIT) {
+        mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("maximum recursion depth exceeded"));
+    }
+}
+
+#if !defined(__linux__)
+void *memcpy(void *dst, const void *src, size_t n) {
+    return mp_fun_table.memmove_(dst, src, n);
+}
+void *memset(void *s, int c, size_t n) {
+    return mp_fun_table.memset_(s, c, n);
+}
+#endif
+
+void *memmove(void *dest, const void *src, size_t n) {
+    return mp_fun_table.memmove_(dest, src, n);
+}
+
+mp_obj_full_type_t match_type;
+mp_obj_full_type_t re_type;
+
+#include "extmod/modre.c"
+
+mp_map_elem_t match_locals_dict_table[5];
+static MP_DEFINE_CONST_DICT(match_locals_dict, match_locals_dict_table);
+
+mp_map_elem_t re_locals_dict_table[3];
+static MP_DEFINE_CONST_DICT(re_locals_dict, re_locals_dict_table);
+
+mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    MP_DYNRUNTIME_INIT_ENTRY
+
+    char dummy;
+    stack_top = &dummy;
+
+    // Because MP_QSTR_start/end/split are static, xtensa and xtensawin will make a small data section
+    // to copy in this key/value pair if they are specified as a struct, so assign them separately.
+
+    match_type.base.type = (void*)&mp_fun_table.type_type;
+    match_type.name = MP_QSTR_match;
+    MP_OBJ_TYPE_SET_SLOT(&match_type, print, match_print, 0);
+    match_locals_dict_table[0] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_group), MP_OBJ_FROM_PTR(&match_group_obj) };
+    match_locals_dict_table[1] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_groups), MP_OBJ_FROM_PTR(&match_groups_obj) };
+    match_locals_dict_table[2] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_span), MP_OBJ_FROM_PTR(&match_span_obj) };
+    match_locals_dict_table[3] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_start), MP_OBJ_FROM_PTR(&match_start_obj) };
+    match_locals_dict_table[4] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_end), MP_OBJ_FROM_PTR(&match_end_obj) };
+    MP_OBJ_TYPE_SET_SLOT(&match_type, locals_dict, (void*)&match_locals_dict, 1);
+
+    re_type.base.type = (void*)&mp_fun_table.type_type;
+    re_type.name = MP_QSTR_re;
+    MP_OBJ_TYPE_SET_SLOT(&re_type, print, re_print, 0);
+    re_locals_dict_table[0] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_match), MP_OBJ_FROM_PTR(&re_match_obj) };
+    re_locals_dict_table[1] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_search), MP_OBJ_FROM_PTR(&re_search_obj) };
+    re_locals_dict_table[2] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_split), MP_OBJ_FROM_PTR(&re_split_obj) };
+    MP_OBJ_TYPE_SET_SLOT(&re_type, locals_dict, (void*)&re_locals_dict, 1);
+
+    mp_store_global(MP_QSTR_compile, MP_OBJ_FROM_PTR(&mod_re_compile_obj));
+    mp_store_global(MP_QSTR_match, MP_OBJ_FROM_PTR(&re_match_obj));
+    mp_store_global(MP_QSTR_search, MP_OBJ_FROM_PTR(&re_search_obj));
+
+    MP_DYNRUNTIME_INIT_EXIT
+}
diff --git a/ports/raspberrypi/boards/raspberry_pi_pico/mpconfigboard.mk b/ports/raspberrypi/boards/raspberry_pi_pico/mpconfigboard.mk
index 20607d50e41..08f1371a07e 100644
--- a/ports/raspberrypi/boards/raspberry_pi_pico/mpconfigboard.mk
+++ b/ports/raspberrypi/boards/raspberry_pi_pico/mpconfigboard.mk
@@ -10,3 +10,6 @@ EXTERNAL_FLASH_DEVICES = "W25Q16JVxQ"
 
 CIRCUITPY__EVE = 1
 CIRCUITPY_PICODVI = 1
+
+# Enable micropython.native & natmod
+CIRCUITPY_ENABLE_MPY_NATIVE = 1
diff --git a/ports/unix/mpconfigport.mk b/ports/unix/mpconfigport.mk
index c836663cd23..3c844ccef3b 100644
--- a/ports/unix/mpconfigport.mk
+++ b/ports/unix/mpconfigport.mk
@@ -55,5 +55,4 @@ MICROPY_VFS_LFS2 = 0
 # CIRCUITPY-CHANGE
 CIRCUITPY_ULAB = 1
 CIRCUITPY_MESSAGE_COMPRESSION_LEVEL = 1
-MICROPY_EMIT_NATIVE = 0
 CFLAGS += -DCIRCUITPY=1
diff --git a/py/dynruntime.h b/py/dynruntime.h
index ab155a13875..9eea5ca6e5c 100644
--- a/py/dynruntime.h
+++ b/py/dynruntime.h
@@ -71,7 +71,7 @@
 #define m_realloc_maybe(ptr, new_num_bytes, allow_move) (m_realloc_maybe_dyn((ptr), (new_num_bytes), (allow_move)))
 
 static MP_NORETURN inline void m_malloc_fail_dyn(size_t num_bytes) {
-    mp_fun_table.raise_msg(
+    mp_fun_table.raise_msg_str(
         mp_fun_table.load_global(MP_QSTR_MemoryError),
         "memory allocation failed");
 }
diff --git a/requirements-dev.txt b/requirements-dev.txt
index 6a33c49daec..aca235d6346 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -24,6 +24,7 @@ intelhex
 
 # for building & testing natmods
 pyelftools
+ar
 
 cryptography
 
diff --git a/tools/mpy_ld.py b/tools/mpy_ld.py
index 26db0726163..f5fc0ffc8a7 100755
--- a/tools/mpy_ld.py
+++ b/tools/mpy_ld.py
@@ -50,11 +50,13 @@
 MP_NATIVE_ARCH_XTENSAWIN = 10
 MP_NATIVE_ARCH_RV32IMC = 11
 MP_PERSISTENT_OBJ_STR = 5
-MP_SCOPE_FLAG_VIPERRELOC = 0x10
-MP_SCOPE_FLAG_VIPERRODATA = 0x20
-MP_SCOPE_FLAG_VIPERBSS = 0x40
+## CIRCUITPY-CHANGE: FLAG_ASYNC
+MP_SCOPE_FLAG_VIPERRELOC = 0x20
+MP_SCOPE_FLAG_VIPERRODATA = 0x40
+MP_SCOPE_FLAG_VIPERBSS = 0x80
 MP_SMALL_INT_BITS = 31
-MP_FUN_TABLE_MP_TYPE_TYPE_OFFSET = 73
+## CIRCUITPY-CHANGE (due to added assert_native_inited)
+MP_FUN_TABLE_MP_TYPE_TYPE_OFFSET = 74
 
 # ELF constants
 R_386_32 = 1