First commit

186 files changed, 14162 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..bdcf7af
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+.cache/
+*build*/
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..37a4912
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,67 @@
+# nanowasm, a tiny WebAssembly/Wasm interpreter
+# Copyright (C) 2023-2025  Xavier Del Campo Romero
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+cmake_minimum_required(VERSION 3.19)
+project(nanowasm LANGUAGES C VERSION 0.0.0)
+option(NW_EXAMPLES "Build examples")
+option(NW_LOG "Enables logging to stderr")
+option(NW_LOG_CUSTOM "Allows user code to define nwp_log. Enables NW_LOG")
+option(NW_CHECK_CODE "Check opcodes inside code section (slow).")
+add_library(${PROJECT_NAME})
+target_include_directories(${PROJECT_NAME} PUBLIC include
+    PRIVATE private_include)
+
+set(compilers
+    "GNU"
+    "Clang"
+    "TinyCC"
+)
+
+if(NW_LOG_CUSTOM)
+    set(NW_LOG ON)
+endif()
+
+foreach(c ${compilers})
+    if(CMAKE_C_COMPILER_ID STREQUAL ${c})
+        set(cflags_np
+            -pedantic
+            -Wall
+        )
+
+        if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+            set(cflags_np ${cflags_np} -Og -g)
+        else()
+            set(cflags_np ${cflags_np} -Os)
+        endif()
+
+        break()
+    endif()
+endforeach()
+
+include(CheckCompilerFlag)
+
+foreach(f ${cflags_np})
+    string(REPLACE "-" "_" var supported_${f})
+    check_compiler_flag(C ${f} ${var})
+
+    if(${var})
+        set(sup_cflags ${sup_cflags} ${f})
+    endif()
+endforeach()
+
+if(NW_LOG)
+    target_compile_definitions(${PROJECT_NAME} PRIVATE NW_LOG)
+endif()
+
+if(NW_EXAMPLES)
+    add_subdirectory(examples)
+endif()
+
+target_compile_options(${PROJECT_NAME} PRIVATE ${sup_cflags})
+set_target_properties(${PROJECT_NAME} PROPERTIES C_STANDARD 90 C_EXTENSIONS OFF)
+add_subdirectory(src)
+install(TARGETS ${PROJECT_NAME})
diff --git a/COMPARE.md b/COMPARE.md
new file mode 100644
index 0000000..635f6ff
--- /dev/null
+++ b/COMPARE.md
@@ -0,0 +1,261 @@
+# Comparing WebAssembly/Wasm interpreters
+
+This document provides a more detailed explanation behind the
+[comparison chart](README.md#comparison-chart).
+
+- **Note:** `N/A` means no measurements have been made yet.
+
+## Asynchronous interface
+
+As of the time of this writing, there is no known asynchronous WebAssembly
+interpreter other than `nanowasm`. All other interpreters implement a
+function that will run the WebAssembly application until it either
+finishes or traps (e.g.: `wasm_application_execute_main` in
+`wasm-micro-runtime`).
+
+In the scope of `nanowasm`, it was deemed interesting to design it as an
+asynchronous library for several reasons:
+
+- Running several module instances synchronously requires OS-level threading,
+which might not be desirable or even feasible to implement under some
+resource-constrained environments.
+- An asynchronous interface allows hosts to stop the execution for a module
+instance as easily as stop calling `nw_run`. Otherwise, interpreters must
+provide an `terminate`-like interface that must be called from a separate
+context (e.g.: `wasm_runtime_terminate` in `wasm-micro-runtime`).
+- The reasons above require a synchronous interpreter to be aware of the
+underlying platform, as it must be aware of primitives such as locks in order
+to remain thread-safe. However, this restricts portability towards new, unknown
+platforms.
+
+Despite its advantages, an asynchronous interface requires a more careful
+design and, more importantly, it incurs a larger memory footprint. However,
+`nanowasm` strives to remain smaller compared to its synchronous counterparts.
+
+## I/O-agnostic
+
+### Module bytecode
+
+As of the time of this writing, all interpreters other than `nanowasm` require
+the module bytecode be memory-mapped. Typically, this requires to either:
+
+- Dump the bytecode into memory.
+- Allocate a memory-mapped file.
+
+Whereas the former is inefficient memory-wise and probably unacceptable on
+resource-constrained environments, the latter is just not possible unless
+a hardware [MMU](https://en.wikipedia.org/wiki/Memory_management_unit) is
+present.
+
+In the context of `nanowasm`, it was considered interesting not to assume
+_where_ the module bytecode comes from, and instead access it via file-like
+semantics. For example, this would allow MMU-less systems to store module
+bytecode on non-volatile memory, which is often larger and less expensive,
+albeit slower.
+
+### Memories
+
+WebAssembly defines four different memory areas:
+
+- Table memory.
+- Linear memory.
+- Global memory.
+- Stack.
+
+All interpreters other than `nanowasm` allocate these memory areas internally
+via the system heap, or a custom heap defined by the user. This raises the
+following concerns:
+
+- Some resource-constrained environments might prefer to avoid the use of
+a heap, or maybe no heap implementation is even available.
+- It forces each of these memory areas to remain contiguous. On environments
+with segmented memory, this might limit the amount of contiguous memory that
+can be allocated.
+
+In the context of `nanowasm`, MMU-less systems were considered a priority for
+its design, and therefore it was conceived so that these memory areas are
+never allocated by `nanowasm` itself. Instead, `nanowasm` provides to the
+host a series of interfaces (i.e., callbacks) to  implement in order to define
+how these areas are accessed. Therefore, whether accessing those areas
+requires the use of a heap, and how it is used, is entirely up to the host
+implementation.
+
+While possibly a bit cumbersome from a first glance, this flexible design
+brings in many new possibilities. For example, it allows MMU-less systems to
+store memory pages into non-contiguous memory areas, or even store them into
+larger, non-volatile memory, similarly to how fully-fledged operating systems
+implement virtual memory.
+
+## No heap required
+
+All interpreters other than `nanowasm` would allocate many internal data
+structures, as well as arbitrarily large chunks of data in order to accomodate
+the different memory areas defined by the WebAssembly standard. Aside from the
+limitations [explained above](#memories), this means the memory required by a
+module or a module instance cannot be known at compile-time, since it depends
+on how the heap is implemented, and even the module bytecode itself.
+
+On the other hand, `nanowasm` was designed with resource-constrained
+environments in mind, where a heap implementation might be either undesired
+or just unavailable. Therefore, it had to be implemented so that the memory
+required by modules and module instances remained static. This is achieved
+efficiently by storing all data structures for all possible states into a
+`union`.
+
+This design allows hosts to allocate modules and module instances in any way,
+be it:
+
+- Automatically i.e., from the stack.
+- Statically i.e., via the `static` qualifier.
+- Dynamically i.e., from the heap.
+
+## Big-endian support
+
+Even if little-endian architectures, such as `amd64`, are arguably more popular
+as of the time of this writing, big-endian counterparts are still being
+produced and are therefore considered equally relevant by `nanowasm`.
+
+### [`wasm-micro-runtime`]
+
+Despite the fact that `wasm-micro-runtime` seems to byte-swap integers
+according to the platform endianness, no big-endian platforms are listed so far
+on its `README.md`. Also, due to its big code base, it is difficult to ensure
+whether all integer reads and write are done in an endianness-agnostic way.
+
+### [`wac`]
+
+`wac` naively compares the `\0asm` magic string as a little-endian integer.
+
+## No compiler-specific extensions
+
+All interpreters other than `nanowasm` rely extensively on system-specific
+macros and/or extensions to the C language. These might restrict their use on
+less popular compilers and/or new environments.
+
+On the other hand, `nanowasm` is written in standard ANSI C (C89/C90)
+i.e., without any language extensions, as well as no system-specific macros.
+On a broader sense, the use of macros and/or other preprocessor directives is
+restricted to a minimum on `nanowasm`, as opposed to other interpreters such
+as `wasm3`.
+
+Such reduced use of the preprocessor is considered to enhance readability,
+even if it might incur some extra boilerplate code.
+
+## Public functions
+
+### `nanowasm`
+
+The numbers were extracted from [`nw.h`](include/nanowasm/nw.h).
+
+### [`wasm-micro-runtime`]
+
+- Commit: `4e50d2191ca8f177ad03a9d80eebc44b59a932db`
+
+The numbers were extracted from `wasm_export.h`.
+
+### [`wasm3`]
+
+- Commit: `35b5e2fb53c5cbc1ff3d7e42c381cd7cfa14f308`
+
+The numbers were extracted from `wasm3.h`.
+
+## Minimal memory footprint
+
+### `nanowasm`
+
+The numbers were extracted from the `test` application built by the project
+by default, which links the `nanowasm` library.
+
+The project was built with:
+
+```
+cmake -B build
+cmake --build build
+```
+
+Then, the size for the `test` executable was obtained via:
+
+```
+$ size build/test/test
+   text    data     bss     dec     hex filename
+  50590    3576      16   54182    d3a6 build/test/test
+```
+
+Of course, these numbers are subject to change since many opcodes are still
+not implemented in `nanowasm`.
+
+### [`wasm-micro-runtime`]
+
+- Commit: `4e50d2191ca8f177ad03a9d80eebc44b59a932db`
+
+A minimal application, namely `wamr-ex`, was written with
+`wasm-micro-runtime`'s `iwasm` library. This application:
+
+1. Dumps a `.wasm` file into memory, since `wasm-micro-runtime` requires
+module code to either reside in memory or belong to a memory-mapped file.
+2. Calls the following functions:
+    - `wasm_runtime_init`
+    - `wasm_runtime_load`
+    - `wasm_runtime_instantiate`
+    - `wasm_application_execute_main`
+    - `wasm_runtime_unload`
+    - `wasm_runtime_deinstantiate`
+
+The example was built with the default CMake flags i.e.:
+
+```
+cmake -B build
+cmake --build build
+```
+
+The executable size was the obtained via:
+
+```
+$ size build/wamr-ex
+   text    data     bss     dec     hex filename
+ 463165    9224     932  473321   738e9 build/wamr-ex
+```
+
+### [`wasm3`]
+
+- Commit: `35b5e2fb53c5cbc1ff3d7e42c381cd7cfa14f308`
+
+`wasm3` provides a sample application, also called `wasm3`, in its source tree.
+This application allows to run any `.wasm` file, along with some extra command
+line options.
+
+The project was built with the default CMake flags i.e.:
+
+```
+cmake -B build
+cmake --build build
+```
+
+The executable size was the obtained via:
+
+```
+$ size build/wasm3
+   text    data     bss     dec     hex filename
+ 531667   20332    6720  558719   8867f build/wasm3
+```
+
+## Per-module memory usage
+
+### `nanowasm`
+
+The numbers were extracted by looking up `sizeof (struct nw_mod)` via `gdb(1)`,
+from an `x86_64-linux-gnu` machine. Results might vary depending on the
+target platform.
+
+## Per-instance memory usage
+
+### `nanowasm`
+
+The numbers were extracted by looking up `sizeof (struct nw_inst)` via `gdb(1)`,
+from an `x86_64-linux-gnu` machine. Results might vary depending on the
+target platform.
+
+[`wasm-micro-runtime`]: https://github.com/bytecodealliance/wasm-micro-runtime
+[`wasm3`]: https://github.com/wasm3/wasm3
+[`wac`]: https://github.com/kanaka/wac
+[`toywasm`]: https://github.com/yamt/toywasm
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..d0a1fa1
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,373 @@
+Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, "control" means (a) the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or (b) ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+    or
+
+(b) for infringements caused by: (i) Your and any other third party's
+    modifications of Covered Software, or (ii) the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+*                                                                      *
+*  6. Disclaimer of Warranty                                           *
+*  -------------------------                                           *
+*                                                                      *
+*  Covered Software is provided under this License on an "as is"       *
+*  basis, without warranty of any kind, either expressed, implied, or  *
+*  statutory, including, without limitation, warranties that the       *
+*  Covered Software is free of defects, merchantable, fit for a        *
+*  particular purpose or non-infringing. The entire risk as to the     *
+*  quality and performance of the Covered Software is with You.        *
+*  Should any Covered Software prove defective in any respect, You     *
+*  (not any Contributor) assume the cost of any necessary servicing,   *
+*  repair, or correction. This disclaimer of warranty constitutes an   *
+*  essential part of this License. No use of any Covered Software is   *
+*  authorized under this License except under this disclaimer.         *
+*                                                                      *
+************************************************************************
+
+************************************************************************
+*                                                                      *
+*  7. Limitation of Liability                                          *
+*  --------------------------                                          *
+*                                                                      *
+*  Under no circumstances and under no legal theory, whether tort      *
+*  (including negligence), contract, or otherwise, shall any           *
+*  Contributor, or anyone who distributes Covered Software as          *
+*  permitted above, be liable to You for any direct, indirect,         *
+*  special, incidental, or consequential damages of any character      *
+*  including, without limitation, damages for lost profits, loss of    *
+*  goodwill, work stoppage, computer failure or malfunction, or any    *
+*  and all other commercial damages or losses, even if such party      *
+*  shall have been informed of the possibility of such damages. This   *
+*  limitation of liability shall not apply to liability for death or   *
+*  personal injury resulting from such party's negligence to the       *
+*  extent applicable law prohibits such limitation. Some               *
+*  jurisdictions do not allow the exclusion or limitation of           *
+*  incidental or consequential damages, so this exclusion and          *
+*  limitation may not apply to You.                                    *
+*                                                                      *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+  This Source Code Form is "Incompatible With Secondary Licenses", as
+  defined by the Mozilla Public License, v. 2.0.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..44065a4
--- /dev/null
+++ b/README.md
@@ -0,0 +1,90 @@
+# `nanowasm`, the tiny Wasm interpreter that does not block you
+
+**This project is still unfinished and is not meant for production use.**
+
+This project aims to provide the most minimal Wasm interpreter possible in
+strictly portable ANSI C (C89/C90). It can run one or more Wasm applications
+concurrently, without threading. This project requires the
+[Nanowasm extensions](https://gitea.privatedns.org/xavi/nanowasm-design/)
+to the WebAssembly language. A NanoWasm-compatible program can be built from
+a MVP WebAssembly program with [`nwc`](https://gitea.privatedns.org/xavi/nwc/).
+
+## Features
+
+- Portable **ANSI C** implementation. **Runs on bare metal environments**.
+- **No dependencies** other than an ANSI C (C89/C90) compiler.
+- Asynchronous interface that allows to **run multiple applications**
+**concurrently, without threads**.
+- **I/O-agnostic** implementation for maximum flexibility: read modules
+from a network, write the stack into a file, implement a MMU in software...
+Anything is possible!
+- Suitable for **resource-constrained devices**, such as microcontrollers.
+- **No memory allocator required**.
+- Supports both **big-endian and little-endian architectures**.
+
+### Comparison chart
+
+| Feature | `nanowasm` | [`wasm-micro-runtime`] | [`wasm3`] | [`wac`] | [`toywasm`] |
+| ------- | ------- | ------- | ------- | ------- | ------- |
+| **Asynchronous interface** | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ |
+| **I/O-agnostic** | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ |
+| **No heap required** | ✅ | ❌ | ❌ | ❌ | ❌ |
+| **Big-endian support** | ✅ | ⚠️ | ✅ | ❌ | ✅ |
+| **No compiler-specific extensions** | ✅ | ❌ | ❌ | ❌ | ❌ |
+| **C dialect** | **`c89`** | `gnu99` | `c99` | `gnu99` | `c11` |
+| **Public functions** | **7** | 156 | 44 | N/A | N/A |
+| **Minimal `.text` footprint** | **49 KiB** | 452 KiB | 519 KiB | N/A | N/A |
+| **Per-module memory usage** | ~1016 bytes | N/A | N/A | N/A | N/A |
+| **Per-instance memory usage** | ~728 bytes | N/A | N/A | N/A | N/A |
+
+Also, see a [detailed explanation](COMPARE.md) behind the numbers above.
+
+## What `nanowasm` is not
+
+As opposed to other interpreters, `nanowasm` prefers lower memory usage
+rather than run-time performance. Therefore, it should not be unfairly
+compared _performance_-wise against other interpreters.
+
+## How to build
+
+Use the conventional process in CMake projects:
+
+```
+cmake -B <dir>
+cmake --build <dir>
+```
+
+## Examples
+
+- [`example/minimal.c`](examples/minimal.c) provides the essential minimum code
+required to work with `nanowasm` i.e., without any imports. This is only meant
+as a starting point for implementations, and not as a standalone program.
+
+- [`example/proc_exit.c`](examples/proc_exit.c) defines the code required to
+support the following minimal C program built with
+[`wasi-sdk`](https://github.com/WebAssembly/wasi-sdk):
+
+```c
+int main()
+{
+    return 0;
+}
+```
+
+## License
+
+```
+nanowasm, a tiny WebAssembly/Wasm interpreter
+Copyright (C) 2023-2025  Xavier Del Campo Romero
+
+This Source Code Form is subject to the terms of the Mozilla Public
+License, v. 2.0. If a copy of the MPL was not distributed with this
+file, You can obtain one at https://mozilla.org/MPL/2.0/.
+```
+
+Also, see [LICENSE](LICENSE).
+
+[`wasm-micro-runtime`]: https://github.com/bytecodealliance/wasm-micro-runtime
+[`wasm3`]: https://github.com/wasm3/wasm3
+[`wac`]: https://github.com/kanaka/wac
+[`toywasm`]: https://github.com/yamt/toywasm
diff --git a/doc/frame b/doc/frame
new file mode 100644
index 0000000..62f387c
--- /dev/null
+++ b/doc/frame
@@ -0,0 +1,30 @@
+[ previous frame ]
+[ meta local 0 ]
+[ entry 0 local 0 ] <- local_start
+[ entry 1 local 0 ]
+[ ... ]
+[ entry n local 0 ]
+[ meta local 1 ]
+[ entry 0 local 1 ]
+[ entry 1 local 1 ]
+[ ... ]
+[ entry m local 1 ]
+[ meta local j ]
+[ ... ]
+[ entry i local j ]
+[ frame 0 ] <- addr
+[ return value 0 ]
+
+[ previous frame ]
+[ entry 0 local 0 ] <- local_start
+[ entry 1 local 0 ]
+[ ... ]
+[ entry n local 0 ]
+[ entry 0 local 1 ]
+[ entry 1 local 1 ]
+[ ... ]
+[ entry m local 1 ]
+[ ... ]
+[ entry i local j ]
+[ frame 1 ] <- addr
+[ return value 0 ]
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
new file mode 100644
index 0000000..c182e37
--- /dev/null
+++ b/examples/CMakeLists.txt
@@ -0,0 +1,10 @@
+function(nw_example example)
+    add_executable(nw_${example} ${example}.c)
+    target_link_libraries(nw_${example} PRIVATE ${PROJECT_NAME})
+    install(TARGETS nw_${example})
+    target_compile_options(nw_${example} PRIVATE ${sup_cflags})
+endfunction()
+
+nw_example(minimal)
+nw_example(proc_exit)
+nw_example(file)
diff --git a/examples/example.wasm b/examples/example.wasm
new file mode 100644
index 0000000..25871e0
--- /dev/null
+++ b/examples/example.wasm
diff --git a/examples/file.c b/examples/file.c
new file mode 100644
index 0000000..c913830
--- /dev/null
+++ b/examples/file.c
@@ -0,0 +1,659 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <errno.h>
+#include <stddef.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct inst
+{
+    long retval;
+    size_t n_files;
+
+    struct file
+    {
+        FILE *f;
+        int fd;
+    } *files;
+
+    struct mem
+    {
+        void *p;
+        size_t n;
+    } stack, linear, global;
+};
+
+static int io_read(void *const buf, const size_t n, void *const user)
+{
+    FILE *const f = user;
+    const size_t r = fread(buf, 1, 1, f);
+
+    if (!r && ferror(f))
+    {
+        fprintf(stderr, "ferror\n");
+        return -1;
+    }
+
+    return r;
+}
+
+static enum nw_state io_seek(const long offset, void *const user)
+{
+    if (fseek(user, offset, SEEK_SET))
+    {
+        fprintf(stderr, "fseek(3): %s\n", strerror(errno));
+        return NW_FATAL;
+    }
+
+    return NW_OK;
+}
+
+static enum nw_state io_tell(long *const out, void *const user)
+{
+    const long offset = ftell(user);
+
+    if (offset < 0)
+    {
+        fprintf(stderr, "ftell(3): %s\n", strerror(errno));
+        return NW_FATAL;
+    }
+
+    *out = offset;
+    return NW_OK;
+}
+
+static int io_eof(void *const user)
+{
+    FILE *const f = user;
+
+    return feof(f);
+}
+
+static int push(const void *const src, const size_t n, void *const user)
+{
+    struct inst *const inst = user;
+    struct mem *const s = &inst->stack;
+    char *const p = realloc(s->p, s->n + n);
+
+    if (!p)
+    {
+        fprintf(stderr, "realloc(3): %s\n", strerror(errno));
+        return -1;
+    }
+
+    fprintf(stderr, "pushed %zu bytes: {", n);
+
+    for (size_t i = 0; i < n; i++)
+    {
+        fprintf(stderr, "%hhu", ((const char *)src)[i]);
+
+        if (i + 1 < n)
+            fputs(", ", stderr);
+    }
+
+    memcpy(&p[s->n], src, n);
+    s->p = p;
+    s->n += n;
+    fprintf(stderr, "}, stack size=%zu\n", s->n);
+    return n;
+}
+
+static int pop(void *const dst, const size_t n, void *const user)
+{
+    struct inst *const inst = user;
+    struct mem *const s = &inst->stack;
+
+    if (s->n < n)
+    {
+        fprintf(stderr, "stack underflow\n");
+        return -1;
+    }
+
+    const char *const src = (const char *)s->p + (s->n - n);
+
+    fprintf(stderr, "popped %zu bytes: {", n);
+
+    for (size_t i = 0; i < n; i++)
+    {
+        fprintf(stderr, "%hhu", ((const char *)src)[i]);
+
+        if (i + 1 < n)
+            fputs(", ", stderr);
+    }
+
+    if (dst)
+        memcpy(dst, src, n);
+
+    if (s->n == n)
+    {
+        free(s->p);
+        s->p = NULL;
+    }
+    else
+    {
+        char *const p = realloc(s->p, s->n - n);
+
+        if (!p)
+        {
+            fprintf(stderr, "realloc(3): %s\n", strerror(errno));
+            return -1;
+        }
+
+        s->p = p;
+    }
+
+    s->n -= n;
+    fprintf(stderr, "}, stack size=%zu\n", s->n);
+    return n;
+}
+
+static size_t ptr(void *const user)
+{
+    return ((const struct inst *)user)->stack.n;
+}
+
+static int load(const nw_varuint32 offset, void *const dst, const size_t n,
+    const struct mem *const m)
+{
+    if (n > m->n || offset > m->n - n)
+    {
+        fprintf(stderr, "out-of-bounds access, offset=%lu, n=%zu\n",
+            (unsigned long)offset, (unsigned long)n);
+        return -1;
+    }
+
+    fprintf(stderr, "loaded %zu bytes from offset %lu: {", (unsigned long)n,
+        (unsigned long)offset);
+
+    for (size_t i = 0; i < n; i++)
+    {
+        fprintf(stderr, "%hhu", ((const char *)m->p)[offset + i]);
+
+        if (i + 1 < n)
+            fputs(", ", stderr);
+    }
+
+    fputs("}\n", stderr);
+    memcpy(dst, (const char *)m->p + offset, n);
+    return n;
+}
+
+static int store(const nw_varuint32 offset, const void *const src,
+    const size_t n, const struct mem *const m)
+{
+    if (n > m->n || offset > m->n - n)
+    {
+        fprintf(stderr, "out-of-bounds access, offset=%lu, n=%lu\n",
+            (unsigned long)offset, (unsigned long)n);
+        return -1;
+    }
+
+    fprintf(stderr, "stored %lu bytes into offset %lu: {", (unsigned long)n,
+        (unsigned long)offset);
+
+    for (size_t i = 0; i < n; i++)
+    {
+        fprintf(stderr, "%hhu", ((const char *)src)[i]);
+
+        if (i + 1 < n)
+            fputs(", ", stderr);
+    }
+
+    fputs("}\n", stderr);
+    memcpy((char *)m->p + offset, src, n);
+    return n;
+}
+
+static int stread(const size_t offset, void *const dst, const size_t n,
+    void *const user)
+{
+    const struct inst *const inst = user;
+
+    return load(offset, dst, n, &inst->stack);
+}
+
+static int stwrite(const size_t offset, const void *const src, const size_t n,
+    void *const user)
+{
+    const struct inst *const inst = user;
+
+    return store(offset, src, n, &inst->stack);
+}
+
+static int ensure_linear(struct mem *const m, const unsigned long offset,
+    const size_t n)
+{
+    void *const p = realloc(m->p, offset + n);
+
+    if (!p)
+    {
+        fprintf(stderr, "realloc(3): %s\n", strerror(errno));
+        return -1;
+    }
+
+    m->p = p;
+    m->n = offset + n;
+    memset((char *)m->p + offset, 0, n);
+    return 0;
+}
+
+static int lnload(const unsigned long offset, void *const dst, const size_t n,
+    void *const user)
+{
+    struct inst *const i = user;
+    struct mem *const m = &i->linear;
+
+    if (offset >= m->n && ensure_linear(m, offset, n))
+    {
+        fprintf(stderr, "ensure_linear failed\n");
+        return -1;
+    }
+
+    fprintf(stderr, "loaded %lu bytes from offset %lu: {", (unsigned long)n,
+        (unsigned long)offset);
+
+    for (size_t i = 0; i < n; i++)
+    {
+        fprintf(stderr, "%hhu", ((const char *)m->p)[offset + i]);
+
+        if (i + 1 < n)
+            fputs(", ", stderr);
+    }
+
+    fputs("}\n", stderr);
+    memcpy(dst, (const char *)m->p + offset, n);
+    return n;
+}
+
+static int lnstore(const unsigned long offset, const void *const src,
+    const size_t n, void *const user)
+{
+    struct inst *const i = user;
+    struct mem *const m = &i->linear;
+
+    if (offset >= m->n && ensure_linear(m, offset, n))
+    {
+        fprintf(stderr, "ensure_linear failed\n");
+        return -1;
+    }
+
+    fprintf(stderr, "stored %lu bytes into offset %lu: {", (unsigned long)n,
+        (unsigned long)offset);
+
+    for (size_t i = 0; i < n; i++)
+    {
+        fprintf(stderr, "%hhu", ((const char *)src)[i]);
+
+        if (i + 1 < n)
+            fputs(", ", stderr);
+    }
+
+    fputs("}\n", stderr);
+    memcpy((char *)m->p + offset, src, n);
+    return n;
+}
+
+static int glload(const unsigned long offset, void *const dst,
+    const size_t n, void *const user)
+{
+    const struct inst *const i = user;
+
+    return load(offset, dst, n, &i->global);
+}
+
+static int glstore(const unsigned long offset, const void *const src,
+    const size_t n, void *const user)
+{
+    const struct inst *const i = user;
+
+    return store(offset, src, n, &i->global);
+}
+
+static enum nw_state wasi_exit(const union nw_value *const params,
+    union nw_value *const ret, void *user)
+{
+    struct inst *const i = user;
+
+    i->retval = params->i32;
+    return NW_OK;
+}
+
+static enum nw_state wasi_fd_close(const union nw_value *const params,
+    union nw_value *const ret, void *user)
+{
+    return NW_FATAL;
+}
+
+static enum nw_state wasi_fd_fdstat_get(const union nw_value *const params,
+    union nw_value *const ret, void *user)
+{
+    return NW_FATAL;
+}
+
+static enum nw_state wasi_fd_prestat_get(const union nw_value *const params,
+    union nw_value *const ret, void *user)
+{
+    /*
+     * From wasi/phases/old/snapshot_0/docs.md:
+     *
+     * fd_prestat_get(fd: fd) -> (errno, prestat)
+     *     Return a description of the given preopened file descriptor.
+     *     Params
+     *     fd: fd
+     *     Results
+     *     error: errno
+     *     buf: prestat The buffer where the description is stored.
+     *
+     * Offset: 0
+     * prestat: Union
+     * Information about a pre-opened capability.
+     * Size: 8
+     * Alignment: 4
+     * Union Layout
+     * tag_size: 1
+     * tag_align: 1
+     * contents_offset: 4
+     * contents_size: 4
+     * contents_align: 4
+     */
+
+    const long fd = params[0].i32;
+    const unsigned long prestat = params[1].i32;
+    const struct file *fl = NULL;
+    struct inst *const inst = user;
+
+    fprintf(stderr, "fd=%lu, prestat=%#lx\n", fd, prestat);
+
+    for (size_t i = 0; i < inst->n_files; i++)
+    {
+        const struct file *const f = &inst->files[i];
+
+        if (fd == (unsigned long)f->fd)
+        {
+            fl = f;
+            break;
+        }
+    }
+
+    if (!fl)
+    {
+        /* __WASI_EBADF */
+        ret->i32 = 8;
+        return NW_OK;
+    }
+
+    return NW_OK;
+}
+
+static enum nw_state wasi_fd_prestat_dir_name(
+    const union nw_value *const params, union nw_value *const ret, void *user)
+{
+    return NW_FATAL;
+}
+
+static enum nw_state wasi_fd_read( const union nw_value *const params,
+    union nw_value *const ret, void *user)
+{
+    const long fd = params[0].i32;
+    const unsigned long iovec = params[1].i32, n = params[2].i32,
+        nread = params[3].i32;
+
+    fprintf(stderr, "fd=%ld, iovec=%#lx, n=%lu, nread=%#lx\n",
+        fd, iovec, n, nread);
+    return NW_FATAL;
+}
+
+static enum nw_state wasi_path_open( const union nw_value *const params,
+    union nw_value *const ret, void *user)
+{
+    return NW_FATAL;
+}
+
+int main(int argc, char *argv[])
+{
+    int ret = EXIT_FAILURE;
+    FILE *f = NULL;
+    struct inst ins = {0};
+
+    if (argc != 2)
+    {
+        fprintf(stderr, "%s <wasm>\n", *argv);
+        goto end;
+    }
+
+    const char *const path = argv[1];
+
+    if (!(f = fopen(path, "rb")))
+    {
+        fprintf(stderr, "fopen(3) %s: %s\n", path, strerror(errno));
+        goto end;
+    }
+
+    static const struct nw_import imports[] =
+    {
+        {
+            .kind = NW_KIND_FUNCTION,
+            .module = "wasi_snapshot_preview1",
+            .field = "proc_exit",
+            .u.function =
+            {
+                .fn = wasi_exit,
+                .signature = "(i)"
+            }
+        },
+
+        {
+            .kind = NW_KIND_FUNCTION,
+            .module = "wasi_snapshot_preview1",
+            .field = "fd_close",
+            .u.function =
+            {
+                .fn = wasi_fd_close,
+                .signature = "i(i)"
+            }
+        },
+
+        {
+            .kind = NW_KIND_FUNCTION,
+            .module = "wasi_snapshot_preview1",
+            .field = "fd_fdstat_get",
+            .u.function =
+            {
+                .fn = wasi_fd_fdstat_get,
+                .signature = "i(ii)"
+            }
+        },
+
+        {
+            .kind = NW_KIND_FUNCTION,
+            .module = "wasi_snapshot_preview1",
+            .field = "fd_prestat_get",
+            .u.function =
+            {
+                .fn = wasi_fd_prestat_get,
+                .signature = "i(ii)"
+            }
+        },
+
+        {
+            .kind = NW_KIND_FUNCTION,
+            .module = "wasi_snapshot_preview1",
+            .field = "fd_prestat_dir_name",
+            .u.function =
+            {
+                .fn = wasi_fd_prestat_dir_name,
+                .signature = "i(ii)"
+            }
+        },
+
+        {
+            .kind = NW_KIND_FUNCTION,
+            .module = "wasi_snapshot_preview1",
+            .field = "fd_read",
+            .u.function =
+            {
+                .fn = wasi_fd_read,
+                .signature = "i(iiii)"
+            }
+        },
+
+        {
+            .kind = NW_KIND_FUNCTION,
+            .module = "wasi_snapshot_preview1",
+            .field = "path_open",
+            .u.function =
+            {
+                .fn = wasi_path_open,
+                .signature = "i(iiiiiIIii)"
+            }
+        },
+    };
+
+    const struct nw_io_cfg io =
+    {
+        .read = io_read,
+        .seek = io_seek,
+        .tell = io_tell,
+        .eof = io_eof,
+        .user = f
+    };
+
+    enum {N_IMPORTS = sizeof imports / sizeof *imports};
+
+    const struct nw_mod_cfg cfg =
+    {
+        .imports = imports,
+        .imp_indexes = (struct nw_import_index[N_IMPORTS]){{0}},
+        .n_imports = N_IMPORTS,
+        .io = io
+    };
+
+    struct nw_mod m;
+    struct nw_mod_out mout;
+
+    nw_init(&m, &cfg);
+
+again:
+
+    switch (nw_load(&m, &mout))
+    {
+        case NW_OK:
+            break;
+
+        case NW_AGAIN:
+            goto again;
+
+        case NW_FATAL:
+            fprintf(stderr, "nw_load failed\n");
+            goto end;
+    }
+
+    if (!(ins.global.p = malloc(ins.global.n = mout.global)))
+    {
+        fprintf(stderr, "malloc(3): %s\n", strerror(errno));
+        goto end;
+    }
+
+    enum {ARGS = 10};
+    const struct nw_inst_cfg icfg =
+    {
+        .entry = "_start",
+        .interp_cfg =
+        {
+            .io = io,
+            .m = &m,
+            .user = &ins,
+            .args = (union nw_value[ARGS]){{0}},
+            .n_args = ARGS,
+            .stack =
+            {
+                .push = push,
+                .pop = pop,
+                .ptr = ptr,
+                .read = stread,
+                .write = stwrite
+            },
+
+            .linear =
+            {
+                .load = lnload,
+                .store = lnstore
+            },
+
+            .global =
+            {
+                .load = glload,
+                .store = glstore
+            }
+        }
+    };
+
+    struct nw_inst inst;
+
+    if (nw_start(&inst, &icfg))
+    {
+        fprintf(stderr, "nw_start failed\n");
+        goto end;
+    }
+
+again2:
+
+    switch (nw_run(&inst))
+    {
+        case NW_OK:
+            break;
+
+        case NW_AGAIN:
+
+            if (ins.retval)
+            {
+                ret = ins.retval;
+                fprintf(stderr, "instance exited with status %d\n", ret);
+                goto end;
+            }
+
+            goto again2;
+
+        case NW_FATAL:
+            fprintf(stderr, "nw_run failed: %s\n", nw_rexc(&inst));
+            goto end;
+    }
+
+    ret = EXIT_SUCCESS;
+
+end:
+
+    for (size_t i = 0; i < ins.n_files; i++)
+    {
+        const struct file *const f = &ins.files[i];
+
+        if (fclose(f->f))
+        {
+            fprintf(stderr, "fclose(3) [%lu]: %s\n", (unsigned long)i,
+                strerror(errno));
+            ret = EXIT_FAILURE;
+        }
+    }
+
+    if (f && fclose(f))
+    {
+        fprintf(stderr, "fclose(3) %s: %s\n", path, strerror(errno));
+        goto end;
+    }
+
+    free(ins.files);
+    free(ins.stack.p);
+    free(ins.linear.p);
+    free(ins.global.p);
+    return ret;
+}
diff --git a/examples/minimal.c b/examples/minimal.c
new file mode 100644
index 0000000..8812ac5
--- /dev/null
+++ b/examples/minimal.c
@@ -0,0 +1,136 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+static int io_read(void *const buf, const size_t n, void *const user)
+{
+    return -1;
+}
+
+static enum nw_state io_seek(const long offset, void *const user)
+{
+    return -1;
+}
+
+static enum nw_state io_tell(long *const out, void *const user)
+{
+    return -1;
+}
+
+static int io_eof(void *const user)
+{
+    return -1;
+}
+
+static int push(const void *const src, const size_t n, void *const user)
+{
+    return -1;
+}
+
+static int pop(void *const dst, const size_t n, void *const user)
+{
+    return -1;
+}
+
+static size_t ptr(void *const user)
+{
+    return 0;
+}
+
+static int load(const nw_varuint32 offset, void *const dst, const size_t n,
+    void *const user)
+{
+    return -1;
+}
+
+static int store(const nw_varuint32 offset, const void *const src,
+    const size_t n, void *const user)
+{
+    return -1;
+}
+
+int main(int argc, char *argv[])
+{
+    const struct nw_io_cfg io =
+    {
+        .read = io_read,
+        .seek = io_seek,
+        .tell = io_tell,
+        .eof = io_eof
+    };
+
+    const struct nw_mod_cfg cfg =
+    {
+        .io = io
+    };
+
+    struct nw_mod m;
+    struct nw_mod_out mout;
+
+    nw_init(&m, &cfg);
+
+again:
+
+    switch (nw_load(&m, &mout))
+    {
+        case NW_OK:
+            break;
+
+        case NW_AGAIN:
+            goto again;
+
+        case NW_FATAL:
+            return EXIT_FAILURE;
+    }
+
+    const struct nw_inst_cfg icfg =
+    {
+        .interp_cfg =
+        {
+            .io = io,
+            .m = &m,
+            .stack =
+            {
+                .push = push,
+                .pop = pop,
+                .ptr = ptr
+            },
+
+            .linear =
+            {
+                .load = load,
+                .store = store
+            }
+        }
+    };
+
+    struct nw_inst inst;
+
+    if (nw_start(&inst, &icfg))
+        return EXIT_FAILURE;
+
+again2:
+
+    switch (nw_run(&inst))
+    {
+        case NW_OK:
+            break;
+
+        case NW_AGAIN:
+            goto again2;
+
+        case NW_FATAL:
+            return EXIT_FAILURE;
+    }
+
+    return EXIT_SUCCESS;
+}
diff --git a/examples/proc_exit.c b/examples/proc_exit.c
new file mode 100644
index 0000000..d4a580e
--- /dev/null
+++ b/examples/proc_exit.c
@@ -0,0 +1,484 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <errno.h>
+#include <stddef.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct inst
+{
+    long retval;
+
+    struct mem
+    {
+        void *p;
+        size_t n;
+    } stack, linear, global;
+};
+
+static int io_read(void *const buf, const size_t n, void *const user)
+{
+    FILE *const f = user;
+    const size_t r = fread(buf, 1, 1, f);
+
+    if (!r && ferror(f))
+    {
+        fprintf(stderr, "%s: ferror\n", __func__);
+        return -1;
+    }
+
+    return r;
+}
+
+static enum nw_state io_seek(const long offset, void *const user)
+{
+    if (fseek(user, offset, SEEK_SET))
+    {
+        fprintf(stderr, "%s: fseek(3): %s\n", __func__, strerror(errno));
+        return NW_FATAL;
+    }
+
+    return NW_OK;
+}
+
+static enum nw_state io_tell(long *const out, void *const user)
+{
+    const long offset = ftell(user);
+
+    if (offset < 0)
+    {
+        fprintf(stderr, "%s: ftell(3): %s\n", __func__, strerror(errno));
+        return NW_FATAL;
+    }
+
+    *out = offset;
+    return NW_OK;
+}
+
+static int io_eof(void *const user)
+{
+    FILE *const f = user;
+
+    return feof(f);
+}
+
+static int push(const void *const src, const size_t n, void *const user)
+{
+    struct inst *const inst = user;
+    struct mem *const s = &inst->stack;
+    char *const p = realloc(s->p, s->n + n);
+
+    if (!p)
+    {
+        fprintf(stderr, "%s: realloc(3): %s\n", __func__, strerror(errno));
+        return -1;
+    }
+
+    fprintf(stderr, "pushed %zu bytes: {", n);
+
+    for (size_t i = 0; i < n; i++)
+    {
+        fprintf(stderr, "%hhu", ((const char *)src)[i]);
+
+        if (i + 1 < n)
+            fputs(", ", stderr);
+    }
+
+    memcpy(&p[s->n], src, n);
+    s->p = p;
+    s->n += n;
+    fprintf(stderr, "}, stack size=%zu\n", s->n);
+    return n;
+}
+
+static int pop(void *const dst, const size_t n, void *const user)
+{
+    struct inst *const inst = user;
+    struct mem *const s = &inst->stack;
+
+    if (s->n < n)
+    {
+        fprintf(stderr, "%s: stack underflow\n", __func__);
+        return -1;
+    }
+
+    const char *const src = (const char *)s->p + (s->n - n);
+
+    fprintf(stderr, "popped %zu bytes: {", n);
+
+    for (size_t i = 0; i < n; i++)
+    {
+        fprintf(stderr, "%hhu", ((const char *)src)[i]);
+
+        if (i + 1 < n)
+            fputs(", ", stderr);
+    }
+
+    memcpy(dst, src, n);
+
+    if (s->n == n)
+    {
+        free(s->p);
+        s->p = NULL;
+    }
+    else
+    {
+        char *const p = realloc(s->p, s->n - n);
+
+        if (!p)
+        {
+            fprintf(stderr, "%s: realloc(3): %s\n", __func__, strerror(errno));
+            return -1;
+        }
+
+        s->p = p;
+    }
+
+    s->n -= n;
+    fprintf(stderr, "}, stack size=%zu\n", s->n);
+    return n;
+}
+
+static size_t ptr(void *const user)
+{
+    return ((const struct inst *)user)->stack.n;
+}
+
+static int load(const nw_varuint32 offset, void *const dst, const size_t n,
+    const struct mem *const m)
+{
+    if (n > m->n || offset > m->n - n)
+    {
+        fprintf(stderr, "%s: out-of-bounds access, offset=%lu, n=%zu\n",
+            __func__, (unsigned long)offset, n);
+        return -1;
+    }
+
+    fprintf(stderr, "%s: loaded %zu bytes from offset %lu: {", __func__, n,
+        (unsigned long)offset);
+
+    for (size_t i = 0; i < n; i++)
+    {
+        fprintf(stderr, "%hhu", ((const char *)m->p)[offset + i]);
+
+        if (i + 1 < n)
+            fputs(", ", stderr);
+    }
+
+    fputs("}\n", stderr);
+    memcpy(dst, (const char *)m->p + offset, n);
+    return n;
+}
+
+static int store(const nw_varuint32 offset, const void *const src,
+    const size_t n, const struct mem *const m)
+{
+    if (n > m->n || offset > m->n - n)
+    {
+        fprintf(stderr, "%s: out-of-bounds access, offset=%lu, n=%zu\n",
+            __func__, (unsigned long)offset, n);
+        return -1;
+    }
+
+    fprintf(stderr, "%s: stored %zu bytes into offset %lu: {", __func__, n,
+        (unsigned long)offset);
+
+    for (size_t i = 0; i < n; i++)
+    {
+        fprintf(stderr, "%hhu", ((const char *)src)[i]);
+
+        if (i + 1 < n)
+            fputs(", ", stderr);
+    }
+
+    fputs("}\n", stderr);
+    memcpy((char *)m->p + offset, src, n);
+    return n;
+}
+
+static int stread(const size_t offset, void *const dst, const size_t n,
+    void *const user)
+{
+    const struct inst *const inst = user;
+
+    return load(offset, dst, n, &inst->stack);
+}
+
+static int stwrite(const size_t offset, const void *const src, const size_t n,
+    void *const user)
+{
+    const struct inst *const inst = user;
+
+    return store(offset, src, n, &inst->stack);
+}
+
+static int ensure_linear(struct mem *const m, const unsigned long offset,
+    const size_t n)
+{
+    void *const p = realloc(m->p, offset + n);
+
+    if (!p)
+    {
+        fprintf(stderr, "%s: realloc(3): %s\n", __func__, strerror(errno));
+        return -1;
+    }
+
+    m->p = p;
+    m->n = offset + n;
+    memset((char *)m->p + offset, 0, n);
+    return 0;
+}
+
+static int lnload(const unsigned long offset, void *const dst, const size_t n,
+    void *const user)
+{
+    struct inst *const i = user;
+    struct mem *const m = &i->linear;
+
+    if (offset >= m->n && ensure_linear(m, offset, n))
+    {
+        fprintf(stderr, "%s: ensure_linear failed\n", __func__);
+        return -1;
+    }
+
+    fprintf(stderr, "%s: loaded %zu bytes from offset %lu: {", __func__, n,
+        (unsigned long)offset);
+
+    for (size_t i = 0; i < n; i++)
+    {
+        fprintf(stderr, "%hhu", ((const char *)m->p)[offset + i]);
+
+        if (i + 1 < n)
+            fputs(", ", stderr);
+    }
+
+    fputs("}\n", stderr);
+    memcpy(dst, (const char *)m->p + offset, n);
+    return n;
+}
+
+static int lnstore(const unsigned long offset, const void *const src,
+    const size_t n, void *const user)
+{
+    struct inst *const i = user;
+    struct mem *const m = &i->linear;
+
+    if (offset >= m->n && ensure_linear(m, offset, n))
+    {
+        fprintf(stderr, "%s: ensure_linear failed\n", __func__);
+        return -1;
+    }
+
+    fprintf(stderr, "%s: stored %zu bytes into offset %lu: {", __func__, n,
+        (unsigned long)offset);
+
+    for (size_t i = 0; i < n; i++)
+    {
+        fprintf(stderr, "%hhu", ((const char *)src)[i]);
+
+        if (i + 1 < n)
+            fputs(", ", stderr);
+    }
+
+    fputs("}\n", stderr);
+    memcpy((char *)m->p + offset, src, n);
+    return n;
+}
+
+static int glload(const unsigned long offset, void *const dst,
+    const size_t n, void *const user)
+{
+    const struct inst *const i = user;
+
+    return load(offset, dst, n, &i->global);
+}
+
+static int glstore(const unsigned long offset, const void *const src,
+    const size_t n, void *const user)
+{
+    const struct inst *const i = user;
+
+    return store(offset, src, n, &i->global);
+}
+
+static enum nw_state wasi_exit(const union nw_value *const params,
+    union nw_value *const ret, void *user, struct nw_next *const next)
+{
+    struct inst *const i = user;
+
+    i->retval = params->i32;
+    return NW_OK;
+}
+
+int main(int argc, char *argv[])
+{
+    int ret = EXIT_FAILURE;
+    FILE *f = NULL;
+    struct inst ins = {0};
+
+    if (argc != 2)
+    {
+        fprintf(stderr, "%s <wasm>\n", *argv);
+        goto end;
+    }
+
+    const char *const path = argv[1];
+
+    if (!(f = fopen(path, "rb")))
+    {
+        fprintf(stderr, "%s: fopen(3) %s: %s\n", __func__, path,
+            strerror(errno));
+        goto end;
+    }
+
+    static const struct nw_import imports[] =
+    {
+        {
+            .kind = NW_KIND_FUNCTION,
+            .module = "wasi_snapshot_preview1",
+            .field = "proc_exit",
+            .u.function =
+            {
+                .fn = wasi_exit,
+                .signature = "(i)"
+            }
+        }
+    };
+
+    const struct nw_io_cfg io =
+    {
+        .read = io_read,
+        .seek = io_seek,
+        .tell = io_tell,
+        .eof = io_eof,
+        .user = f
+    };
+
+    enum {N_IMPORTS = sizeof imports / sizeof *imports};
+
+    const struct nw_mod_cfg cfg =
+    {
+        .imports = imports,
+        .imp_indexes = (struct nw_import_index[N_IMPORTS]){{0}},
+        .n_imports = N_IMPORTS,
+        .io = io
+    };
+
+    struct nw_mod m;
+    struct nw_mod_out mout;
+
+    nw_init(&m, &cfg);
+
+again:
+
+    switch (nw_load(&m, &mout))
+    {
+        case NW_OK:
+            break;
+
+        case NW_AGAIN:
+            goto again;
+
+        case NW_FATAL:
+            fprintf(stderr, "%s: nw_load failed\n", __func__);
+            goto end;
+    }
+
+    if (!(ins.global.p = malloc(ins.global.n = mout.global)))
+    {
+        fprintf(stderr, "%s: malloc(3): %s\n", __func__, strerror(errno));
+        goto end;
+    }
+
+    enum {ARGS = 1};
+    const struct nw_inst_cfg icfg =
+    {
+        .entry = "_start",
+        .interp_cfg =
+        {
+            .io = io,
+            .m = &m,
+            .user = &ins,
+            .args = (union nw_value[ARGS]){{0}},
+            .n_args = ARGS,
+            .stack =
+            {
+                .push = push,
+                .pop = pop,
+                .ptr = ptr,
+                .read = stread,
+                .write = stwrite
+            },
+
+            .linear =
+            {
+                .load = lnload,
+                .store = lnstore
+            },
+
+            .global =
+            {
+                .load = glload,
+                .store = glstore
+            }
+        }
+    };
+
+    struct nw_inst inst;
+
+    if (nw_start(&inst, &icfg))
+    {
+        fprintf(stderr, "%s: nw_start failed\n", __func__);
+        goto end;
+    }
+
+again2:
+
+    switch (nw_run(&inst))
+    {
+        case NW_OK:
+            break;
+
+        case NW_AGAIN:
+
+            if (ins.retval)
+            {
+                ret = ins.retval;
+                fprintf(stderr, "instance exited with status %d\n", ret);
+                goto end;
+            }
+
+            goto again2;
+
+        case NW_FATAL:
+            fprintf(stderr, "%s: nw_run failed: %s\n", __func__,
+                nw_rexc(&inst));
+            goto end;
+    }
+
+    ret = EXIT_SUCCESS;
+
+end:
+
+    if (f && fclose(f))
+    {
+        fprintf(stderr, "%s: fclose(3) %s: %s\n", __func__, path,
+            strerror(errno));
+        goto end;
+    }
+
+    free(ins.stack.p);
+    free(ins.linear.p);
+    free(ins.global.p);
+    return ret;
+}
diff --git a/include/nanowasm/dbg.h b/include/nanowasm/dbg.h
new file mode 100644
index 0000000..010a5c8
--- /dev/null
+++ b/include/nanowasm/dbg.h
@@ -0,0 +1,33 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef NW_DBG_H
+#define NW_DBG_H
+
+#include <nanowasm/types.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+void nw_dbg_init(struct nw_dbg *d, const struct nw_dbg_cfg *cfg);
+void nw_dbg_local(struct nw_dbg *d, unsigned long index);
+void nw_dbg_param(struct nw_dbg *d, unsigned long index);
+void nw_dbg_global(struct nw_dbg *d, unsigned long index);
+void nw_dbg_mem_load(struct nw_dbg *d, enum nw_type t, unsigned long offset);
+void nw_dbg_bt(struct nw_dbg *d, unsigned depth);
+int nw_dbg_value(const struct nw_dbg *d, struct nw_dbg_value *v);
+int nw_dbg_pc(const struct nw_dbg *d, long *pc);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/include/nanowasm/linear.h b/include/nanowasm/linear.h
new file mode 100644
index 0000000..71abf1c
--- /dev/null
+++ b/include/nanowasm/linear.h
@@ -0,0 +1,20 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef NW_LINEAR_H
+#define NW_LINEAR_H
+
+#include <nanowasm/types.h>
+
+enum nw_state nw_linear_load(struct nw_inst *i, struct nw_sm_io *io,
+    unsigned long offset);
+enum nw_state nw_linear_store(struct nw_inst *i, struct nw_sm_io *io,
+    unsigned long offset);
+
+#endif
diff --git a/include/nanowasm/nw.h b/include/nanowasm/nw.h
new file mode 100644
index 0000000..093fa21
--- /dev/null
+++ b/include/nanowasm/nw.h
@@ -0,0 +1,32 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef NW_H
+#define NW_H
+
+#include <nanowasm/types.h>
+#include <nanowasm/linear.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+void nw_init(struct nw_mod *m, const struct nw_mod_cfg *cfg);
+enum nw_state nw_load(struct nw_mod *m, struct nw_mod_out *out);
+int nw_start(struct nw_inst *i, const struct nw_inst_cfg *icfg);
+enum nw_state nw_run(struct nw_inst *i);
+const char *nw_lexc(const struct nw_mod *m);
+const char *nw_rexc(const struct nw_inst *i);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/include/nanowasm/private.h b/include/nanowasm/private.h
new file mode 100644
index 0000000..60fe383
--- /dev/null
+++ b/include/nanowasm/private.h
@@ -0,0 +1,675 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef NANOWASM_PRIVATE_H
+#define NANOWASM_PRIVATE_H
+
+#if !defined(NW_H) && !defined(NW_TYPES_H)
+#error Do not #include <nanowasm/private.h> directly. \
+    Please either #include <nanowasm/nw.h> or <nanowasm/types.h>
+#endif
+
+#include <stddef.h>
+
+typedef signed char nw_varint1;
+typedef unsigned char nw_varuint1;
+typedef signed char nw_varint7;
+typedef unsigned char nw_varuint7;
+typedef unsigned long nw_varuint32;
+typedef long nw_varint32;
+typedef struct nw_ull nw_varuint64;
+typedef struct nw_ll nw_varint64;
+
+struct nw_interp;
+
+enum
+{
+    NW_SECTION_CUSTOM,
+    NW_SECTION_TYPE,
+    NW_SECTION_IMPORT,
+    NW_SECTION_FUNCTION,
+    NW_SECTION_TABLE,
+    NW_SECTION_MEMORY,
+    NW_SECTION_GLOBAL,
+    NW_SECTION_EXPORT,
+    NW_SECTION_START,
+    NW_SECTION_ELEMENT,
+    NW_SECTION_CODE,
+    NW_SECTION_DATA,
+    NW_SECTION_DATA_COUNT,
+
+    NW_SECTIONS
+};
+
+enum
+{
+    NW_CUSTOM_TO,
+    NW_CUSTOM_FTI,
+    NW_CUSTOM_FBO,
+    NW_CUSTOM_LO,
+    NW_CUSTOM_ITI,
+
+    NW_CUSTOM_SECTIONS
+};
+
+struct nw_sm_leb128
+{
+    unsigned shift, bcnt;
+    struct nw_ull result;
+};
+
+struct nw_leuint32
+{
+    unsigned char v[4];
+};
+
+struct nw_leuint64
+{
+    unsigned char v[8];
+};
+
+struct nw_global
+{
+    nw_varuint1 mutability;
+    enum nw_type type;
+    union nw_value value;
+};
+
+struct nw_table
+{
+    unsigned long initial, max;
+    unsigned char data;
+};
+
+struct nw_return
+{
+    nw_varuint1 count;
+    enum nw_type type;
+};
+
+struct nw_fn
+{
+    nw_varuint32 index, param_count;
+    long param_types;
+    struct nw_return ret;
+};
+
+struct nw_frame
+{
+    nw_varuint32 local_count, body_size, block_i;
+    struct nw_fn fn;
+    struct nw_return prev_ret;
+    int child;
+    unsigned char prev_op;
+    size_t fr_start, local_start, local_end;
+    long start, pc;
+};
+
+struct nw_local_meta
+{
+    nw_varuint32 entry_count;
+    enum nw_type type;
+};
+
+struct nw_find_local
+{
+    nw_varuint32 index, entry_i;
+    struct nw_sm_io io;
+    struct nw_local_meta meta;
+    size_t addr;
+    enum nw_state (*next)(struct nw_interp *);
+};
+
+struct nw_find_param
+{
+    const struct nw_fn *fn;
+    struct nw_sm_leb128 leb128;
+    struct nw_sm_io io;
+    long pc;
+    nw_varuint32 index, param_i;
+    size_t sz;
+    enum nw_state (*next)(struct nw_interp *);
+
+    struct nw_find_param_out
+    {
+        enum nw_type type;
+        size_t addr;
+    } out;
+};
+
+struct nw_get_import_type
+{
+    nw_varuint32 index;
+    struct nw_sm_io io;
+    struct nw_leuint32 value;
+    unsigned char kind;
+    enum nw_state (*next)(struct nw_interp *);
+
+    struct nw_get_import_type_out
+    {
+        enum nw_kind kind;
+    } out;
+};
+
+union nw_i_sm
+{
+    struct nw_i_sm_b
+    {
+        unsigned char op;
+        struct nw_sm_io io;
+        struct nw_next next;
+        long pc;
+        void (*f)(struct nw_interp *);
+    } bytecode;
+
+    struct nw_i_sm_unreachable
+    {
+        long offset;
+    } unreachable;
+
+    struct nw_i_sm_i32_const
+    {
+        nw_varint32 value;
+        struct nw_sm_leb128 leb128;
+        struct nw_sm_io io;
+    } i32_const;
+
+    struct nw_i_sm_i64_const
+    {
+        nw_varuint64 value;
+        struct nw_sm_leb128 leb128;
+        struct nw_sm_io io;
+    } i64_const;
+
+    struct nw_i_sm_exp
+    {
+        enum nw_kind kind;
+        struct nw_sm_leb128 leb128;
+        nw_varuint32 count, entry_i, len, len_i;
+        const char *sym;
+        nw_varuint32 index;
+        long offset;
+        enum nw_state (*next)(struct nw_interp *);
+    } export;
+
+    struct nw_i_sm_type
+    {
+        long pc;
+        struct nw_sm_io io;
+        struct nw_sm_leb128 leb128;
+        nw_varuint32 param_i, fn_index;
+        struct nw_leuint32 fti, to;
+        struct nw_get_import_type git;
+        enum nw_state (*next)(struct nw_interp *);
+        struct nw_fn out;
+    } type;
+
+    struct nw_i_sm_ffn
+    {
+        void (*next)(struct nw_interp *);
+        struct nw_sm_io io;
+        struct nw_fn fn;
+        struct nw_leuint32 fbo;
+    } ffn;
+
+    struct nw_i_sm_pl
+    {
+        long body_start;
+        struct nw_sm_leb128 leb128;
+        struct nw_sm_io io;
+        struct nw_frame fr;
+        nw_varuint32 param_i, local_i, local_count, entry_i;
+        union nw_value value;
+        enum nw_type type;
+        struct nw_local_meta meta;
+    } pl;
+
+    struct nw_i_sm_sb
+    {
+        void (*next)(struct nw_interp *);
+        struct nw_sm_leb128 leb128;
+        struct nw_sm_io io;
+    } start_block;
+
+    struct nw_i_sm_imm
+    {
+        void (*next)(struct nw_interp *);
+        struct nw_sm_leb128 leb128;
+
+        struct nw_i_sm_imm_out
+        {
+            nw_varuint32 flags, offset;
+        } out;
+    } imm;
+
+    struct nw_i_sm_load
+    {
+        unsigned long addr;
+        struct nw_sm_io io;
+        struct nw_i_sm_imm_out imm;
+
+        union
+        {
+            char i8;
+            long i32;
+            struct nw_ll i64;
+            float f32;
+            double f64;
+            struct nw_leuint32 v32;
+        } value;
+    } load;
+
+    struct nw_i_sm_store
+    {
+        unsigned long addr;
+        struct nw_sm_io io;
+        struct nw_i_sm_imm_out imm;
+
+        union
+        {
+            long i32;
+            struct nw_ull i64;
+            float f32;
+            double f64;
+            struct nw_leuint32 v32;
+            struct nw_leuint64 v64;
+        } value;
+    } store;
+
+    struct nw_i_sm_br
+    {
+        nw_varuint32 relative_depth;
+        struct nw_sm_leb128 leb128;
+        struct nw_sm_io io;
+    } br;
+
+    struct nw_i_sm_br_if
+    {
+        nw_varuint32 relative_depth;
+        struct nw_sm_leb128 leb128;
+        struct nw_sm_io io;
+        union nw_value condition;
+    } br_if;
+
+    struct nw_i_sm_call
+    {
+        nw_varuint32 index;
+        struct nw_sm_leb128 leb128;
+    } call;
+
+    struct nw_i_sm_call_indirect
+    {
+        nw_varuint32 index, value;
+        struct nw_sm_leb128 leb128;
+    } call_indirect;
+
+    struct nw_i_sm_end
+    {
+        long offset;
+        struct nw_sm_leb128 leb128;
+    } end;
+
+    struct nw_i_sm_unwind
+    {
+        nw_varuint32 pending, entry_i;
+        size_t sz;
+        struct nw_sm_io io;
+        struct nw_sm_leb128 leb128;
+        struct nw_frame fr;
+        union nw_value retval, value;
+        struct nw_find_local fl;
+    } unwind;
+
+    struct nw_i_sm_set_global
+    {
+        nw_varuint32 index;
+        struct nw_sm_leb128 leb128;
+        struct nw_sm_io io;
+        struct nw_global gl;
+    } set_global;
+
+    struct nw_i_sm_get_global
+    {
+        nw_varuint32 index;
+        struct nw_sm_leb128 leb128;
+        struct nw_sm_io io;
+        struct nw_global gl;
+    } get_global;
+
+    struct nw_i_sm_set_local
+    {
+        nw_varuint32 index;
+        struct nw_sm_leb128 leb128;
+        struct nw_sm_io io;
+        enum nw_state (*next)(struct nw_interp *);
+
+        union
+        {
+            struct nw_find_local l;
+            struct nw_find_param p;
+        } f;
+
+        struct nw_i_sm_set_local_out
+        {
+            union nw_value value;
+            enum nw_type type;
+        } out;
+    } set_local;
+
+    struct nw_i_sm_tee_local
+    {
+        struct nw_sm_io io;
+        struct nw_i_sm_set_local_out in;
+    } tee_local;
+
+    struct nw_i_sm_get_local
+    {
+        nw_varuint32 index;
+        struct nw_sm_leb128 leb128;
+        struct nw_sm_io io;
+
+        union
+        {
+            struct nw_find_local l;
+            struct nw_find_param p;
+        } f;
+
+        union nw_value value;
+        enum nw_type type;
+    } get_local;
+
+    struct nw_i_sm_break
+    {
+        nw_varuint32 relative_depth, label_i;
+        struct nw_sm_io io;
+        long pc, lo;
+        struct nw_leuint32 offset, lpc, dst, n;
+    } brk;
+
+    struct nw_i_sm_arithm
+    {
+        enum nw_type type;
+        struct nw_sm_io io;
+        union nw_value value;
+
+        struct nw_i_sm_arithm_out
+        {
+            union nw_value left, right;
+        } out;
+
+        int (*op)(const struct nw_i_sm_arithm_out *, union nw_value *);
+    } arithm;
+
+    struct nw_i_sm_unary
+    {
+        enum nw_type type;
+        struct nw_sm_io io;
+        union nw_value in, out;
+        int (*op)(const union nw_value *, union nw_value *);
+    } unary;
+
+    struct nw_i_sm_drop
+    {
+        struct nw_sm_io io;
+        union nw_value value;
+    } drop;
+
+    struct nw_i_sm_call_import
+    {
+        enum nw_type type;
+        nw_varuint32 type_i, param_i;
+        struct nw_sm_leb128 leb128;
+        struct nw_sm_io io;
+        struct nw_fn fn;
+        struct nw_next next;
+        union nw_value value;
+        long pc;
+        size_t addr, sz;
+        const struct nw_import *imp;
+    } call_import;
+};
+
+struct nw_interp
+{
+    const void *set;
+    const char *exception;
+    int exit;
+    int retval;
+    struct nw_interp_cfg cfg;
+    enum nw_state (*next)(struct nw_interp *);
+    struct nw_frame fr;
+    union nw_i_sm sm;
+    void *state, *args;
+    enum nw_type push_type;
+
+    struct
+    {
+        nw_varuint32 n_pages;
+    } linear, table;
+};
+
+union nw_sm
+{
+    struct nw_sm_cm
+    {
+        unsigned char buf[sizeof "\0asm" - 1];
+        struct nw_sm_io io;
+    } check_magic;
+
+    struct nw_sm_cv
+    {
+        unsigned char version[sizeof (struct nw_leuint32)];
+        struct nw_sm_io io;
+    } check_version;
+
+    struct nw_sm_st
+    {
+        nw_varuint32 entry_i, param_count, p_i;
+        struct nw_sm_leb128 leb128;
+    } type;
+
+    struct nw_sm_imp
+    {
+        long mod_off, field_off;
+        nw_varuint32 entry_i, mod_len, field_len, len_i, imp_i;
+        struct nw_sm_leb128 leb128;
+    } import;
+
+    struct nw_sm_fn
+    {
+        nw_varuint32 entry_i;
+        struct nw_sm_leb128 leb128;
+    } function;
+
+    struct nw_sm_tb
+    {
+        nw_varuint32 count, entry_i;
+        nw_varint7 elem_type;
+        nw_varuint1 flags;
+        size_t out_sz;
+        struct nw_sm_leb128 leb128;
+    } table;
+
+    struct nw_sm_mem
+    {
+        nw_varuint32 count;
+        nw_varuint1 flags;
+        struct nw_sm_leb128 leb128;
+    } memory;
+
+    struct nw_sm_gl
+    {
+        nw_varuint32 entry_i;
+        struct nw_sm_leb128 leb128;
+        struct nw_interp interp;
+        union nw_value value;
+    } global;
+
+    struct nw_sm_d
+    {
+        nw_varuint32 entry_i, index, size;
+        struct nw_sm_leb128 leb128;
+        struct nw_interp interp;
+        long value, offset;
+    } data;
+
+    struct nw_sm_dc
+    {
+        struct nw_sm_leb128 leb128;
+    } data_count;
+
+    struct nw_sm_exp
+    {
+        nw_varuint32 count, entry_i, field_len, len_i;
+        struct nw_sm_io io;
+        struct nw_sm_leb128 leb128;
+    } export;
+
+    struct nw_sm_start
+    {
+        struct nw_sm_leb128 leb128;
+    } start;
+
+    struct nw_sm_c
+    {
+        nw_varuint32 count, entry_i, body_size;
+        struct nw_sm_leb128 leb128;
+        struct nw_sm_io io;
+        long start, body_start, op_off;
+        unsigned long rem;
+        enum nw_state (*next)(struct nw_mod *);
+        unsigned char op;
+
+        union
+        {
+            unsigned long f32;
+            struct nw_ull f64;
+
+            struct nw_sm_c_t
+            {
+                nw_varuint32 count, i;
+            } target;
+        } u;
+
+        struct nw_sm_c_fn
+        {
+            nw_varuint32 local_count, local_i, local_total;
+            unsigned blocks;
+        } fn;
+    } code;
+
+    struct nw_sm_custom
+    {
+        nw_varuint32 name_len, len_i;
+        struct nw_sm_leb128 leb128;
+        unsigned char byte;
+        int candidate[NW_CUSTOM_SECTIONS];
+        long start;
+    } custom;
+
+    struct nw_sm_lo
+    {
+        struct nw_sm_io io;
+    } lo;
+};
+
+struct nw_mod
+{
+    nw_varuint32 type_count, data_count, global_count, import_count,
+        function_count;
+    long sections[NW_SECTIONS], c_sections[NW_CUSTOM_SECTIONS];
+    enum nw_state (*next)(struct nw_mod *);
+    struct nw_mod_cfg cfg;
+    union nw_sm sm;
+    struct nw_mod_out out;
+    const char *exception;
+
+    struct nw_mod_section
+    {
+        nw_varuint7 section;
+        nw_varuint32 len;
+        long offset, cur;
+        struct nw_sm_leb128 leb128;
+    } section;
+};
+
+struct nw_inst;
+
+union nw_inst_sm
+{
+    struct nw_inst_sm_gl
+    {
+        nw_varuint32 count, entry_i;
+        struct nw_sm_leb128 leb128;
+        struct nw_sm_io io;
+        struct nw_global out;
+        enum nw_state (*next)(struct nw_inst *);
+    } global;
+
+    struct nw_inst_sm_d
+    {
+        char b;
+        nw_varuint32 count, index, size, entry_i, bytes_i;
+        struct nw_sm_leb128 leb128;
+        struct nw_sm_io io;
+        struct nw_global out;
+        unsigned long offset;
+        enum nw_state (*next)(struct nw_inst *);
+    } data;
+};
+
+struct nw_inst
+{
+    const char *entry;
+    struct nw_interp interp;
+    union nw_inst_sm sm;
+    enum nw_state (*next)(struct nw_inst *);
+};
+
+union nw_dbg_sm
+{
+    struct nw_dbg_sm_local
+    {
+        struct nw_sm_io io;
+        struct nw_find_local fl;
+        enum nw_state (*inext)(struct nw_interp *);
+    } local;
+
+    struct nw_dbg_sm_param
+    {
+        struct nw_sm_io io;
+        struct nw_find_param fp;
+        enum nw_state (*inext)(struct nw_interp *);
+    } param;
+
+    struct nw_dbg_sm_global
+    {
+        struct nw_sm_io io;
+        unsigned long index;
+        struct nw_global gl;
+        enum nw_state (*inext)(struct nw_interp *);
+    } global;
+
+    struct nw_dbg_sm_mem_load
+    {
+        struct nw_sm_io io;
+        unsigned long offset;
+        enum nw_state (*inext)(struct nw_interp *);
+    } mem_load;
+};
+
+struct nw_dbg
+{
+    long pc;
+    struct nw_dbg_cfg cfg;
+    struct nw_dbg_value v;
+    union nw_dbg_sm sm;
+};
+
+#endif
diff --git a/include/nanowasm/types.h b/include/nanowasm/types.h
new file mode 100644
index 0000000..23cd4fa
--- /dev/null
+++ b/include/nanowasm/types.h
@@ -0,0 +1,180 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef NW_TYPES_H
+#define NW_TYPES_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+struct nw_inst;
+
+enum nw_state
+{
+    NW_OK,
+    NW_AGAIN,
+    NW_FATAL
+};
+
+enum nw_kind
+{
+    NW_KIND_FUNCTION,
+    NW_KIND_TABLE,
+    NW_KIND_MEMORY,
+    NW_KIND_GLOBAL,
+
+    NW_KINDS
+};
+
+struct nw_ull
+{
+    unsigned long low, hi;
+};
+
+struct nw_ll
+{
+    long low, hi;
+};
+
+union nw_value
+{
+    long i32;
+    struct nw_ll i64;
+    float f32;
+    double f64;
+};
+
+enum nw_type
+{
+    NW_TYPE_I32,
+    NW_TYPE_I64,
+    NW_TYPE_F32,
+    NW_TYPE_F64
+};
+
+struct nw_args
+{
+    const union nw_value *args;
+    size_t n;
+};
+
+struct nw_next
+{
+    enum nw_state (*fn)(void *args, struct nw_next *next);
+    void *user;
+};
+
+struct nw_io_cfg
+{
+    int (*read)(void *buf, size_t n, void *user);
+    int (*eof)(void *user);
+    enum nw_state (*pc)(long offset, struct nw_next * next, void *user);
+    enum nw_state (*seek)(long offset, void *user);
+    enum nw_state (*tell)(long *offset, void *user);
+    void *user;
+};
+
+struct nw_sm_io
+{
+    void *buf;
+    size_t n, read;
+};
+
+struct nw_import
+{
+    enum nw_kind kind;
+    const char *module, *field;
+
+    union
+    {
+        struct nw_import_fn
+        {
+            const char *signature;
+            enum nw_state (*fn)(const union nw_value *params,
+                union nw_value *ret, void *user, struct nw_next *next);
+        } function;
+    } u;
+};
+
+struct nw_import_index
+{
+    unsigned long index;
+};
+
+struct nw_mod_cfg
+{
+    const struct nw_import *imports;
+    struct nw_import_index *imp_indexes;
+    struct nw_io_cfg io;
+    size_t n_imports;
+};
+
+struct nw_interp_cfg
+{
+    size_t n_args;
+    void *user;
+
+    struct nw_mem_cfg
+    {
+        int (*load)(unsigned long pos, void *src, size_t n, void *user);
+        int (*store)(unsigned long pos, const void *src, size_t n, void *user);
+    } global, linear, table;
+
+    struct nw_fifo_cfg
+    {
+        int (*push)(const void *src, size_t n, void *user);
+        int (*pop)(void *dst, size_t n, void *user);
+        int (*read)(size_t offset, void *dst, size_t n, void *user);
+        int (*write)(size_t offset, const void *dst, size_t n, void *user);
+        size_t (*ptr)(void *user);
+    } stack;
+
+    struct nw_io_cfg io;
+    const struct nw_mod *m;
+    union nw_value *args;
+};
+
+struct nw_inst_cfg
+{
+    const char *entry;
+    struct nw_interp_cfg interp_cfg;
+};
+
+struct nw_mod_out
+{
+    struct nw_mod_out_mem
+    {
+        unsigned long initial, max;
+    } linear, table;
+
+    size_t global;
+};
+
+struct nw_dbg_cfg
+{
+    struct nw_inst *inst;
+};
+
+struct nw_dbg_value
+{
+    enum nw_type type;
+    union nw_value value;
+};
+
+#include <nanowasm/private.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/private_include/nw/global.h b/private_include/nw/global.h
new file mode 100644
index 0000000..7f289d2
--- /dev/null
+++ b/private_include/nw/global.h
@@ -0,0 +1,20 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef GLOBAL_H
+#define GLOBAL_H
+
+#include <nanowasm/nw.h>
+
+enum nw_state nwp_global_load(struct nw_interp *i, struct nw_sm_io *io,
+    nw_varuint32 index);
+enum nw_state nwp_global_store(struct nw_interp *i, struct nw_sm_io *io,
+    nw_varuint32 index);
+
+#endif
diff --git a/private_include/nw/inst.h b/private_include/nw/inst.h
new file mode 100644
index 0000000..3a68440
--- /dev/null
+++ b/private_include/nw/inst.h
@@ -0,0 +1,17 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef INST_H
+#define INST_H
+
+#include <nanowasm/nw.h>
+
+enum nw_state nwp_inst_run(struct nw_inst *i);
+
+#endif
diff --git a/private_include/nw/interp.h b/private_include/nw/interp.h
new file mode 100644
index 0000000..a6f0d74
--- /dev/null
+++ b/private_include/nw/interp.h
@@ -0,0 +1,39 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef INTERP_H
+#define INTERP_H
+
+#include <nanowasm/nw.h>
+#include <nw/opcodes.h>
+#include <stddef.h>
+
+struct nwp_interp_set
+{
+    const enum opcode *opcodes;
+    size_t n;
+};
+
+struct nwp_ops
+{
+    void (*const *ops)(struct nw_interp *);
+    size_t n;
+};
+
+extern const struct nwp_interp_set nwp_interp_initexpr_set, nwp_interp_data_set;
+extern const struct nwp_ops nwp_ops;
+
+int nwp_interp_start(struct nw_interp *i,
+    const struct nw_interp_cfg *cfg, const struct nwp_interp_set *set);
+void nwp_interp_resume(struct nw_interp *i);
+void nwp_interp_limited(struct nw_interp *i);
+void nwp_interp_full(struct nw_interp *i);
+enum nw_state nwp_interp_run(struct nw_interp *i);
+
+#endif
diff --git a/private_include/nw/io.h b/private_include/nw/io.h
new file mode 100644
index 0000000..2b28847
--- /dev/null
+++ b/private_include/nw/io.h
@@ -0,0 +1,40 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef IO_H
+#define IO_H
+
+#include <nanowasm/nw.h>
+
+enum nw_state nwp_io_read(const struct nw_io_cfg *cfg, struct nw_sm_io *io,
+    void *user);
+enum nw_state nwp_varint1(const struct nw_io_cfg *cfg, struct nw_sm_leb128 *l,
+    nw_varint1 *out, void *user);
+enum nw_state nwp_varint7(const struct nw_io_cfg *cfg, struct nw_sm_leb128 *l,
+    nw_varint7 *out, void *user);
+enum nw_state nwp_varint32(const struct nw_io_cfg *cfg, struct nw_sm_leb128 *l,
+    nw_varint32 *out, void *user);
+enum nw_state nwp_varint64(const struct nw_io_cfg *cfg, struct nw_sm_leb128 *l,
+    nw_varint64 *out, void *user);
+enum nw_state nwp_varuint1(const struct nw_io_cfg *cfg, struct nw_sm_leb128 *l,
+    nw_varuint1 *out, void *user);
+enum nw_state nwp_varuint7(const struct nw_io_cfg *cfg, struct nw_sm_leb128 *l,
+    nw_varuint7 *out, void *user);
+enum nw_state nwp_varuint32(const struct nw_io_cfg *cfg, struct nw_sm_leb128 *l,
+    nw_varuint32 *out, void *user);
+enum nw_state nwp_varuint64(const struct nw_io_cfg *cfg, struct nw_sm_leb128 *l,
+    nw_varuint64 *out, void *user);
+enum nw_state nwp_leb128(const struct nw_io_cfg *cfg, struct nw_sm_leb128 *l,
+    unsigned maxbits, int sign, void *user);
+unsigned long nwp_leuint32(const struct nw_leuint32 *v);
+void nwp_toleuint32(unsigned long v, struct nw_leuint32 *out);
+void nwp_leuint64(const struct nw_leuint64 *v, struct nw_ull *out);
+void nwp_toleuint64(const struct nw_ull *v, struct nw_leuint64 *out);
+
+#endif
diff --git a/private_include/nw/linear.h b/private_include/nw/linear.h
new file mode 100644
index 0000000..a316e77
--- /dev/null
+++ b/private_include/nw/linear.h
@@ -0,0 +1,21 @@
+
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef LINEAR_H
+#define LINEAR_H
+
+#include <nanowasm/types.h>
+
+enum nw_state nwp_linear_load(struct nw_interp *i, struct nw_sm_io *io,
+    unsigned long offset);
+enum nw_state nwp_linear_store(struct nw_interp *i, struct nw_sm_io *io,
+    unsigned long offset);
+
+#endif
diff --git a/private_include/nw/log.h b/private_include/nw/log.h
new file mode 100644
index 0000000..c5e2870
--- /dev/null
+++ b/private_include/nw/log.h
@@ -0,0 +1,17 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef LOG_H
+#define LOG_H
+
+#ifdef NW_LOG
+int nwp_log(const char *fmt, ...);
+#endif
+
+#endif
diff --git a/private_include/nw/mem.h b/private_include/nw/mem.h
new file mode 100644
index 0000000..b1aa7ce
--- /dev/null
+++ b/private_include/nw/mem.h
@@ -0,0 +1,20 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef MEM_H
+#define MEM_H
+
+#include <nanowasm/nw.h>
+
+enum nw_state nwp_mem_store(const struct nw_mem_cfg *const cfg,
+    struct nw_sm_io *io, nw_varuint32 offset, void *user);
+enum nw_state nwp_mem_load(const struct nw_mem_cfg *const cfg,
+    struct nw_sm_io *io, nw_varuint32 offset, void *user);
+
+#endif
diff --git a/private_include/nw/opcodes.h b/private_include/nw/opcodes.h
new file mode 100644
index 0000000..410bd97
--- /dev/null
+++ b/private_include/nw/opcodes.h
@@ -0,0 +1,192 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef OPCODES_H
+#define OPCODES_H
+
+enum opcode
+{
+    OP_UNREACHABLE,
+    OP_NOP,
+    OP_BLOCK,
+    OP_LOOP,
+    OP_IF,
+    OP_ELSE,
+    OP_END = 0xb,
+    OP_BR,
+    OP_BR_IF,
+    OP_BR_TABLE,
+    OP_RETURN,
+    OP_CALL,
+    OP_CALL_INDIRECT,
+    OP_DROP = 0x1a,
+    OP_SELECT,
+    OP_GET_LOCAL = 0x20,
+    OP_SET_LOCAL,
+    OP_TEE_LOCAL,
+    OP_GET_GLOBAL,
+    OP_SET_GLOBAL,
+    OP_I32_LOAD = 0x28,
+    OP_I64_LOAD,
+    OP_F32_LOAD,
+    OP_F64_LOAD,
+    OP_I32_LOAD8_S,
+    OP_I32_LOAD8_U,
+    OP_I32_LOAD16_S,
+    OP_I32_LOAD16_U,
+    OP_I64_LOAD8_S,
+    OP_I64_LOAD8_U,
+    OP_I64_LOAD16_S,
+    OP_I64_LOAD16_U,
+    OP_I64_LOAD32_S,
+    OP_I64_LOAD32_U,
+    OP_I32_STORE,
+    OP_I64_STORE,
+    OP_F32_STORE,
+    OP_F64_STORE,
+    OP_I32_STORE8,
+    OP_I32_STORE16,
+    OP_I64_STORE8,
+    OP_I64_STORE16,
+    OP_I64_STORE32,
+    OP_CURRENT_MEMORY,
+    OP_GROW_MEMORY,
+    OP_I32_CONST,
+    OP_I64_CONST,
+    OP_F32_CONST,
+    OP_F64_CONST,
+    OP_I32_EQZ,
+    OP_I32_EQ,
+    OP_I32_NE,
+    OP_I32_LT_S,
+    OP_I32_LT_U,
+    OP_I32_GT_S,
+    OP_I32_GT_U,
+    OP_I32_LE_S,
+    OP_I32_LE_U,
+    OP_I32_GE_S,
+    OP_I32_GE_U,
+    OP_I64_EQZ,
+    OP_I64_EQ,
+    OP_I64_NE,
+    OP_I64_LT_S,
+    OP_I64_LT_U,
+    OP_I64_GT_S,
+    OP_I64_GT_U,
+    OP_I64_LE_S,
+    OP_I64_LE_U,
+    OP_I64_GE_S,
+    OP_I64_GE_U,
+    OP_F32_EQ,
+    OP_F32_NE,
+    OP_F32_LT,
+    OP_F32_GT,
+    OP_F32_LE,
+    OP_F32_GE,
+    OP_F64_EQ,
+    OP_F64_NE,
+    OP_F64_LT,
+    OP_F64_GT,
+    OP_F64_LE,
+    OP_F64_GE,
+    OP_I32_CLZ,
+    OP_I32_CTZ,
+    OP_I32_POPCNT,
+    OP_I32_ADD,
+    OP_I32_SUB,
+    OP_I32_MUL,
+    OP_I32_DIV_S,
+    OP_I32_DIV_U,
+    OP_I32_REM_S,
+    OP_I32_REM_U,
+    OP_I32_AND,
+    OP_I32_OR,
+    OP_I32_XOR,
+    OP_I32_SHL,
+    OP_I32_SHR_S,
+    OP_I32_SHR_U,
+    OP_I32_ROTL,
+    OP_I32_ROTR,
+    OP_I64_CLZ,
+    OP_I64_CTZ,
+    OP_I64_POPCNT,
+    OP_I64_ADD,
+    OP_I64_SUB,
+    OP_I64_MUL,
+    OP_I64_DIV_S,
+    OP_I64_DIV_U,
+    OP_I64_REM_S,
+    OP_I64_REM_U,
+    OP_I64_AND,
+    OP_I64_OR,
+    OP_I64_XOR,
+    OP_I64_SHL,
+    OP_I64_SHR_S,
+    OP_I64_SHR_U,
+    OP_I64_ROTL,
+    OP_I64_ROTR,
+    OP_F32_ABS,
+    OP_F32_NEG,
+    OP_F32_CEIL,
+    OP_F32_FLOOR,
+    OP_F32_TRUNC,
+    OP_F32_NEAREST,
+    OP_F32_SQRT,
+    OP_F32_ADD,
+    OP_F32_SUB,
+    OP_F32_MUL,
+    OP_F32_DIV,
+    OP_F32_MIN,
+    OP_F32_MAX,
+    OP_F32_COPYSIGN,
+    OP_F64_ABS,
+    OP_F64_NEG,
+    OP_F64_CEIL,
+    OP_F64_FLOOR,
+    OP_F64_TRUNC,
+    OP_F64_NEAREST,
+    OP_F64_SQRT,
+    OP_F64_ADD,
+    OP_F64_SUB,
+    OP_F64_MUL,
+    OP_F64_DIV,
+    OP_F64_MIN,
+    OP_F64_MAX,
+    OP_F64_COPYSIGN,
+    OP_I32_WRAP_I64,
+    OP_I32_TRUNC_S_F32,
+    OP_I32_TRUNC_U_F32,
+    OP_I32_TRUNC_S_F64,
+    OP_I32_TRUNC_U_F64,
+    OP_I64_EXTEND_S_I32,
+    OP_I64_EXTEND_U_I32,
+    OP_I64_TRUNC_S_F32,
+    OP_I64_TRUNC_U_F32,
+    OP_I64_TRUNC_S_F64,
+    OP_I64_TRUNC_U_F64,
+    OP_F32_CONVERT_S_I32,
+    OP_F32_CONVERT_U_I32,
+    OP_F32_CONVERT_S_I64,
+    OP_F32_CONVERT_U_I64,
+    OP_F32_DEMOTE_F64,
+    OP_F64_CONVERT_S_I32,
+    OP_F64_CONVERT_U_I32,
+    OP_F64_CONVERT_S_I64,
+    OP_F64_CONVERT_U_I64,
+    OP_F64_PROMOTE_F32,
+    OP_I32_REINTERPRET_F32,
+    OP_I64_REINTERPRET_F64,
+    OP_F32_REINTERPRET_I32,
+    OP_F64_REINTERPRET_I64,
+    OP_MISC = 0xfc
+};
+
+const char *nwp_op_tostr(enum opcode op);
+
+#endif
diff --git a/private_include/nw/ops.h b/private_include/nw/ops.h
new file mode 100644
index 0000000..dce95a6
--- /dev/null
+++ b/private_include/nw/ops.h
@@ -0,0 +1,90 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef OPS_H
+#define OPS_H
+
+#include <nanowasm/nw.h>
+#include <nw/opcodes.h>
+#include <nw/types.h>
+
+void nwp_op_unreachable(struct nw_interp *i);
+void nwp_op_nop(struct nw_interp *i);
+void nwp_op_block(struct nw_interp *i);
+void nwp_op_loop(struct nw_interp *i);
+void nwp_op_if(struct nw_interp *i);
+void nwp_op_else(struct nw_interp *i);
+void nwp_op_end(struct nw_interp *i);
+void nwp_op_br(struct nw_interp *i);
+void nwp_op_br_if(struct nw_interp *i);
+void nwp_op_br_table(struct nw_interp *i);
+void nwp_op_return(struct nw_interp *i);
+void nwp_op_call(struct nw_interp *i);
+void nwp_op_call_indirect(struct nw_interp *i);
+void nwp_op_drop(struct nw_interp *i);
+void nwp_op_get_local(struct nw_interp *i);
+void nwp_op_set_local(struct nw_interp *i);
+void nwp_op_tee_local(struct nw_interp *i);
+void nwp_op_set_global(struct nw_interp *i);
+void nwp_op_get_global(struct nw_interp *i);
+void nwp_op_set_global(struct nw_interp *i);
+void nwp_op_i32_load(struct nw_interp *i);
+void nwp_op_i32_load8_u(struct nw_interp *i);
+void nwp_op_i32_store(struct nw_interp *i);
+void nwp_op_i64_store(struct nw_interp *i);
+void nwp_op_current_memory(struct nw_interp *i);
+void nwp_op_i32_const(struct nw_interp *i);
+void nwp_op_i64_const(struct nw_interp *i);
+void nwp_op_f32_const(struct nw_interp *i);
+void nwp_op_f64_const(struct nw_interp *i);
+void nwp_op_i32_add(struct nw_interp *i);
+void nwp_op_i32_sub(struct nw_interp *i);
+void nwp_op_i32_mul(struct nw_interp *i);
+void nwp_op_i32_and(struct nw_interp *i);
+void nwp_op_i32_or(struct nw_interp *i);
+void nwp_op_i32_eqz(struct nw_interp *i);
+void nwp_op_i32_eq(struct nw_interp *i);
+void nwp_op_i32_ne(struct nw_interp *i);
+void nwp_op_i32_lt_s(struct nw_interp *i);
+void nwp_op_i32_ge_s(struct nw_interp *i);
+void nwp_op_i32_ge_u(struct nw_interp *i);
+
+void nwp_op_check_no_immediate(struct nw_mod *m);
+void nwp_op_check_block(struct nw_mod *m);
+void nwp_op_check_loop(struct nw_mod *m);
+void nwp_op_check_end(struct nw_mod *m);
+void nwp_op_check_relative_depth(struct nw_mod *m);
+void nwp_op_check_br_table(struct nw_mod *m);
+void nwp_op_check_call(struct nw_mod *m);
+void nwp_op_check_call_indirect(struct nw_mod *m);
+void nwp_op_check_local_index(struct nw_mod *m);
+void nwp_op_check_global_index(struct nw_mod *m);
+void nwp_op_check_memory_immediate(struct nw_mod *m);
+void nwp_op_check_varuint1(struct nw_mod *m);
+void nwp_op_check_varint32(struct nw_mod *m);
+void nwp_op_check_varint64(struct nw_mod *m);
+void nwp_op_check_uint32(struct nw_mod *m);
+void nwp_op_check_uint64(struct nw_mod *m);
+void nwp_op_check_misc(struct nw_mod *m);
+
+struct nwp_check_op
+{
+    enum opcode start, end;
+    void (*f)(struct nw_mod *);
+};
+
+struct nwp_check_ops
+{
+    const struct nwp_check_op *ops;
+    size_t n;
+};
+
+extern const struct nwp_check_ops nwp_check_ops;
+
+#endif
diff --git a/private_include/nw/routines.h b/private_include/nw/routines.h
new file mode 100644
index 0000000..974f6da
--- /dev/null
+++ b/private_include/nw/routines.h
@@ -0,0 +1,71 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef ROUTINES_H
+#define ROUTINES_H
+
+#include <nanowasm/nw.h>
+
+void nwp_check_magic(struct nw_mod *m);
+void nwp_check_version(struct nw_mod *m);
+void nwp_section(struct nw_mod *m);
+void nwp_section_custom(struct nw_mod *m);
+void nwp_section_type(struct nw_mod *m);
+void nwp_section_import(struct nw_mod *m);
+void nwp_section_function(struct nw_mod *m);
+void nwp_section_table(struct nw_mod *m);
+void nwp_section_memory(struct nw_mod *m);
+void nwp_section_global(struct nw_mod *m);
+void nwp_section_export(struct nw_mod *m);
+void nwp_section_start(struct nw_mod *m);
+void nwp_section_element(struct nw_mod *m);
+void nwp_section_code(struct nw_mod *m);
+void nwp_section_data(struct nw_mod *m);
+void nwp_section_data_count(struct nw_mod *m);
+void nwp_section_to(struct nw_mod *m);
+void nwp_section_fti(struct nw_mod *m);
+void nwp_section_fbo(struct nw_mod *m);
+void nwp_section_lo(struct nw_mod *m);
+void nwp_section_iti(struct nw_mod *m);
+void nwp_section_skip(struct nw_mod *m);
+enum nw_state nwp_section_exit(struct nw_mod *m);
+
+void nwp_init_globals(struct nw_inst *i,
+    enum nw_state (*next)(struct nw_inst *));
+void nwp_init_data(struct nw_inst *i,
+    enum nw_state (*next)(struct nw_inst *));
+
+enum nw_state nwp_execute(struct nw_interp *i);
+void nwp_find_export(struct nw_interp *i, const char *sym,
+    enum nw_state (*next)(struct nw_interp *));
+void nwp_call(struct nw_interp *i, nw_varuint32 index);
+void nwp_call_function(struct nw_interp *i, nw_varuint32 index);
+void nwp_call_import(struct nw_interp *i, nw_varuint32 index);
+void nwp_find_function(struct nw_interp *i, const struct nw_fn *fn,
+    void (*next)(struct nw_interp *));
+void nwp_get_function_type(struct nw_interp *i, nw_varuint32 index,
+    enum nw_state (*next)(struct nw_interp *));
+void nwp_get_import_type(struct nw_interp *i, struct nw_get_import_type *t,
+    nw_varuint32 index, enum nw_state (*next)(struct nw_interp *));
+void nwp_mem_imm(struct nw_interp *i, void (*next)(struct nw_interp *));
+void nwp_unwind(struct nw_interp *i);
+void nwp_break(struct nw_interp *i, nw_varuint32 relative_depth);
+void nwp_find_param(struct nw_interp *i, struct nw_find_param *f,
+    nw_varuint32 index, enum nw_state (*next)(struct nw_interp *), void *args);
+void nwp_find_local(struct nw_interp *i, struct nw_find_local *f,
+    nw_varuint32 index, enum nw_state (*next)(struct nw_interp *), void *args);
+void nwp_set_local(struct nw_interp *i,
+    enum nw_state (*next)(struct nw_interp *));
+void nwp_arithm(struct nw_interp *i, enum nw_type t,
+    int (*op)(const struct nw_i_sm_arithm_out *, union nw_value *));
+void nwp_unary(struct nw_interp *i, enum nw_type t,
+    int (*op)(const union nw_value *, union nw_value *));
+void nwp_start_block(struct nw_interp *i);
+
+#endif
diff --git a/private_include/nw/stack.h b/private_include/nw/stack.h
new file mode 100644
index 0000000..332b4f5
--- /dev/null
+++ b/private_include/nw/stack.h
@@ -0,0 +1,24 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef STACK_H
+#define STACK_H
+
+#include <nanowasm/nw.h>
+#include <stddef.h>
+
+size_t nwp_stack_ptr(const struct nw_interp *i);
+enum nw_state nwp_stack_push(struct nw_interp *i, struct nw_sm_io *io);
+enum nw_state nwp_stack_pop(struct nw_interp *i, struct nw_sm_io *io);
+enum nw_state nwp_stack_read(struct nw_interp *i, struct nw_sm_io *io,
+    size_t offset);
+enum nw_state nwp_stack_write(struct nw_interp *i, struct nw_sm_io *io,
+    size_t offset);
+
+#endif
diff --git a/private_include/nw/types.h b/private_include/nw/types.h
new file mode 100644
index 0000000..99e6f55
--- /dev/null
+++ b/private_include/nw/types.h
@@ -0,0 +1,19 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef TYPES_H
+#define TYPES_H
+
+#include <nanowasm/nw.h>
+#include <stddef.h>
+
+int nwp_get_type(nw_varint7 type, enum nw_type *vtype);
+int nwp_type_sz(enum nw_type type, size_t *sz);
+
+#endif
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
new file mode 100644
index 0000000..4151987
--- /dev/null
+++ b/src/CMakeLists.txt
@@ -0,0 +1,23 @@
+# nanowasm, a tiny WebAssembly/Wasm interpreter
+# Copyright (C) 2023-2025  Xavier Del Campo Romero
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+target_sources(${PROJECT_NAME} PRIVATE
+    init.c
+    load.c
+    run.c
+    rexc.c
+    start.c
+)
+
+add_subdirectory(dbg)
+add_subdirectory(inst)
+add_subdirectory(interp)
+add_subdirectory(io)
+add_subdirectory(log)
+add_subdirectory(op)
+add_subdirectory(routines)
+add_subdirectory(types)
diff --git a/src/dbg/CMakeLists.txt b/src/dbg/CMakeLists.txt
new file mode 100644
index 0000000..c68a3c8
--- /dev/null
+++ b/src/dbg/CMakeLists.txt
@@ -0,0 +1,15 @@
+# nanowasm, a tiny WebAssembly/Wasm interpreter
+# Copyright (C) 2023-2025  Xavier Del Campo Romero
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+target_sources(${PROJECT_NAME} PRIVATE
+    global.c
+    init.c
+    local.c
+    mem_read.c
+    param.c
+    value.c
+)
diff --git a/src/dbg/global.c b/src/dbg/global.c
new file mode 100644
index 0000000..cad17ae
--- /dev/null
+++ b/src/dbg/global.c
@@ -0,0 +1,47 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nanowasm/dbg.h>
+#include <nw/global.h>
+#include <nw/log.h>
+#include <nw/types.h>
+
+static enum nw_state read_global(struct nw_interp *const i)
+{
+    struct nw_dbg *const d = i->args;
+    struct nw_dbg_sm_global *const pg = &d->sm.global;
+    struct nw_dbg_value *const v = &d->v;
+    const struct nw_global *const gl = &pg->gl;
+    const enum nw_state n = nwp_global_load(i, &pg->io, pg->index);
+
+    if (n)
+        return n;
+
+    v->type = gl->type;
+    v->value = gl->value;
+    i->next = pg->inext;
+    return NW_AGAIN;
+}
+
+void nw_dbg_global(struct nw_dbg *const d, const unsigned long index)
+{
+    const struct nw_dbg_sm_global gl = {0};
+    struct nw_dbg_sm_global *const pg = &d->sm.global;
+    struct nw_sm_io *const io = &pg->io;
+    struct nw_interp *const i = &d->cfg.inst->interp;
+
+    *pg = gl;
+    pg->index = index;
+    pg->inext = i->next;
+    io->buf = &pg->gl;
+    io->n = sizeof pg->gl;
+    i->args = d;
+    i->next = read_global;
+}
diff --git a/src/dbg/init.c b/src/dbg/init.c
new file mode 100644
index 0000000..6169413
--- /dev/null
+++ b/src/dbg/init.c
@@ -0,0 +1,19 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nanowasm/dbg.h>
+
+void nw_dbg_init(struct nw_dbg *const pd, const struct nw_dbg_cfg *const cfg)
+{
+    const struct nw_dbg d = {0};
+
+    *pd = d;
+    pd->cfg = *cfg;
+}
diff --git a/src/dbg/local.c b/src/dbg/local.c
new file mode 100644
index 0000000..b48ac92
--- /dev/null
+++ b/src/dbg/local.c
@@ -0,0 +1,71 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nanowasm/dbg.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <nw/stack.h>
+#include <nw/types.h>
+
+static enum nw_state read_local(struct nw_interp *const i)
+{
+    struct nw_dbg *const d = i->args;
+    struct nw_dbg_sm_local *const pl = &d->sm.local;
+    const struct nw_find_local *const fl = &pl->fl;
+    const enum nw_state n = nwp_stack_read(i, &pl->io, fl->addr);
+
+    if (n)
+        return n;
+
+    i->next = pl->inext;
+    return NW_AGAIN;
+}
+
+static enum nw_state done(struct nw_interp *const i)
+{
+    struct nw_dbg *const d = i->args;
+    struct nw_dbg_sm_local *const pl = &d->sm.local;
+    const struct nw_local_meta *const m = &pl->fl.meta;
+    const enum nw_type t = m->type;
+    size_t sz;
+
+    if (nwp_type_sz(t, &sz))
+    {
+        static const char *const exc = "invalid type";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#x\n", exc, (unsigned)t);
+#endif
+        return -1;
+    }
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &d->v.value;
+        io.n = sz;
+        pl->io = io;
+    }
+
+    i->next = read_local;
+    return NW_AGAIN;
+}
+
+void nw_dbg_local(struct nw_dbg *const d, const unsigned long index)
+{
+    const struct nw_dbg_sm_local l = {0};
+    struct nw_dbg_sm_local *const pl = &d->sm.local;
+    struct nw_interp *const i = &d->cfg.inst->interp;
+
+    *pl = l;
+    pl->inext = i->next;
+    nwp_find_local(i, &pl->fl, index, done, d);
+}
diff --git a/src/dbg/mem_read.c b/src/dbg/mem_read.c
new file mode 100644
index 0000000..d1f419c
--- /dev/null
+++ b/src/dbg/mem_read.c
@@ -0,0 +1,47 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nanowasm/dbg.h>
+#include <nw/linear.h>
+#include <nw/types.h>
+
+static enum nw_state load_mem(struct nw_interp *const i)
+{
+    struct nw_dbg *const d = i->args;
+    struct nw_dbg_sm_mem_load *const pm = &d->sm.mem_load;
+    const enum nw_state n = nwp_linear_load(i, &pm->io, pm->offset);
+
+    if (n)
+        return n;
+
+    i->next = pm->inext;
+    return NW_AGAIN;
+}
+
+void nw_dbg_mem_load(struct nw_dbg *const d, const enum nw_type t,
+    const unsigned long offset)
+{
+    const struct nw_dbg_sm_mem_load ml = {0};
+    struct nw_dbg_sm_mem_load *const pm = &d->sm.mem_load;
+    struct nw_sm_io *const io = &pm->io;
+    struct nw_interp *const i = &d->cfg.inst->interp;
+    struct nw_dbg_value *const v = &d->v;
+    size_t sz;
+
+    nwp_type_sz(t, &sz);
+    *pm = ml;
+    pm->inext = i->next;
+    pm->offset = offset;
+    v->type = t;
+    io->buf = &v->value;
+    io->n = sz;
+    i->args = d;
+    i->next = load_mem;
+}
diff --git a/src/dbg/param.c b/src/dbg/param.c
new file mode 100644
index 0000000..db0a599
--- /dev/null
+++ b/src/dbg/param.c
@@ -0,0 +1,71 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nanowasm/dbg.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <nw/stack.h>
+#include <nw/types.h>
+
+static enum nw_state read_param(struct nw_interp *const i)
+{
+    struct nw_dbg *const d = i->args;
+    struct nw_dbg_sm_param *const p = &d->sm.param;
+    const struct nw_find_param_out *const out = &p->fp.out;
+    const enum nw_state n = nwp_stack_read(i, &p->io, out->addr);
+
+    if (n)
+        return n;
+
+    i->next = p->inext;
+    return NW_AGAIN;
+}
+
+static enum nw_state done(struct nw_interp *const i)
+{
+    struct nw_dbg *const d = i->args;
+    struct nw_dbg_sm_param *const p = &d->sm.param;
+    const struct nw_find_param_out *const po = &p->fp.out;
+    const enum nw_type t = po->type;
+    size_t sz;
+
+    if (nwp_type_sz(t, &sz))
+    {
+        static const char *const exc = "invalid type";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#x\n", exc, (unsigned)t);
+#endif
+        return -1;
+    }
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &d->v.value;
+        io.n = sz;
+        p->io = io;
+    }
+
+    i->next = read_param;
+    return NW_AGAIN;
+}
+
+void nw_dbg_param(struct nw_dbg *const d, const unsigned long index)
+{
+    const struct nw_dbg_sm_param p = {0};
+    struct nw_dbg_sm_param *const pp = &d->sm.param;
+    struct nw_interp *const i = &d->cfg.inst->interp;
+
+    *pp = p;
+    pp->inext = i->next;
+    nwp_find_param(i, &pp->fp, index, done, d);
+}
diff --git a/src/dbg/value.c b/src/dbg/value.c
new file mode 100644
index 0000000..633c5f7
--- /dev/null
+++ b/src/dbg/value.c
@@ -0,0 +1,17 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nanowasm/dbg.h>
+
+int nw_dbg_value(const struct nw_dbg *const d, struct nw_dbg_value *const v)
+{
+    *v = d->v;
+    return 0;
+}
diff --git a/src/init.c b/src/init.c
new file mode 100644
index 0000000..d0358e9
--- /dev/null
+++ b/src/init.c
@@ -0,0 +1,28 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <stddef.h>
+
+void nw_init(struct nw_mod *const m, const struct nw_mod_cfg *const cfg)
+{
+    const struct nw_mod mm = {0};
+    size_t i;
+
+    *m = mm;
+    m->cfg = *cfg;
+
+    for (i = 0; i < cfg->n_imports; i++)
+        cfg->imp_indexes[i].index = -1;
+
+    nwp_check_magic(m);
+}
diff --git a/src/inst/CMakeLists.txt b/src/inst/CMakeLists.txt
new file mode 100644
index 0000000..a082191
--- /dev/null
+++ b/src/inst/CMakeLists.txt
@@ -0,0 +1,10 @@
+# nanowasm, a tiny WebAssembly/Wasm interpreter
+# Copyright (C) 2023-2025  Xavier Del Campo Romero
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+target_sources(${PROJECT_NAME} PRIVATE
+    run.c
+)
diff --git a/src/inst/run.c b/src/inst/run.c
new file mode 100644
index 0000000..5a8e411
--- /dev/null
+++ b/src/inst/run.c
@@ -0,0 +1,17 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/inst.h>
+#include <nw/interp.h>
+
+enum nw_state nwp_inst_run(struct nw_inst *const i)
+{
+    return nwp_interp_run(&i->interp);
+}
diff --git a/src/interp/CMakeLists.txt b/src/interp/CMakeLists.txt
new file mode 100644
index 0000000..c38da8c
--- /dev/null
+++ b/src/interp/CMakeLists.txt
@@ -0,0 +1,21 @@
+# nanowasm, a tiny WebAssembly/Wasm interpreter
+# Copyright (C) 2023-2025  Xavier Del Campo Romero
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+target_sources(${PROJECT_NAME} PRIVATE
+    data_set.c
+    initexpr_set.c
+    ops.c
+    run.c
+    resume.c
+    start.c
+)
+
+add_subdirectory(global)
+add_subdirectory(linear)
+add_subdirectory(mem)
+add_subdirectory(routines)
+add_subdirectory(stack)
diff --git a/src/interp/data_set.c b/src/interp/data_set.c
new file mode 100644
index 0000000..266852b
--- /dev/null
+++ b/src/interp/data_set.c
@@ -0,0 +1,24 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/opcodes.h>
+
+static const enum opcode opcodes[] =
+{
+    OP_END,
+    OP_I32_CONST,
+};
+
+const struct nwp_interp_set nwp_interp_data_set =
+{
+    opcodes,
+    sizeof opcodes / sizeof *opcodes
+};
diff --git a/src/interp/global/CMakeLists.txt b/src/interp/global/CMakeLists.txt
new file mode 100644
index 0000000..0f0e056
--- /dev/null
+++ b/src/interp/global/CMakeLists.txt
@@ -0,0 +1,11 @@
+# nanowasm, a tiny WebAssembly/Wasm interpreter
+# Copyright (C) 2023-2025  Xavier Del Campo Romero
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+target_sources(${PROJECT_NAME} PRIVATE
+    load.c
+    store.c
+)
diff --git a/src/interp/global/load.c b/src/interp/global/load.c
new file mode 100644
index 0000000..26d8c8d
--- /dev/null
+++ b/src/interp/global/load.c
@@ -0,0 +1,34 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/global.h>
+#include <nw/mem.h>
+#include <nw/log.h>
+
+enum nw_state nwp_global_load(struct nw_interp *const i,
+    struct nw_sm_io *const io, const nw_varuint32 index)
+{
+    const struct nw_interp_cfg *const cfg = &i->cfg;
+    const size_t offset = index * sizeof (struct nw_global);
+    const enum nw_state n = nwp_mem_load(&cfg->global, io, offset, cfg->user);
+
+    if (n == NW_FATAL)
+    {
+        static const char *const exc = "failed to load from global memory";
+
+#ifdef NW_LOG
+        nwp_log("%s\n", exc);
+#endif
+        i->exception = exc;
+    }
+
+    return n;
+}
diff --git a/src/interp/global/store.c b/src/interp/global/store.c
new file mode 100644
index 0000000..91550d4
--- /dev/null
+++ b/src/interp/global/store.c
@@ -0,0 +1,34 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/global.h>
+#include <nw/interp.h>
+#include <nw/mem.h>
+#include <nw/log.h>
+
+enum nw_state nwp_global_store(struct nw_interp *const i,
+    struct nw_sm_io *const io, const nw_varuint32 index)
+{
+    const struct nw_interp_cfg *const cfg = &i->cfg;
+    const size_t offset = index * sizeof (struct nw_global);
+    const enum nw_state n = nwp_mem_store(&cfg->global, io, offset, cfg->user);
+
+    if (n == NW_FATAL)
+    {
+        static const char *const exc = "failed to store into global memory";
+
+#ifdef NW_LOG
+        nwp_log("%s\n", exc);
+#endif
+        i->exception = exc;
+    }
+
+    return n;
+}
diff --git a/src/interp/initexpr_set.c b/src/interp/initexpr_set.c
new file mode 100644
index 0000000..1e200f6
--- /dev/null
+++ b/src/interp/initexpr_set.c
@@ -0,0 +1,28 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/opcodes.h>
+
+static const enum opcode opcodes[] =
+{
+    OP_NOP,
+    OP_END,
+    OP_I32_CONST,
+    OP_I64_CONST,
+    OP_F32_CONST,
+    OP_F64_CONST
+};
+
+const struct nwp_interp_set nwp_interp_initexpr_set =
+{
+    opcodes,
+    sizeof opcodes / sizeof *opcodes
+};
diff --git a/src/interp/linear/CMakeLists.txt b/src/interp/linear/CMakeLists.txt
new file mode 100644
index 0000000..0f0e056
--- /dev/null
+++ b/src/interp/linear/CMakeLists.txt
@@ -0,0 +1,11 @@
+# nanowasm, a tiny WebAssembly/Wasm interpreter
+# Copyright (C) 2023-2025  Xavier Del Campo Romero
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+target_sources(${PROJECT_NAME} PRIVATE
+    load.c
+    store.c
+)
diff --git a/src/interp/linear/load.c b/src/interp/linear/load.c
new file mode 100644
index 0000000..afc6154
--- /dev/null
+++ b/src/interp/linear/load.c
@@ -0,0 +1,39 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nanowasm/linear.h>
+#include <nw/interp.h>
+#include <nw/mem.h>
+#include <nw/log.h>
+
+enum nw_state nwp_linear_load(struct nw_interp *const i,
+    struct nw_sm_io *const io, const unsigned long offset)
+{
+    const struct nw_interp_cfg *const cfg = &i->cfg;
+    const enum nw_state n = nwp_mem_load(&cfg->linear, io, offset, cfg->user);
+
+    if (n == NW_FATAL)
+    {
+        static const char *const exc = "failed to load from linear memory";
+
+#ifdef NW_LOG
+        nwp_log("%s\n", exc);
+#endif
+        i->exception = exc;
+    }
+
+    return n;
+}
+
+enum nw_state nw_linear_load(struct nw_inst *const i,
+    struct nw_sm_io *const io, const unsigned long offset)
+{
+    return nwp_linear_load(&i->interp, io, offset);
+}
diff --git a/src/interp/linear/store.c b/src/interp/linear/store.c
new file mode 100644
index 0000000..6edffd9
--- /dev/null
+++ b/src/interp/linear/store.c
@@ -0,0 +1,40 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nanowasm/linear.h>
+#include <nw/linear.h>
+#include <nw/interp.h>
+#include <nw/mem.h>
+#include <nw/log.h>
+
+enum nw_state nwp_linear_store(struct nw_interp *const i,
+    struct nw_sm_io *const io, const unsigned long offset)
+{
+    const struct nw_interp_cfg *const cfg = &i->cfg;
+    const enum nw_state n = nwp_mem_store(&cfg->linear, io, offset, cfg->user);
+
+    if (n == NW_FATAL)
+    {
+        static const char *const exc = "failed to store into linear memory";
+
+#ifdef NW_LOG
+        nwp_log("%s\n", exc);
+#endif
+        i->exception = exc;
+    }
+
+    return n;
+}
+
+enum nw_state nw_linear_store(struct nw_inst *const i,
+    struct nw_sm_io *const io, const unsigned long offset)
+{
+    return nwp_linear_store(&i->interp, io, offset);
+}
diff --git a/src/interp/mem/CMakeLists.txt b/src/interp/mem/CMakeLists.txt
new file mode 100644
index 0000000..0f0e056
--- /dev/null
+++ b/src/interp/mem/CMakeLists.txt
@@ -0,0 +1,11 @@
+# nanowasm, a tiny WebAssembly/Wasm interpreter
+# Copyright (C) 2023-2025  Xavier Del Campo Romero
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+target_sources(${PROJECT_NAME} PRIVATE
+    load.c
+    store.c
+)
diff --git a/src/interp/mem/load.c b/src/interp/mem/load.c
new file mode 100644
index 0000000..0ccf29b
--- /dev/null
+++ b/src/interp/mem/load.c
@@ -0,0 +1,27 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/mem.h>
+#include <nw/log.h>
+
+enum nw_state nwp_mem_load(const struct nw_mem_cfg *const cfg,
+    struct nw_sm_io *const io, const nw_varuint32 offset, void *const user)
+{
+    void *const dst = (unsigned char *)io->buf + io->read;
+    const int n = cfg->load(offset + io->read, dst, io->n - io->read, user);
+
+    if (n < 0)
+        return NW_FATAL;
+    else if ((io->read += n) >= io->n)
+        return NW_OK;
+
+    return NW_AGAIN;
+}
diff --git a/src/interp/mem/store.c b/src/interp/mem/store.c
new file mode 100644
index 0000000..cc58169
--- /dev/null
+++ b/src/interp/mem/store.c
@@ -0,0 +1,27 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/mem.h>
+#include <nw/log.h>
+
+enum nw_state nwp_mem_store(const struct nw_mem_cfg *const cfg,
+    struct nw_sm_io *const io, const nw_varuint32 offset, void *const user)
+{
+    const void *const src = (const unsigned char *)io->buf + io->read;
+    const int n = cfg->store(offset + io->read, src, io->n - io->read, user);
+
+    if (n < 0)
+        return NW_FATAL;
+    else if ((io->read += n) >= io->n)
+        return NW_OK;
+
+    return NW_AGAIN;
+}
diff --git a/src/interp/ops.c b/src/interp/ops.c
new file mode 100644
index 0000000..6135f96
--- /dev/null
+++ b/src/interp/ops.c
@@ -0,0 +1,278 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/opcodes.h>
+#include <nw/ops.h>
+#include <nw/interp.h>
+
+static void (*const ops[])(struct nw_interp *) =
+{
+    nwp_op_unreachable, /* OP_UNREACHABLE */
+    nwp_op_nop, /* OP_NOP */
+    nwp_op_block, /* OP_BLOCK */
+    nwp_op_loop, /* OP_LOOP */
+    NULL, /* OP_IF */
+    NULL, /* OP_ELSE */
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    nwp_op_end, /* OP_END */
+    nwp_op_br, /* OP_BR */
+    nwp_op_br_if, /* OP_BR_IF */
+    NULL, /* OP_BR_TABLE */
+    nwp_op_return, /* OP_RETURN */
+    nwp_op_call, /* OP_CALL */
+    nwp_op_call_indirect, /* OP_CALL_INDIRECT */
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    nwp_op_drop, /* OP_DROP */
+    NULL, /* OP_SELECT */
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    nwp_op_get_local, /* OP_GET_LOCAL */
+    nwp_op_set_local, /* OP_SET_LOCAL */
+    nwp_op_tee_local, /* OP_TEE_LOCAL */
+    nwp_op_get_global, /* OP_GET_GLOBAL */
+    nwp_op_set_global, /* OP_SET_GLOBAL */
+    NULL,
+    NULL,
+    NULL,
+    nwp_op_i32_load, /* OP_I32_LOAD */
+    NULL, /* OP_I64_LOAD */
+    NULL, /* OP_F32_LOAD */
+    NULL, /* OP_F64_LOAD */
+    NULL, /* OP_I32_LOAD8_S */
+    nwp_op_i32_load8_u, /* OP_I32_LOAD8_U */
+    NULL, /* OP_I32_LOAD16_S */
+    NULL, /* OP_I32_LOAD16_U */
+    NULL, /* OP_I64_LOAD8_S */
+    NULL, /* OP_I64_LOAD8_U */
+    NULL, /* OP_I64_LOAD16_S */
+    NULL, /* OP_I64_LOAD16_U */
+    NULL, /* OP_I64_LOAD32_S */
+    NULL, /* OP_I64_LOAD32_U */
+    nwp_op_i32_store, /* OP_I32_STORE */
+    nwp_op_i64_store, /* OP_I64_STORE */
+    NULL, /* OP_F32_STORE */
+    NULL, /* OP_F64_STORE */
+    NULL, /* OP_I32_STORE8 */
+    NULL, /* OP_I32_STORE16 */
+    NULL, /* OP_I64_STORE8 */
+    NULL, /* OP_I64_STORE16 */
+    NULL, /* OP_I64_STORE32 */
+    NULL, /* OP_CURRENT_MEMORY */
+    NULL, /* OP_GROW_MEMORY */
+    nwp_op_i32_const, /* OP_I32_CONST */
+    nwp_op_i64_const, /* OP_I64_CONST */
+    NULL, /* OP_F32_CONST */
+    NULL, /* OP_F64_CONST */
+    nwp_op_i32_eqz, /* OP_I32_EQZ */
+    nwp_op_i32_eq, /* OP_I32_EQ */
+    nwp_op_i32_ne, /* OP_I32_NE */
+    nwp_op_i32_lt_s, /* OP_I32_LT_S */
+    NULL, /* OP_I32_LT_U */
+    NULL, /* OP_I32_GT_S */
+    NULL, /* OP_I32_GT_U */
+    NULL, /* OP_I32_LE_S */
+    NULL, /* OP_I32_LE_U */
+    nwp_op_i32_ge_s, /* OP_I32_GE_S */
+    nwp_op_i32_ge_u, /* OP_I32_GE_U */
+    NULL, /* OP_I64_EQZ */
+    NULL, /* OP_I64_EQ */
+    NULL, /* OP_I64_NE */
+    NULL, /* OP_I64_LT_S */
+    NULL, /* OP_I64_LT_U */
+    NULL, /* OP_I64_GT_S */
+    NULL, /* OP_I64_GT_U */
+    NULL, /* OP_I64_LE_S */
+    NULL, /* OP_I64_LE_U */
+    NULL, /* OP_I64_GE_S */
+    NULL, /* OP_I64_GE_U */
+    NULL, /* OP_F32_EQ */
+    NULL, /* OP_F32_NE */
+    NULL, /* OP_F32_LT */
+    NULL, /* OP_F32_GT */
+    NULL, /* OP_F32_LE */
+    NULL, /* OP_F32_GE */
+    NULL, /* OP_F64_EQ */
+    NULL, /* OP_F64_NE */
+    NULL, /* OP_F64_LT */
+    NULL, /* OP_F64_GT */
+    NULL, /* OP_F64_LE */
+    NULL, /* OP_F64_GE */
+    NULL, /* OP_I32_CLZ */
+    NULL, /* OP_I32_CTZ */
+    NULL, /* OP_I32_POPCNT */
+    nwp_op_i32_add, /* OP_I32_ADD */
+    nwp_op_i32_sub, /* OP_I32_SUB */
+    nwp_op_i32_mul, /* OP_I32_MUL */
+    NULL, /* OP_I32_DIV_S */
+    NULL, /* OP_I32_DIV_U */
+    NULL, /* OP_I32_REM_S */
+    NULL, /* OP_I32_REM_U */
+    nwp_op_i32_and, /* OP_I32_AND */
+    nwp_op_i32_or, /* OP_I32_OR */
+    NULL, /* OP_I32_XOR */
+    NULL, /* OP_I32_SHL */
+    NULL, /* OP_I32_SHR_S */
+    NULL, /* OP_I32_SHR_U */
+    NULL, /* OP_I32_ROTL */
+    NULL, /* OP_I32_ROTR */
+    NULL, /* OP_I64_CLZ */
+    NULL, /* OP_I64_CTZ */
+    NULL, /* OP_I64_POPCNT */
+    NULL, /* OP_I64_ADD */
+    NULL, /* OP_I64_SUB */
+    NULL, /* OP_I64_MUL */
+    NULL, /* OP_I64_DIV_S */
+    NULL, /* OP_I64_DIV_U */
+    NULL, /* OP_I64_REM_S */
+    NULL, /* OP_I64_REM_U */
+    NULL, /* OP_I64_AND */
+    NULL, /* OP_I64_OR */
+    NULL, /* OP_I64_XOR */
+    NULL, /* OP_I64_SHL */
+    NULL, /* OP_I64_SHR_S */
+    NULL, /* OP_I64_SHR_U */
+    NULL, /* OP_I64_ROTL */
+    NULL, /* OP_I64_ROTR */
+    NULL, /* OP_F32_ABS */
+    NULL, /* OP_F32_NEG */
+    NULL, /* OP_F32_CEIL */
+    NULL, /* OP_F32_FLOOR */
+    NULL, /* OP_F32_TRUNC */
+    NULL, /* OP_F32_NEAREST */
+    NULL, /* OP_F32_SQRT */
+    NULL, /* OP_F32_ADD */
+    NULL, /* OP_F32_SUB */
+    NULL, /* OP_F32_MUL */
+    NULL, /* OP_F32_DIV */
+    NULL, /* OP_F32_MIN */
+    NULL, /* OP_F32_MAX */
+    NULL, /* OP_F32_COPYSIGN */
+    NULL, /* OP_F64_ABS */
+    NULL, /* OP_F64_NEG */
+    NULL, /* OP_F64_CEIL */
+    NULL, /* OP_F64_FLOOR */
+    NULL, /* OP_F64_TRUNC */
+    NULL, /* OP_F64_NEAREST */
+    NULL, /* OP_F64_SQRT */
+    NULL, /* OP_F64_ADD */
+    NULL, /* OP_F64_SUB */
+    NULL, /* OP_F64_MUL */
+    NULL, /* OP_F64_DIV */
+    NULL, /* OP_F64_MIN */
+    NULL, /* OP_F64_MAX */
+    NULL, /* OP_F64_COPYSIGN */
+    NULL, /* OP_I32_WRAP_I64 */
+    NULL, /* OP_I32_TRUNC_S_F32 */
+    NULL, /* OP_I32_TRUNC_U_F32 */
+    NULL, /* OP_I32_TRUNC_S_F64 */
+    NULL, /* OP_I32_TRUNC_U_F64 */
+    NULL, /* OP_I64_EXTEND_S_I32 */
+    NULL, /* OP_I64_EXTEND_U_I32 */
+    NULL, /* OP_I64_TRUNC_S_F32 */
+    NULL, /* OP_I64_TRUNC_U_F32 */
+    NULL, /* OP_I64_TRUNC_S_F64 */
+    NULL, /* OP_I64_TRUNC_U_F64 */
+    NULL, /* OP_F32_CONVERT_S_I32 */
+    NULL, /* OP_F32_CONVERT_U_I32 */
+    NULL, /* OP_F32_CONVERT_S_I64 */
+    NULL, /* OP_F32_CONVERT_U_I64 */
+    NULL, /* OP_F32_DEMOTE_F64 */
+    NULL, /* OP_F64_CONVERT_S_I32 */
+    NULL, /* OP_F64_CONVERT_U_I32 */
+    NULL, /* OP_F64_CONVERT_S_I64 */
+    NULL, /* OP_F64_CONVERT_U_I64 */
+    NULL, /* OP_F64_PROMOTE_F32 */
+    NULL, /* OP_I32_REINTERPRET_F32 */
+    NULL, /* OP_I64_REINTERPRET_F64 */
+    NULL, /* OP_F32_REINTERPRET_I32 */
+    NULL, /* OP_F64_REINTERPRET_I64 */
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL /* OP_MISC */
+};
+
+const struct nwp_ops nwp_ops =
+{
+    ops,
+    sizeof ops / sizeof *ops
+};
diff --git a/src/interp/resume.c b/src/interp/resume.c
new file mode 100644
index 0000000..cf9ece2
--- /dev/null
+++ b/src/interp/resume.c
@@ -0,0 +1,20 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nanowasm/types.h>
+#include <nw/interp.h>
+
+void nwp_interp_resume(struct nw_interp *const i)
+{
+    if (i->set)
+        nwp_interp_limited(i);
+    else
+        nwp_interp_full(i);
+}
diff --git a/src/interp/routines/CMakeLists.txt b/src/interp/routines/CMakeLists.txt
new file mode 100644
index 0000000..b27172b
--- /dev/null
+++ b/src/interp/routines/CMakeLists.txt
@@ -0,0 +1,13 @@
+# nanowasm, a tiny WebAssembly/Wasm interpreter
+# Copyright (C) 2023-2025  Xavier Del Campo Romero
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+target_sources(${PROJECT_NAME} PRIVATE
+    execute.c
+    find_export.c
+    full.c
+    limited.c
+)
diff --git a/src/interp/routines/execute.c b/src/interp/routines/execute.c
new file mode 100644
index 0000000..49711ae
--- /dev/null
+++ b/src/interp/routines/execute.c
@@ -0,0 +1,83 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/opcodes.h>
+#include <nw/ops.h>
+#include <nw/routines.h>
+
+static enum nw_state execute(struct nw_interp *const i)
+{
+    struct nw_i_sm_b *const b = &i->sm.bytecode;
+
+#ifdef NW_LOG
+    nwp_log("opcode: %s, pc=%#lx\n", nwp_op_tostr(b->op), b->pc);
+#endif
+    b->f(i);
+    i->fr.prev_op = b->op;
+    return NW_AGAIN;
+}
+
+static enum nw_state repeat(struct nw_interp *const i)
+{
+    struct nw_i_sm_b *const b = &i->sm.bytecode;
+    struct nw_next *const next = &b->next;
+    const enum nw_state n = next->fn(next->user, next);
+
+    if (n)
+        return n;
+
+    return execute(i);
+}
+
+static enum nw_state exec_pc(struct nw_interp *const i)
+{
+    struct nw_i_sm_b *const b = &i->sm.bytecode;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const long pc = b->pc;
+
+    if (cfg->pc)
+    {
+        const enum nw_state n = cfg->pc(pc, &b->next, cfg->user);
+
+        if (n == NW_FATAL)
+        {
+            static const char *const exc = "pc callback failed";
+
+            i->exception = exc;
+#ifdef NW_LOG
+            nwp_log("%s, pc: %ld\n", exc, pc);
+#endif
+            return NW_FATAL;
+        }
+        else if (n)
+        {
+            i->next = repeat;
+            return n;
+        }
+    }
+
+    return execute(i);
+}
+
+enum nw_state nwp_execute(struct nw_interp *const i)
+{
+    struct nw_i_sm_b *const b = &i->sm.bytecode;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = cfg->tell(&b->pc, cfg->user);
+
+    if (n)
+        return n;
+
+    b->pc -= sizeof b->op;
+    i->next = exec_pc;
+    return NW_AGAIN;
+}
diff --git a/src/interp/routines/find_export.c b/src/interp/routines/find_export.c
new file mode 100644
index 0000000..effa8d1
--- /dev/null
+++ b/src/interp/routines/find_export.c
@@ -0,0 +1,229 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nanowasm/types.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <string.h>
+
+static enum nw_state entry_loop(struct nw_interp *i);
+
+static enum nw_state get_index(struct nw_interp *const i)
+{
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    struct nw_i_sm_exp *const e = &i->sm.export;
+    struct nw_sm_leb128 *const l = &e->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &e->index, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = e->next;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_kind(struct nw_interp *const i)
+{
+    unsigned char kind;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    struct nw_i_sm_exp *const e = &i->sm.export;
+    struct nw_sm_io io = {0};
+    enum nw_state n;
+
+    io.buf = &kind;
+    io.n = sizeof kind;
+
+    if ((n = nwp_io_read(cfg, &io, cfg->user)))
+        return n;
+    else if (kind >= NW_KINDS)
+    {
+        static const char *const exc = "invalid export kind";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#x\n", exc, (unsigned)kind);
+#endif
+        return NW_FATAL;
+    }
+
+    e->kind = kind;
+    i->next = get_index;
+    return NW_AGAIN;
+}
+
+static enum nw_state skip_index(struct nw_interp *const i)
+{
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    struct nw_i_sm_exp *const e = &i->sm.export;
+    struct nw_sm_leb128 *const l = &e->leb128;
+    nw_varuint32 index;
+    const enum nw_state n = nwp_varuint32(cfg, l, &index, cfg->user);
+
+    if (n)
+        return n;
+
+    e->entry_i++;
+    i->next = entry_loop;
+    return NW_AGAIN;
+}
+
+static enum nw_state skip_kind(struct nw_interp *const i)
+{
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    unsigned char b;
+    struct nw_sm_io io = {0};
+    enum nw_state n;
+
+    io.buf = &b;
+    io.n = sizeof b;
+
+    if ((n = nwp_io_read(cfg, &io, cfg->user)))
+        return n;
+
+    i->next = skip_index;
+    return NW_AGAIN;
+}
+
+static enum nw_state skip_field_str(struct nw_interp *const i)
+{
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const struct nw_i_sm_exp *const e = &i->sm.export;
+    const long offset = e->offset + (e->len - e->len_i);
+    const enum nw_state n = cfg->seek(offset, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = skip_kind;
+    return NW_AGAIN;
+}
+
+static enum nw_state tell(struct nw_interp *const i)
+{
+    struct nw_i_sm_exp *const e = &i->sm.export;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = cfg->tell(&e->offset, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = skip_field_str;
+    return NW_AGAIN;
+}
+
+static enum nw_state compare(struct nw_interp *const i)
+{
+    unsigned char b;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    struct nw_i_sm_exp *const e = &i->sm.export;
+    struct nw_sm_io io = {0};
+    enum nw_state n;
+
+    io.buf = &b;
+    io.n = sizeof b;
+
+    if ((n = nwp_io_read(cfg, &io, cfg->user)))
+        return n;
+    else if (b != e->sym[e->len_i++])
+        i->next = tell;
+    else if (e->len_i >= e->len)
+        i->next = get_kind;
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_len(struct nw_interp *const i)
+{
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    struct nw_i_sm_exp *const e = &i->sm.export;
+    struct nw_sm_leb128 *const l = &e->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &e->len, cfg->user);
+
+    if (n)
+        return n;
+    else if (e->len != strlen(e->sym))
+        i->next = skip_field_str;
+    else
+        i->next = compare;
+
+    return NW_AGAIN;
+}
+
+static enum nw_state entry_loop(struct nw_interp *const i)
+{
+    struct nw_i_sm_exp *const e = &i->sm.export;
+
+    if (e->entry_i >= e->count)
+    {
+        static const char *const exc = "failed to find symbol";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %s\n", exc, e->sym);
+#endif
+        return NW_FATAL;
+    }
+
+    e->len_i = 0;
+    i->next = get_len;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_count(struct nw_interp *const i)
+{
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    struct nw_i_sm_exp *const e = &i->sm.export;
+    struct nw_sm_leb128 *const l = &e->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &e->count, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = entry_loop;
+    return NW_AGAIN;
+}
+
+static enum nw_state seek(struct nw_interp *const i)
+{
+    const struct nw_mod *const m = i->cfg.m;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const long offset = m->sections[NW_SECTION_EXPORT];
+    enum nw_state n;
+
+    if (!offset)
+    {
+        static const char *const exc = "section not found";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %s\n", exc, "export");
+#endif
+        return NW_FATAL;
+    }
+    else if ((n = cfg->seek(offset, cfg->user)))
+        return n;
+
+    i->next = get_count;
+    return NW_AGAIN;
+}
+
+void nwp_find_export(struct nw_interp *const i, const char *const sym,
+    enum nw_state (*const next)(struct nw_interp *))
+{
+    const struct nw_i_sm_exp e = {0};
+    struct nw_i_sm_exp *const pe = &i->sm.export;
+
+    *pe = e;
+    pe->sym = sym;
+    pe->next = next;
+    i->next = seek;
+}
diff --git a/src/interp/routines/full.c b/src/interp/routines/full.c
new file mode 100644
index 0000000..c00f11f
--- /dev/null
+++ b/src/interp/routines/full.c
@@ -0,0 +1,63 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/opcodes.h>
+#include <nw/ops.h>
+#include <nw/routines.h>
+
+static enum nw_state tell(struct nw_interp *const i)
+{
+    long offset;
+    struct nw_i_sm_b *const b = &i->sm.bytecode;
+    static const char *const exc = "invalid opcode";
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = cfg->tell(&offset, cfg->user);
+
+    if (n)
+        return n;
+
+    offset -= sizeof b->op;
+
+#ifdef NW_LOG
+    nwp_log("%s: %#x, offset=%#lx\n", exc, (unsigned)b->op, offset);
+#endif
+    i->exception = exc;
+    return NW_FATAL;
+}
+
+static enum nw_state get_bytecode(struct nw_interp *const i)
+{
+    struct nw_i_sm_b *const b = &i->sm.bytecode;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_io_read(cfg, &b->io, cfg->user);
+
+    if (n)
+        return n;
+    else if (b->op >= nwp_ops.n || !(b->f = nwp_ops.ops[b->op]))
+    {
+        i->next = tell;
+        return NW_AGAIN;
+    }
+
+    i->next = nwp_execute;
+    return NW_AGAIN;
+}
+
+void nwp_interp_full(struct nw_interp *const i)
+{
+    struct nw_i_sm_b *const pb = &i->sm.bytecode, b = {0};
+
+    b.io.buf = &pb->op;
+    b.io.n = sizeof pb->op;
+    *pb = b;
+    i->next = get_bytecode;
+}
diff --git a/src/interp/routines/limited.c b/src/interp/routines/limited.c
new file mode 100644
index 0000000..dc18ded
--- /dev/null
+++ b/src/interp/routines/limited.c
@@ -0,0 +1,54 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nanowasm/types.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <stddef.h>
+
+static enum nw_state get_bytecode(struct nw_interp *const in)
+{
+    const struct nw_io_cfg *const cfg = &in->cfg.io;
+    struct nw_i_sm_b *const b = &in->sm.bytecode;
+    const struct nwp_interp_set *const set = in->set;
+    static const char *const exc = "invalid opcode";
+    const enum nw_state n = nwp_io_read(cfg, &b->io, cfg->user);
+    size_t i;
+
+    if (n)
+        return n;
+
+    for (i = 0; i < set->n; i++)
+        if (b->op == set->opcodes[i])
+        {
+            b->f = nwp_ops.ops[b->op];
+            in->next = nwp_execute;
+            return NW_AGAIN;
+        }
+
+#ifdef NW_LOG
+    nwp_log("%s: %#x\n", exc, (unsigned)b->op);
+#endif
+    in->exception = exc;
+    return NW_FATAL;
+}
+
+void nwp_interp_limited(struct nw_interp *const i)
+{
+    struct nw_i_sm_b *const b = &i->sm.bytecode;
+    struct nw_sm_io io = {0};
+
+    io.buf = &b->op;
+    io.n = sizeof b->op;
+    b->io = io;
+    i->next = get_bytecode;
+}
diff --git a/src/interp/run.c b/src/interp/run.c
new file mode 100644
index 0000000..f5e80e6
--- /dev/null
+++ b/src/interp/run.c
@@ -0,0 +1,16 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+
+enum nw_state nwp_interp_run(struct nw_interp *const i)
+{
+    return i->next(i);
+}
diff --git a/src/interp/stack/CMakeLists.txt b/src/interp/stack/CMakeLists.txt
new file mode 100644
index 0000000..51c7cb5
--- /dev/null
+++ b/src/interp/stack/CMakeLists.txt
@@ -0,0 +1,14 @@
+# nanowasm, a tiny WebAssembly/Wasm interpreter
+# Copyright (C) 2023-2025  Xavier Del Campo Romero
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+target_sources(${PROJECT_NAME} PRIVATE
+    pop.c
+    push.c
+    ptr.c
+    read.c
+    write.c
+)
diff --git a/src/interp/stack/pop.c b/src/interp/stack/pop.c
new file mode 100644
index 0000000..03ed689
--- /dev/null
+++ b/src/interp/stack/pop.c
@@ -0,0 +1,37 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/log.h>
+#include <nw/stack.h>
+
+enum nw_state nwp_stack_pop(struct nw_interp *const i,
+    struct nw_sm_io *const io)
+{
+    void *const dst = (unsigned char *)io->buf + io->read;
+    const struct nw_interp_cfg *const cfg = &i->cfg;
+    const struct nw_fifo_cfg *const fc = &cfg->stack;
+    const int n = fc->pop(dst, io->n - io->read, cfg->user);
+
+    if (n < 0)
+    {
+        static const char *const exc = "failed to pop from stack";
+
+#ifdef NW_LOG
+        nwp_log("%s\n", exc);
+#endif
+        i->exception = exc;
+        return NW_FATAL;
+    }
+    else if ((io->read += n) >= io->n)
+        return NW_OK;
+
+    return NW_AGAIN;
+}
diff --git a/src/interp/stack/ptr.c b/src/interp/stack/ptr.c
new file mode 100644
index 0000000..d5fa455
--- /dev/null
+++ b/src/interp/stack/ptr.c
@@ -0,0 +1,21 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/stack.h>
+#include <stddef.h>
+
+size_t nwp_stack_ptr(const struct nw_interp *const i)
+{
+    const struct nw_interp_cfg *const cfg = &i->cfg;
+    const struct nw_fifo_cfg *const fc = &cfg->stack;
+
+    return fc->ptr(cfg->user);
+}
diff --git a/src/interp/stack/push.c b/src/interp/stack/push.c
new file mode 100644
index 0000000..b8b48ce
--- /dev/null
+++ b/src/interp/stack/push.c
@@ -0,0 +1,37 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/log.h>
+#include <nw/stack.h>
+
+enum nw_state nwp_stack_push(struct nw_interp *const i,
+    struct nw_sm_io *const io)
+{
+    const void *const src = (const unsigned char *)io->buf + io->read;
+    const struct nw_interp_cfg *const cfg = &i->cfg;
+    const struct nw_fifo_cfg *const fc = &cfg->stack;
+    const int n = fc->push(src, io->n - io->read, cfg->user);
+
+    if (n < 0)
+    {
+        static const char *const exc = "failed to push to stack";
+
+#ifdef NW_LOG
+        nwp_log("%s\n", exc);
+#endif
+        i->exception = exc;
+        return NW_FATAL;
+    }
+    else if ((io->read += n) >= io->n)
+        return NW_OK;
+
+    return NW_AGAIN;
+}
diff --git a/src/interp/stack/read.c b/src/interp/stack/read.c
new file mode 100644
index 0000000..8db6bcc
--- /dev/null
+++ b/src/interp/stack/read.c
@@ -0,0 +1,37 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/log.h>
+#include <nw/stack.h>
+
+enum nw_state nwp_stack_read(struct nw_interp *const i,
+    struct nw_sm_io *const io, const size_t offset)
+{
+    void *const dst = (unsigned char *)io->buf + io->read;
+    const struct nw_interp_cfg *const cfg = &i->cfg;
+    const struct nw_fifo_cfg *const fc = &cfg->stack;
+    const int n = fc->read(offset + io->read, dst, io->n - io->read, cfg->user);
+
+    if (n < 0)
+    {
+        static const char *const exc = "failed to read from stack";
+
+#ifdef NW_LOG
+        nwp_log("%s\n", exc);
+#endif
+        i->exception = exc;
+        return NW_FATAL;
+    }
+    else if ((io->read += n) >= io->n)
+        return NW_OK;
+
+    return NW_AGAIN;
+}
diff --git a/src/interp/stack/write.c b/src/interp/stack/write.c
new file mode 100644
index 0000000..73e749e
--- /dev/null
+++ b/src/interp/stack/write.c
@@ -0,0 +1,38 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/log.h>
+#include <nw/stack.h>
+
+enum nw_state nwp_stack_write(struct nw_interp *const i,
+    struct nw_sm_io *const io, const size_t offset)
+{
+    const void *const src = (const unsigned char *)io->buf + io->read;
+    const struct nw_interp_cfg *const cfg = &i->cfg;
+    const struct nw_fifo_cfg *const fc = &cfg->stack;
+    const int n = fc->write(offset + io->read, src, io->n - io->read,
+        cfg->user);
+
+    if (n < 0)
+    {
+        static const char *const exc = "failed to write to stack";
+
+#ifdef NW_LOG
+        nwp_log("%s\n", exc);
+#endif
+        i->exception = exc;
+        return NW_FATAL;
+    }
+    else if ((io->read += n) >= io->n)
+        return NW_OK;
+
+    return NW_AGAIN;
+}
diff --git a/src/interp/start.c b/src/interp/start.c
new file mode 100644
index 0000000..2bade41
--- /dev/null
+++ b/src/interp/start.c
@@ -0,0 +1,28 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nanowasm/types.h>
+#include <nw/interp.h>
+
+int nwp_interp_start(struct nw_interp *const i,
+    const struct nw_interp_cfg *const cfg,
+    const struct nwp_interp_set *const set)
+{
+    const struct nw_interp in = {0};
+    const struct nw_mod_out *const mout = &cfg->m->out;
+
+    *i = in;
+    i->cfg = *cfg;
+    i->set = set;
+    i->table.n_pages = mout->table.initial;
+    i->linear.n_pages = mout->linear.initial;
+    nwp_interp_resume(i);
+    return 0;
+}
diff --git a/src/io/CMakeLists.txt b/src/io/CMakeLists.txt
new file mode 100644
index 0000000..b7c19cb
--- /dev/null
+++ b/src/io/CMakeLists.txt
@@ -0,0 +1,23 @@
+# nanowasm, a tiny WebAssembly/Wasm interpreter
+# Copyright (C) 2023-2025  Xavier Del Campo Romero
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+target_sources(${PROJECT_NAME} PRIVATE
+    leb128.c
+    leuint32.c
+    leuint64.c
+    read.c
+    toleuint32.c
+    toleuint64.c
+    varint1.c
+    varint7.c
+    varint32.c
+    varint64.c
+    varuint1.c
+    varuint7.c
+    varuint32.c
+    varuint64.c
+)
diff --git a/src/io/leb128.c b/src/io/leb128.c
new file mode 100644
index 0000000..efb599b
--- /dev/null
+++ b/src/io/leb128.c
@@ -0,0 +1,75 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+
+/* The functions below is a (somewhat heavily) modified version of that
+ * provided by the wac project: https://github.com/kanaka/wac
+ *
+ * Copyright (C) Joel Martin <github@martintribe.org>
+ * The wac project is licensed under the MPL 2.0 (Mozilla Public License
+ * 2.0). The text of the MPL 2.0 license is included below and can be
+ * found at https://www.mozilla.org/MPL/2.0/
+ */
+
+#include <nanowasm/types.h>
+#include <nw/io.h>
+#include <nw/log.h>
+
+enum nw_state nwp_leb128(const struct nw_io_cfg *const cfg,
+    struct nw_sm_leb128 *const l, const unsigned maxbits, const int sign,
+    void *const user)
+{
+    unsigned char byte;
+
+    for (;;)
+    {
+        const int n = cfg->read(&byte, sizeof byte, user);
+        unsigned long v;
+
+        if (n < 0)
+            return NW_FATAL;
+        else if (!n)
+            return NW_AGAIN;
+
+        v = (unsigned long)(byte & 0x7f) << l->shift;;
+
+        if (l->shift < 32)
+            l->result.low |= v;
+        else
+            l->result.hi |= v;
+
+        l->shift += 7;
+
+        if (!(byte & 0x80))
+            break;
+        else if (++l->bcnt > (maxbits + 7u - 1u) / 7u)
+        {
+#ifdef NW_LOG
+            long offset;
+            const enum nw_state n = cfg->tell(&offset, cfg->user);
+
+            if (n)
+                return n;
+
+            nwp_log("leb128 overflow, offset=%#lx\n", (unsigned long)offset);
+#endif
+            return NW_FATAL;
+        }
+    }
+
+    if (sign && (l->shift < maxbits) && (byte & 0x40))
+    {
+        if (l->shift < 32)
+            l->result.low |= -1l << (l->shift);
+        else
+            l->result.hi |= -1l << (l->shift);
+    }
+
+    return NW_OK;
+}
diff --git a/src/io/leuint32.c b/src/io/leuint32.c
new file mode 100644
index 0000000..41a2e3b
--- /dev/null
+++ b/src/io/leuint32.c
@@ -0,0 +1,17 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+
+unsigned long nwp_leuint32(const struct nw_leuint32 *const v)
+{
+    return v->v[0] | (v->v[1] << 8) | ((unsigned long)v->v[2] << 16)
+        | ((unsigned long)v->v[3] << 24);
+}
diff --git a/src/io/leuint64.c b/src/io/leuint64.c
new file mode 100644
index 0000000..6d3deb0
--- /dev/null
+++ b/src/io/leuint64.c
@@ -0,0 +1,24 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+
+void nwp_leuint64(const struct nw_leuint64 *const v,
+    struct nw_ull *const ull)
+{
+    ull->low = v->v[0]
+        | (v->v[1] << 8)
+        | ((unsigned long)v->v[2] << 16ul)
+        | ((unsigned long)v->v[3] << 24ul);
+    ull->hi = v->v[4]
+        | (v->v[5] << 8)
+        | ((unsigned long) v->v[6] << 16ul)
+        | ((unsigned long)v->v[7] << 24ul);
+}
diff --git a/src/io/read.c b/src/io/read.c
new file mode 100644
index 0000000..d4222b5
--- /dev/null
+++ b/src/io/read.c
@@ -0,0 +1,31 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <stddef.h>
+
+enum nw_state nwp_io_read(const struct nw_io_cfg *const cfg,
+    struct nw_sm_io *const io, void *const user)
+{
+    void *const buf = (unsigned char *)io->buf + io->read;
+    const size_t rem = io->n - io->read;
+    const int n = cfg->read(buf, rem, user);
+
+    if (n < 0 || (!n && cfg->eof(user)))
+        return NW_FATAL;
+
+    if ((io->read += n) >= io->n)
+    {
+        io->read = 0;
+        return NW_OK;
+    }
+
+    return NW_AGAIN;
+}
diff --git a/src/io/toleuint32.c b/src/io/toleuint32.c
new file mode 100644
index 0000000..c1c96c7
--- /dev/null
+++ b/src/io/toleuint32.c
@@ -0,0 +1,19 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+
+void nwp_toleuint32(const unsigned long v, struct nw_leuint32 *const r)
+{
+    r->v[0] = v;
+    r->v[1] = v >> 8;
+    r->v[2] = v >> 16;
+    r->v[3] = v >> 24;
+}
diff --git a/src/io/toleuint64.c b/src/io/toleuint64.c
new file mode 100644
index 0000000..57856c2
--- /dev/null
+++ b/src/io/toleuint64.c
@@ -0,0 +1,23 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+
+void nwp_toleuint64(const struct nw_ull *const v, struct nw_leuint64 *const r)
+{
+    r->v[0] = v->low;
+    r->v[1] = v->low >> 8;
+    r->v[2] = v->low >> 16;
+    r->v[3] = v->low >> 24;
+    r->v[4] = v->hi;
+    r->v[5] = v->hi >> 8;
+    r->v[6] = v->hi >> 16;
+    r->v[7] = v->hi >> 24;
+}
diff --git a/src/io/varint1.c b/src/io/varint1.c
new file mode 100644
index 0000000..502765b
--- /dev/null
+++ b/src/io/varint1.c
@@ -0,0 +1,27 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/types.h>
+#include <nw/io.h>
+
+enum nw_state nwp_varint1(const struct nw_io_cfg *const cfg,
+    struct nw_sm_leb128 *const l, nw_varint1 *const out, void *const user)
+{
+    const enum nw_state ret = nwp_leb128(cfg, l, 1, 1, user);
+
+    if (!ret)
+    {
+        static const struct nw_sm_leb128 ll;
+
+        *out = l->result.low;
+        *l = ll;
+    }
+
+    return ret;
+}
diff --git a/src/io/varint32.c b/src/io/varint32.c
new file mode 100644
index 0000000..f1c58cd
--- /dev/null
+++ b/src/io/varint32.c
@@ -0,0 +1,27 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/types.h>
+#include <nw/io.h>
+
+enum nw_state nwp_varint32(const struct nw_io_cfg *const cfg,
+    struct nw_sm_leb128 *const l, nw_varint32 *const out, void *const user)
+{
+    const enum nw_state ret = nwp_leb128(cfg, l, 32, 1, user);
+
+    if (!ret)
+    {
+        static const struct nw_sm_leb128 ll;
+
+        *out = l->result.low;
+        *l = ll;
+    }
+
+    return ret;
+}
diff --git a/src/io/varint64.c b/src/io/varint64.c
new file mode 100644
index 0000000..5d0a3fd
--- /dev/null
+++ b/src/io/varint64.c
@@ -0,0 +1,28 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/types.h>
+#include <nw/io.h>
+
+enum nw_state nwp_varint64(const struct nw_io_cfg *const cfg,
+    struct nw_sm_leb128 *const l, nw_varint64 *const out, void *const user)
+{
+    const enum nw_state ret = nwp_leb128(cfg, l, 64, 1, user);
+
+    if (!ret)
+    {
+        static const struct nw_sm_leb128 ll;
+
+        out->low = l->result.low;
+        out->hi = l->result.hi;
+        *l = ll;
+    }
+
+    return ret;
+}
diff --git a/src/io/varint7.c b/src/io/varint7.c
new file mode 100644
index 0000000..d22d25c
--- /dev/null
+++ b/src/io/varint7.c
@@ -0,0 +1,27 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/types.h>
+#include <nw/io.h>
+
+enum nw_state nwp_varint7(const struct nw_io_cfg *const cfg,
+    struct nw_sm_leb128 *const l, nw_varint7 *const out, void *const user)
+{
+    const enum nw_state ret = nwp_leb128(cfg, l, 7, 1, user);
+
+    if (!ret)
+    {
+        static const struct nw_sm_leb128 ll;
+
+        *out = l->result.low;
+        *l = ll;
+    }
+
+    return ret;
+}
diff --git a/src/io/varuint1.c b/src/io/varuint1.c
new file mode 100644
index 0000000..2f9587c
--- /dev/null
+++ b/src/io/varuint1.c
@@ -0,0 +1,27 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/types.h>
+#include <nw/io.h>
+
+enum nw_state nwp_varuint1(const struct nw_io_cfg *const cfg,
+    struct nw_sm_leb128 *const l, nw_varuint1 *const out, void *const user)
+{
+    const enum nw_state ret = nwp_leb128(cfg, l, 1, 0, user);
+
+    if (!ret)
+    {
+        static const struct nw_sm_leb128 ll;
+
+        *out = l->result.low;
+        *l = ll;
+    }
+
+    return ret;
+}
diff --git a/src/io/varuint32.c b/src/io/varuint32.c
new file mode 100644
index 0000000..1ad2c35
--- /dev/null
+++ b/src/io/varuint32.c
@@ -0,0 +1,27 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/types.h>
+#include <nw/io.h>
+
+enum nw_state nwp_varuint32(const struct nw_io_cfg *const cfg,
+    struct nw_sm_leb128 *const l, nw_varuint32 *const out, void *const user)
+{
+    const enum nw_state ret = nwp_leb128(cfg, l, 32, 0, user);
+
+    if (!ret)
+    {
+        static const struct nw_sm_leb128 ll;
+
+        *out = l->result.low;
+        *l = ll;
+    }
+
+    return ret;
+}
diff --git a/src/io/varuint64.c b/src/io/varuint64.c
new file mode 100644
index 0000000..5538bb8
--- /dev/null
+++ b/src/io/varuint64.c
@@ -0,0 +1,27 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/types.h>
+#include <nw/io.h>
+
+enum nw_state nwp_varuint64(const struct nw_io_cfg *const cfg,
+    struct nw_sm_leb128 *const l, nw_varuint64 *const out, void *const user)
+{
+    const enum nw_state ret = nwp_leb128(cfg, l, 64, 0, user);
+
+    if (!ret)
+    {
+        static const struct nw_sm_leb128 ll;
+
+        *out = l->result;
+        *l = ll;
+    }
+
+    return ret;
+}
diff --git a/src/io/varuint7.c b/src/io/varuint7.c
new file mode 100644
index 0000000..e3c2e91
--- /dev/null
+++ b/src/io/varuint7.c
@@ -0,0 +1,27 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/types.h>
+#include <nw/io.h>
+
+enum nw_state nwp_varuint7(const struct nw_io_cfg *const cfg,
+    struct nw_sm_leb128 *const l, nw_varuint7 *const out, void *const user)
+{
+    const enum nw_state ret = nwp_leb128(cfg, l, 7, 0, user);
+
+    if (!ret)
+    {
+        static const struct nw_sm_leb128 ll;
+
+        *out = l->result.low;
+        *l = ll;
+    }
+
+    return ret;
+}
diff --git a/src/load.c b/src/load.c
new file mode 100644
index 0000000..7b08be4
--- /dev/null
+++ b/src/load.c
@@ -0,0 +1,21 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/types.h>
+
+enum nw_state nw_load(struct nw_mod *const m, struct nw_mod_out *const out)
+{
+    const enum nw_state n = m->next(m);
+
+    if (!n && out)
+        *out = m->out;
+
+    return n;
+}
diff --git a/src/log/CMakeLists.txt b/src/log/CMakeLists.txt
new file mode 100644
index 0000000..0678c22
--- /dev/null
+++ b/src/log/CMakeLists.txt
@@ -0,0 +1,10 @@
+# nanowasm, a tiny WebAssembly/Wasm interpreter
+# Copyright (C) 2023-2025  Xavier Del Campo Romero
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+if(NW_LOG AND NOT NW_LOG_CUSTOM)
+    target_sources(${PROJECT_NAME} PRIVATE log.c)
+endif()
diff --git a/src/log/log.c b/src/log/log.c
new file mode 100644
index 0000000..a0408a9
--- /dev/null
+++ b/src/log/log.c
@@ -0,0 +1,23 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nw/log.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+int nwp_log(const char *const fmt, ...)
+{
+    va_list ap;
+    int ret;
+
+    va_start(ap, fmt);
+    ret = vfprintf(stderr, fmt, ap);
+    va_end(ap);
+    return ret;
+}
diff --git a/src/op/CMakeLists.txt b/src/op/CMakeLists.txt
new file mode 100644
index 0000000..53036f0
--- /dev/null
+++ b/src/op/CMakeLists.txt
@@ -0,0 +1,45 @@
+# nanowasm, a tiny WebAssembly/Wasm interpreter
+# Copyright (C) 2023-2025  Xavier Del Campo Romero
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+target_sources(${PROJECT_NAME} PRIVATE
+    block.c
+    br.c
+    br_if.c
+    call.c
+    call_indirect.c
+    drop.c
+    end.c
+    get_local.c
+    get_global.c
+    i32_add.c
+    i32_and.c
+    i32_const.c
+    i32_eq.c
+    i32_eqz.c
+    i32_ge_s.c
+    i32_ge_u.c
+    i32_load.c
+    i32_load8_u.c
+    i32_lt_s.c
+    i32_mul.c
+    i32_ne.c
+    i32_or.c
+    i32_store.c
+    i32_sub.c
+    i64_const.c
+    i64_store.c
+    loop.c
+    nop.c
+    return.c
+    set_global.c
+    set_local.c
+    tee_local.c
+    tostr.c
+    unreachable.c
+)
+
+add_subdirectory(check)
diff --git a/src/op/block.c b/src/op/block.c
new file mode 100644
index 0000000..e35a722
--- /dev/null
+++ b/src/op/block.c
@@ -0,0 +1,17 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/ops.h>
+#include <nw/routines.h>
+
+void nwp_op_block(struct nw_interp *const i)
+{
+    nwp_start_block(i);
+}
diff --git a/src/op/br.c b/src/op/br.c
new file mode 100644
index 0000000..83ceca7
--- /dev/null
+++ b/src/op/br.c
@@ -0,0 +1,36 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/ops.h>
+#include <nw/routines.h>
+
+static enum nw_state get_relative_depth(struct nw_interp *const i)
+{
+    struct nw_i_sm_br *const b = &i->sm.br;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_varuint32(cfg, &b->leb128,
+        &b->relative_depth, cfg->user);
+
+    if (n)
+        return n;
+
+    nwp_break(i, b->relative_depth);
+    return NW_AGAIN;
+}
+
+void nwp_op_br(struct nw_interp *const i)
+{
+    static const struct nw_i_sm_br b = {0};
+
+    i->next = get_relative_depth;
+    i->sm.br = b;
+}
diff --git a/src/op/br_if.c b/src/op/br_if.c
new file mode 100644
index 0000000..661c959
--- /dev/null
+++ b/src/op/br_if.c
@@ -0,0 +1,95 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+#include <nw/routines.h>
+#include <nw/stack.h>
+#include <nw/types.h>
+
+static int condition(struct nw_interp *const i)
+{
+    const struct nw_i_sm_br_if *const b = &i->sm.br_if;
+
+    switch (i->push_type)
+    {
+        case NW_TYPE_I32:
+            return b->condition.i32;
+
+        case NW_TYPE_I64:
+            return b->condition.i64.low;
+
+        case NW_TYPE_F32:
+            return b->condition.f32;
+
+        case NW_TYPE_F64:
+            return b->condition.f64;
+    }
+
+    return 0;
+}
+
+static enum nw_state pop(struct nw_interp *const i)
+{
+    struct nw_i_sm_br_if *const b = &i->sm.br_if;
+    const enum nw_state n = nwp_stack_pop(i, &b->io);
+
+    if (n)
+        return n;
+    else if (condition(i))
+        nwp_break(i, b->relative_depth);
+    else
+        nwp_interp_resume(i);
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_relative_depth(struct nw_interp *const i)
+{
+    struct nw_i_sm_br_if *const b = &i->sm.br_if;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_varuint32(cfg, &b->leb128,
+        &b->relative_depth, cfg->user);
+    size_t sz;
+
+    if (n)
+        return n;
+    else if (nwp_type_sz(i->push_type, &sz))
+    {
+        static const char *const exc = "invalid type";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#x\n", exc, (unsigned)i->push_type);
+#endif
+        return NW_FATAL;
+    }
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &b->condition;
+        io.n = sz;
+        b->io = io;
+        i->next = pop;
+    }
+
+    return NW_AGAIN;
+}
+
+void nwp_op_br_if(struct nw_interp *const i)
+{
+    static const struct nw_i_sm_br_if b = {0};
+
+    i->next = get_relative_depth;
+    i->sm.br_if = b;
+}
diff --git a/src/op/call.c b/src/op/call.c
new file mode 100644
index 0000000..11a9183
--- /dev/null
+++ b/src/op/call.c
@@ -0,0 +1,50 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/ops.h>
+#include <nw/routines.h>
+#include <nw/types.h>
+
+static enum nw_state get_pc(struct nw_interp *const i)
+{
+    struct nw_i_sm_call *const c = &i->sm.call;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = cfg->tell(&i->fr.pc, cfg->user);
+
+    if (n)
+        return n;
+
+    nwp_call(i, c->index);
+    return NW_AGAIN;
+}
+
+static enum nw_state get_index(struct nw_interp *const i)
+{
+    struct nw_i_sm_call *const c = &i->sm.call;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_varuint32(cfg, l, &c->index, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = get_pc;
+    return NW_AGAIN;
+}
+
+void nwp_op_call(struct nw_interp *const i)
+{
+    static const struct nw_i_sm_call c = {0};
+
+    i->sm.call = c;
+    i->next = get_index;
+}
diff --git a/src/op/call_indirect.c b/src/op/call_indirect.c
new file mode 100644
index 0000000..f41a14d
--- /dev/null
+++ b/src/op/call_indirect.c
@@ -0,0 +1,64 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/ops.h>
+#include <nw/routines.h>
+#include <nw/types.h>
+
+static enum nw_state get_pc(struct nw_interp *const i)
+{
+    struct nw_i_sm_call *const c = &i->sm.call;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = cfg->tell(&i->fr.pc, cfg->user);
+
+    if (n)
+        return n;
+
+    nwp_call(i, c->index);
+    return NW_AGAIN;
+}
+
+static enum nw_state get_value(struct nw_interp *const i)
+{
+    struct nw_i_sm_call_indirect *const ci = &i->sm.call_indirect;
+    struct nw_sm_leb128 *const l = &ci->leb128;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_varuint32(cfg, l, &ci->value, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = get_pc;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_index(struct nw_interp *const i)
+{
+    struct nw_i_sm_call_indirect *const ci = &i->sm.call_indirect;
+    struct nw_sm_leb128 *const l = &ci->leb128;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_varuint32(cfg, l, &ci->index, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = get_value;
+    return NW_AGAIN;
+}
+
+void nwp_op_call_indirect(struct nw_interp *const i)
+{
+    static const struct nw_i_sm_call_indirect ci = {0};
+
+    i->sm.call_indirect = ci;
+    i->next = get_index;
+}
diff --git a/src/op/check/CMakeLists.txt b/src/op/check/CMakeLists.txt
new file mode 100644
index 0000000..0745eb5
--- /dev/null
+++ b/src/op/check/CMakeLists.txt
@@ -0,0 +1,24 @@
+# nanowasm, a tiny WebAssembly/Wasm interpreter
+# Copyright (C) 2023-2025  Xavier Del Campo Romero
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+target_sources(${PROJECT_NAME} PRIVATE
+    block.c
+    br_table.c
+    call.c
+    end.c
+    global_index.c
+    i64_const.c
+    local_index.c
+    memory_immediate.c
+    misc.c
+    no_immediate.c
+    relative_depth.c
+    varint32.c
+    varuint1.c
+    uint32.c
+    uint64.c
+)
diff --git a/src/op/check/block.c b/src/op/check/block.c
new file mode 100644
index 0000000..7d5176e
--- /dev/null
+++ b/src/op/check/block.c
@@ -0,0 +1,43 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+#include <nw/types.h>
+
+static enum nw_state get_type(struct nw_mod *const m)
+{
+    nw_varint7 type;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    const enum nw_state n = nwp_varint7(cfg, l, &type, cfg->user);
+    enum nw_type t;
+
+    if (n)
+        return n;
+    else if (nwp_get_type(type, &t) && type != 0x40)
+    {
+#ifdef NW_LOG
+        nwp_log("invalid block_type %#x\n", (unsigned)type);
+#endif
+        return NW_FATAL;
+    }
+
+    c->fn.blocks++;
+    m->next = m->sm.code.next;
+    return NW_AGAIN;
+}
+
+void nwp_op_check_block(struct nw_mod *const m)
+{
+    m->next = get_type;
+}
diff --git a/src/op/check/br_table.c b/src/op/check/br_table.c
new file mode 100644
index 0000000..d104669
--- /dev/null
+++ b/src/op/check/br_table.c
@@ -0,0 +1,78 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/ops.h>
+
+static enum nw_state loop(struct nw_mod *m);
+
+static enum nw_state get_default_target(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    nw_varuint32 target;
+    const enum nw_state n = nwp_varuint32(cfg, l, &target, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = c->next;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_entry(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_c_t *const t = &c->u.target;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    nw_varuint32 entry;
+    const enum nw_state n = nwp_varuint32(cfg, l, &entry, cfg->user);
+
+    if (n)
+        return n;
+
+    t->i++;
+    m->next = loop;
+    return NW_AGAIN;
+}
+
+static enum nw_state loop(struct nw_mod *const m)
+{
+    const struct nw_sm_c *const c = &m->sm.code;
+    const struct nw_sm_c_t *const t = &c->u.target;
+
+    m->next = t->i >= t->count ? get_default_target : get_entry;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_target_count(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    struct nw_sm_c_t *const t = &c->u.target;
+    const enum nw_state n = nwp_varuint32(cfg, l, &t->count, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = loop;
+    return NW_AGAIN;
+}
+
+void nwp_op_check_br_table(struct nw_mod *const m)
+{
+    static const struct nw_sm_c_t t = {0};
+
+    m->sm.code.u.target = t;
+    m->next = get_target_count;
+}
diff --git a/src/op/check/call.c b/src/op/check/call.c
new file mode 100644
index 0000000..7b02032
--- /dev/null
+++ b/src/op/check/call.c
@@ -0,0 +1,40 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+
+static enum nw_state get_index(struct nw_mod *const m)
+{
+    nw_varuint32 index;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &index, cfg->user);
+
+    if (n)
+        return n;
+    else if (index >= c->count + m->cfg.n_imports)
+    {
+#ifdef NW_LOG
+        nwp_log("invalid function index %lu\n", (unsigned long)index);
+#endif
+        return NW_FATAL;
+    }
+
+    m->next = m->sm.code.next;
+    return NW_AGAIN;
+}
+
+void nwp_op_check_call(struct nw_mod *const m)
+{
+    m->next = get_index;
+}
diff --git a/src/op/check/end.c b/src/op/check/end.c
new file mode 100644
index 0000000..8ec6bf7
--- /dev/null
+++ b/src/op/check/end.c
@@ -0,0 +1,36 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+
+static enum nw_state run(struct nw_mod *const m)
+{
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_c_fn *const fn = &c->fn;
+
+    if (!fn->blocks)
+    {
+#ifdef NW_LOG
+        nwp_log("unexpected end in function %lu\n", (unsigned long)c->entry_i);
+#endif
+        return NW_FATAL;
+    }
+
+    fn->blocks--;
+    m->next = c->next;
+    return NW_AGAIN;
+}
+
+void nwp_op_check_end(struct nw_mod *const m)
+{
+    m->next = run;
+}
diff --git a/src/op/check/global_index.c b/src/op/check/global_index.c
new file mode 100644
index 0000000..b3a18bb
--- /dev/null
+++ b/src/op/check/global_index.c
@@ -0,0 +1,40 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+
+static enum nw_state get_index(struct nw_mod *const m)
+{
+    nw_varuint32 index;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &index, cfg->user);
+
+    if (n)
+        return n;
+    else if (index >= m->global_count)
+    {
+#ifdef NW_LOG
+        nwp_log("invalid global index %lu\n", (unsigned long)index);
+#endif
+        return NW_FATAL;
+    }
+
+    m->next = c->next;
+    return NW_AGAIN;
+}
+
+void nwp_op_check_global_index(struct nw_mod *const m)
+{
+    m->next = get_index;
+}
diff --git a/src/op/check/i64_const.c b/src/op/check/i64_const.c
new file mode 100644
index 0000000..e283642
--- /dev/null
+++ b/src/op/check/i64_const.c
@@ -0,0 +1,32 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/ops.h>
+
+static enum nw_state get_value(struct nw_mod *const m)
+{
+    nw_varint64 value;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    const enum nw_state n = nwp_varint64(cfg, l, &value, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = c->next;
+    return NW_AGAIN;
+}
+
+void nwp_op_check_varint64(struct nw_mod *const m)
+{
+    m->next = get_value;
+}
diff --git a/src/op/check/local_index.c b/src/op/check/local_index.c
new file mode 100644
index 0000000..a6df9ad
--- /dev/null
+++ b/src/op/check/local_index.c
@@ -0,0 +1,43 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+
+static enum nw_state get_index(struct nw_mod *const m)
+{
+    nw_varuint32 index;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &index, cfg->user);
+
+    if (n)
+        return n;
+#if 0
+    else if (index >= c->fn.local_total)
+    {
+        LOG("%s: invalid local index %lu in function %lu\n", __func__,
+            (unsigned long)index, (unsigned long)c->entry_i);
+        return NW_FATAL;
+    }
+#else
+    /* TODO: take function parameters into account for local_total*/
+#endif
+
+    m->next = c->next;
+    return NW_AGAIN;
+}
+
+void nwp_op_check_local_index(struct nw_mod *const m)
+{
+    m->next = get_index;
+}
diff --git a/src/op/check/memory_immediate.c b/src/op/check/memory_immediate.c
new file mode 100644
index 0000000..98aae52
--- /dev/null
+++ b/src/op/check/memory_immediate.c
@@ -0,0 +1,47 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/ops.h>
+
+static enum nw_state get_offset(struct nw_mod *const m)
+{
+    nw_varuint32 offset;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &offset, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = m->sm.code.next;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_flags(struct nw_mod *const m)
+{
+    nw_varuint32 flags;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &flags, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = get_offset;
+    return NW_AGAIN;
+}
+
+void nwp_op_check_memory_immediate(struct nw_mod *const m)
+{
+    m->next = get_flags;
+}
diff --git a/src/op/check/misc.c b/src/op/check/misc.c
new file mode 100644
index 0000000..fc89d21
--- /dev/null
+++ b/src/op/check/misc.c
@@ -0,0 +1,34 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/ops.h>
+
+static enum nw_state run(struct nw_mod *const m)
+{
+    unsigned char op;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_io io = {0};
+    enum nw_state n;
+
+    io.buf = &op;
+    io.n = sizeof op;
+
+    if ((n = nwp_io_read(cfg, &io, cfg->user)))
+        return n;
+
+    m->next = m->sm.code.next;
+    return NW_AGAIN;
+}
+
+void nwp_op_check_misc(struct nw_mod *const m)
+{
+    m->next = run;
+}
diff --git a/src/op/check/no_immediate.c b/src/op/check/no_immediate.c
new file mode 100644
index 0000000..86cd22c
--- /dev/null
+++ b/src/op/check/no_immediate.c
@@ -0,0 +1,23 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/ops.h>
+
+static enum nw_state run(struct nw_mod *const m)
+{
+    m->next = m->sm.code.next;
+    return NW_AGAIN;
+}
+
+void nwp_op_check_no_immediate(struct nw_mod *const m)
+{
+    m->next = run;
+}
diff --git a/src/op/check/relative_depth.c b/src/op/check/relative_depth.c
new file mode 100644
index 0000000..41011b8
--- /dev/null
+++ b/src/op/check/relative_depth.c
@@ -0,0 +1,40 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+
+static enum nw_state get_relative_depth(struct nw_mod *const m)
+{
+    nw_varuint32 relative_depth;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &relative_depth, cfg->user);
+
+    if (n)
+        return n;
+    else if (relative_depth >= c->fn.blocks)
+    {
+#ifdef NW_LOG
+        nwp_log("invalid relative depth %lu\n", (unsigned long)relative_depth);
+#endif
+        return NW_FATAL;
+    }
+
+    m->next = c->next;
+    return NW_AGAIN;
+}
+
+void nwp_op_check_relative_depth(struct nw_mod *const m)
+{
+    m->next = get_relative_depth;
+}
diff --git a/src/op/check/uint32.c b/src/op/check/uint32.c
new file mode 100644
index 0000000..28aa852
--- /dev/null
+++ b/src/op/check/uint32.c
@@ -0,0 +1,36 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/ops.h>
+
+static enum nw_state get_value(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    const enum nw_state n = nwp_io_read(cfg, &c->io, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = c->next;
+    return NW_AGAIN;
+}
+
+void nwp_op_check_uint32(struct nw_mod *const m)
+{
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_io io = {0};
+
+    io.buf = &c->u;
+    io.n = sizeof (struct nw_leuint32);
+    c->io = io;
+    m->next = get_value;
+}
diff --git a/src/op/check/uint64.c b/src/op/check/uint64.c
new file mode 100644
index 0000000..a925999
--- /dev/null
+++ b/src/op/check/uint64.c
@@ -0,0 +1,36 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/ops.h>
+
+static enum nw_state get_value(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    const enum nw_state n = nwp_io_read(cfg, &c->io, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = c->next;
+    return NW_AGAIN;
+}
+
+void nwp_op_check_uint64(struct nw_mod *const m)
+{
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_io io = {0};
+
+    io.buf = &c->u;
+    io.n = sizeof (struct nw_leuint64);
+    c->io = io;
+    m->next = get_value;
+}
diff --git a/src/op/check/varint32.c b/src/op/check/varint32.c
new file mode 100644
index 0000000..aff3904
--- /dev/null
+++ b/src/op/check/varint32.c
@@ -0,0 +1,32 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/ops.h>
+
+static enum nw_state get_value(struct nw_mod *const m)
+{
+    nw_varint32 value;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    const enum nw_state n = nwp_varint32(cfg, l, &value, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = c->next;
+    return NW_AGAIN;
+}
+
+void nwp_op_check_varint32(struct nw_mod *const m)
+{
+    m->next = get_value;
+}
diff --git a/src/op/check/varuint1.c b/src/op/check/varuint1.c
new file mode 100644
index 0000000..87ef6c4
--- /dev/null
+++ b/src/op/check/varuint1.c
@@ -0,0 +1,32 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/ops.h>
+
+static enum nw_state get_value(struct nw_mod *const m)
+{
+    nw_varuint1 value;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    const enum nw_state n = nwp_varuint1(cfg, l, &value, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = c->next;
+    return NW_AGAIN;
+}
+
+void nwp_op_check_varuint1(struct nw_mod *const m)
+{
+    m->next = get_value;
+}
diff --git a/src/op/drop.c b/src/op/drop.c
new file mode 100644
index 0000000..3b5dffd
--- /dev/null
+++ b/src/op/drop.c
@@ -0,0 +1,101 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/opcodes.h>
+#include <nw/ops.h>
+#include <nw/stack.h>
+#include <nw/types.h>
+
+static enum nw_state pop(struct nw_interp *const i)
+{
+    struct nw_i_sm_drop *const d = &i->sm.drop;
+    const enum nw_state n = nwp_stack_pop(i, &d->io);
+
+    if (n)
+        return n;
+
+    nwp_interp_resume(i);
+    return NW_AGAIN;
+}
+
+static enum nw_state check(struct nw_interp *const i)
+{
+    struct nw_i_sm_drop *const d = &i->sm.drop;
+    const struct nw_frame *const fr = &i->fr;
+    const struct nw_return *const r = &fr->prev_ret;
+    const unsigned char prev = fr->prev_op;
+    size_t sz;
+
+    if (prev != OP_CALL && prev != OP_CALL_INDIRECT)
+    {
+        static const char *const exc =
+            "expected call or call_indirect before drop";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s, got: %#x\n", exc, (unsigned)prev);
+#endif
+        return NW_FATAL;
+    }
+    else if (!r->count)
+    {
+        static const char *const exc =
+            "called drop from function without return value";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s\n", exc);
+#endif
+        return NW_FATAL;
+    }
+    else if (r->type != i->push_type)
+    {
+        static const char *const exc =
+            "mismatch between return type and last push type";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s, expected: %#hhx, got: %#hhx\n", exc,
+            (unsigned char)i->push_type, (unsigned char)r->type);
+#endif
+        return NW_FATAL;
+    }
+    else if (nwp_type_sz(r->type, &sz))
+    {
+        static const char *const exc = "invalid return type";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#x\n", exc, (unsigned)r->type);
+#endif
+        return NW_FATAL;
+    }
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &d->value;
+        io.n = sz;
+        d->io = io;
+        i->next = pop;
+    }
+
+    return NW_AGAIN;
+}
+
+void nwp_op_drop(struct nw_interp *const i)
+{
+    const struct nw_i_sm_drop d = {{0}};
+
+    i->sm.drop = d;
+    i->next = check;
+}
diff --git a/src/op/end.c b/src/op/end.c
new file mode 100644
index 0000000..9eb575d
--- /dev/null
+++ b/src/op/end.c
@@ -0,0 +1,67 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+#include <nw/routines.h>
+
+static enum nw_state run(struct nw_interp *const i)
+{
+    const struct nw_i_sm_end *const e = &i->sm.end;
+    struct nw_frame *const f = &i->fr;
+
+    if (i->set)
+        return NW_OK;
+    else if (f->block_i)
+    {
+        f->block_i--;
+        nwp_interp_resume(i);
+    }
+    else
+    {
+        const long expected = f->start + f->body_size;
+
+        if (e->offset != expected)
+        {
+            static const char *const exc = "unexpected end";
+
+#ifdef NW_LOG
+            nwp_log("%s\n", exc);
+#endif
+            i->exception = exc;
+            return NW_FATAL;
+        }
+        else if (f->child)
+            nwp_unwind(i);
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_offset(struct nw_interp *const i)
+{
+    struct nw_i_sm_end *const e = &i->sm.end;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = cfg->tell(&e->offset, cfg->user);
+
+    if (n)
+        return n;
+
+    return run(i);
+}
+
+void nwp_op_end(struct nw_interp *const i)
+{
+    static const struct nw_i_sm_end e = {0};
+
+    i->sm.end = e;
+    i->next = get_offset;
+}
diff --git a/src/op/get_global.c b/src/op/get_global.c
new file mode 100644
index 0000000..eb701b5
--- /dev/null
+++ b/src/op/get_global.c
@@ -0,0 +1,93 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/global.h>
+#include <nw/io.h>
+#include <nw/interp.h>
+#include <nw/stack.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+#include <nw/routines.h>
+
+static enum nw_state push(struct nw_interp *const i)
+{
+    struct nw_i_sm_get_global *const g = &i->sm.get_global;
+    const enum nw_state n = nwp_stack_push(i, &g->io);
+
+    if (n)
+        return n;
+
+    nwp_interp_resume(i);
+    return NW_AGAIN;
+}
+
+static enum nw_state read_global(struct nw_interp *const i)
+{
+    struct nw_i_sm_get_global *const g = &i->sm.get_global;
+    struct nw_sm_io *const io = &g->io;
+    struct nw_global *const gl = &g->gl;
+    const enum nw_state n = nwp_global_load(i, io, g->index);
+    size_t sz;
+
+    if (n)
+        return n;
+    else if (nwp_type_sz(gl->type, &sz))
+    {
+        static const char *const exc = "invalid global type";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#x\n", exc, (unsigned)gl->type);
+#endif
+        return NW_FATAL;
+    }
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &gl->value;
+        io.n = sz;
+        g->io = io;
+        i->next = push;
+        i->push_type = gl->type;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_index(struct nw_interp *const i)
+{
+    struct nw_i_sm_get_global *const g = &i->sm.get_global;
+    struct nw_sm_leb128 *const l = &g->leb128;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_varuint32(cfg, l, &g->index, cfg->user);
+
+    if (n)
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &g->gl;
+        io.n = sizeof g->gl;
+        g->io = io;
+        i->next = read_global;
+    }
+
+    return NW_AGAIN;
+}
+
+void nwp_op_get_global(struct nw_interp *const i)
+{
+    static const struct nw_i_sm_get_global g = {0};
+
+    i->sm.get_global = g;
+    i->next = get_index;
+}
diff --git a/src/op/get_local.c b/src/op/get_local.c
new file mode 100644
index 0000000..6a9a42a
--- /dev/null
+++ b/src/op/get_local.c
@@ -0,0 +1,150 @@
+
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+#include <nw/routines.h>
+#include <nw/stack.h>
+#include <nw/types.h>
+
+static int init_io(struct nw_interp *const i, const enum nw_type t)
+{
+    struct nw_i_sm_get_local *const gl = &i->sm.get_local;
+    size_t sz;
+
+    if (nwp_type_sz(t, &sz))
+    {
+        static const char *const exc = "invalid type";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#x\n", exc, (unsigned)t);
+#endif
+        return -1;
+    }
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &gl->value;
+        io.n = sz;
+        gl->io = io;
+    }
+
+    return 0;
+}
+
+static enum nw_state push(struct nw_interp *const i)
+{
+    struct nw_i_sm_get_local *const gl = &i->sm.get_local;
+    const enum nw_state n = nwp_stack_push(i, &gl->io);
+
+    if (n)
+        return n;
+
+    nwp_interp_resume(i);
+    return NW_AGAIN;
+}
+
+static enum nw_state get_local(struct nw_interp *const i)
+{
+    struct nw_i_sm_get_local *const gl = &i->sm.get_local;
+    const struct nw_local_meta *const m = &gl->f.l.meta;
+    const enum nw_state n = nwp_stack_read(i, &gl->io, gl->f.l.addr);
+
+    if (n)
+        return n;
+    else if (init_io(i, m->type))
+        return NW_FATAL;
+
+    i->next = push;
+    i->push_type = m->type;
+    return NW_AGAIN;
+}
+
+static enum nw_state prepare_local(struct nw_interp *const i)
+{
+    const struct nw_local_meta *const m = &i->sm.get_local.f.l.meta;
+
+    if (init_io(i, m->type))
+        return NW_FATAL;
+
+    i->next = get_local;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_param(struct nw_interp *const i)
+{
+    struct nw_i_sm_get_local *const gl = &i->sm.get_local;
+    const struct nw_find_param_out *const o = &gl->f.p.out;
+    const enum nw_state n = nwp_stack_read(i, &gl->io, o->addr);
+
+    if (n)
+        return n;
+    else if (init_io(i, o->type))
+        return NW_FATAL;
+
+    i->next = push;
+    i->push_type = o->type;
+    return NW_AGAIN;
+}
+
+static enum nw_state prepare_param(struct nw_interp *const i)
+{
+    struct nw_i_sm_get_local *const gl = &i->sm.get_local;
+    const struct nw_find_param_out *const o = &gl->f.p.out;
+
+    if (init_io(i, o->type))
+        return NW_FATAL;
+
+    i->next = get_param;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_index(struct nw_interp *const i)
+{
+    struct nw_i_sm_get_local *const gl = &i->sm.get_local;
+    struct nw_sm_leb128 *const l = &gl->leb128;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const struct nw_frame *const fr = &i->fr;
+    const struct nw_fn *const fn = &fr->fn;
+    const enum nw_state n = nwp_varuint32(cfg, l, &gl->index, cfg->user);
+    nw_varuint32 index;
+
+    if (n)
+        return n;
+    else if (gl->index < fn->param_count)
+        nwp_find_param(i, &gl->f.p, gl->index, prepare_param, NULL);
+    else if ((index = gl->index - fn->param_count) >= fr->local_count)
+    {
+        static const char *const exc = "invalid local index";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %lu\n", exc, (unsigned long)gl->index);
+#endif
+        return NW_FATAL;
+    }
+    else
+        nwp_find_local(i, &gl->f.l, index, prepare_local, NULL);
+
+    return NW_AGAIN;
+}
+
+void nwp_op_get_local(struct nw_interp *const i)
+{
+    static const struct nw_i_sm_get_local gl = {0};
+
+    i->sm.get_local = gl;
+    i->next = get_index;
+}
diff --git a/src/op/i32_add.c b/src/op/i32_add.c
new file mode 100644
index 0000000..fe2ec69
--- /dev/null
+++ b/src/op/i32_add.c
@@ -0,0 +1,23 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/routines.h>
+
+static int add(const struct nw_i_sm_arithm_out *const o,
+    union nw_value *const res)
+{
+    res->i32 = (unsigned long)o->left.i32 + (unsigned long)o->right.i32;
+    return 0;
+}
+
+void nwp_op_i32_add(struct nw_interp *const i)
+{
+    nwp_arithm(i, NW_TYPE_I32, add);
+}
diff --git a/src/op/i32_and.c b/src/op/i32_and.c
new file mode 100644
index 0000000..d52bead
--- /dev/null
+++ b/src/op/i32_and.c
@@ -0,0 +1,23 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/routines.h>
+
+static int and(const struct nw_i_sm_arithm_out *const o,
+    union nw_value *const res)
+{
+    res->i32 = o->left.i32 & o->right.i32;
+    return 0;
+}
+
+void nwp_op_i32_and(struct nw_interp *const i)
+{
+    nwp_arithm(i, NW_TYPE_I32, and);
+}
diff --git a/src/op/i32_const.c b/src/op/i32_const.c
new file mode 100644
index 0000000..80dc9dd
--- /dev/null
+++ b/src/op/i32_const.c
@@ -0,0 +1,58 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/interp.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+#include <nw/stack.h>
+
+static enum nw_state push(struct nw_interp *const i)
+{
+    struct nw_i_sm_i32_const *const c = &i->sm.i32_const;
+    const enum nw_state n = nwp_stack_push(i, &c->io);
+
+    if (n)
+        return n;
+
+    i->push_type = NW_TYPE_I32;
+    nwp_interp_resume(i);
+    return NW_AGAIN;
+}
+
+static enum nw_state get_value(struct nw_interp *const i)
+{
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    struct nw_i_sm_i32_const *const c = &i->sm.i32_const;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    const enum nw_state n = nwp_varint32(cfg, l, &c->value, cfg->user);
+
+    if (n)
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &c->value;
+        io.n = sizeof c->value;
+        c->io = io;
+        i->next = push;
+    }
+
+    return NW_AGAIN;
+}
+
+void nwp_op_i32_const(struct nw_interp *const i)
+{
+    static const struct nw_i_sm_i32_const c = {0};
+
+    i->next = get_value;
+    i->sm.i32_const = c;
+}
diff --git a/src/op/i32_eq.c b/src/op/i32_eq.c
new file mode 100644
index 0000000..3f2cc42
--- /dev/null
+++ b/src/op/i32_eq.c
@@ -0,0 +1,23 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/routines.h>
+
+static int eq(const struct nw_i_sm_arithm_out *const o,
+    union nw_value *const res)
+{
+    res->i32 = o->left.i32 == o->right.i32;
+    return 0;
+}
+
+void nwp_op_i32_eq(struct nw_interp *const i)
+{
+    nwp_arithm(i, NW_TYPE_I32, eq);
+}
diff --git a/src/op/i32_eqz.c b/src/op/i32_eqz.c
new file mode 100644
index 0000000..cd533fd
--- /dev/null
+++ b/src/op/i32_eqz.c
@@ -0,0 +1,22 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/routines.h>
+
+static int eqz(const union nw_value *const in, union nw_value *const out)
+{
+    out->i32 = !in->i32;
+    return 0;
+}
+
+void nwp_op_i32_eqz(struct nw_interp *const i)
+{
+    nwp_unary(i, NW_TYPE_I32, eqz);
+}
diff --git a/src/op/i32_ge_s.c b/src/op/i32_ge_s.c
new file mode 100644
index 0000000..137b80d
--- /dev/null
+++ b/src/op/i32_ge_s.c
@@ -0,0 +1,23 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/routines.h>
+
+static int ge_s(const struct nw_i_sm_arithm_out *const o,
+    union nw_value *const res)
+{
+    res->i32 = o->left.i32 >= o->right.i32;
+    return 0;
+}
+
+void nwp_op_i32_ge_s(struct nw_interp *const i)
+{
+    nwp_arithm(i, NW_TYPE_I32, ge_s);
+}
diff --git a/src/op/i32_ge_u.c b/src/op/i32_ge_u.c
new file mode 100644
index 0000000..c280dec
--- /dev/null
+++ b/src/op/i32_ge_u.c
@@ -0,0 +1,23 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/routines.h>
+
+static int ge_u(const struct nw_i_sm_arithm_out *const o,
+    union nw_value *const res)
+{
+    res->i32 = (unsigned long)o->left.i32 >= (unsigned long)o->right.i32;
+    return 0;
+}
+
+void nwp_op_i32_ge_u(struct nw_interp *const i)
+{
+    nwp_arithm(i, NW_TYPE_I32, ge_u);
+}
diff --git a/src/op/i32_load.c b/src/op/i32_load.c
new file mode 100644
index 0000000..e2d883b
--- /dev/null
+++ b/src/op/i32_load.c
@@ -0,0 +1,89 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/interp.h>
+#include <nw/linear.h>
+#include <nw/stack.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+#include <nw/routines.h>
+
+static enum nw_state push(struct nw_interp *const i)
+{
+    struct nw_i_sm_load *const l = &i->sm.load;
+    const enum nw_state n = nwp_stack_push(i, &l->io);
+
+    if (n)
+        return n;
+
+    i->push_type = NW_TYPE_I32;
+    nwp_interp_resume(i);
+    return NW_AGAIN;
+}
+
+static enum nw_state load(struct nw_interp *const i)
+{
+    struct nw_i_sm_load *const l = &i->sm.load;
+    const enum nw_state n = nwp_linear_load(i, &l->io, l->addr + l->imm.offset);
+
+    if (n)
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        l->value.i32 = nwp_leuint32(&l->value.v32);
+        io.buf = &l->value.i32;
+        io.n = sizeof l->value.i32;
+        l->io = io;
+        i->next = push;
+    }
+
+    i->next = push;
+    return NW_AGAIN;
+}
+
+static enum nw_state pop_addr(struct nw_interp *const i)
+{
+    struct nw_i_sm_load *const l = &i->sm.load;
+    const enum nw_state n = nwp_stack_pop(i, &l->io);
+
+    if (n)
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &l->value.i32;
+        io.n = sizeof l->value.i32;
+        l->io = io;
+        i->next = load;
+    }
+
+    return NW_AGAIN;
+}
+
+static void prepare(struct nw_interp *const i)
+{
+    struct nw_i_sm_imm_out imm = i->sm.imm.out;
+    struct nw_i_sm_load *const pl = &i->sm.load, l = {0};
+
+    l.imm = imm;
+    l.io.buf = &pl->addr;
+    l.io.n = sizeof pl->addr;
+    *pl = l;
+    i->next = pop_addr;
+}
+
+void nwp_op_i32_load(struct nw_interp *const i)
+{
+    nwp_mem_imm(i, prepare);
+}
diff --git a/src/op/i32_load8_u.c b/src/op/i32_load8_u.c
new file mode 100644
index 0000000..da4282b
--- /dev/null
+++ b/src/op/i32_load8_u.c
@@ -0,0 +1,89 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/linear.h>
+#include <nw/io.h>
+#include <nw/interp.h>
+#include <nw/stack.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+#include <nw/routines.h>
+
+static enum nw_state push(struct nw_interp *const i)
+{
+    struct nw_i_sm_load *const l = &i->sm.load;
+    const enum nw_state n = nwp_stack_push(i, &l->io);
+
+    if (n)
+        return n;
+
+    i->push_type = NW_TYPE_I32;
+    nwp_interp_resume(i);
+    return NW_AGAIN;
+}
+
+static enum nw_state load(struct nw_interp *const i)
+{
+    struct nw_i_sm_load *const l = &i->sm.load;
+    const enum nw_state n = nwp_linear_load(i, &l->io, l->addr + l->imm.offset);
+
+    if (n)
+        return n;
+    else
+    {
+        const unsigned char b = l->value.i8;
+        struct nw_sm_io io = {0};
+
+        io.buf = &l->value.i32;
+        io.n = sizeof l->value.i32;
+        l->value.i32 = b;
+        l->io = io;
+        i->next = push;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state pop_addr(struct nw_interp *const i)
+{
+    struct nw_i_sm_load *const l = &i->sm.load;
+    const enum nw_state n = nwp_stack_pop(i, &l->io);
+
+    if (n)
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &l->value.i8;
+        io.n = sizeof l->value.i8;
+        l->io = io;
+        i->next = load;
+    }
+
+    return NW_AGAIN;
+}
+
+static void prepare(struct nw_interp *const i)
+{
+    struct nw_i_sm_imm_out imm = i->sm.imm.out;
+    struct nw_i_sm_load *const pl = &i->sm.load, l = {0};
+
+    l.imm = imm;
+    l.io.buf = &pl->addr;
+    l.io.n = sizeof pl->addr;
+    *pl = l;
+    i->next = pop_addr;
+}
+
+void nwp_op_i32_load8_u(struct nw_interp *const i)
+{
+    nwp_mem_imm(i, prepare);
+}
diff --git a/src/op/i32_lt_s.c b/src/op/i32_lt_s.c
new file mode 100644
index 0000000..3e583c3
--- /dev/null
+++ b/src/op/i32_lt_s.c
@@ -0,0 +1,23 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/routines.h>
+
+static int lt_s(const struct nw_i_sm_arithm_out *const o,
+    union nw_value *const res)
+{
+    res->i32 = o->left.i32 < o->right.i32;
+    return 0;
+}
+
+void nwp_op_i32_lt_s(struct nw_interp *const i)
+{
+    nwp_arithm(i, NW_TYPE_I32, lt_s);
+}
diff --git a/src/op/i32_mul.c b/src/op/i32_mul.c
new file mode 100644
index 0000000..8af64de
--- /dev/null
+++ b/src/op/i32_mul.c
@@ -0,0 +1,23 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/routines.h>
+
+static int mul(const struct nw_i_sm_arithm_out *const o,
+    union nw_value *const res)
+{
+    res->i32 = (unsigned long)o->left.i32 * (unsigned long)o->right.i32;
+    return 0;
+}
+
+void nwp_op_i32_mul(struct nw_interp *const i)
+{
+    nwp_arithm(i, NW_TYPE_I32, mul);
+}
diff --git a/src/op/i32_ne.c b/src/op/i32_ne.c
new file mode 100644
index 0000000..c62a2a7
--- /dev/null
+++ b/src/op/i32_ne.c
@@ -0,0 +1,23 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/routines.h>
+
+static int ne(const struct nw_i_sm_arithm_out *const o,
+    union nw_value *const res)
+{
+    res->i32 = o->left.i32 != o->right.i32;
+    return 0;
+}
+
+void nwp_op_i32_ne(struct nw_interp *const i)
+{
+    nwp_arithm(i, NW_TYPE_I32, ne);
+}
diff --git a/src/op/i32_or.c b/src/op/i32_or.c
new file mode 100644
index 0000000..774dbed
--- /dev/null
+++ b/src/op/i32_or.c
@@ -0,0 +1,23 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/routines.h>
+
+static int or(const struct nw_i_sm_arithm_out *const o,
+    union nw_value *const res)
+{
+    res->i32 = o->left.i32 | o->right.i32;
+    return 0;
+}
+
+void nwp_op_i32_or(struct nw_interp *const i)
+{
+    nwp_arithm(i, NW_TYPE_I32, or);
+}
diff --git a/src/op/i32_store.c b/src/op/i32_store.c
new file mode 100644
index 0000000..caff6b9
--- /dev/null
+++ b/src/op/i32_store.c
@@ -0,0 +1,90 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/linear.h>
+#include <nw/io.h>
+#include <nw/interp.h>
+#include <nw/stack.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+#include <nw/routines.h>
+
+static enum nw_state store(struct nw_interp *const i)
+{
+    struct nw_i_sm_store *const s = &i->sm.store;
+    const enum nw_state n = nwp_linear_store(i, &s->io, s->addr + s->imm.offset);
+
+    if (n)
+        return n;
+
+    nwp_interp_resume(i);
+    return NW_AGAIN;
+}
+
+static enum nw_state pop_addr(struct nw_interp *const i)
+{
+    struct nw_i_sm_store *const s = &i->sm.store;
+    const enum nw_state n = nwp_stack_pop(i, &s->io);
+
+    if (n)
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &s->value.i32;
+        io.n = sizeof s->value.i32;
+        s->io = io;
+        i->next = store;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state pop_value(struct nw_interp *const i)
+{
+    struct nw_i_sm_store *const s = &i->sm.store;
+    const enum nw_state n = nwp_stack_pop(i, &s->io);
+
+    if (n)
+        return n;
+    else
+    {
+        const struct nw_sm_io io = {0};
+
+        s->value.i32 = nwp_leuint32(&s->value.v32);
+        s->io = io;
+        s->io.buf = &s->addr;
+        s->io.n = sizeof s->addr;
+        i->next = pop_addr;
+    }
+
+    return NW_AGAIN;
+}
+
+static void prepare(struct nw_interp *const i)
+{
+    const struct nw_i_sm_store s = {0};
+    struct nw_i_sm_store *const ps = &i->sm.store;
+    struct nw_sm_io *const io = &ps->io;
+    struct nw_i_sm_imm_out out;
+
+    out = i->sm.imm.out;
+    *ps = s;
+    ps->imm = out;
+    io->buf = &ps->value.i32;
+    io->n = sizeof ps->value.i32;
+    i->next = pop_value;
+}
+
+void nwp_op_i32_store(struct nw_interp *const i)
+{
+    nwp_mem_imm(i, prepare);
+}
diff --git a/src/op/i32_sub.c b/src/op/i32_sub.c
new file mode 100644
index 0000000..46c4f66
--- /dev/null
+++ b/src/op/i32_sub.c
@@ -0,0 +1,23 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/routines.h>
+
+static int sub(const struct nw_i_sm_arithm_out *const o,
+    union nw_value *const res)
+{
+    res->i32 = (unsigned long)o->left.i32 - (unsigned long)o->right.i32;
+    return 0;
+}
+
+void nwp_op_i32_sub(struct nw_interp *const i)
+{
+    nwp_arithm(i, NW_TYPE_I32, sub);
+}
diff --git a/src/op/i64_const.c b/src/op/i64_const.c
new file mode 100644
index 0000000..20d539b
--- /dev/null
+++ b/src/op/i64_const.c
@@ -0,0 +1,58 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/interp.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+#include <nw/stack.h>
+
+static enum nw_state push(struct nw_interp *const i)
+{
+    struct nw_i_sm_i64_const *const c = &i->sm.i64_const;
+    const enum nw_state n = nwp_stack_push(i, &c->io);
+
+    if (n)
+        return n;
+
+    i->push_type = NW_TYPE_I64;
+    nwp_interp_resume(i);
+    return NW_AGAIN;
+}
+
+static enum nw_state get_value(struct nw_interp *const i)
+{
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    struct nw_i_sm_i64_const *const c = &i->sm.i64_const;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    const enum nw_state n = nwp_varuint64(cfg, l, &c->value, cfg->user);
+
+    if (n)
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &c->value;
+        io.n = sizeof c->value;
+        c->io = io;
+        i->next = push;
+    }
+
+    return NW_AGAIN;
+}
+
+void nwp_op_i64_const(struct nw_interp *const i)
+{
+    const struct nw_i_sm_i64_const c = {{0}};
+
+    i->next = get_value;
+    i->sm.i64_const = c;
+}
diff --git a/src/op/i64_store.c b/src/op/i64_store.c
new file mode 100644
index 0000000..fbae8b4
--- /dev/null
+++ b/src/op/i64_store.c
@@ -0,0 +1,87 @@
+/*
+* nanowasm, a tiny WebAssembly/Wasm interpreter
+* Copyright (C) 2023-2025  Xavier Del Campo Romero
+*
+* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at https://mozilla.org/MPL/2.0/.
+*/
+
+#include <nanowasm/nw.h>
+#include <nw/linear.h>
+#include <nw/io.h>
+#include <nw/interp.h>
+#include <nw/stack.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+#include <nw/routines.h>
+
+static enum nw_state store(struct nw_interp *const i)
+{
+    struct nw_i_sm_store *const s = &i->sm.store;
+    const enum nw_state n = nwp_linear_store(i, &s->io,
+        s->addr + s->imm.offset);
+
+    if (n)
+        return n;
+
+    nwp_interp_resume(i);
+    return NW_AGAIN;
+}
+
+static enum nw_state pop_addr(struct nw_interp *const i)
+{
+    struct nw_i_sm_store *const s = &i->sm.store;
+    const enum nw_state n = nwp_stack_pop(i, &s->io);
+
+    if (n)
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &s->value.i64;
+        io.n = sizeof s->value.i64;
+        s->io = io;
+        i->next = store;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state pop_value(struct nw_interp *const i)
+{
+    struct nw_i_sm_store *const s = &i->sm.store;
+    const enum nw_state n = nwp_stack_pop(i, &s->io);
+
+    if (n)
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        nwp_leuint64(&s->value.v64, &s->value.i64);
+        io.buf = &s->addr;
+        io.n = sizeof s->addr;
+        s->io = io;
+        i->next = pop_addr;
+    }
+
+    return NW_AGAIN;
+}
+
+static void prepare(struct nw_interp *const i)
+{
+    struct nw_i_sm_store *const ps = &i->sm.store, s = {0};
+
+    s.imm = i->sm.imm.out;
+    s.io.buf = &ps->value.v64;
+    s.io.n = sizeof ps->value.v64;
+    *ps =s;
+    i->next = pop_value;
+}
+
+void nwp_op_i64_store(struct nw_interp *const i)
+{
+    nwp_mem_imm(i, prepare);
+}
diff --git a/src/op/loop.c b/src/op/loop.c
new file mode 100644
index 0000000..e129610
--- /dev/null
+++ b/src/op/loop.c
@@ -0,0 +1,16 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/routines.h>
+
+void nwp_op_loop(struct nw_interp *const i)
+{
+    nwp_start_block(i);
+}
diff --git a/src/op/nop.c b/src/op/nop.c
new file mode 100644
index 0000000..b6ef7c2
--- /dev/null
+++ b/src/op/nop.c
@@ -0,0 +1,17 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/ops.h>
+
+void nwp_op_nop(struct nw_interp *const i)
+{
+    nwp_interp_resume(i);
+}
diff --git a/src/op/return.c b/src/op/return.c
new file mode 100644
index 0000000..0b2a129
--- /dev/null
+++ b/src/op/return.c
@@ -0,0 +1,19 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+#include <nw/routines.h>
+
+void nwp_op_return(struct nw_interp *const i)
+{
+    nwp_unwind(i);
+}
diff --git a/src/op/set_global.c b/src/op/set_global.c
new file mode 100644
index 0000000..9448c32
--- /dev/null
+++ b/src/op/set_global.c
@@ -0,0 +1,122 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/global.h>
+#include <nw/io.h>
+#include <nw/interp.h>
+#include <nw/stack.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+#include <nw/routines.h>
+
+static enum nw_state set_global(struct nw_interp *const i)
+{
+    struct nw_i_sm_get_global *const g = &i->sm.get_global;
+    const enum nw_state n = nwp_global_store(i, &g->io, g->index);
+
+    if (n)
+        return n;
+
+    nwp_interp_resume(i);
+    return NW_AGAIN;
+}
+
+static enum nw_state pop(struct nw_interp *const i)
+{
+    struct nw_i_sm_get_global *const g = &i->sm.get_global;
+    const enum nw_state n = nwp_stack_pop(i, &g->io);
+
+    if (n)
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &g->gl;
+        io.n = sizeof g->gl;
+        g->io = io;
+        i->next = set_global;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state read_global(struct nw_interp *const i)
+{
+    struct nw_i_sm_get_global *const g = &i->sm.get_global;
+    struct nw_global *const gl = &g->gl;
+    const enum nw_state n = nwp_global_load(i, &g->io, g->index);
+    size_t sz;
+
+    if (n)
+        return n;
+    else if (!gl->mutability)
+    {
+        static const char *const exc = "cannot set non-mutable global";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s, index: %lu\n", exc, (unsigned long)g->index);
+#endif
+        return NW_FATAL;
+    }
+    else if (nwp_type_sz(gl->type, &sz))
+    {
+        static const char *const exc = "invalid global type";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#x\n", exc, (unsigned)gl->type);
+#endif
+        return NW_FATAL;
+    }
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &gl->value;
+        io.n = sz;
+        g->io = io;
+        i->next = pop;
+        i->push_type = gl->type;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_index(struct nw_interp *const i)
+{
+    struct nw_i_sm_get_global *const g = &i->sm.get_global;
+    struct nw_sm_leb128 *const l = &g->leb128;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_varuint32(cfg, l, &g->index, cfg->user);
+
+    if (n)
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &g->gl;
+        io.n = sizeof g->gl;
+        g->io = io;
+        i->next = read_global;
+    }
+
+    return NW_AGAIN;
+}
+
+void nwp_op_set_global(struct nw_interp *const i)
+{
+    static const struct nw_i_sm_set_global g = {0};
+
+    i->sm.set_global = g;
+    i->next = get_index;
+}
diff --git a/src/op/set_local.c b/src/op/set_local.c
new file mode 100644
index 0000000..0488e16
--- /dev/null
+++ b/src/op/set_local.c
@@ -0,0 +1,24 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/ops.h>
+#include <nw/routines.h>
+
+static enum nw_state resume(struct nw_interp *const i)
+{
+    nwp_interp_resume(i);
+    return NW_AGAIN;
+}
+
+void nwp_op_set_local(struct nw_interp *const i)
+{
+    nwp_set_local(i, resume);
+}
diff --git a/src/op/tee_local.c b/src/op/tee_local.c
new file mode 100644
index 0000000..b95603c
--- /dev/null
+++ b/src/op/tee_local.c
@@ -0,0 +1,64 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+#include <nw/routines.h>
+#include <nw/stack.h>
+
+static enum nw_state push(struct nw_interp *const i)
+{
+    struct nw_i_sm_tee_local *const t = &i->sm.tee_local;
+    const enum nw_state n = nwp_stack_push(i, &t->io);
+
+    if (n)
+        return n;
+
+    nwp_interp_resume(i);
+    return NW_AGAIN;
+}
+
+static enum nw_state prepare(struct nw_interp *const i)
+{
+    struct nw_i_sm_tee_local *const t = &i->sm.tee_local;
+    struct nw_i_sm_set_local_out o;
+    size_t sz;
+
+    o = i->sm.set_local.out;
+
+    if (nwp_type_sz(o.type, &sz))
+    {
+        static const char *const exc = "invalid local type";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#x\n", exc, (unsigned)o.type);
+#endif
+        return NW_FATAL;
+    }
+    else
+    {
+        struct nw_i_sm_tee_local tl = {{0}};
+
+        tl.in = o;
+        tl.io.buf = &t->in.value;
+        tl.io.n = sz;
+        *t = tl;
+        i->next = push;
+    }
+
+    return NW_AGAIN;
+}
+
+void nwp_op_tee_local(struct nw_interp *const i)
+{
+    nwp_set_local(i, prepare);
+}
diff --git a/src/op/tostr.c b/src/op/tostr.c
new file mode 100644
index 0000000..b2ac6dd
--- /dev/null
+++ b/src/op/tostr.c
@@ -0,0 +1,278 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/opcodes.h>
+
+const char *nwp_op_tostr(const enum opcode op)
+{
+    static const char *const s[] =
+    {
+        "OP_UNREACHABLE",
+        "OP_NOP",
+        "OP_BLOCK",
+        "OP_LOOP",
+        "OP_IF",
+        "OP_ELSE",
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        "OP_END",
+        "OP_BR",
+        "OP_BR_IF",
+        "OP_BR_TABLE",
+        "OP_RETURN",
+        "OP_CALL",
+        "OP_CALL_INDIRECT",
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        "OP_DROP",
+        "OP_SELECT",
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        "OP_GET_LOCAL",
+        "OP_SET_LOCAL",
+        "OP_TEE_LOCAL",
+        "OP_GET_GLOBAL",
+        "OP_SET_GLOBAL",
+        NULL,
+        NULL,
+        NULL,
+        "OP_I32_LOAD",
+        "OP_I64_LOAD",
+        "OP_F32_LOAD",
+        "OP_F64_LOAD",
+        "OP_I32_LOAD8_S",
+        "OP_I32_LOAD8_U",
+        "OP_I32_LOAD16_S",
+        "OP_I32_LOAD16_U",
+        "OP_I64_LOAD8_S",
+        "OP_I64_LOAD8_U",
+        "OP_I64_LOAD16_S",
+        "OP_I64_LOAD16_U",
+        "OP_I64_LOAD32_S",
+        "OP_I64_LOAD32_U",
+        "OP_I32_STORE",
+        "OP_I64_STORE",
+        "OP_F32_STORE",
+        "OP_F64_STORE",
+        "OP_I32_STORE8",
+        "OP_I32_STORE16",
+        "OP_I64_STORE8",
+        "OP_I64_STORE16",
+        "OP_I64_STORE32",
+        "OP_CURRENT_MEMORY",
+        "OP_GROW_MEMORY",
+        "OP_I32_CONST",
+        "OP_I64_CONST",
+        "OP_F32_CONST",
+        "OP_F64_CONST",
+        "OP_I32_EQZ",
+        "OP_I32_EQ",
+        "OP_I32_NE",
+        "OP_I32_LT_S",
+        "OP_I32_LT_U",
+        "OP_I32_GT_S",
+        "OP_I32_GT_U",
+        "OP_I32_LE_S",
+        "OP_I32_LE_U",
+        "OP_I32_GE_S",
+        "OP_I32_GE_U",
+        "OP_I64_EQZ",
+        "OP_I64_EQ",
+        "OP_I64_NE",
+        "OP_I64_LT_S",
+        "OP_I64_LT_U",
+        "OP_I64_GT_S",
+        "OP_I64_GT_U",
+        "OP_I64_LE_S",
+        "OP_I64_LE_U",
+        "OP_I64_GE_S",
+        "OP_I64_GE_U",
+        "OP_F32_EQ",
+        "OP_F32_NE",
+        "OP_F32_LT",
+        "OP_F32_GT",
+        "OP_F32_LE",
+        "OP_F32_GE",
+        "OP_F64_EQ",
+        "OP_F64_NE",
+        "OP_F64_LT",
+        "OP_F64_GT",
+        "OP_F64_LE",
+        "OP_F64_GE",
+        "OP_I32_CLZ",
+        "OP_I32_CTZ",
+        "OP_I32_POPCNT",
+        "OP_I32_ADD",
+        "OP_I32_SUB",
+        "OP_I32_MUL",
+        "OP_I32_DIV_S",
+        "OP_I32_DIV_U",
+        "OP_I32_REM_S",
+        "OP_I32_REM_U",
+        "OP_I32_AND",
+        "OP_I32_OR",
+        "OP_I32_XOR",
+        "OP_I32_SHL",
+        "OP_I32_SHR_S",
+        "OP_I32_SHR_U",
+        "OP_I32_ROTL",
+        "OP_I32_ROTR",
+        "OP_I64_CLZ",
+        "OP_I64_CTZ",
+        "OP_I64_POPCNT",
+        "OP_I64_ADD",
+        "OP_I64_SUB",
+        "OP_I64_MUL",
+        "OP_I64_DIV_S",
+        "OP_I64_DIV_U",
+        "OP_I64_REM_S",
+        "OP_I64_REM_U",
+        "OP_I64_AND",
+        "OP_I64_OR",
+        "OP_I64_XOR",
+        "OP_I64_SHL",
+        "OP_I64_SHR_S",
+        "OP_I64_SHR_U",
+        "OP_I64_ROTL",
+        "OP_I64_ROTR",
+        "OP_F32_ABS",
+        "OP_F32_NEG",
+        "OP_F32_CEIL",
+        "OP_F32_FLOOR",
+        "OP_F32_TRUNC",
+        "OP_F32_NEAREST",
+        "OP_F32_SQRT",
+        "OP_F32_ADD",
+        "OP_F32_SUB",
+        "OP_F32_MUL",
+        "OP_F32_DIV",
+        "OP_F32_MIN",
+        "OP_F32_MAX",
+        "OP_F32_COPYSIGN",
+        "OP_F64_ABS",
+        "OP_F64_NEG",
+        "OP_F64_CEIL",
+        "OP_F64_FLOOR",
+        "OP_F64_TRUNC",
+        "OP_F64_NEAREST",
+        "OP_F64_SQRT",
+        "OP_F64_ADD",
+        "OP_F64_SUB",
+        "OP_F64_MUL",
+        "OP_F64_DIV",
+        "OP_F64_MIN",
+        "OP_F64_MAX",
+        "OP_F64_COPYSIGN",
+        "OP_I32_WRAP_I64",
+        "OP_I32_TRUNC_S_F32",
+        "OP_I32_TRUNC_U_F32",
+        "OP_I32_TRUNC_S_F64",
+        "OP_I32_TRUNC_U_F64",
+        "OP_I64_EXTEND_S_I32",
+        "OP_I64_EXTEND_U_I32",
+        "OP_I64_TRUNC_S_F32",
+        "OP_I64_TRUNC_U_F32",
+        "OP_I64_TRUNC_S_F64",
+        "OP_I64_TRUNC_U_F64",
+        "OP_F32_CONVERT_S_I32",
+        "OP_F32_CONVERT_U_I32",
+        "OP_F32_CONVERT_S_I64",
+        "OP_F32_CONVERT_U_I64",
+        "OP_F32_DEMOTE_F64",
+        "OP_F64_CONVERT_S_I32",
+        "OP_F64_CONVERT_U_I32",
+        "OP_F64_CONVERT_S_I64",
+        "OP_F64_CONVERT_U_I64",
+        "OP_F64_PROMOTE_F32",
+        "OP_I32_REINTERPRET_F32",
+        "OP_I64_REINTERPRET_F64",
+        "OP_F32_REINTERPRET_I32",
+        "OP_F64_REINTERPRET_I64",
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        "OP_MISC",
+    };
+
+    if (op < 0 || op >= sizeof s / sizeof *s)
+        return "invalid opcode";
+
+    return s[op];
+}
diff --git a/src/op/unreachable.c b/src/op/unreachable.c
new file mode 100644
index 0000000..6ecd374
--- /dev/null
+++ b/src/op/unreachable.c
@@ -0,0 +1,38 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+
+static enum nw_state tell(struct nw_interp *const i)
+{
+    struct nw_i_sm_unreachable *const u = &i->sm.unreachable;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    static const char *const exc = "unreachable";
+    const enum nw_state n = cfg->tell(&u->offset, cfg->user);
+
+    if (n)
+        return n;
+
+    i->exception = exc;
+#ifdef NW_LOG
+    nwp_log("%s, offset: %ld\n", exc, u->offset);
+#endif
+    return NW_FATAL;
+}
+
+void nwp_op_unreachable(struct nw_interp *const i)
+{
+    static const struct nw_i_sm_unreachable u = {0};
+
+    i->sm.unreachable = u;
+    i->next = tell;
+}
diff --git a/src/rexc.c b/src/rexc.c
new file mode 100644
index 0000000..b2c73a4
--- /dev/null
+++ b/src/rexc.c
@@ -0,0 +1,15 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+
+const char *nw_rexc(const struct nw_inst *const i)
+{
+    return i->interp.exception;
+}
diff --git a/src/routines/CMakeLists.txt b/src/routines/CMakeLists.txt
new file mode 100644
index 0000000..05c055b
--- /dev/null
+++ b/src/routines/CMakeLists.txt
@@ -0,0 +1,32 @@
+# nanowasm, a tiny WebAssembly/Wasm interpreter
+# Copyright (C) 2023-2025  Xavier Del Campo Romero
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+target_sources(${PROJECT_NAME} PRIVATE
+    arithm.c
+    break.c
+    call.c
+    call_function.c
+    call_import.c
+    call_indirect.c
+    check_magic.c
+    check_version.c
+    find_function.c
+    find_local.c
+    find_param.c
+    get_function_type.c
+    get_import_type.c
+    init_data.c
+    init_globals.c
+    mem_imm.c
+    section.c
+    set_local.c
+    start_block.c
+    unary.c
+    unwind.c
+)
+
+add_subdirectory(section)
diff --git a/src/routines/arithm.c b/src/routines/arithm.c
new file mode 100644
index 0000000..6ab4799
--- /dev/null
+++ b/src/routines/arithm.c
@@ -0,0 +1,119 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/interp.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <nw/stack.h>
+#include <nw/types.h>
+
+static enum nw_state push(struct nw_interp *const i)
+{
+    struct nw_i_sm_arithm *const s = &i->sm.arithm;
+    const enum nw_state n = nwp_stack_push(i, &s->io);
+
+    if (n)
+        return n;
+
+    i->push_type = s->type;
+    nwp_interp_resume(i);
+    return NW_AGAIN;
+}
+
+static int init_io(struct nw_interp *const i)
+{
+    struct nw_i_sm_arithm *const s = &i->sm.arithm;
+    size_t sz;
+
+    if (nwp_type_sz(s->type, &sz))
+    {
+        static const char *const exc = "invalid operand type";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#x\n", exc, (unsigned)s->type);
+#endif
+        return -1;
+    }
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &s->value;
+        io.n = sz;
+        s->io = io;
+    }
+
+    return 0;
+}
+
+static enum nw_state pop_left(struct nw_interp *const i)
+{
+    struct nw_i_sm_arithm *const s = &i->sm.arithm;
+    const enum nw_state n = nwp_stack_pop(i, &s->io);
+
+    if (n)
+        return n;
+
+    s->out.left = s->value;
+
+    if (s->op(&s->out, &s->value))
+    {
+        static const char *const exc = "arithmetic operation failed";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s\n", exc);
+#endif
+        return NW_FATAL;
+    }
+    else if (init_io(i))
+        return NW_FATAL;
+
+    i->next = push;
+    return NW_AGAIN;
+}
+
+static enum nw_state pop_right(struct nw_interp *const i)
+{
+    struct nw_i_sm_arithm *const s = &i->sm.arithm;
+    const enum nw_state n = nwp_stack_pop(i, &s->io);
+
+    if (n)
+        return n;
+    else if (init_io(i))
+        return NW_FATAL;
+
+    s->out.right = s->value;
+    i->next = pop_left;
+    return NW_AGAIN;
+}
+
+static enum nw_state prepare_right(struct nw_interp *const i)
+{
+    if (init_io(i))
+        return NW_FATAL;
+
+    i->next = pop_right;
+    return NW_AGAIN;
+}
+
+void nwp_arithm(struct nw_interp *const i, const enum nw_type t,
+    int (*const op)(const struct nw_i_sm_arithm_out *, union nw_value *))
+{
+    const struct nw_i_sm_arithm s = {0};
+    struct nw_i_sm_arithm *const ps = &i->sm.arithm;
+
+    *ps = s;
+    ps->type = t;
+    ps->op = op;
+    i->next = prepare_right;
+}
diff --git a/src/routines/break.c b/src/routines/break.c
new file mode 100644
index 0000000..3ee94a1
--- /dev/null
+++ b/src/routines/break.c
@@ -0,0 +1,243 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+
+static enum nw_state get_pc(struct nw_interp *);
+
+static enum nw_state seek_dst(struct nw_interp *const i)
+{
+    const struct nw_i_sm_break *const b = &i->sm.brk;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const unsigned long dst = nwp_leuint32(&b->dst);
+    const enum nw_state n = cfg->seek(dst, cfg->user);
+
+    if (n)
+        return n;
+
+    nwp_interp_resume(i);
+    return NW_AGAIN;
+}
+
+static enum nw_state skip(struct nw_interp *const i)
+{
+    struct nw_i_sm_break *const b = &i->sm.brk;
+    const unsigned long n_labels = nwp_leuint32(&b->n);
+
+    if (++b->label_i >= n_labels)
+    {
+        static const char *const exc = "no label found";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s from offset: %ld\n", exc, b->pc);
+#endif
+        return NW_FATAL;
+    }
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &b->lpc;
+        io.n = sizeof b->lpc;
+        b->io = io;
+        i->next = get_pc;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_dst(struct nw_interp *const i)
+{
+    struct nw_i_sm_break *const b = &i->sm.brk;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const unsigned long pc = nwp_leuint32(&b->lpc);
+    const enum nw_state n = nwp_io_read(cfg, &b->io, cfg->user);
+
+    if (n)
+        return n;
+    else if (pc == b->pc)
+        i->next = seek_dst;
+    else
+        return skip(i);
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_pc(struct nw_interp *const i)
+{
+    struct nw_i_sm_break *const b = &i->sm.brk;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_io_read(cfg, &b->io, cfg->user);
+
+    if (n)
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &b->dst;
+        io.n = sizeof b->dst;
+        b->io = io;
+        i->next = get_dst;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_n(struct nw_interp *const i)
+{
+    struct nw_i_sm_break *const b = &i->sm.brk;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_io_read(cfg, &b->io, cfg->user);
+
+    if (n)
+        return n;
+    else if (!nwp_leuint32(&b->n))
+    {
+        static const char *const exc = "function has no labels";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s\n", exc);
+#endif
+        return NW_FATAL;
+    }
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &b->lpc;
+        io.n = sizeof b->lpc;
+        b->io = io;
+    }
+
+    i->next = get_pc;
+    return NW_AGAIN;
+}
+
+static enum nw_state seek_start(struct nw_interp *const i)
+{
+    struct nw_i_sm_break *const b = &i->sm.brk;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const unsigned long offset = nwp_leuint32(&b->offset);
+    const enum nw_state n = cfg->seek(offset, cfg->user);
+
+    if (n)
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &b->n;
+        io.n = sizeof b->n;
+        b->io = io;
+        i->next = get_n;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_start(struct nw_interp *const i)
+{
+    struct nw_i_sm_break *const b = &i->sm.brk;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_io_read(cfg, &b->io, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = seek_start;
+    return NW_AGAIN;
+}
+
+static enum nw_state seek_lo(struct nw_interp *const i)
+{
+    const struct nw_mod *const m = i->cfg.m;
+    struct nw_i_sm_break *const b = &i->sm.brk;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    long offset = m->c_sections[NW_CUSTOM_LO];
+    enum nw_state n;
+
+    if (!offset)
+    {
+        static const char *const exc = "nw_lo section not found";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s\n", exc);
+#endif
+        return NW_FATAL;
+    }
+    else if (i->fr.fn.index < m->import_count)
+    {
+        static const char *const exc = "invalid function index";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %lu\n", exc, (unsigned long)i->fr.fn.index);
+#endif
+        return NW_FATAL;
+    }
+
+    offset += sizeof b->offset * (i->fr.fn.index - m->import_count);
+
+    if ((n = cfg->seek(offset, cfg->user)))
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &b->offset;
+        io.n = sizeof b->offset;
+        b->io = io;
+        i->next = get_start;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state tell(struct nw_interp *const i)
+{
+    struct nw_i_sm_break *const b = &i->sm.brk;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = cfg->tell(&b->pc, cfg->user);
+
+    if (n)
+        return n;
+    else if (i->fr.block_i < b->relative_depth)
+    {
+        static const char *const exc = "relative depth exceeds block level";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s, rdepth: %lu, blvl: %lu\n", exc,
+            (unsigned long)i->fr.block_i, (unsigned long)b->relative_depth);
+#endif
+        return NW_FATAL;
+    }
+
+    i->fr.block_i -= b->relative_depth;
+    i->next = seek_lo;
+    return NW_AGAIN;
+}
+
+void nwp_break(struct nw_interp *const i, const nw_varuint32 relative_depth)
+{
+    const struct nw_i_sm_break b = {0};
+    struct nw_i_sm_break *const pb = &i->sm.brk;
+
+    *pb = b;
+    pb->relative_depth = relative_depth;
+    i->next = tell;
+}
diff --git a/src/routines/call.c b/src/routines/call.c
new file mode 100644
index 0000000..d564344
--- /dev/null
+++ b/src/routines/call.c
@@ -0,0 +1,17 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/routines.h>
+
+void nwp_call(struct nw_interp *const i, const nw_varuint32 index)
+{
+    index >= i->cfg.m->import_count ?
+        nwp_call_function(i, index) : nwp_call_import(i, index);
+}
diff --git a/src/routines/call_function.c b/src/routines/call_function.c
new file mode 100644
index 0000000..eeee2fc
--- /dev/null
+++ b/src/routines/call_function.c
@@ -0,0 +1,242 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nanowasm/types.h>
+#include <nw/io.h>
+#include <nw/interp.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <nw/stack.h>
+#include <nw/types.h>
+
+static enum nw_state get_entry_count(struct nw_interp *);
+
+static enum nw_state push_frame(struct nw_interp *const i)
+{
+    struct nw_i_sm_pl *const pl = &i->sm.pl;
+    const enum nw_state n = nwp_stack_push(i, &pl->io);
+
+    if (n)
+        return n;
+
+    i->fr = pl->fr;
+#ifdef NW_LOG
+    nwp_log("entering function %lu\n", (unsigned long)i->fr.fn.index);
+#endif
+    nwp_interp_resume(i);
+    return NW_AGAIN;
+}
+
+static void init(struct nw_i_sm_pl *const pl)
+{
+    union nw_value *const v = &pl->value;
+    struct nw_sm_io io = {0};
+
+    io.buf = v;
+
+    switch (pl->meta.type)
+    {
+        case NW_TYPE_I32:
+            v->i32 = 0;
+            io.n = sizeof v->i32;
+            break;
+
+        case NW_TYPE_I64:
+            v->i64.low = 0;
+            v->i64.hi = 0;
+            io.n = sizeof v->i64;
+            break;
+
+        case NW_TYPE_F32:
+            v->f32 = 0;
+            io.n = sizeof v->f32;
+            break;
+
+        case NW_TYPE_F64:
+            v->f64 = 0;
+            io.n = sizeof v->f64;
+            break;
+    }
+
+    pl->io = io;
+}
+
+static enum nw_state get_code_start(struct nw_interp *const i)
+{
+    struct nw_i_sm_pl *const pl = &i->sm.pl;
+    struct nw_frame *const fr = &pl->fr;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = cfg->tell(&fr->start, cfg->user);
+
+    if (n)
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &i->fr;
+        io.n = sizeof i->fr;
+        pl->io = io;
+        fr->local_end = nwp_stack_ptr(i);
+        fr->body_size -= fr->start - pl->body_start;
+        i->next = push_frame;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state push_local(struct nw_interp *const i)
+{
+    struct nw_i_sm_pl *const pl = &i->sm.pl;
+    const enum nw_state n = nwp_stack_push(i, &pl->io);
+
+    if (n)
+        return n;
+    else if (++pl->entry_i >= pl->meta.entry_count)
+        i->next = ++pl->local_i >= pl->local_count ?
+            get_code_start : get_entry_count;
+    else
+        init(pl);
+
+    return NW_AGAIN;
+}
+
+static enum nw_state push_meta(struct nw_interp *const i)
+{
+    struct nw_i_sm_pl *const pl = &i->sm.pl;
+    const enum nw_state n = nwp_stack_push(i, &pl->io);
+
+    if (n)
+        return n;
+
+    init(pl);
+    i->next = push_local;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_type(struct nw_interp *const i)
+{
+    nw_varint7 type;
+    struct nw_i_sm_pl *const pl = &i->sm.pl;
+    struct nw_sm_leb128 *const l = &pl->leb128;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_varint7(cfg, l, &type, cfg->user);
+
+    if (n)
+        return n;
+    else if (nwp_get_type(type, &pl->meta.type))
+    {
+        static const char *const exc = "invalid type";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %x\n", exc, (unsigned)type);
+#endif
+        return NW_FATAL;
+    }
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &pl->meta;
+        io.n = sizeof pl->meta;
+        pl->io = io;
+        i->next = push_meta;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_entry_count(struct nw_interp *const i)
+{
+    struct nw_i_sm_pl *const pl = &i->sm.pl;
+    struct nw_sm_leb128 *const l = &pl->leb128;
+    nw_varuint32 *const count = &pl->meta.entry_count;
+    struct nw_frame *const fr = &pl->fr;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_varuint32(cfg, l, count, cfg->user);
+
+    if (n)
+        return n;
+
+    pl->entry_i = 0;
+    fr->local_count += *count;
+    i->next = get_type;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_count(struct nw_interp *const i)
+{
+    struct nw_i_sm_pl *const pl = &i->sm.pl;
+    struct nw_sm_leb128 *const l = &pl->leb128;
+    struct nw_frame *const fr = &pl->fr;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_varuint32(cfg, l, &pl->local_count, cfg->user);
+
+    if (n)
+        return n;
+
+    fr->local_start = nwp_stack_ptr(i);
+    i->next = pl->local_count ? get_entry_count : get_code_start;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_body_start(struct nw_interp *const i)
+{
+    struct nw_i_sm_pl *const pl = &i->sm.pl;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = cfg->tell(&pl->body_start, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = get_count;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_body_len(struct nw_interp *const i)
+{
+    struct nw_i_sm_pl *const pl = &i->sm.pl;
+    struct nw_sm_leb128 *const l = &pl->leb128;
+    struct nw_frame *const fr = &pl->fr;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_varuint32(cfg, l, &fr->body_size, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = get_body_start;
+    return NW_AGAIN;
+}
+
+static void begin(struct nw_interp *const i)
+{
+    const struct nw_i_sm_pl l = {0};
+    const struct nw_fn fn = i->sm.ffn.fn;
+    struct nw_i_sm_pl *const pl = &i->sm.pl;
+    struct nw_frame *const fr = &pl->fr;
+
+    *pl = l;
+    fr->child = 1;
+    fr->fn = fn;
+    fr->fr_start = nwp_stack_ptr(i);
+    i->next = get_body_len;
+}
+
+static enum nw_state find(struct nw_interp *const i)
+{
+    nwp_find_function(i, &i->sm.type.out, begin);
+    return NW_AGAIN;
+}
+
+void nwp_call_function(struct nw_interp *const i, const nw_varuint32 index)
+{
+    nwp_get_function_type(i, index, find);
+}
diff --git a/src/routines/call_import.c b/src/routines/call_import.c
new file mode 100644
index 0000000..63a736e
--- /dev/null
+++ b/src/routines/call_import.c
@@ -0,0 +1,477 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nanowasm/types.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <nw/stack.h>
+#include <nw/types.h>
+#include <stddef.h>
+#include <string.h>
+
+static enum nw_state seek_param_types(struct nw_interp *);
+
+static enum nw_state seek_pc(struct nw_interp *const i)
+{
+    struct nw_i_sm_call_import *const ci = &i->sm.call_import;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = cfg->seek(ci->pc, cfg->user);
+
+    if (n)
+        return n;
+
+    nwp_interp_resume(i);
+    return NW_AGAIN;
+}
+
+static enum nw_state push_return(struct nw_interp *const i)
+{
+    struct nw_i_sm_call_import *const ci = &i->sm.call_import;
+    const enum nw_state n = nwp_stack_push(i, &ci->io);
+
+    if (n)
+        return n;
+
+    i->next = seek_pc;
+    return NW_AGAIN;
+}
+
+static int parse_signature(const struct nw_import *const imp,
+    size_t *const nargs, int *const ret)
+{
+    enum
+    {
+        RETURN,
+        PARAM_BEGIN,
+        PARAM,
+        END
+    } state = 0;
+
+    const char *s;
+
+    if (nargs)
+        *nargs = 0;
+
+    if (ret)
+        *ret = 0;
+
+    for (s = imp->u.function.signature; *s; s++)
+    {
+        switch (state)
+        {
+            case RETURN:
+                if (strchr("iIfF", *s))
+                {
+                    if (ret)
+                        *ret = 1;
+
+                    state++;
+                }
+                else if (*s == '(')
+                    state = PARAM;
+
+                break;
+
+            case PARAM_BEGIN:
+                if (*s != '(')
+                    return -1;
+
+                state++;
+                break;
+
+            case PARAM:
+                if (strchr("iIfF", *s))
+                {
+                    if (nargs)
+                        (*nargs)++;
+                }
+                else if (*s == ')')
+                    state++;
+                else
+                    return -1;
+
+                break;
+
+            case END:
+                goto end;
+        }
+    }
+
+end:
+    return state != END || *s;
+}
+
+static int check_ret(struct nw_interp *const i)
+{
+    struct nw_i_sm_call_import *const ci = &i->sm.call_import;
+    const struct nw_import *const imp = ci->imp;
+    const struct nw_fn *const fn = &ci->fn;
+    const nw_varuint1 retcnt = fn->ret.count;
+    int hasret;
+
+    if (parse_signature(imp, NULL, &hasret))
+    {
+        static const char *const exc = "invalid imported function signature";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s::%s: %s: %s\n", imp->module, imp->field, exc,
+            imp->u.function.signature);
+#endif
+        return NW_FATAL;
+    }
+    else if (hasret != retcnt)
+    {
+        static const char *const exc = "return count mismatch";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s::%s: %s: expected: %d, got: %d\n", imp->module, imp->field,
+            exc, hasret, retcnt);
+#endif
+        return -1;
+    }
+
+    return 0;
+}
+
+static enum nw_state call_done(struct nw_interp *const i)
+{
+    struct nw_i_sm_call_import *const ci = &i->sm.call_import;
+    const struct nw_fn *const fn = &ci->fn;
+    const nw_varuint32 pcnt = fn->param_count;
+    const struct nw_interp_cfg *const icfg = &i->cfg;
+    union nw_value *const ret = fn->ret.count ? icfg->args + pcnt : NULL;
+
+    if (ret)
+    {
+        size_t sz;
+
+        if (nwp_type_sz(fn->ret.type, &sz))
+        {
+            static const char *const exc = "invalid return type";
+
+            i->exception = exc;
+#ifdef NW_LOG
+            nwp_log("%s: %#x\n", exc, (unsigned)fn->ret.type);
+#endif
+            return NW_FATAL;
+        }
+        else
+        {
+            struct nw_sm_io io = {0};
+
+            io.buf = ret;
+            io.n = sz;
+            ci->io = io;
+            i->next = push_return;
+        }
+    }
+    else
+        nwp_interp_resume(i);
+
+    return NW_AGAIN;
+}
+
+static enum nw_state repeat(struct nw_interp *const i)
+{
+    struct nw_i_sm_call_import *const ci = &i->sm.call_import;
+    struct nw_next *const next = &ci->next;
+    const struct nw_import *const imp = ci->imp;
+    const enum nw_state n = next->fn(next->user, next);
+
+    if (n == NW_FATAL)
+    {
+        static const char *const exc = "import function failed";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %s::%s\n", exc, imp->module, imp->field);
+#endif
+        return NW_FATAL;
+    }
+    else if (n)
+        return n;
+
+    return call_done(i);
+}
+
+static enum nw_state call(struct nw_interp *const i)
+{
+    struct nw_i_sm_call_import *const ci = &i->sm.call_import;
+    const struct nw_fn *const fn = &ci->fn;
+    const nw_varuint32 pcnt = fn->param_count;
+    const struct nw_interp_cfg *const icfg = &i->cfg;
+    const union nw_value *const args = pcnt ? icfg->args : NULL;
+    union nw_value *const ret = fn->ret.count ? icfg->args + pcnt : NULL;
+    const struct nw_import *const imp = ci->imp;
+    enum nw_state n;
+
+    if (fn->ret.count && check_ret(i))
+        return NW_FATAL;
+    else if ((n = imp->u.function.fn(args, ret, icfg->user, &ci->next)))
+    {
+        if (n == NW_FATAL)
+        {
+            static const char *const exc = "import function failed";
+
+            i->exception = exc;
+#ifdef NW_LOG
+            nwp_log("%s: %s::%s\n", exc, imp->module, imp->field);
+#endif
+        }
+        else if (ci->next.fn)
+            i->next = repeat;
+
+        return n;
+    }
+
+    return call_done(i);
+}
+
+static enum nw_state pop_args(struct nw_interp *const i)
+{
+    struct nw_i_sm_call_import *const ci = &i->sm.call_import;
+    const enum nw_state n = nwp_stack_pop(i, &ci->io);
+
+    if (n)
+        return n;
+
+    i->next = call;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_value(struct nw_interp *const i)
+{
+    struct nw_i_sm_call_import *const ci = &i->sm.call_import;
+    const enum nw_state n = nwp_stack_read(i, &ci->io, ci->addr);
+    const struct nw_import *const imp = ci->imp;
+    const size_t max = i->cfg.n_args;
+    const nw_varuint32 pcnt = ci->fn.param_count;
+    size_t nargs;
+
+    if (n)
+        return n;
+    else if (parse_signature(imp, &nargs, NULL))
+    {
+        static const char *const exc = "invalid imported function signature";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s::%s: %s: %s\n", imp->module, imp->field, exc,
+            imp->u.function.signature);
+#endif
+        return NW_FATAL;
+    }
+    else if (nargs > max)
+    {
+        static const char *const exc = "exceeded maximum args";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s, %s::%s requests %lu, max: %lu\n", exc, imp->module,
+            imp->field, (unsigned long)nargs, (unsigned long)max);
+#endif
+        return NW_FATAL;
+    }
+    else if (pcnt != nargs)
+    {
+        static const char *const exc = "arg number mismatch";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s, %s::%s expected %lu args, got %lu\n", exc, imp->module,
+            imp->field, (unsigned long)nargs, (unsigned long)pcnt);
+#endif
+        return NW_FATAL;
+    }
+
+    i->cfg.args[ci->param_i++] = ci->value;
+
+    if (ci->param_i >= ci->fn.param_count)
+    {
+        struct nw_sm_io io = {0};
+
+        io.n = ci->sz;
+        ci->io = io;
+        i->next = pop_args;
+    }
+    else
+        i->next =  seek_param_types;
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_param_type(struct nw_interp *const i)
+{
+    nw_varint7 type;
+    struct nw_i_sm_call_import *const ci = &i->sm.call_import;
+    struct nw_sm_leb128 *const l = &ci->leb128;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_varint7(cfg, l, &type, cfg->user);
+    enum nw_type vtype;
+    size_t sz;
+
+    if (n)
+        return n;
+    else if (nwp_get_type(type, &vtype) || nwp_type_sz(vtype, &sz))
+    {
+        static const char *const exc = "invalid param type";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#x\n", exc, (unsigned)type);
+#endif
+        return NW_FATAL;
+    }
+    else if (ci->type_i >= ci->param_i)
+    {
+        if (ci->addr < sz)
+        {
+            static const char *const exc = "stack underflow";
+
+            i->exception = exc;
+#ifdef NW_LOG
+            nwp_log("%s: %#x\n", exc, (unsigned)type);
+#endif
+            return NW_FATAL;
+        }
+
+        if (ci->type_i == ci->param_i)
+            ci->type = vtype;
+
+        ci->addr -= sz;
+    }
+
+    ci->sz += sz;
+
+    if (++ci->type_i >= ci->fn.param_count)
+    {
+        struct nw_sm_io io = {0};
+
+        if (nwp_type_sz(ci->type, &sz))
+        {
+            static const char *const exc = "invalid param type";
+
+            i->exception = exc;
+#ifdef NW_LOG
+            nwp_log("%s: %#x\n", exc, (unsigned)type);
+#endif
+            return NW_FATAL;
+        }
+
+        io.buf = &ci->value;
+        io.n = sz;
+        ci->io = io;
+        i->next = get_value;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state seek_param_types(struct nw_interp *const i)
+{
+    struct nw_i_sm_call_import *const ci = &i->sm.call_import;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = cfg->seek(ci->fn.param_types, cfg->user);
+
+    if (n)
+        return n;
+
+    ci->type_i = 0;
+    ci->sz = 0;
+    ci->addr = nwp_stack_ptr(i);
+    i->next = get_param_type;
+    return NW_AGAIN;
+}
+
+static enum nw_state tell(struct nw_interp *const i)
+{
+    struct nw_i_sm_call_import *const ci = &i->sm.call_import;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = cfg->tell(&ci->pc, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = seek_param_types;
+    return NW_AGAIN;
+}
+
+static const struct nw_import *find(const struct nw_interp *const i,
+    const nw_varuint32 index)
+{
+    const struct nw_mod_cfg *const cfg = &i->cfg.m->cfg;
+    size_t j;
+
+    for (j = 0; j < cfg->n_imports; j++)
+    {
+        const struct nw_import_index *const ii = &cfg->imp_indexes[j];
+
+        if (ii->index == index)
+        {
+            const struct nw_import *const imp = &cfg->imports[j];
+
+#ifdef NW_LOG
+            nwp_log("import function index %lu matches %s::%s (import index %lu)\n",
+                (unsigned long)index, imp->module, imp->field, (unsigned long)j);
+#endif
+            return &cfg->imports[j];
+        }
+    }
+
+    return NULL;
+}
+
+static enum nw_state prepare(struct nw_interp *const i)
+{
+    const struct nw_fn fn = i->sm.type.out;
+    const struct nw_import *const imp = find(i, fn.index);
+
+    if (!imp)
+    {
+        static const char *const exc = "function import not found";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %lu\n", exc, (unsigned long)fn.index);
+#endif
+        return NW_FATAL;
+    }
+    else if (imp->kind != NW_KIND_FUNCTION)
+    {
+        static const char *const exc = "import not a function";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %s::%s\n", exc, imp->module, imp->field);
+#endif
+        return NW_FATAL;
+    }
+    else
+    {
+        const struct nw_i_sm_call_import ci = {0};
+        struct nw_i_sm_call_import *const pci = &i->sm.call_import;
+
+        *pci = ci;
+        pci->fn = fn;
+        pci->imp = imp;
+        i->next = pci->fn.param_count ? tell : call;
+    }
+
+    return NW_AGAIN;
+}
+
+void nwp_call_import(struct nw_interp *const i, const nw_varuint32 index)
+{
+    nwp_get_function_type(i, index, prepare);
+}
diff --git a/src/routines/call_indirect.c b/src/routines/call_indirect.c
new file mode 100644
index 0000000..9500969
--- /dev/null
+++ b/src/routines/call_indirect.c
@@ -0,0 +1,48 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+
+static enum nw_state get_value(struct nw_mod *const m)
+{
+    nw_varuint32 index;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &index, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = m->sm.code.next;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_index(struct nw_mod *const m)
+{
+    nw_varuint32 index;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &index, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = get_value;
+    return NW_AGAIN;
+}
+
+void nwp_op_check_call_indirect(struct nw_mod *const m)
+{
+    m->next = get_index;
+}
diff --git a/src/routines/check_magic.c b/src/routines/check_magic.c
new file mode 100644
index 0000000..868d669
--- /dev/null
+++ b/src/routines/check_magic.c
@@ -0,0 +1,48 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <string.h>
+
+static enum nw_state run(struct nw_mod *const m)
+{
+    static const unsigned char magic[] = {'\0', 'a', 's', 'm'};
+    struct nw_sm_cm *const cm = &m->sm.check_magic;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const enum nw_state n = nwp_io_read(cfg, &cm->io, cfg->user);
+
+    if (n)
+        return n;
+
+    if (memcmp(cm->buf, magic, sizeof cm->buf))
+    {
+#ifdef NW_LOG
+        nwp_log("wrong magic bytes\n");
+#endif
+        return NW_FATAL;
+    }
+
+    nwp_check_version(m);
+    return NW_AGAIN;
+}
+
+void nwp_check_magic(struct nw_mod *const m)
+{
+    const struct nw_sm_cm cm = {0};
+    struct nw_sm_cm *const pcm = &m->sm.check_magic;
+    struct nw_sm_io *const io = &pcm->io;
+
+    *pcm = cm;
+    io->buf = &pcm->buf;
+    io->n = sizeof pcm->buf;
+    m->next = run;
+}
diff --git a/src/routines/check_version.c b/src/routines/check_version.c
new file mode 100644
index 0000000..4f6ee05
--- /dev/null
+++ b/src/routines/check_version.c
@@ -0,0 +1,48 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <string.h>
+
+static enum nw_state run(struct nw_mod *const m)
+{
+    static const unsigned char version[] = {1, 0, 0, 0};
+    struct nw_sm_cv *const cv = &m->sm.check_version;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const enum nw_state n = nwp_io_read(cfg, &cv->io, cfg->user);
+
+    if (n)
+        return n;
+
+    if (memcmp(&cv->version, version, sizeof cv->version))
+    {
+#ifdef NW_LOG
+        nwp_log("wrong version bytes\n");
+#endif
+        return NW_FATAL;
+    }
+
+    nwp_section(m);
+    return NW_AGAIN;
+}
+
+void nwp_check_version(struct nw_mod *const m)
+{
+    const struct nw_sm_cv cv = {0};
+    struct nw_sm_cv *const pcv = &m->sm.check_version;
+    struct nw_sm_io *const io = &pcv->io;
+
+    *pcv = cv;
+    io->buf = &pcv->version;
+    io->n = sizeof pcv->version;
+    m->next = run;
+}
diff --git a/src/routines/find_function.c b/src/routines/find_function.c
new file mode 100644
index 0000000..c0273ec
--- /dev/null
+++ b/src/routines/find_function.c
@@ -0,0 +1,100 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nanowasm/types.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+
+static enum nw_state seek_code(struct nw_interp *const i)
+{
+    const struct nw_i_sm_ffn *const f = &i->sm.ffn;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const unsigned long fbo = nwp_leuint32(&f->fbo);
+    const enum nw_state n = cfg->seek(fbo, cfg->user);
+
+    if (n)
+        return n;
+
+    f->next(i);
+    return NW_AGAIN;
+}
+
+static enum nw_state get_fbo(struct nw_interp *const i)
+{
+    struct nw_i_sm_ffn *const f = &i->sm.ffn;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_io_read(cfg, &f->io, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = seek_code;
+    return NW_AGAIN;
+}
+
+static enum nw_state seek_fbo(struct nw_interp *const i)
+{
+    struct nw_i_sm_ffn *const f = &i->sm.ffn;
+    const struct nw_mod *const m = i->cfg.m;
+    long offset = m->c_sections[NW_CUSTOM_FBO];
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    enum nw_state n;
+
+    if (!offset)
+    {
+        static const char *const exc = "nw_fbo section not found";
+
+#ifdef NW_LOG
+        nwp_log("%s\n", exc);
+#endif
+        i->exception = exc;
+        return NW_FATAL;
+    }
+    else if (f->fn.index < m->import_count)
+    {
+        static const char *const exc = "invalid function index";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %lu\n", exc, (unsigned long)f->fn.index);
+#endif
+        return NW_FATAL;
+    }
+
+    offset += sizeof f->fbo * (f->fn.index - m->import_count);
+
+    if ((n = cfg->seek(offset, cfg->user)))
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &f->fbo;
+        io.n = sizeof f->fbo;
+        f->io = io;
+        i->next = get_fbo;
+    }
+
+    return NW_AGAIN;
+}
+
+void nwp_find_function(struct nw_interp *const i, const struct nw_fn *const fn,
+    void (*const next)(struct nw_interp *))
+{
+    const struct nw_i_sm_ffn f = {0};
+    struct nw_i_sm_ffn *const pf = &i->sm.ffn;
+
+    *pf = f;
+    pf->fn = *fn;
+    pf->next = next;
+    i->next = seek_fbo;
+}
diff --git a/src/routines/find_local.c b/src/routines/find_local.c
new file mode 100644
index 0000000..e5ab9d2
--- /dev/null
+++ b/src/routines/find_local.c
@@ -0,0 +1,125 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <nw/stack.h>
+#include <nw/types.h>
+#include <limits.h>
+
+static enum nw_state read_meta(struct nw_interp *const i)
+{
+    struct nw_find_local *const f = i->state;
+    const struct nw_local_meta *const m = &f->meta;
+    const nw_varuint32 index = f->index - f->entry_i;
+    const enum nw_state n = nwp_stack_read(i, &f->io, f->addr);
+    size_t sz;
+    nw_varuint32 count;
+
+    if (n)
+        return n;
+
+    f->addr += sizeof f->meta;
+    count = m->entry_count;
+
+    if (nwp_type_sz(m->type, &sz))
+    {
+        static const char *const exc = "invalid type";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#x\n", exc, (unsigned)m->type);
+#endif
+        return NW_FATAL;
+    }
+    else if (index < count)
+    {
+        const size_t offset = sz * index;
+
+        if (f->addr > ULONG_MAX - offset)
+        {
+            static const char *const exc = "out-of-bounds access to local";
+
+            i->exception = exc;
+#ifdef NW_LOG
+            nwp_log("%s: addr: %lu, offset: %lu\n", exc,
+                (unsigned long)f->addr, (unsigned long)offset);
+#endif
+            return NW_FATAL;
+        }
+        else if ((f->addr += offset) >= i->fr.local_end)
+        {
+            static const char *const exc = "invalid local index";
+
+            i->exception = exc;
+#ifdef NW_LOG
+            nwp_log("%s: %lu\n", exc, (unsigned long)f->index);
+#endif
+            return NW_FATAL;
+        }
+
+        i->next = f->next;
+    }
+    else
+    {
+        const size_t offset = sz * count;
+
+        f->entry_i += count;
+
+        if (f->addr > ULONG_MAX - offset)
+        {
+            static const char *const exc = "out-of-bounds access to local";
+
+            i->exception = exc;
+#ifdef NW_LOG
+            nwp_log("%s: addr: %lu, offset: %lu\n", exc,
+                (unsigned long)f->addr, (unsigned long)offset);
+#endif
+            return NW_FATAL;
+        }
+        else if ((f->addr += offset) >= i->fr.local_end)
+        {
+            static const char *const exc = "invalid local index";
+
+            i->exception = exc;
+#ifdef NW_LOG
+            nwp_log("%s: %lu\n", exc, (unsigned long)f->index);
+#endif
+            return NW_FATAL;
+        }
+        else
+        {
+            struct nw_sm_io io = {0};
+
+            io.buf = &f->meta;
+            io.n = sizeof f->meta;
+            f->io = io;
+        }
+    }
+
+    return NW_AGAIN;
+}
+
+void nwp_find_local(struct nw_interp *const i, struct nw_find_local *const f,
+    const nw_varuint32 index, enum nw_state (*const next)(struct nw_interp *),
+    void *const args)
+{
+    const struct nw_find_local fl = {0};
+
+    *f = fl;
+    f->index = index;
+    f->next = next;
+    f->addr = i->fr.local_start;
+    f->io.buf = &f->meta;
+    f->io.n = sizeof f->meta;
+    i->state = f;
+    i->args = args;
+    i->next = read_meta;
+}
diff --git a/src/routines/find_param.c b/src/routines/find_param.c
new file mode 100644
index 0000000..eeae86d
--- /dev/null
+++ b/src/routines/find_param.c
@@ -0,0 +1,104 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <nw/types.h>
+
+static enum nw_state seek_pc(struct nw_interp *const i)
+{
+    struct nw_find_param *const fp = i->state;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = cfg->seek(fp->pc, cfg->user);
+
+    if (n)
+        return n;
+
+    fp->out.addr = i->fr.fr_start - fp->sz;
+    i->next = fp->next;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_param_type(struct nw_interp *const i)
+{
+    nw_varint7 type;
+    struct nw_find_param *const fp = i->state;
+    struct nw_sm_leb128 *const l = &fp->leb128;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_varint7(cfg, l, &type, cfg->user);
+    enum nw_type param_type;
+    size_t sz;
+
+    if (n)
+        return n;
+    else if (nwp_get_type(type, &param_type)
+        || nwp_type_sz(param_type, &sz))
+    {
+        static const char *const exc = "invalid param type";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#x\n", exc, (unsigned)type);
+#endif
+        return NW_FATAL;
+    }
+
+    if (fp->param_i == fp->index)
+        fp->out.type = param_type;
+
+    if (fp->param_i >= fp->index)
+        fp->sz += sz;
+
+    if (++fp->param_i >= i->fr.fn.param_count)
+        i->next = seek_pc;
+
+    return NW_AGAIN;
+}
+
+static enum nw_state seek_param_types(struct nw_interp *const i)
+{
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const long offset = i->fr.fn.param_types;
+    const enum nw_state n = cfg->seek(offset, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = get_param_type;
+    return NW_AGAIN;
+}
+
+static enum nw_state tell(struct nw_interp *const i)
+{
+    struct nw_find_param *const fp = i->state;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = cfg->tell(&fp->pc, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = seek_param_types;
+    return NW_AGAIN;
+}
+
+void nwp_find_param(struct nw_interp *const i, struct nw_find_param *const f,
+    const nw_varuint32 index, enum nw_state (*const next)(struct nw_interp *),
+    void *const args)
+{
+    const struct nw_find_param fp = {0};
+
+    *f = fp;
+    f->index = index;
+    f->next = next;
+    i->state = f;
+    i->next = tell;
+    i->args = args;
+}
diff --git a/src/routines/get_function_type.c b/src/routines/get_function_type.c
new file mode 100644
index 0000000..e30200f
--- /dev/null
+++ b/src/routines/get_function_type.c
@@ -0,0 +1,331 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nanowasm/types.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <nw/stack.h>
+#include <nw/types.h>
+
+static enum nw_state get_param_type(struct nw_interp *);
+
+static enum nw_state seek_pc(struct nw_interp *const i)
+{
+    const struct nw_i_sm_type *const t = &i->sm.type;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = cfg->seek(t->pc, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = t->next;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_return_type(struct nw_interp *const i)
+{
+    nw_varint7 type;
+    struct nw_i_sm_type *const t = &i->sm.type;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_varint7(cfg, &t->leb128, &type, cfg->user);
+
+    if (n)
+        return n;
+    else if (nwp_get_type(type, &t->out.ret.type))
+    {
+        static const char *const exc = "invalid type";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#x\n", exc, (unsigned)type);
+#endif
+        return NW_FATAL;
+    }
+
+    i->next = seek_pc;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_return_count(struct nw_interp *const i)
+{
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    struct nw_i_sm_type *const t = &i->sm.type;
+    struct nw_sm_leb128 *const l = &t->leb128;
+    nw_varuint1 *const return_count = &t->out.ret.count;
+    const enum nw_state n = nwp_varuint1(cfg, l, return_count, cfg->user);
+
+    if (n)
+        return n;
+    else if (*return_count)
+        i->next = get_return_type;
+    else
+        t->next(i);
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_param_type(struct nw_interp *const i)
+{
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    struct nw_i_sm_type *const t = &i->sm.type;
+    nw_varint7 type;
+    enum nw_type param_type;
+    const enum nw_state n = nwp_varint7(cfg, &t->leb128, &type, cfg->user);
+
+    if (n)
+        return n;
+    else if (nwp_get_type(type, &param_type))
+    {
+        i->exception = "invalid type";
+        return NW_FATAL;
+    }
+    else if (++t->param_i >= t->out.param_count)
+        i->next = get_return_count;
+
+    return NW_AGAIN;
+}
+
+static enum nw_state tell_param_types(struct nw_interp *const i)
+{
+    struct nw_i_sm_type *const t = &i->sm.type;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = cfg->tell(&t->out.param_types, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = get_param_type;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_param_count(struct nw_interp *const i)
+{
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    struct nw_i_sm_type *const t = &i->sm.type;
+    struct nw_sm_leb128 *const l = &t->leb128;
+    nw_varuint32 *const count = &t->out.param_count;
+    const enum nw_state n = nwp_varuint32(cfg, l, count, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = *count ? tell_param_types : get_return_count;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_form(struct nw_interp *const i)
+{
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    struct nw_i_sm_type *const t = &i->sm.type;
+    struct nw_sm_leb128 *const l = &t->leb128;
+    nw_varint7 form;
+    const enum nw_state n = nwp_varint7(cfg, l, &form, cfg->user);
+
+    if (n)
+        return n;
+    else if (form != 0x60)
+    {
+        static const char *const exc = "type index not a function";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#x\n", exc, (unsigned)form);
+#endif
+        return NW_FATAL;
+    }
+
+    i->next = get_param_count;
+    return NW_AGAIN;
+}
+
+static enum nw_state seek_type(struct nw_interp *const i)
+{
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const struct nw_i_sm_type *const t = &i->sm.type;
+    const unsigned long to = nwp_leuint32(&t->to);
+    const enum nw_state n = cfg->seek(to, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = get_form;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_to(struct nw_interp *const i)
+{
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    struct nw_i_sm_type *const t = &i->sm.type;
+    const enum nw_state n = nwp_io_read(cfg, &t->io, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = seek_type;
+    return NW_AGAIN;
+}
+
+static enum nw_state seek_to(struct nw_interp *const i)
+{
+    const struct nw_interp_cfg *const icfg = &i->cfg;
+    struct nw_i_sm_type *const t = &i->sm.type;
+    const struct nw_mod *const m = icfg->m;
+    long offset = m->c_sections[NW_CUSTOM_TO];
+    const unsigned long fti = nwp_leuint32(&t->fti);
+    const struct nw_io_cfg *const cfg = &icfg->io;
+    enum nw_state n;
+
+    if (fti >= m->type_count)
+    {
+        static const char *const exc = "invalid type index";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %lu\n", exc, fti);
+#endif
+        return NW_FATAL;
+    }
+    else if (!offset)
+    {
+        static const char *const exc = "nw_to section not found";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s\n", exc);
+#endif
+        return NW_FATAL;
+    }
+
+    offset += sizeof t->to * fti;
+
+    if ((n = cfg->seek(offset, cfg->user)))
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &t->to;
+        io.n = sizeof t->to;
+        t->io = io;
+        i->next = get_to;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_fti(struct nw_interp *const i)
+{
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    struct nw_i_sm_type *const t = &i->sm.type;
+    const enum nw_state n = nwp_io_read(cfg, &t->io, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = seek_to;
+    return NW_AGAIN;
+}
+
+static enum nw_state seek_fti(struct nw_interp *const i)
+{
+    const struct nw_interp_cfg *const icfg = &i->cfg;
+    const struct nw_io_cfg *const cfg = &icfg->io;
+    struct nw_i_sm_type *const t = &i->sm.type;
+    long offset = icfg->m->c_sections[NW_CUSTOM_FTI];
+    enum nw_state n;
+
+    if (!offset)
+    {
+        static const char *const exc = "nw_fti section not found";
+
+#ifdef NW_LOG
+        nwp_log("%s: %s\n", exc, "function type index");
+#endif
+        i->exception = exc;
+        return NW_FATAL;
+    }
+
+    offset += sizeof t->fti * t->fn_index;
+
+    if ((n = cfg->seek(offset, cfg->user)))
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &t->fti;
+        io.n = sizeof t->fti;
+        t->io = io;
+        i->next = get_fti;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_index(struct nw_interp *const i)
+{
+    struct nw_i_sm_type *const t = &i->sm.type;
+    const struct nw_get_import_type_out *const out = &t->git.out;
+    struct nw_sm_leb128 *const l = &t->leb128;
+    nw_varuint32 index;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    enum nw_state n;
+
+    if (out->kind != NW_KIND_FUNCTION)
+    {
+        static const char *const exc = "import type not a function";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#x\n", exc, (unsigned)out->kind);
+#endif
+        return NW_FATAL;
+    }
+    else if ((n = nwp_varuint32(cfg, l, &index, cfg->user)))
+        return n;
+
+    nwp_toleuint32(index, &t->fti);
+    i->next = seek_to;
+    return NW_AGAIN;
+}
+
+static enum nw_state tell(struct nw_interp *const i)
+{
+    struct nw_i_sm_type *const t = &i->sm.type;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const nw_varuint32 icnt = i->cfg.m->import_count, index = t->out.index;
+    const enum nw_state n = cfg->tell(&t->pc, cfg->user);
+
+    if (n)
+        return n;
+    else if (index >= icnt)
+    {
+        t->fn_index = index - icnt;
+        i->next = seek_fti;
+    }
+    else
+        nwp_get_import_type(i, &t->git, index, get_index);
+
+    return NW_AGAIN;
+}
+
+void nwp_get_function_type(struct nw_interp *const i, const nw_varuint32 index,
+    enum nw_state (*const next)(struct nw_interp *))
+{
+    const struct nw_i_sm_type t = {0};
+    struct nw_i_sm_type *const pt = &i->sm.type;
+
+    *pt = t;
+    pt->out.index = index;
+    pt->next = next;
+    i->next = tell;
+}
diff --git a/src/routines/get_import_type.c b/src/routines/get_import_type.c
new file mode 100644
index 0000000..cf5c371
--- /dev/null
+++ b/src/routines/get_import_type.c
@@ -0,0 +1,123 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nanowasm/types.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <nw/types.h>
+
+static enum nw_state get_kind(struct nw_interp *const i)
+{
+    struct nw_get_import_type *const t = i->state;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_io_read(cfg, &t->io, cfg->user);
+
+    if (n)
+        return n;
+    else if (t->kind >= NW_KINDS)
+    {
+        static const char *const exc = "invalid external_kind";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#x\n", exc, (unsigned)t->kind);
+#endif
+        return NW_FATAL;
+    }
+
+    t->out.kind = t->kind;
+    i->next = t->next;
+    return NW_AGAIN;
+}
+
+static enum nw_state seek_type(struct nw_interp *const i)
+{
+    struct nw_get_import_type *const t = i->state;
+    const unsigned long offset = nwp_leuint32(&t->value);
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = cfg->seek(offset, cfg->user);
+
+    if (n)
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &t->kind;
+        io.n = sizeof t->kind;
+        t->io = io;
+        i->next = get_kind;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_value(struct nw_interp *const i)
+{
+    struct nw_get_import_type *const t = i->state;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_io_read(cfg, &t->io, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = seek_type;
+    return NW_AGAIN;
+}
+
+static enum nw_state seek_iti(struct nw_interp *const i)
+{
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    struct nw_get_import_type *const t = i->state;
+    long offset = i->cfg.m->c_sections[NW_CUSTOM_ITI];
+    enum nw_state n;
+
+    if (!offset)
+    {
+        static const char *const exc = "nw_iti section not found";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s\n", exc);
+#endif
+        return NW_FATAL;
+    }
+
+    offset += t->index * sizeof t->value;
+
+    if ((n = cfg->seek(offset, cfg->user)))
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &t->value;
+        io.n = sizeof t->value;
+        t->io = io;
+        i->next = get_value;
+    }
+
+    return NW_AGAIN;
+}
+
+void nwp_get_import_type(struct nw_interp *const i,
+    struct nw_get_import_type *const it,
+    const nw_varuint32 index,
+    enum nw_state (*const next)(struct nw_interp *const i))
+{
+    const struct nw_get_import_type t = {0};
+
+    *it = t;
+    it->index = index;
+    it->next = next;
+    i->state = it;
+    i->next = seek_iti;
+}
diff --git a/src/routines/i32_arithm.c b/src/routines/i32_arithm.c
new file mode 100644
index 0000000..e833a11
--- /dev/null
+++ b/src/routines/i32_arithm.c
@@ -0,0 +1,39 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/interp.h>
+#include <nw/stack.h>
+#include <nw/routines.h>
+
+static enum nw_state push(struct nw_interp *const i)
+{
+    struct nw_i_sm_i32_arithm *const a = &i->sm.i32_arithm;
+    const enum nw_state n = nwp_stack_push(i, &a->io);
+
+    if (n)
+        return n;
+
+    i->push_type = NW_TYPE_I32;
+    nwp_interp_resume(i);
+    return NW_AGAIN;
+}
+
+void nwp_op_i32_arithm(struct nw_interp *const i, const long result)
+{
+    const struct nw_i_sm_i32_arithm a = {0};
+    struct nw_i_sm_i32_arithm *const s = &i->sm.i32_arithm;
+
+    *s = a;
+    s->result = result;
+    s->io.buf = &s->result;
+    s->io.n = sizeof s->result;
+    i->next = push;
+}
diff --git a/src/routines/init_data.c b/src/routines/init_data.c
new file mode 100644
index 0000000..c9482a0
--- /dev/null
+++ b/src/routines/init_data.c
@@ -0,0 +1,196 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nanowasm/types.h>
+#include <nw/linear.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <nw/stack.h>
+#include <nw/types.h>
+
+static enum nw_state get_index(struct nw_inst *);
+static enum nw_state get_byte(struct nw_inst *);
+
+static enum nw_state store_byte(struct nw_inst *const inst)
+{
+    struct nw_inst_sm_d *const d = &inst->sm.data;
+    struct nw_interp *const i = &inst->interp;
+    const unsigned long offset = d->offset + d->bytes_i;
+    const enum nw_state n = nwp_linear_store(i, &d->io, offset);
+
+    if (n)
+        return n;
+    else if (++d->bytes_i >= d->size)
+        inst->next = ++d->entry_i >= d->count ? d->next : get_index;
+    else
+        inst->next = get_byte;
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_byte(struct nw_inst *const inst)
+{
+    struct nw_inst_sm_d *const d = &inst->sm.data;
+    struct nw_interp *const i = &inst->interp;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    struct nw_sm_io io = {0};
+    enum nw_state n;
+
+    io.buf = &d->b;
+    io.n = sizeof d->b;
+
+    if ((n = nwp_io_read(cfg, &io, cfg->user)))
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &d->b;
+        io.n = sizeof d->b;
+        d->io = io;
+    }
+
+    inst->next = store_byte;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_size(struct nw_inst *const inst)
+{
+    struct nw_inst_sm_d *const d = &inst->sm.data;
+    struct nw_sm_leb128 *const l = &d->leb128;
+    struct nw_interp *const i = &inst->interp;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_varuint32(cfg, l, &d->size, cfg->user);
+
+    if (n)
+        return n;
+
+    d->bytes_i = 0;
+    inst->next = get_byte;
+    return NW_AGAIN;
+}
+
+static enum nw_state pop(struct nw_inst *const inst)
+{
+    struct nw_inst_sm_d *const d = &inst->sm.data;
+    const enum nw_state n = nwp_stack_pop(&inst->interp, &d->io);
+
+    if (n)
+        return n;
+
+    inst->next = get_size;
+    return NW_AGAIN;
+}
+
+static enum nw_state loop(struct nw_inst *const inst)
+{
+    struct nw_inst_sm_d *const d = &inst->sm.data;
+    const enum nw_state n = nwp_interp_run(&inst->interp);
+    struct nw_sm_io io = {0};
+
+    if (n)
+        return n;
+
+    io.buf = &d->offset;
+    io.n = sizeof d->offset;
+    d->io = io;
+    inst->next = pop;
+    return NW_AGAIN;
+}
+
+static enum nw_state setup_initexpr(struct nw_inst *const inst)
+{
+    struct nw_interp *const i = &inst->interp;
+    const struct nw_interp_cfg icfg = i->cfg;
+
+    if (nwp_interp_start(i, &icfg, &nwp_interp_data_set))
+    {
+#ifdef NW_LOG
+        nwp_log("nw_interp_start failed\n");
+#endif
+        return NW_FATAL;
+    }
+
+    inst->next = loop;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_index(struct nw_inst *const inst)
+{
+    struct nw_inst_sm_d *const d = &inst->sm.data;
+    struct nw_sm_leb128 *const l = &d->leb128;
+    struct nw_interp *const i = &inst->interp;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_varuint32(cfg, l, &d->index, cfg->user);
+
+    if (n)
+        return n;
+
+    return setup_initexpr(inst);
+}
+
+static enum nw_state get_count(struct nw_inst *const i)
+{
+    struct nw_inst_sm_d *const d = &i->sm.data;
+    struct nw_sm_leb128 *const l = &d->leb128;
+    const struct nw_interp_cfg *const icfg = &i->interp.cfg;
+    const struct nw_io_cfg *const cfg = &icfg->io;
+    const nw_varuint32 expected = icfg->m->data_count;
+    const enum nw_state n = nwp_varuint32(cfg, l, &d->count, cfg->user);
+
+    if (n)
+        return n;
+    else if (d->count != expected)
+    {
+#ifdef NW_LOG
+        static const char *const exc = "data count mismatch";
+
+        nwp_log("%s, expected %lu, got %lu\n", exc,
+            (unsigned long)expected, (unsigned long)d->count);
+#endif
+        return NW_FATAL;
+    }
+
+    i->next = d->count ? get_index : d->next;
+    return NW_AGAIN;
+}
+
+static enum nw_state seek_data(struct nw_inst *const i)
+{
+    struct nw_inst_sm_gl *const d = &i->sm.global;
+    const struct nw_interp_cfg *const icfg = &i->interp.cfg;
+    const struct nw_io_cfg *const cfg = &icfg->io;
+    const long offset = icfg->m->sections[NW_SECTION_DATA];
+    enum nw_state n;
+
+    if (!offset)
+    {
+        i->next = d->next;
+        return NW_AGAIN;
+    }
+    else if ((n = cfg->seek(offset, cfg->user)))
+        return n;
+
+    i->next = get_count;
+    return NW_AGAIN;
+}
+
+void nwp_init_data(struct nw_inst *const i,
+    enum nw_state (*const next)(struct nw_inst *))
+{
+    const struct nw_inst_sm_d d = {0};
+    struct nw_inst_sm_d *const p = &i->sm.data;
+
+    *p = d;
+    p->next = next;
+    i->next = seek_data;
+}
diff --git a/src/routines/init_globals.c b/src/routines/init_globals.c
new file mode 100644
index 0000000..6d1e5e4
--- /dev/null
+++ b/src/routines/init_globals.c
@@ -0,0 +1,181 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nanowasm/types.h>
+#include <nw/global.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <nw/stack.h>
+#include <nw/types.h>
+
+static enum nw_state get_content_type(struct nw_inst *const i);
+
+static enum nw_state store(struct nw_inst *const inst)
+{
+    struct nw_inst_sm_gl *const g = &inst->sm.global;
+    struct nw_interp *const i = &inst->interp;
+    const enum nw_state n = nwp_global_store(i, &g->io, g->entry_i);
+
+    if (n)
+        return n;
+
+    inst->next = ++g->entry_i >= g->count ? g->next : get_content_type;
+    return NW_AGAIN;
+}
+
+static enum nw_state pop(struct nw_inst *const inst)
+{
+    struct nw_inst_sm_gl *const g = &inst->sm.global;
+    struct nw_interp *const i = &inst->interp;
+    const enum nw_state n = nwp_stack_pop(i, &g->io);
+
+    if (n)
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &g->out;
+        io.n = sizeof g->out;
+        g->io = io;
+        inst->next = store;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state loop(struct nw_inst *const i)
+{
+    struct nw_inst_sm_gl *const g = &i->sm.global;
+    const enum nw_state n = nwp_interp_run(&i->interp);
+    size_t sz;
+
+    if (n)
+        return n;
+    else if (nwp_type_sz(g->out.type, &sz))
+    {
+#ifdef NW_LOG
+        static const char *const exc = "invalid type";
+
+        nwp_log("%s: %#x\n", exc, (unsigned)g->out.type);
+#endif
+        return NW_FATAL;
+    }
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &g->out.value;
+        io.n = sz;
+        g->io = io;
+        i->next = pop;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_mutability(struct nw_inst *const inst)
+{
+    struct nw_inst_sm_gl *const g = &inst->sm.global;
+    struct nw_interp *const i = &inst->interp;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    struct nw_sm_leb128 *const l = &g->leb128;
+    const enum nw_state n = nwp_varuint1(cfg, l, &g->out.mutability, cfg->user);
+
+    if (n)
+        return n;
+
+    nwp_interp_resume(i);
+    inst->next = loop;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_content_type(struct nw_inst *const i)
+{
+    nw_varint7 content_type;
+    struct nw_inst_sm_gl *const g = &i->sm.global;
+    const struct nw_io_cfg *const cfg = &i->interp.cfg.io;
+    struct nw_sm_leb128 *const l = &g->leb128;
+    const enum nw_state n = nwp_varint7(cfg, l, &content_type, cfg->user);
+
+    if (n)
+        return n;
+    else if (nwp_get_type(content_type, &g->out.type))
+    {
+#ifdef NW_LOG
+        static const char *const exc = "invalid type";
+
+        nwp_log("%s: %#x\n", exc, (unsigned)content_type);
+#endif
+        return NW_FATAL;
+    }
+
+    i->next = get_mutability;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_count(struct nw_inst *const i)
+{
+    struct nw_inst_sm_gl *const g = &i->sm.global;
+    struct nw_sm_leb128 *const l = &g->leb128;
+    const struct nw_interp_cfg *const icfg = &i->interp.cfg;
+    const struct nw_io_cfg *const cfg = &icfg->io;
+    const nw_varuint32 expected = icfg->m->global_count;
+    const enum nw_state n = nwp_varuint32(cfg, l, &g->count, cfg->user);
+
+    if (n)
+        return n;
+    else if (g->count != expected)
+    {
+#ifdef NW_LOG
+        static const char *const exc = "global count mismatch";
+
+        nwp_log("%s, expected %lu, got %lu\n", exc,
+            (unsigned long)expected, (unsigned long)g->count);
+#endif
+        return NW_FATAL;
+    }
+
+    i->next = g->count ? get_content_type : g->next;
+    return NW_AGAIN;
+}
+
+static enum nw_state seek_global(struct nw_inst *const i)
+{
+    struct nw_inst_sm_gl *const g = &i->sm.global;
+    const struct nw_interp_cfg *const icfg = &i->interp.cfg;
+    const struct nw_io_cfg *const cfg = &icfg->io;
+    const long offset = icfg->m->sections[NW_SECTION_GLOBAL];
+    enum nw_state n;
+
+    if (!offset)
+    {
+        i->next = g->next;
+        return NW_AGAIN;
+    }
+    else if ((n = cfg->seek(offset, cfg->user)))
+        return n;
+
+    i->next = get_count;
+    return NW_AGAIN;
+}
+
+void nwp_init_globals(struct nw_inst *const i,
+    enum nw_state (*const next)(struct nw_inst *))
+{
+    const struct nw_inst_sm_gl gl = {0};
+    struct nw_inst_sm_gl *const p = &i->sm.global;
+
+    *p = gl;
+    p->next = next;
+    i->next = seek_global;
+}
diff --git a/src/routines/mem_imm.c b/src/routines/mem_imm.c
new file mode 100644
index 0000000..c93ee1a
--- /dev/null
+++ b/src/routines/mem_imm.c
@@ -0,0 +1,51 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/routines.h>
+#include <nw/io.h>
+
+static enum nw_state get_offset(struct nw_interp *const i)
+{
+    struct nw_i_sm_imm *const imm = &i->sm.imm;
+    struct nw_sm_leb128 *const l = &imm->leb128;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_varuint32(cfg, l, &imm->out.offset, cfg->user);
+
+    if (n)
+        return n;
+
+    imm->next(i);
+    return NW_AGAIN;
+}
+
+static enum nw_state get_flags(struct nw_interp *const i)
+{
+    struct nw_i_sm_imm *const imm = &i->sm.imm;
+    struct nw_sm_leb128 *const l = &imm->leb128;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_varuint32(cfg, l, &imm->out.flags, cfg->user);
+
+    if (n)
+        return n;
+
+    i->next = get_offset;
+    return NW_AGAIN;
+}
+
+void nwp_mem_imm(struct nw_interp *const i,
+    void (*const next)(struct nw_interp *))
+{
+    const struct nw_i_sm_imm imm = {0};
+    struct nw_i_sm_imm *const p = &i->sm.imm;
+
+    *p = imm;
+    p->next = next;
+    i->next = get_flags;
+}
diff --git a/src/routines/section.c b/src/routines/section.c
new file mode 100644
index 0000000..5198424
--- /dev/null
+++ b/src/routines/section.c
@@ -0,0 +1,105 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+
+static void (*const fn[])(struct nw_mod *) =
+{
+    nwp_section_custom,
+    nwp_section_type,
+    nwp_section_import,
+    nwp_section_function,
+    nwp_section_table,
+    nwp_section_memory,
+    nwp_section_global,
+    nwp_section_export,
+    nwp_section_start,
+    nwp_section_element,
+    nwp_section_code,
+    nwp_section_data,
+    nwp_section_data_count
+};
+
+static enum nw_state get_offset(struct nw_mod *const m)
+{
+    struct nw_mod_section *const s = &m->section;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const enum nw_state n = cfg->tell(&s->offset, cfg->user);
+    long *const offset = &m->sections[s->section];
+
+    if (n)
+        return n;
+    /* Custom section can appear more than once. */
+    else if (s->section != NW_SECTION_CUSTOM && *offset)
+    {
+#ifdef NW_LOG
+        nwp_log("ignoring duplicate section %u\n", (unsigned)s->section);
+#endif
+        nwp_section_skip(m);
+    }
+    else
+    {
+        nwp_log("processing section %u\n", (unsigned)s->section);
+        *offset = s->offset;
+        fn[s->section](m);
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_length(struct nw_mod *const m)
+{
+    struct nw_mod_section *const s = &m->section;
+    struct nw_sm_leb128 *const l = &s->leb128;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const enum nw_state n = nwp_varuint32(cfg, l, &s->len, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = get_offset;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_section(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_mod_section *const s = &m->section;
+    struct nw_sm_leb128 *const l = &s->leb128;
+    const enum nw_state n = nwp_varuint7(cfg, l, &s->section, cfg->user);
+
+    if (n)
+    {
+        if (cfg->eof(cfg->user))
+            return NW_OK;
+
+        return n;
+    }
+    else if (s->section >= sizeof fn / sizeof *fn)
+    {
+#ifdef NW_LOG
+        nwp_log("invalid section %u\n", (unsigned)s->section);
+#endif
+        return NW_FATAL;
+    }
+
+    m->next = get_length;
+    return NW_AGAIN;
+}
+
+void nwp_section(struct nw_mod *const m)
+{
+    const struct nw_mod_section s = {0};
+
+    m->section = s;
+    m->next = get_section;
+}
diff --git a/src/routines/section/CMakeLists.txt b/src/routines/section/CMakeLists.txt
new file mode 100644
index 0000000..ae78d27
--- /dev/null
+++ b/src/routines/section/CMakeLists.txt
@@ -0,0 +1,34 @@
+# nanowasm, a tiny WebAssembly/Wasm interpreter
+# Copyright (C) 2023-2025  Xavier Del Campo Romero
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+target_sources(${PROJECT_NAME} PRIVATE
+    code.c
+    custom.c
+    data.c
+    data_count.c
+    element.c
+    exit.c
+    export.c
+    fbo.c
+    fti.c
+    function.c
+    global.c
+    import.c
+    iti.c
+    lo.c
+    memory.c
+    ops.c
+    skip.c
+    start.c
+    table.c
+    to.c
+    type.c
+)
+
+if(NW_CHECK_CODE)
+    target_compile_definitions(${PROJECT_NAME} PRIVATE NW_CHECK_CODE)
+endif()
diff --git a/src/routines/section/code.c b/src/routines/section/code.c
new file mode 100644
index 0000000..3ee0c5b
--- /dev/null
+++ b/src/routines/section/code.c
@@ -0,0 +1,298 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/opcodes.h>
+#include <nw/ops.h>
+#include <nw/routines.h>
+
+static enum nw_state local_loop(struct nw_mod *);
+static enum nw_state get_opcode(struct nw_mod *);
+static enum nw_state entry_loop(struct nw_mod *);
+
+static enum nw_state get_post_offset(struct nw_mod *const m)
+{
+    long offset;
+    unsigned long consumed;
+    struct nw_sm_c *const c = &m->sm.code;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const enum nw_state n = cfg->tell(&offset, cfg->user);
+
+    if (n)
+        return n;
+    else if ((consumed = offset - c->op_off) && consumed >= c->rem)
+    {
+#ifdef NW_LOG
+        nwp_log("parameters exceed expected body length\n");
+#endif
+        return NW_FATAL;
+    }
+
+    c->rem -= consumed;
+    m->next = get_opcode;
+    return NW_AGAIN;
+}
+
+typedef void (*op_fn)(struct nw_mod *);
+
+static op_fn find(unsigned char op)
+{
+    size_t i;
+
+    for (i = 0; i < nwp_check_ops.n; i++)
+    {
+        const struct nwp_check_op *const o = &nwp_check_ops.ops[i];
+
+        if (op >= o->start && op <= o->end)
+            return o->f;
+    }
+
+    return NULL;
+}
+
+static enum nw_state get_op_offset(struct nw_mod *const m)
+{
+    struct nw_sm_c *const c = &m->sm.code;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const enum nw_state n = cfg->tell(&c->op_off, cfg->user);
+    op_fn fn;
+
+    if (n)
+        return n;
+    else if (!(fn = find(c->op)))
+    {
+#ifdef NW_LOG
+        nwp_log("invalid opcode %#hhx\n", (unsigned char)c->op);
+#endif
+        return NW_FATAL;
+    }
+
+#ifdef NW_LOG
+    nwp_log("opcode: %#hhx\n", (unsigned char)c->op);
+#endif
+    c->next = get_post_offset;
+    fn(m);
+    return NW_AGAIN;
+}
+
+static enum nw_state check_exit(struct nw_mod *const m)
+{
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_c_fn *const fn = &c->fn;
+
+    if (fn->blocks)
+    {
+#ifdef NW_LOG
+        nwp_log("mismatched number of blocks in function %lu\n",
+            (unsigned long)c->entry_i);
+#endif
+        return NW_FATAL;
+    }
+
+    c->entry_i++;
+    m->next = entry_loop;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_opcode(struct nw_mod *const m)
+{
+    struct nw_sm_c *const c = &m->sm.code;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_io io = {0};
+    enum nw_state n;
+
+    io.buf = &c->op;
+    io.n = sizeof c->op;
+
+    if (!c->rem)
+        return check_exit(m);
+    else if ((n = nwp_io_read(cfg, &io, cfg->user)))
+        return n;
+    else if (c->rem == 1 && c->op != OP_END)
+    {
+#ifdef NW_LOG
+        nwp_log("%s: unexpected opcode %#x at body end\n", (unsigned)c->op);
+#endif
+        return NW_FATAL;
+    }
+
+    c->rem--;
+    m->next = get_op_offset;
+    return NW_AGAIN;
+}
+
+#ifndef NW_CHECK_CODE
+static enum nw_state skip(struct nw_mod *const m)
+{
+    struct nw_sm_c *const c = &m->sm.code;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const enum nw_state n = cfg->seek(c->body_start + c->rem, cfg->user);
+
+    if (n)
+        return n;
+
+    c->entry_i++;
+    m->next = entry_loop;
+    return NW_AGAIN;
+}
+#endif
+
+static enum nw_state get_rem(struct nw_mod *const m)
+{
+    unsigned long consumed;
+    struct nw_sm_c *const c = &m->sm.code;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const enum nw_state n = cfg->tell(&c->body_start, cfg->user);
+
+    if (n)
+        return n;
+    else if ((consumed = c->body_start - c->start) >= c->body_size)
+    {
+#ifdef NW_LOG
+        nwp_log("exceeded function body size\n");
+#endif
+        return NW_FATAL;
+    }
+
+    c->rem = c->body_size - consumed;
+#ifdef NW_CHECK_CODE
+    m->next = get_opcode;
+#else
+    m->next = skip;
+#endif
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_type(struct nw_mod *const m)
+{
+    nw_varint7 type;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    const enum nw_state n = nwp_varint7(cfg, l, &type, cfg->user);
+
+    if (n)
+        return n;
+
+    c->fn.local_i++;
+    m->next = local_loop;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_group_count(struct nw_mod *const m)
+{
+    nw_varuint32 group_count;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &group_count, cfg->user);
+
+    if (n)
+        return n;
+
+    c->fn.local_total += group_count;
+    m->next = get_type;
+    return NW_AGAIN;
+}
+
+static enum nw_state local_loop(struct nw_mod *const m)
+{
+    const struct nw_sm_c_fn *const fn = &m->sm.code.fn;
+
+    m->next = fn->local_i < fn->local_count ? get_group_count : get_rem;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_local_count(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_c_fn *const fn = &c->fn;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &fn->local_count,
+        cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = fn->local_count ? local_loop : get_rem;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_start(struct nw_mod *const m)
+{
+    struct nw_sm_c *const c = &m->sm.code;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const enum nw_state n = cfg->tell(&c->start, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = get_local_count;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_body_size(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &c->body_size, cfg->user);
+
+    if (n)
+        return n;
+    else if (!c->body_size)
+    {
+#ifdef NW_LOG
+        nwp_log("unexpected zero size for function body %lu\n",
+            (unsigned long)c->entry_i);
+#endif
+        return NW_FATAL;
+    }
+
+    m->next = get_start;
+    return NW_AGAIN;
+}
+
+static enum nw_state entry_loop(struct nw_mod *const m)
+{
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_c_fn fn = {0};
+
+    fn.blocks = 1;
+    c->fn = fn;
+    m->next = c->entry_i < c->count ? get_body_size : nwp_section_exit;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_count(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_c *const c = &m->sm.code;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &c->count, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = entry_loop;
+    return NW_AGAIN;
+}
+
+void nwp_section_code(struct nw_mod *const m)
+{
+    const struct nw_sm_c c = {0};
+
+    m->sm.code = c;
+    m->next = get_count;
+}
diff --git a/src/routines/section/custom.c b/src/routines/section/custom.c
new file mode 100644
index 0000000..926f46b
--- /dev/null
+++ b/src/routines/section/custom.c
@@ -0,0 +1,145 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <string.h>
+
+static enum nw_state get_byte(struct nw_mod *);
+
+static enum nw_state skip(struct nw_mod *const m)
+{
+    const struct nw_sm_custom *const c = &m->sm.custom;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const enum nw_state n = cfg->seek(c->start, cfg->user);
+
+    if (n)
+        return n;
+
+    nwp_section_skip(m);
+    return NW_AGAIN;
+}
+
+static enum nw_state compare(struct nw_mod *const m)
+{
+    struct nw_sm_custom *const c = &m->sm.custom;
+    const struct entry *out = NULL;
+    size_t i;
+    static const struct entry
+    {
+        const char *section;
+        void (*f)(struct nw_mod *);
+    } s[] =
+    {
+        {"nw_to", nwp_section_to},
+        {"nw_fti", nwp_section_fti},
+        {"nw_fbo", nwp_section_fbo},
+        {"nw_lo", nwp_section_lo},
+        {"nw_iti", nwp_section_iti}
+    };
+
+    for (i = 0; i < sizeof s / sizeof *s; i++)
+    {
+        int *const candidate = &c->candidate[i];
+        const struct entry *const e = &s[i];
+
+        if (!*candidate)
+            continue;
+        else if (strlen(e->section) != c->name_len
+            || e->section[c->len_i] != c->byte)
+        {
+            *candidate = 0;
+            continue;
+        }
+
+        out = e;
+        break;
+    }
+
+    if (++c->len_i >= c->name_len)
+    {
+        if (out)
+        {
+            if (m->c_sections[out - s])
+            {
+#ifdef NW_LOG
+                nwp_log("duplicate section: %s\n", out->section);
+#endif
+                return NW_FATAL;
+            }
+
+            out->f(m);
+        }
+        else
+            m->next = skip;
+    }
+    else
+        m->next = get_byte;
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_byte(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_custom *const c = &m->sm.custom;
+    struct nw_sm_io io = {0};
+    enum nw_state n;
+
+    io.buf = &c->byte;
+    io.n = sizeof c->byte;
+
+    if ((n = nwp_io_read(cfg, &io, cfg->user)))
+        return n;
+
+    m->next = compare;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_name_len(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_custom *const c = &m->sm.custom;
+    struct nw_sm_leb128 *const l = &c->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &c->name_len, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = get_byte;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_start(struct nw_mod *const m)
+{
+    struct nw_sm_custom *const c = &m->sm.custom;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const enum nw_state n = cfg->tell(&c->start, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = get_name_len;
+    return NW_AGAIN;
+}
+
+void nwp_section_custom(struct nw_mod *const m)
+{
+    const struct nw_sm_custom c = {0};
+    struct nw_sm_custom *const pc = &m->sm.custom;
+    size_t i;
+
+    m->next = get_start;
+    *pc = c;
+
+    for (i = 0; i < sizeof pc->candidate / sizeof *pc->candidate; i++)
+        pc->candidate[i] = 1;
+}
diff --git a/src/routines/section/data.c b/src/routines/section/data.c
new file mode 100644
index 0000000..b189c9d
--- /dev/null
+++ b/src/routines/section/data.c
@@ -0,0 +1,178 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <string.h>
+
+static enum nw_state get_index(struct nw_mod *);
+
+static enum nw_state skip_bytes(struct nw_mod *const m)
+{
+    struct nw_sm_d *const d = &m->sm.data;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const long offset = d->offset + d->size;
+    const enum nw_state n = cfg->seek(offset, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = ++d->entry_i >= m->data_count ? nwp_section_exit : get_index;
+    return NW_AGAIN;
+}
+
+static enum nw_state tell(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_d *const d = &m->sm.data;
+    const enum nw_state n = cfg->tell(&d->offset, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = skip_bytes;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_size(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_d *const d = &m->sm.data;
+    struct nw_sm_leb128 *const l = &d->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &d->size, cfg->user);
+
+    if (n)
+        return n;
+    else if (!d->size)
+    {
+#ifdef NW_LOG
+        nwp_log("unexpected zero size for data entry %lu\n",
+            (unsigned long)d->entry_i);
+#endif
+        return NW_FATAL;
+    }
+
+    m->next = tell;
+    return NW_AGAIN;
+}
+
+static int push(const void *const src, const size_t n, void *const user)
+{
+    struct nw_mod *const m = user;
+    struct nw_sm_d *const d = &m->sm.data;
+
+    if (n > sizeof d->value)
+    {
+#ifdef NW_LOG
+        nwp_log("stack overflow\n");
+#endif
+        return -1;
+    }
+
+    memcpy(&d->value, src, n);
+    return n;
+}
+
+static enum nw_state loop(struct nw_mod *const m)
+{
+    struct nw_sm_d *const d = &m->sm.data;
+    const enum nw_state n = nwp_interp_run(&d->interp);
+
+    if (n)
+        return n;
+
+    m->next = get_size;
+    return NW_AGAIN;
+}
+
+static enum nw_state setup_initexpr(struct nw_mod *const m)
+{
+    struct nw_interp_cfg icfg = {0};
+    struct nw_sm_d *const d = &m->sm.data;
+
+    icfg.m = m;
+    icfg.io = m->cfg.io;
+    icfg.user = m;
+    icfg.stack.push = push;
+
+    if (nwp_interp_start(&d->interp, &icfg, &nwp_interp_data_set))
+    {
+#ifdef NW_LOG
+        nwp_log("nw_interp_start failed\n");
+#endif
+        return NW_FATAL;
+    }
+
+    m->next = loop;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_index(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_d *const d = &m->sm.data;
+    struct nw_sm_leb128 *const l = &d->leb128;
+    nw_varuint32 *const index = &d->index;
+    const enum nw_state n = nwp_varuint32(cfg, l, index, cfg->user);
+
+    if (n)
+        return n;
+    else if (*index)
+    {
+#ifdef NW_LOG
+        nwp_log("expected memory index 0 in data entry %lu, got %lu\n",
+            (unsigned long)d->entry_i, *index);
+#endif
+        return NW_FATAL;
+    }
+
+    return setup_initexpr(m);
+}
+
+static enum nw_state get_count(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const long dc = m->sections[NW_SECTION_DATA_COUNT];
+    struct nw_sm_d *const d = &m->sm.data;
+    struct nw_sm_leb128 *const l = &d->leb128;
+    nw_varuint32 count, *const pcount = dc ? &count : &m->data_count;
+    enum nw_state n;
+
+    if (!m->sections[NW_SECTION_MEMORY])
+    {
+#ifdef NW_LOG
+        nwp_log("data section found before memory section\n");
+#endif
+        return NW_FATAL;
+    }
+    else if ((n = nwp_varuint32(cfg, l, pcount, cfg->user)))
+        return n;
+    else if (dc && count != m->data_count)
+    {
+#ifdef NW_LOG
+        nwp_log("data count mismatch, expected %lu, got %lu\n",
+            (unsigned long)m->data_count, (unsigned long)count);
+#endif
+        return NW_FATAL;
+    }
+
+    m->next = m->data_count ? get_index : nwp_section_exit;
+    return NW_AGAIN;
+}
+
+void nwp_section_data(struct nw_mod *const m)
+{
+    const struct nw_sm_d d = {0};
+
+    m->sm.data = d;
+    m->next = get_count;
+}
diff --git a/src/routines/section/data_count.c b/src/routines/section/data_count.c
new file mode 100644
index 0000000..9e7ea07
--- /dev/null
+++ b/src/routines/section/data_count.c
@@ -0,0 +1,35 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+
+static enum nw_state get_count(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_dc *const dc = &m->sm.data_count;
+    struct nw_sm_leb128 *const l = &dc->leb128;
+    enum nw_state n;
+
+    if ((n = nwp_varuint32(cfg, l, &m->data_count, cfg->user)))
+        return n;
+
+    m->next = nwp_section_exit;
+    return NW_AGAIN;
+}
+
+void nwp_section_data_count(struct nw_mod *const m)
+{
+    const struct nw_sm_dc dc = {0};
+
+    m->sm.data_count = dc;
+    m->next = get_count;
+}
diff --git a/src/routines/section/element.c b/src/routines/section/element.c
new file mode 100644
index 0000000..7fd2f54
--- /dev/null
+++ b/src/routines/section/element.c
@@ -0,0 +1,20 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+
+void nwp_section_element(struct nw_mod *const m)
+{
+    /* TODO */
+    nwp_section_skip(m);
+}
diff --git a/src/routines/section/exit.c b/src/routines/section/exit.c
new file mode 100644
index 0000000..93a2446
--- /dev/null
+++ b/src/routines/section/exit.c
@@ -0,0 +1,36 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+
+enum nw_state nwp_section_exit(struct nw_mod *const m)
+{
+    long offset;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const struct nw_mod_section *const s = &m->section;
+    const enum nw_state n = cfg->tell(&offset, cfg->user);
+    unsigned long size;
+
+    if (n)
+        return n;
+    else if ((size = offset - s->offset) != s->len)
+    {
+#ifdef NW_LOG
+        nwp_log("size mismatch (%lu expected, got %lu)\n",
+            (unsigned long)s->len, size);
+#endif
+        return NW_FATAL;
+    }
+
+    nwp_section(m);
+    return NW_AGAIN;
+}
diff --git a/src/routines/section/export.c b/src/routines/section/export.c
new file mode 100644
index 0000000..643b55f
--- /dev/null
+++ b/src/routines/section/export.c
@@ -0,0 +1,123 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+
+static enum nw_state entry_loop(struct nw_mod *m);
+
+static enum nw_state get_index(struct nw_mod *const m)
+{
+    nw_varuint32 index;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_exp *const e = &m->sm.export;
+    struct nw_sm_leb128 *const l = &e->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &index, cfg->user);
+
+    if (n)
+        return n;
+
+    e->entry_i++;
+    m->next = entry_loop;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_kind(struct nw_mod *const m)
+{
+    unsigned char kind;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_io io = {0};
+    enum nw_state n;
+
+    io.buf = &kind;
+    io.n = sizeof kind;
+
+    if ((n = nwp_io_read(cfg, &io, cfg->user)))
+        return n;
+
+    /* TODO: check kind */
+    m->next = get_index;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_name(struct nw_mod *const m)
+{
+    unsigned char b;
+    struct nw_sm_exp *const e = &m->sm.export;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_io io = {0};
+    enum nw_state n;
+
+    io.buf = &b;
+    io.n = sizeof b;
+
+    if ((n = nwp_io_read(cfg, &io, cfg->user)))
+        return n;
+    else if (++e->len_i >= e->field_len)
+    {
+        e->len_i = 0;
+        m->next = get_kind;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_len(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_exp *const e = &m->sm.export;
+    struct nw_sm_leb128 *const l = &e->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &e->field_len, cfg->user);
+
+    if (n)
+        return n;
+    else if (!e->field_len)
+    {
+#ifdef NW_LOG
+        nwp_log("invalid field length\n");
+#endif
+        return NW_FATAL;
+    }
+
+    m->next = get_name;
+    return NW_AGAIN;
+}
+
+static enum nw_state entry_loop(struct nw_mod *const m)
+{
+    const struct nw_sm_exp *const e = &m->sm.export;
+
+    m->next = e->entry_i < e->count ? get_len : nwp_section_exit;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_count(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_exp *const e = &m->sm.export;
+    struct nw_sm_leb128 *const l = &e->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &e->count, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = entry_loop;
+    return NW_AGAIN;
+}
+
+void nwp_section_export(struct nw_mod *const m)
+{
+    const struct nw_sm_exp e = {0};
+
+    m->sm.export = e;
+    m->next = get_count;
+}
diff --git a/src/routines/section/fbo.c b/src/routines/section/fbo.c
new file mode 100644
index 0000000..82ebd14
--- /dev/null
+++ b/src/routines/section/fbo.c
@@ -0,0 +1,52 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+
+static enum nw_state skip(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const long offset = m->c_sections[NW_CUSTOM_FBO]
+        + sizeof (struct nw_leuint32) * m->function_count;
+    const enum nw_state n = cfg->seek(offset, cfg->user);
+
+    if (n)
+        return n;
+
+    nwp_section(m);
+    return NW_AGAIN;
+}
+
+static enum nw_state check(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    enum nw_state n;
+
+    if (!m->sections[NW_SECTION_CODE])
+    {
+#ifdef NW_LOG
+        nwp_log("code section must be defined first\n");
+#endif
+        return NW_FATAL;
+    }
+    else if ((n = cfg->tell(&m->c_sections[NW_CUSTOM_FBO], cfg->user)))
+        return n;
+
+    m->next = skip;
+    return NW_AGAIN;
+}
+
+void nwp_section_fbo(struct nw_mod *const m)
+{
+    m->next = check;
+}
diff --git a/src/routines/section/fti.c b/src/routines/section/fti.c
new file mode 100644
index 0000000..ddc7762
--- /dev/null
+++ b/src/routines/section/fti.c
@@ -0,0 +1,59 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+
+static enum nw_state skip(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const long offset = m->c_sections[NW_CUSTOM_FTI]
+        + sizeof (struct nw_leuint32) * m->function_count;
+    const enum nw_state n = cfg->seek(offset, cfg->user);
+
+    if (n)
+        return n;
+
+    nwp_section(m);
+    return NW_AGAIN;
+}
+
+static enum nw_state check(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    enum nw_state n;
+
+    if (!m->sections[NW_SECTION_FUNCTION])
+    {
+#ifdef NW_LOG
+        nwp_log("function section must be defined first\n");
+#endif
+        return NW_FATAL;
+    }
+    else if (!m->sections[NW_SECTION_IMPORT])
+    {
+#ifdef NW_LOG
+        nwp_log("import section must be defined first\n");
+#endif
+        return NW_FATAL;
+    }
+    else if ((n = cfg->tell(&m->c_sections[NW_CUSTOM_FTI], cfg->user)))
+        return n;
+
+    m->next = skip;
+    return NW_AGAIN;
+}
+
+void nwp_section_fti(struct nw_mod *const m)
+{
+    m->next = check;
+}
diff --git a/src/routines/section/function.c b/src/routines/section/function.c
new file mode 100644
index 0000000..7cbcaca
--- /dev/null
+++ b/src/routines/section/function.c
@@ -0,0 +1,52 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+
+static enum nw_state get_entry(struct nw_mod *const m)
+{
+    struct nw_sm_fn *const fn = &m->sm.function;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_leb128 *const l = &fn->leb128;
+    nw_varuint32 type;
+    const enum nw_state n = nwp_varuint32(cfg, l, &type, cfg->user);
+
+    if (n)
+        return n;
+    else if (++fn->entry_i >= m->function_count)
+        m->next = nwp_section_exit;
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_count(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_fn *const fn = &m->sm.function;
+    struct nw_sm_leb128 *const l = &fn->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &m->function_count,
+        cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = get_entry;
+    return NW_AGAIN;
+}
+
+void nwp_section_function(struct nw_mod *const m)
+{
+    const struct nw_sm_fn fn = {0};
+
+    m->next = get_count;
+    m->sm.function = fn;
+}
diff --git a/src/routines/section/global.c b/src/routines/section/global.c
new file mode 100644
index 0000000..6223fc9
--- /dev/null
+++ b/src/routines/section/global.c
@@ -0,0 +1,148 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <nw/types.h>
+#include <limits.h>
+#include <string.h>
+
+static enum nw_state get_content_type(struct nw_mod *);
+
+static int push(const void *const src, const size_t n, void *const user)
+{
+    struct nw_mod *const m = user;
+    struct nw_sm_gl *const gl = &m->sm.global;
+
+    if (n > sizeof gl->value)
+    {
+#ifdef NW_LOG
+        nwp_log("stack overflow\n");
+#endif
+        return -1;
+    }
+
+    memcpy(&gl->value, src, n);
+    return n;
+}
+
+static enum nw_state loop(struct nw_mod *const m)
+{
+    struct nw_sm_gl *const gl = &m->sm.global;
+    const enum nw_state n = nwp_interp_run(&gl->interp);
+
+    if (n)
+        return n;
+
+    m->next = ++gl->entry_i >= m->global_count ?
+        nwp_section_exit : get_content_type;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_global(struct nw_mod *const m)
+{
+    struct nw_sm_gl *const gl = &m->sm.global;
+    struct nw_interp_cfg cfg = {0};
+
+    cfg.m = m;
+    cfg.io = m->cfg.io;
+    cfg.user = m;
+    cfg.stack.push = push;
+
+    if (nwp_interp_start(&gl->interp, &cfg, &nwp_interp_initexpr_set))
+    {
+#ifdef NW_LOG
+        nwp_log("nw_interp_start failed\n");
+#endif
+        return NW_FATAL;
+    }
+
+    m->next = loop;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_mutability(struct nw_mod *const m)
+{
+    nw_varuint1 mutability;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_gl *const gl = &m->sm.global;
+    struct nw_sm_leb128 *const l = &gl->leb128;
+    const enum nw_state n = nwp_varuint1(cfg, l, &mutability, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = get_global;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_content_type(struct nw_mod *const m)
+{
+    nw_varint7 content_type;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_gl *const gl = &m->sm.global;
+    struct nw_sm_leb128 *const l = &gl->leb128;
+    const enum nw_state n = nwp_varint7(cfg, l, &content_type, cfg->user);
+    enum nw_type type;
+
+    /* TODO: do not ignore type */
+    if (n)
+        return n;
+    else if (nwp_get_type(content_type, &type))
+    {
+#ifdef NW_LOG
+        nwp_log("nwp_get_type failed\n");
+#endif
+        return NW_FATAL;
+    }
+
+    m->next = get_mutability;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_count(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_gl *const gl = &m->sm.global;
+    struct nw_sm_leb128 *const l = &gl->leb128;
+    enum nw_state n;
+
+    if (!m->sections[NW_SECTION_IMPORT])
+    {
+#ifdef NW_LOG
+        nwp_log("global section found before import section\n");
+#endif
+        return NW_FATAL;
+    }
+    else if ((n = nwp_varuint32(cfg, l, &m->global_count, cfg->user)))
+        return n;
+    else if (m->global_count > ULONG_MAX / sizeof (struct nw_global))
+    {
+#ifdef NW_LOG
+        nwp_log("global_count too large: %lu\n",
+            (unsigned long)m->global_count);
+#endif
+        return NW_FATAL;
+    }
+
+    m->out.global = m->global_count * sizeof (struct nw_global);
+    m->next = m->global_count ? get_content_type : nwp_section_exit;
+    return NW_AGAIN;
+}
+
+void nwp_section_global(struct nw_mod *const m)
+{
+    const struct nw_sm_gl g = {0};
+
+    m->sm.global = g;
+    m->next = get_count;
+}
diff --git a/src/routines/section/import.c b/src/routines/section/import.c
new file mode 100644
index 0000000..26ef49a
--- /dev/null
+++ b/src/routines/section/import.c
@@ -0,0 +1,339 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <string.h>
+
+static enum nw_state entry_loop(struct nw_mod *);
+static enum nw_state find_import(struct nw_mod *);
+
+static enum nw_state get_function_type(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_imp *const imp = &m->sm.import;
+    struct nw_sm_leb128 *const l = &imp->leb128;
+    struct nw_import_index *const ii = &m->cfg.imp_indexes[imp->imp_i];
+    nw_varuint32 type;
+    const enum nw_state n = nwp_varuint32(cfg, l, &type, cfg->user);
+
+    if (n)
+        return n;
+    else if (imp->entry_i >= m->cfg.n_imports)
+    {
+#ifdef NW_LOG
+        nwp_log("too many import entries\n");
+#endif
+        return NW_FATAL;
+    }
+
+    ii->index = imp->entry_i++;
+    m->next = entry_loop;
+    return NW_AGAIN;
+}
+
+static enum nw_state skip_import(struct nw_mod *const m)
+{
+    struct nw_sm_imp *const imp = &m->sm.import;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const enum nw_state n = cfg->seek(imp->mod_off, cfg->user);
+
+    if (n)
+        return n;
+
+    imp->len_i = 0;
+    imp->imp_i++;
+    m->next = find_import;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_kind(struct nw_mod *const m)
+{
+    unsigned char kind;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_imp *const imp = &m->sm.import;
+    const struct nw_import *const i = &m->cfg.imports[imp->imp_i];
+    struct nw_sm_io io = {0};
+    enum nw_state n;
+
+    io.buf = &kind;
+    io.n = sizeof kind;
+
+    if ((n = nwp_io_read(cfg, &io, cfg->user)))
+        return n;
+    else if (kind != i->kind)
+        m->next = skip_import;
+    /* TODO: process every import type. */
+    else if (kind != NW_KIND_FUNCTION)
+        m->next = nwp_section_exit;
+    else
+        m->next = get_function_type;
+
+    return NW_AGAIN;
+}
+
+static enum nw_state compare_field(struct nw_mod *const m)
+{
+    unsigned char byte;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_imp *const imp = &m->sm.import;
+    const struct nw_import *const i = &m->cfg.imports[imp->imp_i];
+    struct nw_sm_io io = {0};
+    enum nw_state n;
+
+    io.buf = &byte;
+    io.n = sizeof byte;
+
+    if ((n = nwp_io_read(cfg, &io, cfg->user)))
+        return n;
+    else if (byte != i->field[imp->len_i])
+        m->next = skip_import;
+    else if (++imp->len_i >= imp->field_len)
+    {
+        m->next = get_kind;
+        imp->len_i = 0;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_field_offset(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_imp *const imp = &m->sm.import;
+    const enum nw_state n = cfg->tell(&imp->field_off, cfg->user);
+    const struct nw_import *const i = &m->cfg.imports[imp->imp_i];
+
+    if (n)
+        return n;
+
+    m->next = imp->field_len != strlen(i->field) ? skip_import : compare_field;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_field_len(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_imp *const imp = &m->sm.import;
+    struct nw_sm_leb128 *const l = &imp->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &imp->field_len, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = get_field_offset;
+    return NW_AGAIN;
+}
+
+static enum nw_state compare_name(struct nw_mod *const m)
+{
+    unsigned char byte;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_imp *const imp = &m->sm.import;
+    const struct nw_import *const i = &m->cfg.imports[imp->imp_i];
+    struct nw_sm_io io = {0};
+    enum nw_state n;
+
+    io.buf = &byte;
+    io.n = sizeof byte;
+
+    if ((n = nwp_io_read(cfg, &io, cfg->user)))
+        return n;
+    else if (byte != i->module[imp->len_i])
+        m->next = skip_import;
+    else if (++imp->len_i >= imp->mod_len)
+    {
+        m->next = get_field_len;
+        imp->len_i = 0;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state dump_import_field_name(struct nw_mod *const m)
+{
+    unsigned char byte;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_io io = {0};
+    struct nw_sm_imp *const imp = &m->sm.import;
+    enum nw_state n;
+
+    io.buf = &byte;
+    io.n = sizeof byte;
+
+    if ((n = nwp_io_read(cfg, &io, cfg->user)))
+        return n;
+
+#ifdef NW_LOG
+    nwp_log("%c", (char)byte);
+#endif
+
+    if (++imp->len_i >= imp->field_len)
+    {
+#ifdef NW_LOG
+        nwp_log("\n");
+#endif
+        return NW_FATAL;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state rewind_to_field_name(struct nw_mod *const m)
+{
+    struct nw_sm_imp *const imp = &m->sm.import;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const enum nw_state n = cfg->seek(imp->field_off, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = dump_import_field_name;
+    return NW_AGAIN;
+}
+
+static enum nw_state dump_import_mod_name(struct nw_mod *const m)
+{
+    unsigned char byte;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_imp *const imp = &m->sm.import;
+    struct nw_sm_io io = {0};
+    enum nw_state n;
+
+    io.buf = &byte;
+    io.n = sizeof byte;
+
+    if ((n = nwp_io_read(cfg, &io, cfg->user)))
+        return n;
+
+#ifdef NW_LOG
+    nwp_log("%c", (char)byte);
+#endif
+
+    if (++imp->len_i >= imp->mod_len)
+    {
+        imp->len_i = 0;
+
+        if (imp->field_off)
+        {
+#ifdef NW_LOG
+            nwp_log("::");
+#endif
+            m->next = rewind_to_field_name;
+        }
+        else
+        {
+#ifdef NW_LOG
+            nwp_log("\n");
+#endif
+            return NW_FATAL;
+        }
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state rewind_to_mod_name(struct nw_mod *const m)
+{
+    struct nw_sm_imp *const imp = &m->sm.import;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const enum nw_state n = cfg->seek(imp->mod_off, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = dump_import_mod_name;
+    return NW_AGAIN;
+}
+
+static enum nw_state find_import(struct nw_mod *const m)
+{
+    struct nw_sm_imp *const imp = &m->sm.import;
+    const struct nw_import *i;
+
+    if (imp->imp_i >= m->cfg.n_imports)
+    {
+#ifdef NW_LOG
+        nwp_log("required import: ");
+#endif
+        m->next = rewind_to_mod_name;
+        return NW_AGAIN;
+    }
+
+    i = &m->cfg.imports[imp->imp_i];
+
+    if (imp->mod_len == strlen(i->module))
+        m->next = compare_name;
+    else
+        imp->imp_i++;
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_module_offset(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_imp *const imp = &m->sm.import;
+    const enum nw_state n = cfg->tell(&imp->mod_off, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = find_import;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_module_len(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_imp *const imp = &m->sm.import;
+    struct nw_sm_leb128 *const l = &imp->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &imp->mod_len, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = get_module_offset;
+    return NW_AGAIN;
+}
+
+static enum nw_state entry_loop(struct nw_mod *const m)
+{
+    struct nw_sm_imp *const imp = &m->sm.import;
+
+    imp->len_i = 0;
+    imp->imp_i = 0;
+    m->next = imp->entry_i < m->import_count ?
+        get_module_len : nwp_section_exit;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_count(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_imp *const imp = &m->sm.import;
+    struct nw_sm_leb128 *const l = &imp->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &m->import_count, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = entry_loop;
+    return NW_AGAIN;
+}
+
+void nwp_section_import(struct nw_mod *const m)
+{
+    const struct nw_sm_imp imp = {0};
+
+    m->next = get_count;
+    m->sm.import = imp;
+}
diff --git a/src/routines/section/iti.c b/src/routines/section/iti.c
new file mode 100644
index 0000000..6fc7abc
--- /dev/null
+++ b/src/routines/section/iti.c
@@ -0,0 +1,52 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+
+static enum nw_state skip(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const long offset = m->c_sections[NW_CUSTOM_ITI]
+        + sizeof (struct nw_leuint32) * m->import_count;
+    const enum nw_state n = cfg->seek(offset, cfg->user);
+
+    if (n)
+        return n;
+
+    nwp_section(m);
+    return NW_AGAIN;
+}
+
+static enum nw_state check(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    enum nw_state n;
+
+    if (!m->sections[NW_SECTION_IMPORT])
+    {
+#ifdef NW_LOG
+        nwp_log("import section must be defined first\n");
+#endif
+        return NW_FATAL;
+    }
+    else if ((n = cfg->tell(&m->c_sections[NW_CUSTOM_ITI], cfg->user)))
+        return n;
+
+    m->next = skip;
+    return NW_AGAIN;
+}
+
+void nwp_section_iti(struct nw_mod *const m)
+{
+    m->next = check;
+}
diff --git a/src/routines/section/lo.c b/src/routines/section/lo.c
new file mode 100644
index 0000000..aacfa67
--- /dev/null
+++ b/src/routines/section/lo.c
@@ -0,0 +1,58 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+
+static enum nw_state skip(struct nw_mod *const m)
+{
+    const struct nw_sm_custom *const c = &m->sm.custom;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const enum nw_state n = cfg->seek(c->start, cfg->user);
+
+    if (n)
+        return n;
+
+    nwp_section_skip(m);
+    return NW_AGAIN;
+}
+
+static enum nw_state get_offset(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const enum nw_state n = cfg->tell(&m->c_sections[NW_CUSTOM_LO], cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = skip;
+    return NW_AGAIN;
+}
+
+static enum nw_state check(struct nw_mod *const m)
+{
+    if (!m->sections[NW_SECTION_CODE])
+    {
+#ifdef NW_LOG
+        nwp_log("code section must be defined first\n");
+#endif
+        return NW_FATAL;
+    }
+
+    m->next = get_offset;
+    return NW_AGAIN;
+}
+
+void nwp_section_lo(struct nw_mod *const m)
+{
+    m->next = check;
+}
diff --git a/src/routines/section/memory.c b/src/routines/section/memory.c
new file mode 100644
index 0000000..9277230
--- /dev/null
+++ b/src/routines/section/memory.c
@@ -0,0 +1,86 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+
+static enum nw_state get_maximum(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_mem *const mem = &m->sm.memory;
+    struct nw_mod_out_mem *const lin = &m->out.linear;
+    struct nw_sm_leb128 *const l = &mem->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &lin->max, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = nwp_section_exit;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_initial(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_mem *const mem = &m->sm.memory;
+    struct nw_mod_out_mem *const lin = &m->out.linear;
+    struct nw_sm_leb128 *const l = &mem->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &lin->initial, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = mem->flags ? get_maximum : nwp_section_exit;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_flags(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_mem *const mem = &m->sm.memory;
+    struct nw_sm_leb128 *const l = &mem->leb128;
+    const enum nw_state n = nwp_varuint1(cfg, l, &mem->flags, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = get_initial;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_count(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_mem *const mem = &m->sm.memory;
+    struct nw_sm_leb128 *const l = &mem->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &mem->count, cfg->user);
+
+    if (n)
+        return n;
+    else if (mem->count > 1)
+    {
+#ifdef NW_LOG
+        nwp_log("MVP WebAssembly supports no more than 1 memory\n");
+#endif
+        return NW_FATAL;
+    }
+
+    m->next = mem->count ? get_flags : nwp_section_exit;
+    return NW_AGAIN;
+}
+
+void nwp_section_memory(struct nw_mod *const m)
+{
+    const struct nw_sm_mem mem = {0};
+
+    m->next = get_count;
+    m->sm.memory = mem;
+}
diff --git a/src/routines/section/ops.c b/src/routines/section/ops.c
new file mode 100644
index 0000000..a81c8e7
--- /dev/null
+++ b/src/routines/section/ops.c
@@ -0,0 +1,141 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/ops.h>
+#include <nw/opcodes.h>
+
+static const struct nwp_check_op ops[] =
+{
+    {
+        OP_UNREACHABLE,
+        OP_NOP,
+        nwp_op_check_no_immediate
+    },
+
+    {
+        OP_BLOCK,
+        OP_IF,
+        nwp_op_check_block
+    },
+
+    {
+        OP_ELSE,
+        OP_ELSE,
+        nwp_op_check_no_immediate
+    },
+
+    {
+        OP_END,
+        OP_END,
+        nwp_op_check_end
+    },
+
+    {
+        OP_BR,
+        OP_BR_IF,
+        nwp_op_check_relative_depth
+    },
+
+    {
+        OP_BR_TABLE,
+        OP_BR_TABLE,
+        nwp_op_check_br_table
+    },
+
+    {
+        OP_RETURN,
+        OP_RETURN,
+        nwp_op_check_no_immediate
+    },
+
+    {
+        OP_CALL,
+        OP_CALL,
+        nwp_op_check_call
+    },
+
+    {
+        OP_CALL_INDIRECT,
+        OP_CALL_INDIRECT,
+        nwp_op_check_call_indirect
+    },
+
+    {
+        OP_DROP,
+        OP_SELECT,
+        nwp_op_check_no_immediate
+    },
+
+    {
+        OP_GET_LOCAL,
+        OP_TEE_LOCAL,
+        nwp_op_check_local_index,
+    },
+
+    {
+        OP_GET_GLOBAL,
+        OP_SET_GLOBAL,
+        nwp_op_check_global_index
+    },
+
+    {
+        OP_I32_LOAD,
+        OP_I64_STORE32,
+        nwp_op_check_memory_immediate
+    },
+
+    {
+        OP_CURRENT_MEMORY,
+        OP_GROW_MEMORY,
+        nwp_op_check_varuint1
+    },
+
+    {
+        OP_I32_CONST,
+        OP_I32_CONST,
+        nwp_op_check_varint32
+    },
+
+    {
+        OP_I64_CONST,
+        OP_I64_CONST,
+        nwp_op_check_varint64
+    },
+
+    {
+        OP_F32_CONST,
+        OP_F32_CONST,
+        nwp_op_check_uint32
+    },
+
+    {
+        OP_F64_CONST,
+        OP_F64_CONST,
+        nwp_op_check_uint64
+    },
+
+    {
+        OP_I32_EQZ,
+        OP_F64_PROMOTE_F32,
+        nwp_op_check_no_immediate
+    },
+
+    {
+        OP_MISC,
+        OP_MISC,
+        nwp_op_check_misc
+    }
+};
+
+const struct nwp_check_ops nwp_check_ops =
+{
+    ops,
+    sizeof ops / sizeof *ops
+};
diff --git a/src/routines/section/skip.c b/src/routines/section/skip.c
new file mode 100644
index 0000000..72296ce
--- /dev/null
+++ b/src/routines/section/skip.c
@@ -0,0 +1,45 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+
+static enum nw_state skip(struct nw_mod *const m)
+{
+    const struct nw_mod_section *const s = &m->section;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const long offset = s->cur + s->len;
+    const enum nw_state n = cfg->seek(offset, cfg->user);
+
+    if (n)
+        return n;
+
+    nwp_section(m);
+    return NW_AGAIN;
+}
+
+static enum nw_state tell(struct nw_mod *const m)
+{
+    struct nw_mod_section *const s = &m->section;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const enum nw_state n = cfg->tell(&s->cur, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = skip;
+    return NW_AGAIN;
+}
+
+void nwp_section_skip(struct nw_mod *const m)
+{
+    m->next = tell;
+}
diff --git a/src/routines/section/start.c b/src/routines/section/start.c
new file mode 100644
index 0000000..8ff22f3
--- /dev/null
+++ b/src/routines/section/start.c
@@ -0,0 +1,37 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+
+static enum nw_state get_index(struct nw_mod *const m)
+{
+    nw_varuint32 index;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_start *const st = &m->sm.start;
+    struct nw_sm_leb128 *const l = &st->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &index, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = nwp_section_exit;
+    return NW_AGAIN;
+}
+
+void nwp_section_start(struct nw_mod *const m)
+{
+    const struct nw_sm_start s = {0};
+
+    m->sm.start = s;
+    m->next = get_index;
+}
diff --git a/src/routines/section/table.c b/src/routines/section/table.c
new file mode 100644
index 0000000..56f62ae
--- /dev/null
+++ b/src/routines/section/table.c
@@ -0,0 +1,117 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+
+static enum nw_state get_maximum(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_tb *const tb = &m->sm.table;
+    struct nw_mod_out_mem *const ot = &m->out.table;
+    struct nw_sm_leb128 *const l = &tb->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &ot->max, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = nwp_section_exit;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_initial(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_tb *const tb = &m->sm.table;
+    struct nw_mod_out_mem *const ot = &m->out.table;
+    struct nw_sm_leb128 *const l = &tb->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &ot->initial, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = tb->flags ? get_maximum : nwp_section_exit;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_flags(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_tb *const tb = &m->sm.table;
+    struct nw_sm_leb128 *const l = &tb->leb128;
+    const enum nw_state n = nwp_varuint1(cfg, l, &tb->flags, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = get_initial;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_element_type(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_tb *const tb = &m->sm.table;
+    struct nw_sm_leb128 *const l = &tb->leb128;
+    const enum nw_state n = nwp_varint7(cfg, l, &tb->elem_type, cfg->user);
+
+    if (n)
+        return n;
+    /* TODO: replace with enum? */
+    else if (tb->elem_type != 0x70)
+    {
+#ifdef NW_LOG
+        nwp_log("unexpected elem_type %hhx\n", (char)tb->elem_type);
+#endif
+        return NW_FATAL;
+    }
+
+    m->next = get_flags;
+    return NW_AGAIN;
+}
+
+static enum nw_state entry_loop(struct nw_mod *const m)
+{
+    const struct nw_sm_tb *const tb = &m->sm.table;
+
+    m->next = tb->entry_i < tb->count ? get_element_type : nwp_section_exit;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_count(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_tb *const tb = &m->sm.table;
+    struct nw_sm_leb128 *const l = &tb->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &tb->count, cfg->user);
+
+    if (n)
+        return n;
+    else if (tb->count > 1u)
+    {
+#ifdef NW_LOG
+        nwp_log("got %lu tables, but only 1 supported by the MVP\n",
+            (unsigned long)tb->count);
+#endif
+        return NW_FATAL;
+    }
+
+    m->next = entry_loop;
+    return NW_AGAIN;
+}
+
+void nwp_section_table(struct nw_mod *const m)
+{
+    const struct nw_sm_tb t = {0};
+
+    m->sm.table = t;
+    m->next = get_count;
+}
diff --git a/src/routines/section/to.c b/src/routines/section/to.c
new file mode 100644
index 0000000..cf459cd
--- /dev/null
+++ b/src/routines/section/to.c
@@ -0,0 +1,52 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+
+static enum nw_state skip(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const long offset = m->c_sections[NW_CUSTOM_TO]
+        + sizeof (struct nw_leuint32) * m->type_count;
+    const enum nw_state n = cfg->seek(offset, cfg->user);
+
+    if (n)
+        return n;
+
+    nwp_section(m);
+    return NW_AGAIN;
+}
+
+static enum nw_state check(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    enum nw_state n;
+
+    if (!m->sections[NW_SECTION_TYPE])
+    {
+#ifdef NW_LOG
+        nwp_log("type section must be defined first\n");
+#endif
+        return NW_FATAL;
+    }
+    else if ((n = cfg->tell(&m->c_sections[NW_CUSTOM_TO], cfg->user)))
+        return n;
+
+    m->next = skip;
+    return NW_AGAIN;
+}
+
+void nwp_section_to(struct nw_mod *const m)
+{
+    m->next = check;
+}
diff --git a/src/routines/section/type.c b/src/routines/section/type.c
new file mode 100644
index 0000000..c8e5e9c
--- /dev/null
+++ b/src/routines/section/type.c
@@ -0,0 +1,164 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <stddef.h>
+
+static enum nw_state entry_loop(struct nw_mod *);
+
+static enum nw_state get_return_type(struct nw_mod *const m)
+{
+    struct nw_sm_st *const st = &m->sm.type;
+    struct nw_sm_leb128 *const l = &st->leb128;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    nw_varint7 return_type;
+    const enum nw_state n = nwp_varint7(cfg, l, &return_type, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = entry_loop;
+    st->entry_i++;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_return_count(struct nw_mod *const m)
+{
+    struct nw_sm_st *const st = &m->sm.type;
+    struct nw_sm_leb128 *const l = &st->leb128;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    nw_varuint1 return_count;
+    const enum nw_state n = nwp_varuint1(cfg, l, &return_count, cfg->user);
+
+    if (n)
+        return n;
+    else if (return_count)
+        m->next = get_return_type;
+    else
+    {
+        m->next = entry_loop;
+        st->entry_i++;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state param_loop(struct nw_mod *const m)
+{
+    struct nw_sm_st *const st = &m->sm.type;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_leb128 *const l = &st->leb128;
+    nw_varint7 type;
+    enum nw_state n;
+
+    if (st->p_i >= st->param_count)
+    {
+        m->next = get_return_count;
+        return NW_AGAIN;
+    }
+    else if ((n = nwp_varint7(cfg, l, &type, cfg->user)))
+        return n;
+
+    st->p_i++;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_param_count(struct nw_mod *const m)
+{
+    struct nw_sm_st *const st = &m->sm.type;
+    struct nw_sm_leb128 *const l = &st->leb128;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    const enum nw_state n = nwp_varuint32(cfg, l, &st->param_count,
+        cfg->user);
+
+    if (n)
+        return n;
+
+    st->p_i = 0;
+    m->next = param_loop;
+    return NW_AGAIN;
+}
+
+static int check_form(const nw_varint7 form)
+{
+    static const nw_varint7 v[] =
+    {
+        /* TODO: move values to enums? */
+        0x7f, /* i32 */
+        0x7e, /* i64 */
+        0x7d, /* f32 */
+        0x7c, /* f64 */
+        0x70, /* anyfunc */
+        0x60, /* func */
+        0x40 /* empty block_type */
+    };
+
+    size_t i;
+
+    for (i = 0; i < sizeof v / sizeof *v; i++)
+        if (form == v[i])
+            return 0;
+
+    return -1;
+}
+
+static enum nw_state get_form(struct nw_mod *const m)
+{
+    struct nw_sm_st *const st = &m->sm.type;
+    struct nw_sm_leb128 *const l = &st->leb128;
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    nw_varint7 form;
+    const enum nw_state n = nwp_varint7(cfg, l, &form, cfg->user);
+
+    if (n)
+        return n;
+    else if (check_form(form))
+    {
+#ifdef NW_LOG
+        nwp_log("invalid form %#x\n", (unsigned)form);
+#endif
+        return NW_FATAL;
+    }
+
+    m->next = get_param_count;
+    return NW_AGAIN;
+}
+
+static enum nw_state entry_loop(struct nw_mod *const m)
+{
+    struct nw_sm_st *const st = &m->sm.type;
+
+    m->next = st->entry_i < m->type_count ? get_form : nwp_section_exit;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_count(struct nw_mod *const m)
+{
+    const struct nw_io_cfg *const cfg = &m->cfg.io;
+    struct nw_sm_st *const st = &m->sm.type;
+    struct nw_sm_leb128 *const l = &st->leb128;
+    const enum nw_state n = nwp_varuint32(cfg, l, &m->type_count, cfg->user);
+
+    if (n)
+        return n;
+
+    m->next = entry_loop;
+    return NW_AGAIN;
+}
+
+void nwp_section_type(struct nw_mod *const m)
+{
+    const struct nw_sm_st st = {0};
+
+    m->next = get_count;
+    m->sm.type = st;
+}
diff --git a/src/routines/set_local.c b/src/routines/set_local.c
new file mode 100644
index 0000000..84c7c26
--- /dev/null
+++ b/src/routines/set_local.c
@@ -0,0 +1,162 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/ops.h>
+#include <nw/routines.h>
+#include <nw/stack.h>
+#include <nw/types.h>
+
+static enum nw_state set_local(struct nw_interp *const i)
+{
+    struct nw_i_sm_set_local *const sl = &i->sm.set_local;
+    const enum nw_state n = nwp_stack_write(i, &sl->io, sl->f.l.addr);
+
+    if (n)
+        return n;
+
+    i->next = sl->next;
+    return NW_AGAIN;
+}
+
+static int init_io(struct nw_interp *const i, const enum nw_type t)
+{
+    struct nw_i_sm_set_local *const sl = &i->sm.set_local;
+    size_t sz;
+
+    if (nwp_type_sz(t, &sz))
+    {
+        static const char *const exc = "invalid type";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#x\n", exc, (unsigned)t);
+#endif
+        return -1;
+    }
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &sl->out.value;
+        io.n = sz;
+        sl->io = io;
+    }
+
+    return 0;
+}
+
+static enum nw_state pop(struct nw_interp *const i, const enum nw_type t,
+    enum nw_state (*const next)(struct nw_interp *))
+{
+    struct nw_i_sm_set_local *const sl = &i->sm.set_local;
+    const enum nw_state n = nwp_stack_pop(i, &sl->io);
+
+    if (n)
+        return n;
+    else if (init_io(i, t))
+        return NW_FATAL;
+
+    sl->out.type = t;
+    i->next = next;
+    return NW_AGAIN;
+}
+
+static enum nw_state pop_local(struct nw_interp *const i)
+{
+    const struct nw_local_meta *const m = &i->sm.set_local.f.l.meta;
+
+    return pop(i, m->type, set_local);
+}
+
+static enum nw_state prepare_local(struct nw_interp *const i)
+{
+    const struct nw_local_meta *const m = &i->sm.set_local.f.l.meta;
+
+    if (init_io(i, m->type))
+        return NW_FATAL;
+
+    i->next = pop_local;
+    return NW_AGAIN;
+}
+
+static enum nw_state set_param(struct nw_interp *const i)
+{
+    struct nw_i_sm_set_local *const sl = &i->sm.set_local;
+    const enum nw_state n = nwp_stack_write(i, &sl->io, sl->f.p.out.addr);
+
+    if (n)
+        return n;
+
+    nwp_interp_resume(i);
+    return NW_AGAIN;
+}
+
+static enum nw_state pop_param(struct nw_interp *const i)
+{
+    const struct nw_find_param_out *const o = &i->sm.set_local.f.p.out;
+
+    return pop(i, o->type, set_param);
+}
+
+static enum nw_state prepare_param(struct nw_interp *const i)
+{
+    struct nw_i_sm_set_local *const sl = &i->sm.set_local;
+    const struct nw_find_param_out *const o = &sl->f.p.out;
+
+    if (init_io(i, o->type))
+        return NW_FATAL;
+
+    i->next = pop_param;
+    return NW_AGAIN;
+}
+
+static enum nw_state get_index(struct nw_interp *const i)
+{
+    struct nw_i_sm_set_local *const sl = &i->sm.set_local;
+    struct nw_sm_leb128 *const l = &sl->leb128;
+    const struct nw_frame *const fr = &i->fr;
+    const struct nw_fn *const fn = &fr->fn;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_varuint32(cfg, l, &sl->index, cfg->user);
+    nw_varuint32 index;
+
+    if (n)
+        return n;
+    else if (sl->index < fn->param_count)
+        nwp_find_param(i, &sl->f.p, sl->index, prepare_param, NULL);
+    else if ((index = sl->index - fn->param_count) >= fr->local_count)
+    {
+        static const char *const exc = "invalid local index";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %lu\n", exc, (unsigned long)sl->index);
+#endif
+        return NW_FATAL;
+    }
+    else
+        nwp_find_local(i, &sl->f.l, index, prepare_local, NULL);
+
+    return NW_AGAIN;
+}
+
+void nwp_set_local(struct nw_interp *const i,
+    enum nw_state (*const next)(struct nw_interp *))
+{
+    const struct nw_i_sm_set_local sl = {0};
+    struct nw_i_sm_set_local *const p = &i->sm.set_local;
+
+    *p = sl;
+    p->next = next;
+    i->next = get_index;
+}
diff --git a/src/routines/start_block.c b/src/routines/start_block.c
new file mode 100644
index 0000000..83be44c
--- /dev/null
+++ b/src/routines/start_block.c
@@ -0,0 +1,49 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <nw/types.h>
+
+static enum nw_state get_block_type(struct nw_interp *const i)
+{
+    nw_varint7 type;
+    struct nw_i_sm_sb *const sb = &i->sm.start_block;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_varint7(cfg, &sb->leb128, &type, cfg->user);
+    enum nw_type block_type;
+
+    if (n)
+        return n;
+    else if (type != 0x40 && nwp_get_type(type, &block_type))
+    {
+        static const char *const exc = "invalid block_type";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#hhx\n", exc, (unsigned char)type);
+#endif
+        return NW_FATAL;
+    }
+
+    i->fr.block_i++;
+    nwp_interp_resume(i);
+    return NW_AGAIN;
+}
+
+void nwp_start_block(struct nw_interp *const i)
+{
+    const struct nw_i_sm_sb sb = {0};
+
+    i->sm.start_block = sb;
+    i->next = get_block_type;
+}
diff --git a/src/routines/unary.c b/src/routines/unary.c
new file mode 100644
index 0000000..d65f8aa
--- /dev/null
+++ b/src/routines/unary.c
@@ -0,0 +1,86 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/io.h>
+#include <nw/interp.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <nw/stack.h>
+#include <nw/types.h>
+
+static enum nw_state push(struct nw_interp *const i)
+{
+    struct nw_i_sm_unary *const u = &i->sm.unary;
+    const enum nw_state n = nwp_stack_push(i, &u->io);
+
+    if (n)
+        return n;
+
+    i->push_type = u->type;
+    nwp_interp_resume(i);
+    return NW_AGAIN;
+}
+
+static enum nw_state pop(struct nw_interp *const i)
+{
+    struct nw_i_sm_unary *const u = &i->sm.unary;
+    const enum nw_state n = nwp_stack_pop(i, &u->io);
+    size_t sz;
+
+    if (n)
+        return n;
+    else if (u->op(&u->in, &u->out))
+    {
+        static const char *const exc = "unary operation failed";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s\n", exc);
+#endif
+        return NW_FATAL;
+    }
+    else if (nwp_type_sz(u->type, &sz))
+    {
+        static const char *const exc = "invalid type";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %d\n", exc, u->type);
+#endif
+        return NW_FATAL;
+    }
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &u->out;
+        io.n = sz;
+        u->io = io;
+    }
+
+    i->next = push;
+    return NW_AGAIN;
+}
+
+void nwp_unary(struct nw_interp *const i, const enum nw_type t,
+    int (*const op)(const union nw_value *, union nw_value *))
+{
+    const struct nw_i_sm_unary u = {0};
+    struct nw_i_sm_unary *const pu = &i->sm.unary;
+    size_t sz;
+
+    *pu = u;
+    pu->type = t;
+    pu->op = op;
+    nwp_type_sz(t, &sz);
+    pu->io.buf = &pu->in;
+    pu->io.n = sz;
+    i->next = pop;
+}
diff --git a/src/routines/unwind.c b/src/routines/unwind.c
new file mode 100644
index 0000000..e4200fd
--- /dev/null
+++ b/src/routines/unwind.c
@@ -0,0 +1,391 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/routines.h>
+#include <nw/interp.h>
+#include <nw/io.h>
+#include <nw/log.h>
+#include <nw/stack.h>
+#include <nw/types.h>
+
+static enum nw_state prepare_pop(struct nw_interp *);
+
+static enum nw_state seek_pc(struct nw_interp *const i)
+{
+    const struct nw_i_sm_unwind *const u = &i->sm.unwind;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = cfg->seek(u->fr.pc, cfg->user);
+    struct nw_return r;
+
+    if (n)
+        return n;
+
+#ifdef NW_LOG
+    nwp_log("returning to function %lu\n", u->fr.fn.index);
+#endif
+
+    r = i->fr.fn.ret;
+    i->fr = u->fr;
+    i->fr.prev_ret = r;
+    nwp_interp_resume(i);
+    return NW_AGAIN;
+}
+
+static enum nw_state push_return_value(struct nw_interp *const i)
+{
+    struct nw_i_sm_unwind *const u = &i->sm.unwind;
+    const enum nw_state n = nwp_stack_push(i, &u->io);
+
+    if (n)
+        return n;
+    else if (u->fr.child)
+        i->next = seek_pc;
+    else
+        return NW_OK;
+
+    return NW_AGAIN;
+}
+
+static int prepare_retval(struct nw_interp *const i)
+{
+    struct nw_i_sm_unwind *const u = &i->sm.unwind;
+    const struct nw_fn *const fn = &i->fr.fn;
+    const struct nw_return *const r = &fn->ret;
+    const enum nw_type t = r->type;
+    size_t sz;
+
+    if (nwp_type_sz(t, &sz))
+    {
+        static const char *const exc = "invalid return type";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#x\n", exc, (unsigned)t);
+#endif
+        return -1;
+    }
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &u->retval;
+        io.n = sz;
+        u->io = io;
+        i->push_type = t;
+        i->next = push_return_value;
+    }
+
+    return 0;
+}
+
+static enum nw_state pop_params(struct nw_interp *const i)
+{
+    struct nw_i_sm_unwind *const u = &i->sm.unwind;
+    const struct nw_fn *const fn = &i->fr.fn;
+    const struct nw_return *const r = &fn->ret;
+    const enum nw_state n = nwp_stack_pop(i, &u->io);
+
+    if (n)
+        return n;
+    else if (r->count)
+    {
+        if (prepare_retval(i))
+            return NW_FATAL;
+    }
+    else if (u->fr.child)
+        i->next = seek_pc;
+    else
+        return NW_OK;
+
+    return NW_AGAIN;
+}
+
+static enum nw_state get_param_type(struct nw_interp *const i)
+{
+    nw_varint7 type;
+    struct nw_i_sm_unwind *const u = &i->sm.unwind;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = nwp_varint7(cfg, &u->leb128, &type, cfg->user);
+    enum nw_type vtype;
+    size_t sz;
+
+    if (n)
+        return n;
+    else if (nwp_get_type(type, &vtype) || nwp_type_sz(vtype, &sz))
+    {
+        static const char *const exc = "invalid param type";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#x\n", exc, (unsigned)type);
+#endif
+        return NW_FATAL;
+    }
+
+    u->sz += sz;
+
+    if (++u->entry_i >= i->fr.fn.param_count)
+    {
+        struct nw_sm_io io = {0};
+
+        io.n = u->sz;
+        u->io = io;
+        i->next = pop_params;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state seek_param_types(struct nw_interp *const i)
+{
+    struct nw_i_sm_unwind *const u = &i->sm.unwind;
+    const struct nw_io_cfg *const cfg = &i->cfg.io;
+    const enum nw_state n = cfg->seek(i->fr.fn.param_types, cfg->user);
+
+    if (n)
+        return n;
+
+    u->entry_i = 0;
+    i->next = get_param_type;
+    return NW_AGAIN;
+}
+
+static enum nw_state check_retval(struct nw_interp *const i)
+{
+    struct nw_i_sm_unwind *const u = &i->sm.unwind;
+    const struct nw_fn *const fn = &i->fr.fn;
+    const size_t addr = nwp_stack_ptr(i), start = i->fr.local_start;
+    const struct nw_return *const r = &fn->ret;
+
+    if (addr != start)
+    {
+        static const char *const exc = "mismatched stack address";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: expected: %lu, got: %lu\n", exc,
+            (unsigned long)start, (unsigned long)addr);
+#endif
+        return NW_FATAL;
+    }
+    else if (fn->param_count)
+        i->next = seek_param_types;
+    else if (r->count)
+    {
+        if (prepare_retval(i))
+            return NW_FATAL;
+    }
+    else if (u->fr.child)
+        i->next = seek_pc;
+    else
+        return NW_OK;
+
+    return NW_AGAIN;
+}
+
+static enum nw_state pop_meta(struct nw_interp *const i)
+{
+    struct nw_i_sm_unwind *const u = &i->sm.unwind;
+    const enum nw_state n = nwp_stack_pop(i, &u->io);
+
+    if (n)
+        return n;
+    else if (u->pending)
+        nwp_find_local(i, &u->fl, u->pending - 1, prepare_pop, NULL);
+    else
+        return check_retval(i);
+
+    return NW_AGAIN;
+}
+
+static enum nw_state pop_local(struct nw_interp *const i)
+{
+    struct nw_i_sm_unwind *const u = &i->sm.unwind;
+    struct nw_local_meta *const m = &u->fl.meta;
+    const enum nw_state n = nwp_stack_pop(i, &u->io);
+
+    if (n)
+        return n;
+
+    u->pending--;
+
+    if (++u->entry_i >= m->entry_count)
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = m;
+        io.n = sizeof *m;
+        u->io = io;
+        u->entry_i = 0;
+        i->next = pop_meta;
+    }
+    else if (u->pending)
+        return prepare_pop(i);
+    else
+    {
+        static const char *const exc = "entry and local count mismatch";
+#ifdef NW_LOG
+        const unsigned long pending = m->entry_count - u->entry_i;
+#endif
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %lu locals pending\n", exc, pending);
+#endif
+        return NW_FATAL;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state prepare_pop(struct nw_interp *const i)
+{
+    struct nw_i_sm_unwind *const u = &i->sm.unwind;
+    const struct nw_local_meta *const m = &u->fl.meta;
+    size_t sz;
+
+    if (nwp_type_sz(m->type, &sz))
+    {
+        static const char *const exc = "invalid type";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %#x\n", exc, (unsigned)m->type);
+#endif
+        return NW_FATAL;
+    }
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &u->value;
+        io.n = sz;
+        u->io = io;
+        i->next = pop_local;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state pop_frame(struct nw_interp *const i)
+{
+    struct nw_i_sm_unwind *const u = &i->sm.unwind;
+    const struct nw_frame *const fr = &i->fr;
+    const enum nw_state n = nwp_stack_pop(i, &u->io);
+
+    if (n)
+        return n;
+    else if (fr->local_count)
+    {
+        u->pending = fr->local_count;
+        nwp_find_local(i, &u->fl, u->pending - 1, prepare_pop, NULL);
+    }
+    else
+        return check_retval(i);
+
+    return NW_AGAIN;
+}
+
+static enum nw_state pop_return_value(struct nw_interp *const i)
+{
+    struct nw_i_sm_unwind *const u = &i->sm.unwind;
+    const enum nw_state n = nwp_stack_pop(i, &u->io);
+
+    if (n)
+        return n;
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &u->fr;
+        io.n = sizeof u->fr;
+        u->io = io;
+        i->next = pop_frame;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state run(struct nw_interp *const i)
+{
+    struct nw_i_sm_unwind *const u = &i->sm.unwind;
+    const struct nw_frame *const fr = &i->fr;
+    const struct nw_fn *const fn = &fr->fn;
+    const struct nw_return *const r = &fn->ret;
+
+    if (r->count)
+    {
+        size_t sz, end, addr;
+
+        if (nwp_type_sz(r->type, &sz))
+        {
+            static const char *const exc = "invalid type";
+
+            i->exception = exc;
+#ifdef NW_LOG
+            nwp_log("%s: %#x\n", exc, (unsigned)r->type);
+#endif
+            return NW_FATAL;
+        }
+
+        end = fr->local_end;
+        addr = nwp_stack_ptr(i);
+
+        if (addr < sz || addr < sizeof *fr)
+        {
+            static const char *const exc = "stack underflow";
+
+            i->exception = exc;
+#ifdef NW_LOG
+            nwp_log("%s\n", exc);
+#endif
+            return NW_FATAL;
+        }
+        else if ((addr -= sizeof *fr + sz) != end)
+        {
+            static const char *const exc = "stack memory leak";
+
+            i->exception = exc;
+#ifdef NW_LOG
+            nwp_log("%s: expected: %lu, got: %lu\n", exc,  (unsigned long)end,
+            (unsigned long)addr);
+#endif
+            return NW_FATAL;
+        }
+        else
+        {
+            struct nw_sm_io io = {0};
+
+            io.buf = &u->retval;
+            io.n = sz;
+            u->io = io;
+            i->next = pop_return_value;
+        }
+    }
+    else
+    {
+        struct nw_sm_io io = {0};
+
+        io.buf = &u->fr;
+        io.n = sizeof u->fr;
+        u->io = io;
+        i->next = pop_frame;
+    }
+
+    return NW_AGAIN;
+}
+
+void nwp_unwind(struct nw_interp *const i)
+{
+    const struct nw_i_sm_unwind u = {0};
+
+    i->sm.unwind = u;
+    i->next = run;
+}
diff --git a/src/run.c b/src/run.c
new file mode 100644
index 0000000..2995ece
--- /dev/null
+++ b/src/run.c
@@ -0,0 +1,16 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/interp.h>
+
+enum nw_state nw_run(struct nw_inst *const i)
+{
+    return i->next(i);
+}
diff --git a/src/start.c b/src/start.c
new file mode 100644
index 0000000..788a5ad
--- /dev/null
+++ b/src/start.c
@@ -0,0 +1,81 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nanowasm/types.h>
+#include <nw/inst.h>
+#include <nw/interp.h>
+#include <nw/log.h>
+#include <nw/routines.h>
+#include <stddef.h>
+
+static enum nw_state push(struct nw_interp *const i)
+{
+    const struct nw_i_sm_exp *const e = &i->sm.export;
+
+    if (e->kind != NW_KIND_FUNCTION)
+    {
+        static const char *const exc = "unexpected import kind";
+
+        i->exception = exc;
+#ifdef NW_LOG
+        nwp_log("%s: %d\n", exc, e->kind);
+#endif
+        return NW_FATAL;
+    }
+
+    nwp_call(i, e->index);
+    return NW_AGAIN;
+}
+
+static enum nw_state find_start(struct nw_inst *const inst)
+{
+    struct nw_interp *const i = &inst->interp;
+    struct nw_interp_cfg cfg;
+
+    cfg = i->cfg;
+
+    if (nwp_interp_start(i, &cfg, NULL))
+    {
+#ifdef NW_LOG
+        nwp_log("nwp_interp_start failed\n");
+#endif
+        return NW_FATAL;
+    }
+
+    nwp_find_export(i, inst->entry, push);
+    inst->next = nwp_inst_run;
+    return NW_AGAIN;
+}
+
+static enum nw_state init_data(struct nw_inst *const i)
+{
+    nwp_init_data(i, find_start);
+    return NW_AGAIN;
+}
+
+int nw_start(struct nw_inst *const i, const struct nw_inst_cfg *const icfg)
+{
+    const struct nw_inst inst = {0};
+
+    *i = inst;
+    i->entry = icfg->entry;
+
+    if (nwp_interp_start(&i->interp, &icfg->interp_cfg,
+        &nwp_interp_initexpr_set))
+    {
+#ifdef NW_LOG
+        nwp_log("nwp_interp_start failed\n");
+#endif
+        return -1;
+    }
+
+    nwp_init_globals(i, init_data);
+    return 0;
+}
diff --git a/src/types/CMakeLists.txt b/src/types/CMakeLists.txt
new file mode 100644
index 0000000..f3f0cb3
--- /dev/null
+++ b/src/types/CMakeLists.txt
@@ -0,0 +1,11 @@
+# nanowasm, a tiny WebAssembly/Wasm interpreter
+# Copyright (C) 2023-2025  Xavier Del Campo Romero
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+target_sources(${PROJECT_NAME} PRIVATE
+    get.c
+    sz.c
+)
diff --git a/src/types/get.c b/src/types/get.c
new file mode 100644
index 0000000..40ce472
--- /dev/null
+++ b/src/types/get.c
@@ -0,0 +1,42 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/types.h>
+#include <nw/log.h>
+
+int nwp_get_type(const nw_varint7 type, enum nw_type *const out)
+{
+    static const struct type
+    {
+        nw_varint7 key;
+        enum nw_type value;
+    } list[] =
+    {
+        {0x7f, NW_TYPE_I32},
+        {0x7e, NW_TYPE_I64},
+        {0x7d, NW_TYPE_F32},
+        {0x7c, NW_TYPE_F64}
+    };
+
+    size_t i;
+
+    for (i = 0; i < sizeof list / sizeof *list; i++)
+    {
+        const struct type *const t = &list[i];
+
+        if (type == t->key)
+        {
+            *out = t->value;
+            return 0;
+        }
+    }
+
+    return -1;
+}
diff --git a/src/types/sz.c b/src/types/sz.c
new file mode 100644
index 0000000..e6660a9
--- /dev/null
+++ b/src/types/sz.c
@@ -0,0 +1,29 @@
+/*
+ * nanowasm, a tiny WebAssembly/Wasm interpreter
+ * Copyright (C) 2023-2025  Xavier Del Campo Romero
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanowasm/nw.h>
+#include <nw/types.h>
+#include <stddef.h>
+
+int nwp_type_sz(const enum nw_type t, size_t *const out)
+{
+    static const size_t sz[] =
+    {
+        sizeof (long),
+        sizeof (struct nw_ll),
+        sizeof (float),
+        sizeof (double)
+    };
+
+    if (t < 0 || t >= sizeof sz / sizeof *sz)
+        return -1;
+
+    *out = sz[t];
+    return 0;
+}