diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..526c8a3
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1 @@
+*.sh text eol=lf
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
index a9af212..ca7c5d2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,24 +4,24 @@ project(PiCo VERSION 0.1.0 LANGUAGES C)
 
 include(GNUInstallDirs)
 
-set(CMAKE_C_COMPILER "gcc")
-
 if(NOT CMAKE_C_COMPILER_ID MATCHES "GNU")
-    message(FATAL_ERROR "FATAL: This project requires the GCC compiler due to specific GNU C extensions. "
-                        "The attempt to set GCC as the compiler failed. Please ensure 'gcc' is installed and in your PATH.")
+    message(FATAL_ERROR
+        "PiCo requires GCC because it uses GNU C extensions. "
+        "Configure CMake with a GCC-based toolchain or preset."
+    )
 endif()
 
 set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_STANDARD_REQUIRED ON)
 set(CMAKE_C_EXTENSIONS ON)
 
-file(GLOB_RECURSE CORE_SRC "core/*.c")
-file(GLOB_RECURSE VM_SRC "vm/*.c")
-file(GLOB_RECURSE COMPILER_SRC "compiler/*.c")
+file(GLOB_RECURSE CORE_SRC CONFIGURE_DEPENDS "core/*.c")
+file(GLOB_RECURSE VM_SRC CONFIGURE_DEPENDS "vm/*.c")
+file(GLOB_RECURSE COMPILER_SRC CONFIGURE_DEPENDS "compiler/*.c")
 file(GLOB_RECURSE STD_SRC CONFIGURE_DEPENDS "std/*.c")
-file(GLOB_RECURSE CMD_SRC "cmd/*.c")
+file(GLOB_RECURSE CMD_SRC CONFIGURE_DEPENDS "cmd/*.c")
 
-include_directories(
+set(PICO_INTERNAL_INCLUDE_DIRS
     cmd
     core
     vm
@@ -30,15 +30,22 @@ include_directories(
     vendor/xxhash
 )
 
-add_library(xxhash_lib STATIC vendor/xxhash/xxhash.c)
-target_include_directories(xxhash_lib PUBLIC vendor/xxhash)
+set(PICO_API_SRC
+    api/pico.c
+)
 
-if(NOT WIN32)
-    add_library(linenoise_lib STATIC vendor/linenoise/linenoise.c)
-    target_include_directories(linenoise_lib PUBLIC vendor/linenoise)
-    add_definitions(-DUSE_LINENOISE) 
-else()
-endif()
+set(PICO_VENDOR_SRC
+    vendor/xxhash/xxhash.c
+)
+
+set(PICO_RUNTIME_SRC
+    ${PICO_API_SRC}
+    ${PICO_VENDOR_SRC}
+    ${CORE_SRC}
+    ${VM_SRC}
+    ${COMPILER_SRC}
+    ${STD_SRC}
+)
 
 add_compile_options(
     $<$<CONFIG:Debug>:-g>
@@ -46,41 +53,191 @@ add_compile_options(
     $<$<CONFIG:Release>:-O3>
 )
 
-add_executable(pico 
-    ${CORE_SRC} 
-    ${VM_SRC} 
-    ${COMPILER_SRC} 
-    ${STD_SRC} 
+add_library(picort STATIC
+    ${PICO_RUNTIME_SRC}
+)
+
+target_include_directories(picort
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+    PRIVATE
+        ${PICO_INTERNAL_INCLUDE_DIRS}
+)
+
+set_target_properties(picort PROPERTIES
+    OUTPUT_NAME pico
+)
+
+target_link_libraries(picort
+    PRIVATE
+        m
+)
+
+add_executable(pico
     ${CMD_SRC}
 )
 
-if(WIN32)
-    target_link_libraries(pico PRIVATE xxhash_lib m)
-else()
-    target_link_libraries(pico PRIVATE xxhash_lib linenoise_lib m)
+target_include_directories(pico
+    PRIVATE
+        ${PICO_INTERNAL_INCLUDE_DIRS}
+)
+
+target_link_libraries(pico
+    PRIVATE
+        picort
+)
+
+if(NOT WIN32)
+    add_library(linenoise_lib STATIC
+        vendor/linenoise/linenoise.c
+    )
+
+    target_include_directories(linenoise_lib
+        PUBLIC
+            vendor/linenoise
+    )
+
+    target_compile_definitions(pico
+        PRIVATE
+            USE_LINENOISE
+    )
+
+    target_link_libraries(pico
+        PRIVATE
+            linenoise_lib
+    )
 endif()
 
+add_executable(pico_embed_basic
+    examples/embedding/basic.c
+)
+
+target_link_libraries(pico_embed_basic
+    PRIVATE
+        picort
+)
+
+add_executable(pico_embed_exit_policy
+    tests/embedding_exit_policy.c
+)
+
+target_link_libraries(pico_embed_exit_policy
+    PRIVATE
+        picort
+)
+
+add_executable(pico_embed_native_function
+    tests/embedding_native_function.c
+)
+
+target_link_libraries(pico_embed_native_function
+    PRIVATE
+        picort
+)
+
+add_executable(pico_embed_output_callback
+    tests/embedding_output_callback.c
+)
+
+target_link_libraries(pico_embed_output_callback
+    PRIVATE
+        picort
+)
+
+add_executable(pico_embed_call_script
+    tests/embedding_call_script.c
+)
+
+target_link_libraries(pico_embed_call_script
+    PRIVATE
+        picort
+)
+
 include(CTest)
 
 if(BUILD_TESTING)
+    if(WIN32)
+        find_program(
+            PICO_BASH_EXECUTABLE
+            NAMES bash.exe
+            PATHS
+                "$ENV{ProgramFiles}/Git/bin"
+                "$ENV{ProgramFiles}/Git/usr/bin"
+                "C:/Program Files/Git/bin"
+                "C:/Program Files/Git/usr/bin"
+                "C:/msys64/usr/bin"
+            NO_DEFAULT_PATH
+        )
+    else()
+        find_program(
+            PICO_BASH_EXECUTABLE
+            NAMES bash
+        )
+    endif()
+
+    if(NOT PICO_BASH_EXECUTABLE)
+        message(FATAL_ERROR
+            "Bash was not found. On Windows, install Git for Windows or MSYS2."
+        )
+    endif()
+
     add_test(
         NAME pico_script_tests
-        COMMAND ${CMAKE_COMMAND} -E env
-                "PICO_EXEC=$<TARGET_FILE:pico>"
-                "TIMEOUT_SEC=60"
-                bash run_tests.sh
-        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/tests
+        COMMAND
+            "${PICO_BASH_EXECUTABLE}"
+            "${CMAKE_SOURCE_DIR}/tests/run_tests.sh"
+            "$<TARGET_FILE:pico>"
+            "60"
+        WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}/tests"
+    )
+
+    add_test(
+        NAME pico_embedding_basic
+        COMMAND $<TARGET_FILE:pico_embed_basic>
+    )
+
+    add_test(
+        NAME pico_embedding_exit_policy
+        COMMAND $<TARGET_FILE:pico_embed_exit_policy>
+    )
+
+    add_test(
+        NAME pico_embedding_native_function
+        COMMAND $<TARGET_FILE:pico_embed_native_function>
+    )
+
+    add_test(
+        NAME pico_embedding_call_script
+        COMMAND $<TARGET_FILE:pico_embed_call_script>
+    )
+
+    add_test(
+        NAME pico_embedding_output_callback
+        COMMAND $<TARGET_FILE:pico_embed_output_callback>
     )
 endif()
 
 add_custom_target(check
     COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure
-    DEPENDS pico
+    DEPENDS
+        pico
+        pico_embed_basic
+        pico_embed_exit_policy
+        pico_embed_native_function
+        pico_embed_call_script
+        pico_embed_output_callback
     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
 )
 
-install(TARGETS pico
+install(TARGETS pico picort
     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+)
+
+install(FILES include/pico.h
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
 )
 
 install(FILES README.md manual.md LICENSE gpl-3.0.txt
@@ -89,7 +246,10 @@ install(FILES README.md manual.md LICENSE gpl-3.0.txt
 
 install(DIRECTORY examples/
     DESTINATION ${CMAKE_INSTALL_DOCDIR}/examples
-    FILES_MATCHING PATTERN "*.pcs"
+    FILES_MATCHING
+        PATTERN "*.pcs"
+        PATTERN "*.c"
+        PATTERN "README.md"
 )
 
-message(STATUS "Project 'PiCo' configured to use C Compiler: ${CMAKE_C_COMPILER}")
+message(STATUS "Project 'PiCo' configured to use C Compiler: ${CMAKE_C_COMPILER}")
\ No newline at end of file
diff --git a/README.md b/README.md
index 4ec1a64..e7bcf60 100644
--- a/README.md
+++ b/README.md
@@ -128,6 +128,83 @@ To install system-wide:
 sudo cmake --install build/release
 ```
 
+## Embedding PiCo in C
+
+PiCo can also be used as an embedded scripting VM inside a C program. The host program owns a `PicoVM`, loads PiCo source code, registers native C functions, calls PiCo functions, and can capture script output and runtime errors.
+
+A minimal embedded program looks like this:
+
+```c
+#include <stdio.h>
+#include <pico.h>
+
+int main(void){
+    PicoVM* vm = pico_vm_create();
+
+    if(vm == NULL){
+        return 1;
+    }
+
+    PicoStatus status = pico_vm_eval(vm,
+        "func add(a, b){ return a + b; }\n",
+        "<embedded>"
+    );
+
+    if(status != PICO_STATUS_OK){
+        fprintf(stderr, "%s\n", pico_vm_last_error(vm));
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    PicoValue args[] = {
+        pico_value_number(20),
+        pico_value_number(22)
+    };
+
+    PicoValue result;
+    status = pico_vm_call(vm, "add", 2, args, &result);
+
+    if(status == PICO_STATUS_OK && result.type == PICO_VALUE_NUMBER){
+        printf("%.14g\n", result.as.number);
+    }
+
+    pico_vm_destroy(vm);
+    return status == PICO_STATUS_OK ? 0 : 1;
+}
+```
+
+The third argument of `pico_vm_eval()` is a diagnostic source name. It does not need to be a real file path; names like `"<embedded>"` or `"<plugin>"` are useful for error messages.
+
+The embedding API currently supports these core operations:
+
+- `pico_vm_create()` / `pico_vm_destroy()` for VM lifetime management
+- `pico_vm_eval()` for loading PiCo source code
+- `pico_vm_register_native()` for exposing C functions to PiCo
+- `pico_vm_call()` for calling global PiCo functions from C
+- `pico_vm_set_output()` and `pico_vm_set_error_output()` for capturing `print` output and runtime error output
+- `pico_vm_last_error()` for reading the latest compile or runtime error
+
+More complete examples are in `examples/embedding/`.
+
+### Linking against an installed libpico
+
+After installation, an external C program can include `pico.h` and link against `libpico.a`:
+
+```sh
+gcc main.c -I /path/to/pico/include -L /path/to/pico/lib -lpico -lm -o embed_app
+```
+
+On Windows with MinGW, the command is the same except paths usually point to the local install prefix, for example:
+
+```powershell
+gcc .\main.c `
+    -I .\install-debug\include `
+    -L .\install-debug\lib `
+    -lpico `
+    -lm `
+    -o .\embed_app.exe
+```
+
 ## Testing
 
 Run the test suite with *CTest*:
diff --git a/api/pico.c b/api/pico.c
new file mode 100644
index 0000000..25a6e1e
--- /dev/null
+++ b/api/pico.c
@@ -0,0 +1,475 @@
+#include "pico.h"
+
+#include <stdlib.h>
+#include <limits.h>
+#include <string.h>
+
+#include "global_env.h"
+#include "object.h"
+#include "value.h"
+#include "vm.h"
+
+struct PicoCall{
+    VM* vm;
+    int argCount;
+    Value* args;
+    Value result;
+};
+
+static PicoStatus mapInterpreterStatus(InterpreterStatus status){
+    switch(status){
+        case VM_OK:
+            return PICO_STATUS_OK;
+        case VM_COMPILE_ERROR:
+            return PICO_STATUS_COMPILE_ERROR;
+        case VM_RUNTIME_ERROR:
+            return PICO_STATUS_RUNTIME_ERROR;
+    }
+
+    return PICO_STATUS_RUNTIME_ERROR;
+}
+
+static Value callHostFunc(VM* vm, int argCount, Value* args){
+    Value callee = args[-1];
+    // the callee is stored immediately before the first arg
+
+    if(!IS_CFUNC(callee)){
+        runtimeError(vm, "Invalid host function call.");
+        return NULL_VAL;
+    }
+
+    ObjectCFunc* func = AS_CFUNC_OBJECT(callee);
+
+    if(func->hostFunc == NULL){
+        runtimeError(vm, "Host function callback is not available.");
+        return NULL_VAL;
+    }
+
+    PicoCall call = {
+        .vm = vm,
+        .argCount = argCount,
+        .args = args,
+        .result = NULL_VAL
+    };
+
+    func->hostFunc(&call, func->userData);
+
+    return call.result;
+}
+
+static bool isValidArgIndex(const PicoCall* call, int index){
+    return call != NULL && index >= 0 && index < call->argCount;
+}
+
+static void setCallResult(PicoCall* call, Value value){
+    if(call == NULL){
+        return;
+    }
+
+    call->result = value;
+}
+
+static bool toInternalValue(const PicoValue* publicValue, Value* internalValue){
+    if(publicValue == NULL || internalValue == NULL){
+        return false;
+    }
+
+    switch(publicValue->type){
+        case PICO_VALUE_NULL:
+            *internalValue = NULL_VAL;
+            return true;
+        case PICO_VALUE_BOOL:
+            *internalValue = BOOL_VAL(publicValue->as.boolean);
+            return true;
+        case PICO_VALUE_NUMBER:
+            *internalValue = NUM_VAL(publicValue->as.number);
+            return true;
+        case PICO_VALUE_STRING:
+        case PICO_VALUE_OTHER:
+        default:
+            return false;
+    }
+
+    return false;
+}
+
+static bool fromInternalValue(Value internalValue, PicoValue* publicValue){
+    if(publicValue == NULL){
+        return false;
+    }
+
+    if(IS_NULL(internalValue)){
+        *publicValue = pico_value_null();
+        return true;
+    }
+
+    if(IS_BOOL(internalValue)){
+        *publicValue = pico_value_bool(AS_BOOL(internalValue));
+        return true;
+    }
+
+    if(IS_NUM(internalValue)){
+        *publicValue = pico_value_number(AS_NUM(internalValue));
+        return true;
+    }
+
+    publicValue->type = PICO_VALUE_OTHER;
+    return false;
+}
+
+static PicoStatus setApiError(PicoVM* vm, PicoStatus status, const char* message){
+    if(vm != NULL && message != NULL){
+        snprintf(vm->lastError, sizeof(vm->lastError), "%s", message);
+    }
+
+    return status;
+}
+
+PicoValue pico_value_null(void){
+    PicoValue value = {
+        .type = PICO_VALUE_NULL
+    };
+
+    return value;
+}
+
+PicoValue pico_value_bool(bool value){
+    PicoValue result = {
+        .type = PICO_VALUE_BOOL,
+        .as.boolean = value
+    };
+
+    return result;
+}
+
+PicoValue pico_value_number(double value){
+    PicoValue result = {
+        .type = PICO_VALUE_NUMBER,
+        .as.number = value
+    };
+
+    return result;
+}
+
+PicoVM* pico_vm_create(void){
+    PicoVM* vm = malloc(sizeof(*vm));
+
+    if(vm == NULL){
+        return NULL;
+    }
+
+    initVM(vm, 0, NULL);
+
+    /*
+     * A script embedded must not be allowed to terminate host process through os.exit().
+     * This overrides the initialization of initVM().
+    */
+
+    vm->allowProcessExit = false;
+
+    return vm;
+}
+
+void pico_vm_destroy(PicoVM* vm){
+    if(vm == NULL){
+        return;
+    }
+
+    freeVM(vm);
+    free(vm);
+}
+
+PicoStatus pico_vm_eval(
+    PicoVM* vm,
+    const char* source,
+    const char* source_name
+){
+    if(vm == NULL || source == NULL){
+        return PICO_STATUS_INVALID_ARGUMENT;
+    }
+
+    if(source_name == NULL){
+        source_name = "<embedded>";
+    }
+
+    InterpreterStatus status = interpret(vm, source, source_name);
+    return mapInterpreterStatus(status);
+}
+
+int pico_call_arg_count(const PicoCall* call){
+    if(call == NULL){
+        return 0;
+    }
+
+    return call->argCount;
+}
+
+void pico_vm_set_output(PicoVM* vm, PicoWriteFunc func, void* userData){
+    if(vm == NULL){
+        return;
+    }
+
+    vm->output.write = func;
+    vm->output.userData = userData;
+}
+
+void pico_vm_set_error_output(PicoVM* vm, PicoWriteFunc func, void* userData){
+    if(vm == NULL){
+        return;
+    }
+
+    vm->errOutput.write = func;
+    vm->errOutput.userData = userData;
+}
+
+PicoValueType pico_call_arg_type(const PicoCall* call, int index){
+    if(!isValidArgIndex(call, index)){
+        return PICO_VALUE_OTHER;
+    }
+
+    Value value = call->args[index];
+
+    if(IS_NULL(value)){
+        return PICO_VALUE_NULL;
+    }
+
+    if(IS_BOOL(value)){
+        return PICO_VALUE_BOOL;
+    }
+
+    if(IS_NUM(value)){
+        return PICO_VALUE_NUMBER;
+    }
+
+    if(IS_STRING(value)){
+        return PICO_VALUE_STRING;
+    }
+
+    return PICO_VALUE_OTHER;
+}
+
+bool pico_call_get_bool(const PicoCall* call, int index, bool* result){
+    if(result == NULL || !isValidArgIndex(call, index)){
+        return false;
+    }
+
+    Value value = call->args[index];
+
+    if(!IS_BOOL(value)){
+        return false;
+    }
+
+    *result = AS_BOOL(value);
+    return true;
+}
+
+bool pico_call_get_number(const PicoCall* call, int index, double* result){
+    if(result == NULL || !isValidArgIndex(call, index)){
+        return false;
+    }
+
+    Value value = call->args[index];
+
+    if(!IS_NUM(value)){
+        return false;
+    }
+
+    *result = AS_NUM(value);
+    return true;
+}
+
+const char* pico_call_get_string(const PicoCall* call, int index, size_t* length){
+    if(!isValidArgIndex(call, index)){
+        return NULL;
+    }
+
+    Value value = call->args[index];
+
+    if(!IS_STRING(value)){
+        return NULL;
+    }
+
+    ObjectString* string = AS_STRING(value);
+
+    if(length != NULL){
+        *length = string->length;
+    }
+
+    return string->chars;
+}
+
+void pico_call_return_null(PicoCall* call){
+    setCallResult(call, NULL_VAL);
+}
+
+void pico_call_return_bool(PicoCall* call, bool value){
+    setCallResult(call, BOOL_VAL(value));
+}
+
+void pico_call_return_number(PicoCall* call, double value){
+    setCallResult(call, NUM_VAL(value));
+}
+
+void pico_call_return_string(PicoCall* call, const char* value, size_t length){
+    if(call == NULL){
+        return;
+    }
+
+    if(value == NULL){
+        pico_call_error(call, "Host function returned a null string pointer.");
+        return;
+    }
+
+    if(length > INT_MAX){
+        pico_call_error(call, "Host function returned a string that is too large.");
+        return;
+    }
+
+    ObjectString* string = copyString(call->vm, value, (int)length);
+
+    setCallResult(call, OBJECT_VAL(string));
+}
+
+void pico_call_error(PicoCall* call, const char* message){
+    if(call == NULL){
+        return;
+    }
+
+    if(message == NULL){
+        message = "Host function failed.";
+    }
+
+    runtimeError(call->vm, "%s", message);
+
+    setCallResult(call, NULL_VAL);
+}
+
+PicoStatus pico_vm_register_native(PicoVM* vm, const char* name, PicoNativeFunc function, void* user_data){
+    if(vm == NULL || name == NULL || name[0] == '\0' || function == NULL){
+        return PICO_STATUS_INVALID_ARGUMENT;
+    }
+
+    ObjectString* key = copyString(vm, name, (int)strlen(name));
+
+    //Root the key while the function object and global table may allocate.
+    push(vm, OBJECT_VAL(key));
+
+    ObjectCFunc* native = newHostCFunc(vm, callHostFunc, function, user_data);
+
+    push(vm, OBJECT_VAL(native));
+
+    bool success = globalSetName(vm, &vm->globals, key, OBJECT_VAL(native));
+
+    pop(vm);
+    pop(vm);
+
+    if(!success){
+        return PICO_STATUS_RUNTIME_ERROR;
+    }
+
+    return PICO_STATUS_OK;
+}
+
+PicoStatus pico_vm_call(
+    PicoVM* vm, 
+    const char* name, 
+    int argCount,
+    const PicoValue* args, 
+    PicoValue* result
+){
+    if(vm == NULL || name == NULL || name[0] == '\0' || argCount < 0){
+        return PICO_STATUS_INVALID_ARGUMENT;
+    }
+
+    if(argCount > 0 && args == NULL){
+        return PICO_STATUS_INVALID_ARGUMENT;
+    }
+
+    if(vm->frameCount != 0){
+        return setApiError(vm, PICO_STATUS_RUNTIME_ERROR, "PiCo VM calls are not reentrant.");
+    }
+
+    size_t nameLength = strlen(name);
+
+    if(nameLength > INT_MAX){
+        return setApiError(vm, PICO_STATUS_INVALID_ARGUMENT, "PiCo function name is too long.");
+    }
+
+    vm->lastError[0] = '\0';
+
+    ObjectString* key = copyString(vm, name, (int)nameLength);
+    push(vm, OBJECT_VAL(key));
+
+    Value callee;
+    bool found = globalGetName(&vm->globals, key, &callee);
+
+    pop(vm);
+
+    if(!found){
+        snprintf(vm->lastError, sizeof(vm->lastError), "Global function '%s' is not defined.", name);
+        return PICO_STATUS_RUNTIME_ERROR;
+    }
+
+    Value* internalArgs = NULL;
+
+    if(argCount > 0){
+        internalArgs = malloc(sizeof(Value) * (size_t)argCount);
+
+        if(internalArgs == NULL){
+            return setApiError(vm, PICO_STATUS_OUT_OF_MEMORY, "Could not allocate PiCo call arguments.");
+        }
+    }
+
+    for(int i = 0; i < argCount; i++){
+        if(!toInternalValue(&args[i], &internalArgs[i])){
+            free(internalArgs);
+            return setApiError(vm, PICO_STATUS_UNSUPPORTED_TYPE, "Arguments contain unsupported value types.");
+        }
+    }
+
+    Value internalResult = NULL_VAL;
+    InterpreterStatus status = vmCallValue(vm, callee, argCount, internalArgs, &internalResult);
+
+    free(internalArgs);
+
+    if(status != VM_OK){
+        return mapInterpreterStatus(status);
+    }
+
+    if(result == NULL){
+        return PICO_STATUS_OK;
+    }
+
+    if(!fromInternalValue(internalResult, result)){
+        return setApiError(vm, PICO_STATUS_UNSUPPORTED_TYPE, "PiCo function returned an unsupported value type.");
+    }
+
+    return PICO_STATUS_OK;
+}
+
+const char* pico_vm_last_error(const PicoVM* vm){
+    if(vm == NULL || vm->lastError[0] == '\0'){
+        return NULL;
+    }
+
+    return vm->lastError;
+}
+
+const char* pico_status_string(PicoStatus status){
+    switch(status){
+        case PICO_STATUS_OK:
+            return "OK";
+        case PICO_STATUS_COMPILE_ERROR:
+            return "compile error";
+        case PICO_STATUS_RUNTIME_ERROR:
+            return "runtime error";
+        case PICO_STATUS_INVALID_ARGUMENT:
+            return "invalid argument";
+        case PICO_STATUS_OUT_OF_MEMORY:
+            return "out of memory";
+        case PICO_STATUS_UNSUPPORTED_TYPE:
+            return "unsupported type";
+    }
+
+    return "unknown status";
+}
\ No newline at end of file
diff --git a/core/object.c b/core/object.c
index 6a692a5..b9341a3 100644
--- a/core/object.c
+++ b/core/object.c
@@ -174,18 +174,26 @@ ObjectFunc* newFunction(VM* vm){
     return func;
 }
 
-ObjectCFunc* newCFunc(VM* vm, CFunc func){
+ObjectCFunc* newHostCFunc(VM* vm, CFunc adapter, HostCFunc hostFunc, void* userData){
     ObjectCFunc* cfunc = (ObjectCFunc*)reallocate(vm, NULL, 0, sizeof(ObjectCFunc));
+
     cfunc->obj.type = OBJECT_CFUNC;
     cfunc->obj.isMarked = false;
-    cfunc->func = func;
-    cfunc->obj.isMarked = false;
+
+    cfunc->func = adapter;
+    cfunc->hostFunc = hostFunc;
+    cfunc->userData = userData;
 
     cfunc->obj.next = vm->objects;
     vm->objects = (Object*)cfunc;
+
     return cfunc;
 }
 
+ObjectCFunc* newCFunc(VM* vm, CFunc func){
+    return newHostCFunc(vm, func, NULL, NULL);
+}
+
 ObjectModule* newModule(VM* vm, ObjectString* name, ObjectString* path, ModuleKind kind){
     ObjectModule* module = (ObjectModule*)reallocate(vm, NULL, 0, sizeof(ObjectModule));
     module->obj.type = OBJECT_MODULE;
@@ -391,66 +399,88 @@ void freeObjects(VM* vm){
     }
 }
 
-void printObject(Value value){
+void objectWrite(Value value, Writer* writer){
     switch(OBJECT_TYPE(value)){
         case OBJECT_STRING:
-            printf("%s", AS_CSTRING(value));
+            writerW(writer, AS_STRING(value)->chars, (size_t)AS_STRING(value)->length);
             break;
-        case OBJECT_LIST:
-        {
+
+        case OBJECT_LIST:{
             ObjectList* list = AS_LIST(value);
-            printf("[");
+
+            writerWCString(writer, "[");
+
             for(int i = 0; i < list->count; i++){
-                printValue(list->items[i]);
-                if(i < list->count - 1) printf(", ");
+                valueWrite(list->items[i], writer);
+
+                if(i < list->count - 1){
+                    writerWCString(writer, ", ");
+                }
             }
-            printf("]");
+
+            writerWCString(writer, "]");
             break;
         }
+
         case OBJECT_MAP:
-            printf("{map}");
+            writerWCString(writer, "{map}");
             break;
+
         case OBJECT_FUNC:
-            if(AS_FUNC(value)->name == NULL)
-                printf("<script>");
-            else
-                printf("<fn %s>", AS_FUNC(value)->name->chars);
+            if(AS_FUNC(value)->name == NULL){
+                writerWCString(writer, "<script>");
+            }else{
+                writerWFormat(writer, "<fn %s>", AS_FUNC(value)->name->chars);
+            }
             break;
+
         case OBJECT_CFUNC:
-            printf("<cfunc>");
+            writerWCString(writer, "<cfunc>");
             break;
+
         case OBJECT_MODULE:
-            printf("<module '%s'>", AS_MODULE(value)->name->chars);
+            writerWFormat(writer, "<module '%s'>", AS_MODULE(value)->name->chars);
             break;
+
         case OBJECT_CLOSURE:
-            if(AS_CLOSURE(value)->func->name == NULL)
-                printf("<script>");
-            else
-                printf("<fn %s>", AS_CLOSURE(value)->func->name->chars);
+            if(AS_CLOSURE(value)->func->name == NULL){
+                writerWCString(writer, "<script>");
+            }else{
+                writerWFormat(writer, "<fn %s>", AS_CLOSURE(value)->func->name->chars);
+            }
             break;
+
         case OBJECT_UPVALUE:
-            printf("<upvalue>");
+            writerWCString(writer, "<upvalue>");
             break;
+
         case OBJECT_CLASS:
-            printf("<class %s>", AS_CLASS(value)->name->chars);
+            writerWFormat(writer, "<class %s>", AS_CLASS(value)->name->chars);
             break;
+
         case OBJECT_INSTANCE:
-            printf("<instance of %s>", AS_INSTANCE(value)->klass->name->chars);
+            writerWFormat(writer, "<instance of %s>", AS_INSTANCE(value)->klass->name->chars);
             break;
-        case OBJECT_BOUND_METHOD:
+
+        case OBJECT_BOUND_METHOD:{
             ObjectBoundMethod* bound = AS_BOUND_METHOD(value);
+
             if(bound->method->type == OBJECT_CLOSURE){
                 ObjectClosure* closure = (ObjectClosure*)bound->method;
-                printf("<bound method %s>", closure->func->name->chars);
+                writerWFormat(writer, "<bound method %s>", closure->func->name->chars);
             }else{
-                printf("<bound native method>");
+                writerWCString(writer, "<bound native method>");
             }
+
             break;
+        }
+
         case OBJECT_FILE:
-            printf("<file '%s'>", AS_FILE(value)->isOpen ? "open" : "closed");
+            writerWFormat(writer, "<file '%s'>", AS_FILE(value)->isOpen ? "open" : "closed");
             break;
+
         case OBJECT_ITERATOR:
-            printf("<iterator>");
+            writerWCString(writer, "<iterator>");
             break;
     }
 }
\ No newline at end of file
diff --git a/core/object.h b/core/object.h
index ad44b43..0dc27df 100644
--- a/core/object.h
+++ b/core/object.h
@@ -7,11 +7,16 @@
 #include "chunk.h"
 #include "hashtable.h"
 #include "global_env.h"
+#include "writer.h"
 
 typedef struct VM VM;
 
 typedef Value (*CFunc)(VM* vm, int argCount, Value* args);
 
+typedef struct PicoCall PicoCall;
+
+typedef void (*HostCFunc)(PicoCall* call, void* userData);
+
 #define OBJECT_TYPE(value)  (AS_OBJECT(value)->type)
 
 #define IS_STRING(value)        (IS_OBJECT(value) && OBJECT_TYPE(value) == OBJECT_STRING)
@@ -28,6 +33,7 @@ typedef Value (*CFunc)(VM* vm, int argCount, Value* args);
 #define AS_FUNC(value)          ((ObjectFunc*)AS_OBJECT(value))
 
 #define IS_CFUNC(value)         (IS_OBJECT(value) && OBJECT_TYPE(value) == OBJECT_CFUNC)
+#define AS_CFUNC_OBJECT(value)  ((ObjectCFunc*)AS_OBJECT(value))
 #define AS_CFUNC(value)         (((ObjectCFunc*)AS_OBJECT(value))->func)
 
 #define IS_MODULE(value)        (IS_OBJECT(value) && OBJECT_TYPE(value) == OBJECT_MODULE)
@@ -129,10 +135,14 @@ ObjectFunc* newFunction(VM* vm);
 typedef struct ObjectCFunc{
     Object obj;
     CFunc func;
+    HostCFunc hostFunc;
+    void* userData;
 }ObjectCFunc;
 
 ObjectCFunc* newCFunc(VM* vm, CFunc func);
 
+ObjectCFunc* newHostCFunc(VM* vm, CFunc adapter, HostCFunc hostFunc, void* userData);
+
 typedef enum{
     MODULE_NATIVE,
     MODULE_SCRIPT
@@ -219,6 +229,8 @@ typedef struct ObjectIterator{
 
 ObjectIterator* newIterator(VM* vm, Value receiver);
 
+void objectWrite(Value value, Writer* writer);
+
 void freeObject(VM* vm, Object* object);
 void freeObjects(VM* vm);
 
diff --git a/core/value.c b/core/value.c
index d9760e4..2c4425e 100644
--- a/core/value.c
+++ b/core/value.c
@@ -143,17 +143,19 @@ void freeValueArray(VM* vm, ValueArray* array){
     initValueArray(array);
 }
 
-void printValue(Value value){
+void valueWrite(Value value, Writer* writer){
     if(IS_NULL(value)){
-        printf("null");
+        writerWCString(writer, "null");
     }else if(IS_BOOL(value)){
-        printf(AS_BOOL(value) ? "true" : "false");
+        writerWCString(writer, AS_BOOL(value) ? "true" : "false");
     }else if(IS_NUM(value)){
-        printf("%.14g", AS_NUM(value));
+        char buffer[32];
+        int length = numToString(AS_NUM(value), buffer, sizeof(buffer));
+        writerW(writer, buffer, (size_t)length);
     }else if(IS_OBJECT(value)){
-        printObject(value);
+        objectWrite(value, writer);
     }else{
-        printf("Unknown value type");
+        writerWCString(writer, "Unknown value type");
     }
 }
 
diff --git a/core/value.h b/core/value.h
index 1211c0d..46860a1 100644
--- a/core/value.h
+++ b/core/value.h
@@ -4,6 +4,7 @@
 #include <string.h>
 
 #include "common.h"
+#include "writer.h"
 
 typedef struct Object Object;
 typedef struct ObjectString ObjectString;
@@ -64,12 +65,11 @@ typedef struct{
 void initValueArray(ValueArray* array);
 void writeValueArray(VM* vm, ValueArray* array, Value value);
 void freeValueArray(VM* vm, ValueArray* array);
-void printValue(Value value);
 
 char* valueToString(Value value);
 ObjectString* toString(VM* vm, Value value);
 
-void printObject(Value value);
+void valueWrite(Value value, Writer* writer);
 
 ValueType getValueType(Value value);
 bool isEqual(Value a, Value b);
diff --git a/core/writer.c b/core/writer.c
new file mode 100644
index 0000000..bb865e4
--- /dev/null
+++ b/core/writer.c
@@ -0,0 +1,44 @@
+#include "writer.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+
+void writerW(Writer* writer, const char* text, size_t length){
+    if(writer == NULL || writer->write == NULL || text == NULL || length == 0){
+        return;
+    }
+
+    writer->write(text, length, writer->userData);
+}
+
+void writerWCString(Writer* writer, const char* text){
+    if(text == NULL){
+        return;
+    }
+
+    writerW(writer, text, strlen(text));
+}
+
+void writerWFormat(Writer* writer, const char* format, ...){
+    if(writer == NULL || writer->write == NULL || format == NULL){
+        return;
+    }
+
+    char buffer[256];
+
+    va_list args;
+    va_start(args, format);
+    int length = vsnprintf(buffer, sizeof(buffer), format, args);
+    va_end(args);
+
+    if(length < 0){
+        return;
+    }
+
+    if((size_t)length >= sizeof(buffer)){
+        length = (int)sizeof(buffer) - 1;
+    }
+
+    writerW(writer, buffer, (size_t)length);
+}
\ No newline at end of file
diff --git a/core/writer.h b/core/writer.h
new file mode 100644
index 0000000..3b3a745
--- /dev/null
+++ b/core/writer.h
@@ -0,0 +1,17 @@
+#ifndef PICO_WRITER_H
+#define PICO_WRITER_H
+
+#include <stddef.h>
+
+typedef void (*WriterFunc)(const char* text, size_t length, void* userData);
+
+typedef struct Writer{
+    WriterFunc write;
+    void* userData;
+} Writer;
+
+void writerW(Writer* writer, const char* text, size_t length);
+void writerWCString(Writer* writer, const char* text);
+void writerWFormat(Writer* writer, const char* format, ...);
+
+#endif // PICO_WRITER_H
\ No newline at end of file
diff --git a/examples/embedding/README.md b/examples/embedding/README.md
new file mode 100644
index 0000000..a9683c4
--- /dev/null
+++ b/examples/embedding/README.md
@@ -0,0 +1,70 @@
+# Embedding examples
+
+These examples show how to use PiCo as an embedded scripting VM from C.
+
+- `basic.c`: create a VM and evaluate PiCo source code.
+- `native_function.c`: expose a C function to PiCo.
+- `call_script.c`: call a PiCo function from C and let the PiCo function call back into C.
+
+## `basic.c`
+
+Creates a VM, evaluates a PiCo source string, and destroys the VM.
+
+```sh
+cmake --build --preset debug --target pico_embed_basic
+./build/debug/pico_embed_basic
+```
+
+## `native_function.c`
+
+Registers a C function and calls it from PiCo.
+
+```c
+pico_vm_register_native(vm, "hostAdd", hostAdd, NULL);
+```
+
+PiCo can then call it as a normal function:
+
+```javascript
+print hostAdd(20, 22);
+```
+
+## `call_script.c`
+
+Loads a PiCo function and calls it from C. The PiCo function calls back into a native C function.
+
+This demonstrates the full embedding loop:
+
+```text
+C -> PiCo -> C -> PiCo -> C
+```
+
+## `external-cmake/`
+
+A minimal standalone CMake project that links against an installed `libpico.a`.
+
+After installing PiCo into a local prefix, configure it with:
+
+```sh
+cmake -S examples/embedding/external-cmake -B build/external-pico -DPICO_ROOT=/path/to/pico/install
+cmake --build build/external-pico
+```
+
+On Windows PowerShell, for a local debug install:
+
+```powershell
+cmake -S .\examples\embedding\external-cmake -B .\build\external-pico -DPICO_ROOT="$PWD\install-debug"
+cmake --build .\build\external-pico
+.\build\external-pico\embed_app.exe
+```
+
+## Source names
+
+The third argument of `pico_vm_eval()` is a diagnostic name:
+
+```c
+pico_vm_eval(vm, source, "<script>");
+```
+
+It does not need to be a real file. It is used in error messages.
+
diff --git a/examples/embedding/basic.c b/examples/embedding/basic.c
new file mode 100644
index 0000000..0a43d1d
--- /dev/null
+++ b/examples/embedding/basic.c
@@ -0,0 +1,28 @@
+#include <stdio.h>
+
+#include <pico.h>
+
+int main(void){
+    PicoVM* vm = pico_vm_create();
+
+    if(vm == NULL){
+        fprintf(stderr, "Could not create PiCo VM.\n");
+        return 1;
+    }
+
+    PicoStatus status = pico_vm_eval(vm,
+        "var name = \"PiCo\";\n"
+        "print \"Hello from ${name}!\";\n",
+        "<basic>"
+    );
+
+    if(status != PICO_STATUS_OK){
+        const char* error = pico_vm_last_error(vm);
+        fprintf(stderr, "%s\n", error != NULL ? error : pico_status_string(status));
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    pico_vm_destroy(vm);
+    return 0;
+}
diff --git a/examples/embedding/call_script.c b/examples/embedding/call_script.c
new file mode 100644
index 0000000..3186ae4
--- /dev/null
+++ b/examples/embedding/call_script.c
@@ -0,0 +1,62 @@
+#include <stdio.h>
+
+#include <pico.h>
+
+static void hostAdd(PicoCall* call, void* userData){
+    (void)userData;
+
+    double left;
+    double right;
+
+    if(!pico_call_get_number(call, 0, &left) || !pico_call_get_number(call, 1, &right)){
+        pico_call_error(call, "hostAdd() expects two numbers.");
+        return;
+    }
+
+    pico_call_return_number(call, left + right);
+}
+
+int main(void){
+    PicoVM* vm = pico_vm_create();
+
+    if(vm == NULL){
+        fprintf(stderr, "Could not create PiCo VM.\n");
+        return 1;
+    }
+
+    pico_vm_register_native(vm, "hostAdd", hostAdd, NULL);
+
+    const char* source =
+        "func calculate(a, b){\n"
+        "    return hostAdd(a, b) * 2;\n"
+        "}\n";
+
+    PicoStatus status = pico_vm_eval(vm, source, "<call_script>");
+
+    if(status != PICO_STATUS_OK){
+        const char* error = pico_vm_last_error(vm);
+        fprintf(stderr, "%s\n", error != NULL ? error : pico_status_string(status));
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    PicoValue args[] = {
+        pico_value_number(10),
+        pico_value_number(11)
+    };
+
+    PicoValue result;
+    status = pico_vm_call(vm, "calculate", 2, args, &result);
+
+    if(status != PICO_STATUS_OK){
+        const char* error = pico_vm_last_error(vm);
+        fprintf(stderr, "%s\n", error != NULL ? error : pico_status_string(status));
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    printf("Result: %.14g\n", result.as.number);
+
+    pico_vm_destroy(vm);
+    return 0;
+}
diff --git a/examples/embedding/external-cmake/CMakeLists.txt b/examples/embedding/external-cmake/CMakeLists.txt
new file mode 100644
index 0000000..58dbb4a
--- /dev/null
+++ b/examples/embedding/external-cmake/CMakeLists.txt
@@ -0,0 +1,28 @@
+cmake_minimum_required(VERSION 3.21)
+
+project(pico_embed_app LANGUAGES C)
+
+include(GNUInstallDirs)
+
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+
+set(PICO_ROOT "" CACHE PATH "Path to the PiCo install prefix")
+
+if(PICO_ROOT STREQUAL "")
+    message(FATAL_ERROR "Set PICO_ROOT to the PiCo install prefix, for example -DPICO_ROOT=/path/to/install")
+endif()
+
+add_library(pico STATIC IMPORTED)
+
+set_target_properties(pico PROPERTIES
+    IMPORTED_LOCATION "${PICO_ROOT}/${CMAKE_INSTALL_LIBDIR}/libpico.a"
+    INTERFACE_INCLUDE_DIRECTORIES "${PICO_ROOT}/${CMAKE_INSTALL_INCLUDEDIR}"
+)
+
+add_executable(embed_app main.c)
+target_link_libraries(embed_app PRIVATE pico)
+
+if(UNIX OR MINGW)
+    target_link_libraries(embed_app PRIVATE m)
+endif()
diff --git a/examples/embedding/external-cmake/main.c b/examples/embedding/external-cmake/main.c
new file mode 100644
index 0000000..c16811b
--- /dev/null
+++ b/examples/embedding/external-cmake/main.c
@@ -0,0 +1,59 @@
+#include <stdio.h>
+
+#include <pico.h>
+
+static void hostAdd(PicoCall* call, void* userData){
+    (void)userData;
+
+    double left;
+    double right;
+
+    if(!pico_call_get_number(call, 0, &left) || !pico_call_get_number(call, 1, &right)){
+        pico_call_error(call, "hostAdd() expects two numbers.");
+        return;
+    }
+
+    pico_call_return_number(call, left + right);
+}
+
+int main(void){
+    PicoVM* vm = pico_vm_create();
+
+    if(vm == NULL){
+        return 1;
+    }
+
+    pico_vm_register_native(vm, "hostAdd", hostAdd, NULL);
+
+    const char* source =
+        "func calculate(a, b){\n"
+        "    return hostAdd(a, b) * 2;\n"
+        "}\n";
+
+    PicoStatus status = pico_vm_eval(vm, source, "<external_cmake>");
+
+    if(status != PICO_STATUS_OK){
+        fprintf(stderr, "%s\n", pico_vm_last_error(vm));
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    PicoValue args[] = {
+        pico_value_number(10),
+        pico_value_number(11)
+    };
+
+    PicoValue result;
+    status = pico_vm_call(vm, "calculate", 2, args, &result);
+
+    if(status != PICO_STATUS_OK){
+        fprintf(stderr, "%s\n", pico_vm_last_error(vm));
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    printf("Result: %.14g\n", result.as.number);
+
+    pico_vm_destroy(vm);
+    return 0;
+}
diff --git a/examples/embedding/native_function.c b/examples/embedding/native_function.c
new file mode 100644
index 0000000..d7a5d23
--- /dev/null
+++ b/examples/embedding/native_function.c
@@ -0,0 +1,44 @@
+#include <stdio.h>
+
+#include <pico.h>
+
+static void hostAdd(PicoCall* call, void* userData){
+    (void)userData;
+
+    double left;
+    double right;
+
+    if(!pico_call_get_number(call, 0, &left) || !pico_call_get_number(call, 1, &right)){
+        pico_call_error(call, "hostAdd() expects two numbers.");
+        return;
+    }
+
+    pico_call_return_number(call, left + right);
+}
+
+int main(void){
+    PicoVM* vm = pico_vm_create();
+
+    if(vm == NULL){
+        fprintf(stderr, "Could not create PiCo VM.\n");
+        return 1;
+    }
+
+    pico_vm_register_native(vm, "hostAdd", hostAdd, NULL);
+
+    PicoStatus status = pico_vm_eval(vm,
+        "var result = hostAdd(20, 22);\n"
+        "print result;\n",
+        "<native_function>"
+    );
+
+    if(status != PICO_STATUS_OK){
+        const char* error = pico_vm_last_error(vm);
+        fprintf(stderr, "%s\n", error != NULL ? error : pico_status_string(status));
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    pico_vm_destroy(vm);
+    return 0;
+}
diff --git a/include/pico.h b/include/pico.h
new file mode 100644
index 0000000..9847618
--- /dev/null
+++ b/include/pico.h
@@ -0,0 +1,188 @@
+#ifndef PICO_H
+#define PICO_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+/*
+ * Public opaque handle for a PiCo
+*/
+
+typedef struct VM PicoVM;
+
+typedef struct PicoCall PicoCall;
+
+typedef enum PicoValueType{
+    PICO_VALUE_NULL = 0,
+    PICO_VALUE_BOOL,
+    PICO_VALUE_NUMBER,
+    PICO_VALUE_STRING,
+    PICO_VALUE_OTHER
+} PicoValueType;
+
+typedef struct PicoValue{
+    PicoValueType type;
+
+    union{
+        bool boolean;
+        double number;
+    }as;
+} PicoValue;
+
+typedef void (*PicoWriteFunc)(const char* text, size_t length, void* userData);
+typedef void (*PicoNativeFunc)(PicoCall* call, void* userData);
+
+/*
+ * Result of a public PiCo API operation
+*/
+
+typedef enum PicoStatus{
+    PICO_STATUS_OK = 0,
+    PICO_STATUS_COMPILE_ERROR,
+    PICO_STATUS_RUNTIME_ERROR,
+    PICO_STATUS_INVALID_ARGUMENT,
+    PICO_STATUS_OUT_OF_MEMORY,
+    PICO_STATUS_UNSUPPORTED_TYPE
+} PicoStatus;
+
+PicoValue pico_value_null(void);
+PicoValue pico_value_bool(bool value);
+PicoValue pico_value_number(double value);
+
+/*
+ * Creates a new PiCo virtual machine.
+ * The VM is created without script command-line arguments.
+ * Returns NULL when storage for the VM cannot be allocated.
+*/
+
+PicoVM* pico_vm_create(void);
+
+/*
+ * Destroys a VM created by pico_vm_create().
+ * Passing NULL is allowed and has no effect.
+*/
+void pico_vm_destroy(PicoVM* vm);
+
+/*
+ * Compiles and executes a null-terminated PiCo source string.
+ * source_name is used in diagnostics. It may be NULL, in which case "<embedded>" is used.
+*/
+PicoStatus pico_vm_eval(
+    PicoVM* vm,
+    const char* source,
+    const char* source_name
+);
+
+/*
+ * Sets the output function for the VM.
+ * The userData pointer is passed to the output function.
+*/
+void pico_vm_set_output(PicoVM* vm, PicoWriteFunc func, void* userData);
+
+/*
+ * Sets the error output function for the VM.
+ * The userData pointer is passed to the error output function.
+*/
+void pico_vm_set_error_output(PicoVM* vm, PicoWriteFunc func, void* userData);
+
+/*
+ * Registers a host-provided native function as a PiCo global.
+ * The user_data pointer is borrowed. PiCo does not free it, so it must remain valid
+ * Register native functions before evaluating scripts that use them.
+*/
+PicoStatus pico_vm_register_native(
+    PicoVM* vm,
+    const char* name,
+    PicoNativeFunc function,
+    void* user_data
+);
+
+/*
+ * Calls a global PiCo function.
+ * result may be NULL if the caller does not need the return value.
+*/
+PicoStatus pico_vm_call(
+    PicoVM* vm, 
+    const char* name, 
+    int argCount,
+    const PicoValue* args, 
+    PicoValue* result
+);
+
+/*
+ * Returns the number of arguments passed by the PiCo script.
+*/
+int pico_call_arg_count(const PicoCall* call);
+
+/*
+ * Returns the public type of an argument.
+ * Invalid indexes return PICO_VALUE_OTHER.
+*/
+PicoValueType pico_call_arg_type(const PicoCall* call, int index);
+
+bool pico_call_get_bool(
+    const PicoCall* call,
+    int index,
+    bool* result
+);
+
+bool pico_call_get_number(
+    const PicoCall* call,
+    int index,
+    double* result
+);
+
+/*
+ * Returns a borrowed string pointer.
+ * The returned pointer belongs to the VM and must not be freed.
+ * It is valid only during the native function call.
+*/
+const char* pico_call_get_string(
+    const PicoCall* call,
+    int index,
+    size_t* length
+);
+
+void pico_call_return_null(PicoCall* call);
+
+void pico_call_return_bool(PicoCall* call, bool value);
+
+void pico_call_return_number(PicoCall* call, double value);
+
+/*
+ * Copies the supplied string into the PiCo VM.
+*/
+void pico_call_return_string(
+    PicoCall* call,
+    const char* value,
+    size_t length
+);
+
+/*
+ * Stops the current PiCo call with a runtime error.
+ */
+void pico_call_error(PicoCall* call, const char* message);
+
+/*
+ * Returns the most recent compilation or runtime error message.
+ * Returns NULL if vm is NULL or no error message is currently available.
+ * The returned pointer is owned by the VM and must not be freed.
+ * It remains valid until the next pico_vm_eval() call or until the VM is destroyed.
+*/
+const char* pico_vm_last_error(const PicoVM* vm);
+
+/*
+ * Returns a static human-readable name for a status value.
+ * The returned string must not be freed.
+*/
+const char* pico_status_string(PicoStatus status);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
\ No newline at end of file
diff --git a/manual.md b/manual.md
index 67c3956..f398ac9 100644
--- a/manual.md
+++ b/manual.md
@@ -16,7 +16,7 @@ PiCo supports two types of comments:
 
 Examples:
 
-```
+```javascript
 # This is a single-line comment
 
 #{ 
@@ -45,13 +45,13 @@ PiCo is dynamically typed. It supports the following fundamental types:
 
 ### Strings and Interpolation
 
-Strings are enclosed in double quotes `"`. 
+Strings are enclosed in double quotes `"`.
 
 PiCo supports interpolation, allowing expressions to be embedded directly within string literals. Supports standard escapes like `\n`, `\t`, `\r`, `\"`, `\\`, and `\$`.
 
 Example:
 
-```
+```javascript
 var name = "PiCo";
 print "Hello, ${name}!"; 
 # Output: Hello, PiCo!
@@ -67,7 +67,7 @@ Lists are defined using square brackets `[]`.
 
 Example:
 
-```
+```javascript
 var zeros = [0; 5]; # Creates [0, 0, 0, 0, 0]
 ```
 
@@ -82,7 +82,7 @@ Maps are key-value pairs enclosed in curly braces `{}`.
 
 Example:
 
-```
+```javascript
 var dict = { 
     "name": "PiCo", 
     "version": 1, 
@@ -103,7 +103,7 @@ Variables are declared using the `var` keyword.
 
 Example:
 
-```
+```javascript
 var x = 10;
 var y;      
 # y is null
@@ -117,7 +117,7 @@ PiCo supports standard operators with precedence rules defined in the compiler.
 
 - `+` (Addition), `-` (Subtraction), `*` (Multiplication), `/` (Division), `%` (Modulo).
 
-- Increment & Decrement: `++`, `--`. 
+- Increment & Decrement: `++`, `--`.
 
 Prefix (`++i`, `--i`): Increments/Decrements the value and returns the new value. Only supported for variables.
 
@@ -125,7 +125,7 @@ Postfix (`i++`, `i--`): Increments/Decrements the value and returns the original
 
 Example:
 
-```
+```javascript
 var a = 15;
 print ++a;      # Output: 16 (a is 16)
 print a++;      # Output: 16 (a becomes 17)
@@ -146,6 +146,7 @@ list[0]++;      # Supported (Postfix), list[0] becomes 11
 - **Unary**: `-` (Negation).
 
 ### Assignment & Increment
+
 PiCo provides shorthand operators for modifying variables and properties.
 
 - Compound Assignment: `+=`, `-=`.
@@ -160,7 +161,7 @@ If either operand of the `+` operator is a String, the other operand is automati
 
 Example:
 
-```
+```javascript
 var age = 20;
 print "Age: " + age;  # Output: "Age: 20"
 print 100 + "%";      # Output: "100%"
@@ -172,7 +173,7 @@ When the division operator `/` is used with two strings, it functions as a platf
 
 Example:
 
-```
+```javascript
 var path = "users" / "docs" / "report.txt";
 # Linux/Mac: "users/docs/report.txt"
 # Windows:   "users\docs\report.txt"
@@ -195,7 +196,7 @@ PiCo supports the conditional (ternary) operator, which is the only operator tha
 
 Example:
 
-```
+```javascript
 var age = 20;
 var status = age >= 18 ? "Adult" : "Minor";
 print status; # Output: Adult
@@ -218,7 +219,7 @@ The pipe operator `|>` allows for chaining function calls in a readable, left-to
 
 Example:
 
-```
+```javascript
 func addOne(n) { 
     return n + 1; 
 }
@@ -247,7 +248,7 @@ Access a single element using square brackets `[]`.
 
 Example:
 
-```
+```javascript
 var list = [10, 20, 30]; 
 print list[0]; # 10 
 print list[-1]; # 30
@@ -270,7 +271,7 @@ Extract a subsequence using the slice operator `:`. This creates a new string or
 
 Examples:
 
-```
+```javascript
 var s = "Hello World";
 
 # Basic Slicing
@@ -306,7 +307,7 @@ The `if` statement executes a block of code if a condition is `true`. An optiona
 
 - Example:
 
-```
+```javascript
 if(condition){
     # body
 }else{
@@ -326,7 +327,7 @@ PiCo supports `while` and C-style `for` loops. Both support `break` and `continu
 
 Repeats a block of code as long as the condition is true.
 
-```
+```javascript
 while(condition){
     # body
 }
@@ -336,7 +337,7 @@ while(condition){
 
 Standard C-style for loop with initialization, condition, and increment clauses.
 
-```
+```javascript
 for(var i = 0; i < 10; i = i + 1){
     print i;
 }
@@ -352,7 +353,7 @@ PiCo supports a simplified syntax for iterating over any iterable object (List,
 
 Example:
 
-```
+```javascript
 # Iterating over a List
 var nums = [10, 20, 30];
 for (var n : nums) {
@@ -392,7 +393,7 @@ PiCo provides a `switch` statement for matching a value against multiple possibi
 
 Example:
 
-```
+```javascript
 switch(value){
     case 1, 2 => {
         print "One or Two";
@@ -420,7 +421,7 @@ The `defer` statement defers the execution of a statement (or a block of code) u
 
 Example:
 
-```
+```javascript
 func processFile() {
     var f = fs.open("log.txt", "w");
     if (!f) return;
@@ -451,7 +452,6 @@ var res = test();
 
 ```
 
-
 ### Command Statement
 
 PiCo features a simple syntax for executing system shell commands directly.
@@ -466,7 +466,7 @@ PiCo features a simple syntax for executing system shell commands directly.
   
   3. Prints the command's output directly to the standard output (stdout).
   
-  4. $> is a statement, not an expression. It executes the rest of the line through the system shell. The normalized exit code is stored in the global variable _exit_code. 
+  4. $> is a statement, not an expression. It executes the rest of the line through the system shell. The normalized exit code is stored in the global variable _exit_code.
   
   5. $> does not require a semicolon. It ends at the end of the line.
 
@@ -478,7 +478,7 @@ Non-zero: Indicates an error or a specific status code returned by the command.
 
 Example:
 
-```
+```javascript
 print "Listing files:";
 $> ls -la
 print "Done.";
@@ -504,7 +504,6 @@ PiCo exposes two global functions to work with iterators:
   
   - *Returns*: The next value, or `null` if the iteration has finished.
 
-
 ## Functions
 
 Functions in PiCo are first-class citizens (internally). Current syntax supports function declarations primarily as statements. They support closures, capturing variables from their enclosing scope.
@@ -513,7 +512,7 @@ Functions in PiCo are first-class citizens (internally). Current syntax supports
 
 Use the `func` keyword to define a function.
 
-```
+```javascript
 func add(a, b){
     return a + b;
 }
@@ -525,7 +524,7 @@ The `return` keyword exits the function with a value. If no value is returned, i
 
 Functions can access variables defined in their outer scopes (by upvalues).
 
-```
+```javascript
 func makeCounter(){
     var count = 0;
     func increment(){
@@ -546,7 +545,7 @@ Functions can be created without a name and used as expressions. This is particu
 
 Example:
 
-```
+```javascript
 var square = func(x) { return x * x; };
 print square(5); # Output: 25
 ```
@@ -559,7 +558,7 @@ PiCo implements a unique flavor of Object-Oriented Programming (OOP) that separa
 
 The `class` block is strictly for defining data structures (fields) and their default values.
 
-```
+```javascript
 class Point{
     x = 0;
     y = 0;
@@ -569,7 +568,7 @@ class Point{
 
 Call the class name like a function to create a new instance.
 
-```
+```javascript
 var p = Point();
 p.x = 10;
 ```
@@ -580,7 +579,7 @@ Methods are defined **outside** the class body using the `method` keyword. This
 
 **Syntax**: `method (receiver_name ClassName) MethodName(args...) { ... }`
 
-```
+```javascript
 method (p Point) move(dx, dy){
     p.x = p.x + dx;
     p.y = p.y + dy;
@@ -601,7 +600,7 @@ PiCo uses a special method named `init` as the constructor to initialize new ins
 
 Example:
 
-```
+```javascript
 class Point {
     x = 0;
     y = 0;
@@ -627,7 +626,7 @@ PiCo enforces access control based on **Capitalization**.
 
 Example:
 
-```
+```javascript
 class User{
     Name;  # Public
     age;   # Private
@@ -667,14 +666,14 @@ Example:
 
 - FIle `math.pcs`:
 
-```
+```javascript
 func add(a, b) { return a + b; }
 var PI = 3.14;
 ```
 
 - File `main.pcs`:
 
-```
+```javascript
 import "math.pcs"; # Creates variable 'math'
 
 print math.PI;
@@ -687,7 +686,7 @@ When importing a module, PiCo automatically creates a variable derived from the
 
 Example:
 
-```
+```javascript
 import "./utils/logger.pcs"; 
 # Automatically creates a variable named 'logger'
 logger.log("Ready");
@@ -701,13 +700,13 @@ Core value types such as strings and lists do not require imports; their operati
 
 The `fs` module provides functionality for interacting with the file system.
 
-#### Import:
+#### Import
 
-```
+```javascript
 import "fs";
 ```
 
-#### Functions:
+#### Functions
 
 - `fs.read(path)`
   
@@ -774,9 +773,9 @@ import "fs";
   - *Description*: Opens a file and returns a iterable **File Object** for advanced operations.
   
   - *Arguments*:
-    
+
     - `path` (String).
-    
+
     - `mode` (String, optional): "r" (read), "w" (write), etc. Defaults to "r".
   
   - *Returns*: A File Object.
@@ -785,19 +784,19 @@ import "fs";
 
 The `os` module provides tools to interact with the underlying operating system.
 
-#### Import:
+#### Import
 
-```
+```javascript
 import "os";
 ```
 
-#### Variables:
+#### Variables
 
 - `os.argv`
   
   - *Description*: A List of Strings containing the command-line arguments passed to the PiCo script. `os.argv[0]` is the script name.
 
-#### Functions:
+#### Functions
 
 - `os.run(command)`
   
@@ -825,7 +824,7 @@ import "os";
   
   - *Description*: Sets or creates an environment variable.
   
-  - *Arguments*: 
+  - *Arguments*:
     - `key` (String).
     - `value` (String).
   
@@ -839,13 +838,13 @@ import "os";
 
 ### time - Time Module
 
-#### Import:
+#### Import
 
-```
+```javascript
 import "time";
 ```
 
-#### Functions:
+#### Functions
 
 - `time.now()`
   
@@ -870,9 +869,9 @@ import "time";
   - *Description*: Formats a timestamp into a readable string.
   
   - *Arguments*:
-    
+
     - `timestamp` (Number).
-    
+
     - `format` (String, optional): Default is `"%Y-%m-%d %H:%M:%S"`.
   
   - *Returns*: String.
@@ -881,13 +880,13 @@ import "time";
 
 Utilities for handling file paths cross-platform.
 
-#### Import:
+#### Import
 
-```
+```javascript
 import "path";
 ```
 
-#### Functions:
+#### Functions
 
 - `path.join(part1, part2, ...)`
   
@@ -919,13 +918,13 @@ import "path";
 
 ### glob - Glob Module
 
-#### Import:
+#### Import
 
-```
+```javascript
 import "glob";
 ```
 
-#### Funtions:
+#### Funtions
 
 - `glob.match(pattern, text)`
   - *Description*: Checks if the text string matches the specified pattern. It supports:
@@ -939,7 +938,7 @@ import "glob";
 
 Example:
 
-```
+```javascript
 glob.match("*.txt", "doc.txt");            # true
 glob.match("img_{0..5}.png", "img_2.png"); # true
 ```
@@ -949,6 +948,7 @@ glob.match("img_{0..5}.png", "img_2.png"); # true
 The `Glob` class is used to configure complex file searches. Instances of this class can be passed to `fs.list()` to retrieve matching files.
 
 Properties:
+
 - `Dir` (String): The root directory to start the search from. Defaults to "`.`" (current directory).
 - `Pattern` (String): The glob pattern to match files against (e.g., "`*.txt`", "`**/*.c`"). Defaults to "`*`" (match all files).
 - `Recursive` (Boolean): If true, the search will traverse subdirectories recursively. Defaults to false.
@@ -959,7 +959,7 @@ Example:
 
 To search for files, instantiate `glob.Glob`, configure its properties, and pass the object to `fs.list()`.
 
-```
+```javascript
 import "fs";
 import "glob";
 
@@ -1020,9 +1020,9 @@ Available on any String object (e.g., `"hello"`).
   - *Description*: Returns a substring from `start` index up to (but not including) `end`. Supports negative indexing (e.g., `-1` is the last character).
   
   - *Arguments*:
-    
+
     - `start` (Number).
-    
+
     - `end` (Number, optional): Defaults to the end of the string.
   
   - *Returns*: String.
@@ -1069,6 +1069,122 @@ Available on any String object (e.g., `"hello"`).
   
   - *Returns*: String.
 
+## Embedding PiCo in C
+
+PiCo can be embedded into a C host program. In embedded mode, the host owns the VM and decides when to load scripts, what native functions are available, how output is handled, and when the VM is destroyed.
+
+The basic lifecycle is:
+
+```c
+PicoVM* vm = pico_vm_create();
+
+pico_vm_eval(vm, source, "<script>");
+pico_vm_call(vm, "functionName", argCount, args, &result);
+
+pico_vm_destroy(vm);
+```
+
+### Evaluating source code
+
+`pico_vm_eval()` compiles and executes a null-terminated PiCo source string:
+
+```c
+PicoStatus status = pico_vm_eval(vm,
+    "func add(a, b){ return a + b; }\n",
+    "<embedded>"
+);
+```
+
+The source name is used only for diagnostics. It can be a real file path, but it can also be a virtual name such as `"<embedded>"`.
+
+### Calling PiCo from C
+
+A host program can call a global PiCo function with `pico_vm_call()`:
+
+```c
+PicoValue args[] = {
+    pico_value_number(20),
+    pico_value_number(22)
+};
+
+PicoValue result;
+PicoStatus status = pico_vm_call(vm, "add", 2, args, &result);
+```
+
+The initial public `PicoValue` API supports `null`, `bool`, and `number` for C-to-PiCo calls and return values. String arguments can be read inside native callbacks, and strings can be returned from native callbacks to PiCo, but persistent public string ownership for `pico_vm_call()` results should be handled by a future API.
+
+### Registering C functions
+
+A C function can be registered as a global PiCo function:
+
+```c
+static void hostAdd(PicoCall* call, void* userData){
+    (void)userData;
+
+    double left;
+    double right;
+
+    if(!pico_call_get_number(call, 0, &left) || !pico_call_get_number(call, 1, &right)){
+        pico_call_error(call, "hostAdd() expects two numbers.");
+        return;
+    }
+
+    pico_call_return_number(call, left + right);
+}
+
+pico_vm_register_native(vm, "hostAdd", hostAdd, NULL);
+```
+
+After registration, PiCo code can call it like an ordinary function:
+
+```javascript
+print hostAdd(20, 22);
+```
+
+`userData` is borrowed by PiCo. The host must keep it valid for as long as the registered function may be called.
+
+### Capturing output and errors
+
+By default, PiCo output goes to standard output and runtime error output goes to standard error. A host can redirect both streams:
+
+```c
+static void captureWrite(const char* text, size_t length, void* userData){
+    fwrite(text, 1, length, (FILE*)userData);
+}
+
+pico_vm_set_output(vm, captureWrite, stdout);
+pico_vm_set_error_output(vm, captureWrite, stderr);
+```
+
+This is useful for GUI programs, servers, tests, and plugin systems where embedded scripts should not write directly to the process console.
+
+### Error handling
+
+Most public API functions return a `PicoStatus`. When compilation or runtime execution fails, the host can read the last error message:
+
+```c
+if(status != PICO_STATUS_OK){
+    const char* error = pico_vm_last_error(vm);
+    fprintf(stderr, "%s\n", error != NULL ? error : pico_status_string(status));
+}
+```
+
+The returned error pointer is owned by the VM. It must not be freed and remains valid until the next API call that updates the VM error state or until the VM is destroyed.
+
+### Host safety
+
+VMs created by `pico_vm_create()` are embedding-oriented. Script code cannot terminate the host process through `os.exit()`; this produces a normal PiCo runtime error instead. This keeps embedded scripts inside the host application's error boundary.
+
+### Building against an installed PiCo
+
+After installing PiCo, external programs can link against `libpico.a`:
+
+```sh
+gcc main.c -I /path/to/pico/include -L /path/to/pico/lib -lpico -lm -o embed_app
+```
+
+For CMake users, see `examples/embedding/external-cmake/`.
+
 ## REPL
 
 ### Launch the REPL
diff --git a/std/modules/os.c b/std/modules/os.c
index 5efbd21..e560fe0 100644
--- a/std/modules/os.c
+++ b/std/modules/os.c
@@ -134,6 +134,12 @@ static Value os_exit(VM* vm, int argCount, Value* args){
     if(argCount > 0 && IS_NUM(args[0])){
         exitCode = (int)AS_NUM(args[0]);
     }
+
+    if(!vm->allowProcessExit){
+        runtimeError(vm, "os.exit() is disabled when PiCo is embedded.");
+        return NULL_VAL;
+    }
+    
     exit(exitCode);
     return NULL_VAL; // Unreachable
 }
diff --git a/tests/embedding_call_script.c b/tests/embedding_call_script.c
new file mode 100644
index 0000000..4dc6e61
--- /dev/null
+++ b/tests/embedding_call_script.c
@@ -0,0 +1,193 @@
+#include <stdio.h>
+#include <string.h>
+
+#include <pico.h>
+
+static void hostAdd(PicoCall* call, void* userData) {
+    (void)userData;
+
+    if(pico_call_arg_count(call) != 2){
+        pico_call_error(call, "hostAdd() expects exactly two arguments.");
+        return;
+    }
+
+    double left;
+    double right;
+
+    if(!pico_call_get_number(call, 0, &left) ||
+       !pico_call_get_number(call, 1, &right)){
+        pico_call_error(call, "hostAdd() expects two numbers.");
+        return;
+    }
+
+    pico_call_return_number(call, left + right);
+}
+
+static int reportFailure(PicoVM* vm, const char* operation,
+                         PicoStatus status) {
+    const char* error = pico_vm_last_error(vm);
+
+    fprintf(stderr, "%s failed: %s\n", operation,
+            error != NULL ? error : pico_status_string(status));
+
+    return 1;
+}
+
+int main(void) {
+    PicoVM* vm = pico_vm_create();
+
+    if(vm == NULL){
+        fprintf(stderr, "Could not create PiCo VM.\n");
+        return 1;
+    }
+
+    PicoStatus status =
+        pico_vm_register_native(vm, "hostAdd", hostAdd, NULL);
+
+    if(status != PICO_STATUS_OK){
+        int exitCode = reportFailure(vm, "Registering hostAdd", status);
+        pico_vm_destroy(vm);
+        return exitCode;
+    }
+
+    const char* source =
+        "func add(a, b) {\n"
+        "    return a + b;\n"
+        "}\n"
+        "\n"
+        "func calculate(a, b) {\n"
+        "    return hostAdd(a, b) * 2;\n"
+        "}\n"
+        "\n"
+        "func failCall() {\n"
+        "    return hostAdd(\"invalid\", 1);\n"
+        "}\n"
+        "\n"
+        "var notCallable = 42;\n";
+
+    status = pico_vm_eval(vm, source, "embedding_call_script.pcs");
+
+    if(status != PICO_STATUS_OK){
+        int exitCode = reportFailure(vm, "Loading PiCo functions", status);
+        pico_vm_destroy(vm);
+        return exitCode;
+    }
+
+    PicoValue addArgs[] = {
+        pico_value_number(20),
+        pico_value_number(22)
+    };
+
+    PicoValue result;
+    status = pico_vm_call(vm, "add", 2, addArgs, &result);
+
+    if(status != PICO_STATUS_OK){
+        int exitCode = reportFailure(vm, "Calling add", status);
+        pico_vm_destroy(vm);
+        return exitCode;
+    }
+
+    if(result.type != PICO_VALUE_NUMBER || result.as.number != 42.0){
+        fprintf(stderr, "Expected add() to return 42.\n");
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    printf("PiCo add result: %.14g\n", result.as.number);
+
+    PicoValue calculateArgs[] = {
+        pico_value_number(10),
+        pico_value_number(11)
+    };
+
+    status = pico_vm_call(vm, "calculate", 2, calculateArgs, &result);
+
+    if(status != PICO_STATUS_OK){
+        int exitCode = reportFailure(vm, "Calling calculate", status);
+        pico_vm_destroy(vm);
+        return exitCode;
+    }
+
+    if(result.type != PICO_VALUE_NUMBER || result.as.number != 42.0){
+        fprintf(stderr, "Expected calculate() to return 42.\n");
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    printf("C -> PiCo -> C result: %.14g\n", result.as.number);
+
+    status = pico_vm_call(vm, "missingFunction", 0, NULL, &result);
+
+    if(status != PICO_STATUS_RUNTIME_ERROR){
+        fprintf(stderr, "Expected missing function call to fail.\n");
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    const char* error = pico_vm_last_error(vm);
+
+    if(error == NULL || strstr(error, "not defined") == NULL){
+        fprintf(stderr, "Unexpected missing-function error: %s\n",
+                error != NULL ? error : "<none>");
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    printf("Captured missing function error: %s\n", error);
+
+    status = pico_vm_call(vm, "notCallable", 0, NULL, &result);
+
+    if(status != PICO_STATUS_RUNTIME_ERROR){
+        fprintf(stderr, "Expected non-callable global to fail.\n");
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    error = pico_vm_last_error(vm);
+
+    if(error == NULL || strstr(error, "Can only call") == NULL){
+        fprintf(stderr, "Unexpected non-callable error: %s\n",
+                error != NULL ? error : "<none>");
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    printf("Captured non-callable error: %s\n", error);
+
+    status = pico_vm_call(vm, "failCall", 0, NULL, &result);
+
+    if(status != PICO_STATUS_RUNTIME_ERROR){
+        fprintf(stderr, "Expected failCall() to produce a runtime error.\n");
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    error = pico_vm_last_error(vm);
+
+    if(error == NULL || strstr(error, "expects two numbers") == NULL){
+        fprintf(stderr, "Unexpected nested callback error: %s\n",
+                error != NULL ? error : "<none>");
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    printf("Captured nested callback error: %s\n", error);
+
+    /*
+     * Verify that the VM remains usable after a failed host-triggered call.
+    */
+    status = pico_vm_call(vm, "add", 2, addArgs, &result);
+
+    if(status != PICO_STATUS_OK ||
+       result.type != PICO_VALUE_NUMBER ||
+       result.as.number != 42.0){
+        int exitCode = reportFailure(vm, "Calling add after recovery", status);
+        pico_vm_destroy(vm);
+        return exitCode;
+    }
+
+    printf("VM recovered after failed call: %.14g\n", result.as.number);
+
+    pico_vm_destroy(vm);
+    return 0;
+}
\ No newline at end of file
diff --git a/tests/embedding_exit_policy.c b/tests/embedding_exit_policy.c
new file mode 100644
index 0000000..71c278d
--- /dev/null
+++ b/tests/embedding_exit_policy.c
@@ -0,0 +1,52 @@
+#include <stdio.h>
+#include <string.h>
+
+#include <pico.h>
+
+int main(void){
+    PicoVM* vm = pico_vm_create();
+
+    if(vm == NULL){
+        fprintf(stderr, "Could not create PiCo VM.\n");
+        return 1;
+    }
+
+    const char* source =
+        "import \"os\";\n"
+        "os.exit(7);\n"
+        "print \"This line must not execute.\";\n";
+
+    PicoStatus status = pico_vm_eval(
+        vm,
+        source,
+        "embedding_exit_policy.pcs"
+    );
+
+    if(status != PICO_STATUS_RUNTIME_ERROR){
+        fprintf(stderr, "Expected runtime error, got: %s\n", pico_status_string(status));
+
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    const char* error = pico_vm_last_error(vm);
+
+    if(error == NULL){
+        fprintf(stderr, "Expected an error message.\n");
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    if(strstr(error, "disabled") == NULL){
+        fprintf(stderr, "Unexpected error message: %s\n", error);
+
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    printf("Host survived os.exit().\n");
+    printf("Captured error: %s\n", error);
+
+    pico_vm_destroy(vm);
+    return 0;
+}
\ No newline at end of file
diff --git a/tests/embedding_native_function.c b/tests/embedding_native_function.c
new file mode 100644
index 0000000..394104a
--- /dev/null
+++ b/tests/embedding_native_function.c
@@ -0,0 +1,162 @@
+#include <stdio.h>
+#include <string.h>
+
+#include <pico.h>
+
+typedef struct HostState {
+    int addCalls;
+    int recordCalls;
+    double recordedValue;
+} HostState;
+
+static void hostAdd(PicoCall* call, void* userData) {
+    HostState* state = (HostState*)userData;
+
+    if(pico_call_arg_count(call) != 2){
+        pico_call_error(call, "hostAdd() expects exactly two arguments.");
+        return;
+    }
+
+    double left;
+    double right;
+
+    if(!pico_call_get_number(call, 0, &left) || !pico_call_get_number(call, 1, &right)){
+        pico_call_error(call, "hostAdd() expects two numbers.");
+        return;
+    }
+
+    state->addCalls++;
+    pico_call_return_number(call, left + right);
+}
+
+static void hostRecord(PicoCall* call, void* userData) {
+    HostState* state = (HostState*)userData;
+
+    if(pico_call_arg_count(call) != 1){
+        pico_call_error(call, "hostRecord() expects exactly one argument.");
+        return;
+    }
+
+    double value;
+
+    if(!pico_call_get_number(call, 0, &value)){
+        pico_call_error(call, "hostRecord() expects a number.");
+        return;
+    }
+
+    state->recordCalls++;
+    state->recordedValue = value;
+
+    pico_call_return_bool(call, true);
+}
+
+static int reportStatus(PicoVM* vm, const char* operation, PicoStatus status) {
+    const char* error = pico_vm_last_error(vm);
+
+    fprintf(stderr, "%s failed: %s\n", operation, error != NULL ? error : pico_status_string(status));
+
+    return 1;
+}
+
+int main(void) {
+    PicoVM* vm = pico_vm_create();
+
+    if(vm == NULL){
+        fprintf(stderr, "Could not create PiCo VM.\n");
+        return 1;
+    }
+
+    HostState state = {0};
+
+    PicoStatus status = pico_vm_register_native(vm, "hostAdd", hostAdd, &state);
+
+    if(status != PICO_STATUS_OK){
+        int result = reportStatus(vm, "Registering hostAdd", status);
+        pico_vm_destroy(vm);
+        return result;
+    }
+
+    status = pico_vm_register_native(vm, "hostRecord", hostRecord, &state);
+
+    if(status != PICO_STATUS_OK){
+        int result = reportStatus(vm, "Registering hostRecord", status);
+        pico_vm_destroy(vm);
+        return result;
+    }
+
+    const char* source =
+        "var result = hostAdd(20, 22);\n"
+        "hostRecord(result);\n";
+
+    status = pico_vm_eval(vm, source, "embedding_native_function.pcs");
+
+    if(status != PICO_STATUS_OK){
+        int result = reportStatus(vm, "Execution", status);
+        pico_vm_destroy(vm);
+        return result;
+    }
+
+    if(state.addCalls != 1){
+        fprintf(stderr, "Expected hostAdd() to be called once, got %d calls.\n", state.addCalls);
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    if(state.recordCalls != 1){
+        fprintf(stderr, "Expected hostRecord() to be called once, got %d calls.\n", state.recordCalls);
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    if(state.recordedValue != 42.0){
+        fprintf(stderr, "Expected recorded value 42, got %.14g.\n", state.recordedValue);
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    printf("Host function result: %.14g\n", state.recordedValue);
+
+    status = pico_vm_eval(vm,
+        "hostAdd(\"invalid\", 1);\n",
+        "embedding_native_error.pcs"
+    );
+
+    if(status != PICO_STATUS_RUNTIME_ERROR){
+        fprintf(stderr, "Expected runtime error, got %s.\n", pico_status_string(status));
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    const char* error = pico_vm_last_error(vm);
+
+    if(error == NULL || strstr(error, "expects two numbers") == NULL){
+        fprintf(stderr, "Unexpected callback error: %s\n", error != NULL ? error : "<none>");
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    printf("Captured callback error: %s\n", error);
+
+    status = pico_vm_eval(vm,
+        "var nestedResult = hostAdd(10, 5);\n"
+        "hostRecord(hostAdd(nestedResult, 27));\n",
+        "embedding_nested_native_function.pcs"
+    );
+
+    if(status != PICO_STATUS_OK){
+        int result = reportStatus(vm, "Nested execution", status);
+        pico_vm_destroy(vm);
+        return result;
+    }
+
+    if(state.recordedValue != 42.0){
+        fprintf(stderr, "Expected nested result 42, got %.14g.\n", state.recordedValue);
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    printf("Nested host function result: %.14g\n", state.recordedValue);
+
+    pico_vm_destroy(vm);
+    return 0;
+}
\ No newline at end of file
diff --git a/tests/embedding_output_callback.c b/tests/embedding_output_callback.c
new file mode 100644
index 0000000..eef9059
--- /dev/null
+++ b/tests/embedding_output_callback.c
@@ -0,0 +1,75 @@
+#include <stdio.h>
+#include <string.h>
+
+#include <pico.h>
+
+typedef struct Buffer{
+    char data[1024];
+    size_t length;
+}Buffer;
+
+static void bufferWrite(const char* text, size_t length, void* userData){
+    Buffer* buffer = (Buffer*)userData;
+
+    if(buffer->length + length >= sizeof(buffer->data)){
+        length = sizeof(buffer->data) - buffer->length - 1;
+    }
+
+    memcpy(buffer->data + buffer->length, text, length);
+    buffer->length += length;
+    buffer->data[buffer->length] = '\0';
+}
+
+int main(void){
+    PicoVM* vm = pico_vm_create();
+
+    if(vm == NULL){
+        fprintf(stderr, "Could not create PiCo VM.\n");
+        return 1;
+    }
+
+    Buffer out = {0};
+    Buffer err = {0};
+
+    pico_vm_set_output(vm, bufferWrite, &out);
+    pico_vm_set_error_output(vm, bufferWrite, &err);
+
+    PicoStatus status = pico_vm_eval(vm,
+        "print \"hello\";\n"
+        "print 42;\n"
+        "print [1, true, null];\n",
+        "<output_test>"
+    );
+
+    if(status != PICO_STATUS_OK){
+        fprintf(stderr, "Unexpected eval failure: %s\n", pico_status_string(status));
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    if(strcmp(out.data, "hello\n42\n[1, true, null]\n") != 0){
+        fprintf(stderr, "Unexpected captured output: [%s]\n", out.data);
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    status = pico_vm_eval(vm, "print 1 / 0;\n", "<error_test>");
+
+    if(status != PICO_STATUS_RUNTIME_ERROR){
+        fprintf(stderr, "Expected runtime error, got %s.\n", pico_status_string(status));
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    if(strstr(err.data, "Division by zero") == NULL){
+        fprintf(stderr, "Unexpected captured error: [%s]\n", err.data);
+        pico_vm_destroy(vm);
+        return 1;
+    }
+
+    printf("Captured output: %s", out.data);
+    printf("Captured error: %s", err.data);
+
+    pico_vm_destroy(vm);
+    return 0;
+}
\ No newline at end of file
diff --git a/tests/run_tests.ps1 b/tests/run_tests.ps1
new file mode 100644
index 0000000..3b2caac
--- /dev/null
+++ b/tests/run_tests.ps1
@@ -0,0 +1,180 @@
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+
+$timeoutSec = 5
+
+if (-not [string]::IsNullOrWhiteSpace($env:TIMEOUT_SEC)) {
+    $timeoutSec = [int]$env:TIMEOUT_SEC
+}
+
+$picoExec = $env:PICO_EXEC
+
+if ([string]::IsNullOrWhiteSpace($picoExec)) {
+    $candidates = @(
+        (Join-Path $PSScriptRoot "..\build\debug\pico.exe"),
+        (Join-Path $PSScriptRoot "..\build\release\pico.exe")
+    )
+
+    foreach ($candidate in $candidates) {
+        if (Test-Path -LiteralPath $candidate) {
+            $picoExec = $candidate
+            break
+        }
+    }
+}
+
+if ([string]::IsNullOrWhiteSpace($picoExec) -or
+    -not (Test-Path -LiteralPath $picoExec)) {
+    Write-Error @"
+PiCo executable was not found.
+
+Set PICO_EXEC explicitly, for example:
+
+    `$env:PICO_EXEC = "..\build\debug\pico.exe"
+    .\run_tests.ps1
+"@
+    exit 1
+}
+
+$picoExec = (Resolve-Path -LiteralPath $picoExec).Path
+
+function Show-CapturedOutput {
+    param(
+        [string]$StdoutPath,
+        [string]$StderrPath
+    )
+
+    $lines = @()
+
+    if (Test-Path -LiteralPath $StdoutPath) {
+        $lines += @(Get-Content -LiteralPath $StdoutPath)
+    }
+
+    if (Test-Path -LiteralPath $StderrPath) {
+        $lines += @(Get-Content -LiteralPath $StderrPath)
+    }
+
+    if ($lines.Count -eq 0) {
+        Write-Host "No output captured."
+        return
+    }
+
+    $lines |
+        Select-Object -First 120 |
+        ForEach-Object {
+            Write-Host $_
+        }
+}
+
+$testFiles = Get-ChildItem `
+    -LiteralPath $PSScriptRoot `
+    -Filter "test_*.pcs" |
+    Where-Object {
+        -not $_.PSIsContainer
+    } |
+    Sort-Object Name
+
+$passed = 0
+$failed = 0
+$timeouts = 0
+
+Write-Host "Starting tests..."
+Write-Host "PICO_EXEC: $picoExec"
+Write-Host "TIMEOUT_SEC: $timeoutSec"
+Write-Host ""
+
+foreach ($test in $testFiles) {
+    Write-Host ("Running {0,-35} " -f $test.Name) -NoNewline
+
+    $temporaryBase = Join-Path `
+        ([System.IO.Path]::GetTempPath()) `
+        ("pico-test-{0}-{1}" -f $PID, [Guid]::NewGuid().ToString("N"))
+
+    $stdoutFile = "$temporaryBase.stdout.log"
+    $stderrFile = "$temporaryBase.stderr.log"
+
+    try {
+        $process = Start-Process `
+            -FilePath $picoExec `
+            -ArgumentList @($test.Name) `
+            -WorkingDirectory $PSScriptRoot `
+            -RedirectStandardOutput $stdoutFile `
+            -RedirectStandardError $stderrFile `
+            -NoNewWindow `
+            -PassThru
+
+        $finished = $process.WaitForExit($timeoutSec * 1000)
+
+        if (-not $finished) {
+            try {
+                $process.Kill()
+            }
+            catch {
+                # The process may already have exited.
+            }
+
+            $process.WaitForExit()
+
+            Write-Host "[TIMEOUT]"
+            Write-Host "Timed out after $timeoutSec seconds."
+
+            Show-CapturedOutput `
+                -StdoutPath $stdoutFile `
+                -StderrPath $stderrFile
+
+            $timeouts++
+            $failed++
+            continue
+        }
+
+        # Wait once more so redirected output is completely flushed.
+        $process.WaitForExit()
+
+        $exitCode = $process.ExitCode
+
+        if ($exitCode -eq 0) {
+            Write-Host "[PASS]"
+            $passed++
+        }
+        elseif ($exitCode -lt 0) {
+            Write-Host "[CRASH: exit $exitCode]"
+
+            Show-CapturedOutput `
+                -StdoutPath $stdoutFile `
+                -StderrPath $stderrFile
+
+            $failed++
+        }
+        else {
+            Write-Host "[FAIL: exit $exitCode]"
+
+            Show-CapturedOutput `
+                -StdoutPath $stdoutFile `
+                -StderrPath $stderrFile
+
+            $failed++
+        }
+    }
+    catch {
+        Write-Host "[ERROR]"
+        Write-Host $_.Exception.Message
+        $failed++
+    }
+    finally {
+        Remove-Item `
+            -LiteralPath $stdoutFile, $stderrFile `
+            -Force `
+            -ErrorAction SilentlyContinue
+    }
+}
+
+Write-Host ""
+Write-Host "========================================"
+Write-Host "Summary: $passed Passed, $failed Failed ($timeouts Timeouts)"
+Write-Host "========================================"
+
+if ($failed -eq 0) {
+    exit 0
+}
+
+exit 1
diff --git a/tests/run_tests.sh b/tests/run_tests.sh
index 6b7787f..a5ce1c3 100644
--- a/tests/run_tests.sh
+++ b/tests/run_tests.sh
@@ -2,29 +2,21 @@
 
 set -u
 
-TIMEOUT_SEC="${TIMEOUT_SEC:-5}"
+PICO_EXEC="${1:-${PICO_EXEC:-}}"
+TIMEOUT_SEC="${2:-${TIMEOUT_SEC:-5}}"
 LOG_FILE="${LOG_FILE:-test_output.log}"
 
-if [ -z "${PICO_EXEC:-}" ]; then
-    if [ -f "../build/pico.exe" ]; then
-        PICO_EXEC="../build/pico.exe"
-    elif [ -f "../build/pico" ]; then
-        PICO_EXEC="../build/pico"
-    else
-        PICO_EXEC="$(find ../build -name "pico*" -type f 2>/dev/null | head -n 1)"
-    fi
-fi
-
-if [ -z "${PICO_EXEC:-}" ] || [ ! -f "$PICO_EXEC" ]; then
-    echo "Error: pico executable not found."
-    echo "Set it manually, for example:"
-    echo "  PICO_EXEC=\"../build/pico\" bash run_tests.sh"
-    echo "  PICO_EXEC=\"../build-stress/pico\" TIMEOUT_SEC=60 bash run_tests.sh"
+if [ -z "$PICO_EXEC" ]; then
+    echo "Error: PiCo executable path was not provided."
+    echo "Usage:"
+    echo "  bash run_tests.sh /path/to/pico [timeout_seconds]"
     exit 1
 fi
 
-if [ ! -x "$PICO_EXEC" ]; then
-    chmod +x "$PICO_EXEC" 2>/dev/null || true
+if [ ! -f "$PICO_EXEC" ]; then
+    echo "Error: PiCo executable not found:"
+    echo "  $PICO_EXEC"
+    exit 1
 fi
 
 PASSED=0
diff --git a/vm/debug.c b/vm/debug.c
index d3bbf60..703b3cd 100644
--- a/vm/debug.c
+++ b/vm/debug.c
@@ -16,6 +16,16 @@
 #define CLR_CYAN    "\033[36m"
 #define CLR_MAGENTA "\033[35m"
 
+static void debugWrite(const char* text, size_t length, void* userData){
+    (void)userData;
+    fwrite(text, 1, length, stdout);
+}
+
+static Writer debugWriter = {
+    debugWrite,
+    NULL
+};
+
 static const char* opNames[] = {
     "OP_MOVE",        // R[A] <= R[B]
     "OP_LOADK",       // R[A] <= K[Bx]
@@ -206,7 +216,7 @@ static void dasmLoadK(const char* name, const Chunk* chunk, Instruction instruct
 
     if((size_t)bx < chunk->constants.count){
         printf(CLR_GRAY "'");
-        printValue(chunk->constants.values[bx]);
+        valueWrite(chunk->constants.values[bx], &debugWriter);
         printf(CLR_RESET);
     }else{
         printf(CLR_RED "<invalid constant>" CLR_RESET);
@@ -251,7 +261,7 @@ static void dasmField(const char* name, const Chunk* chunk, Instruction instruct
         CLR_YELLOW "%5d" CLR_GRAY " | " \
         CLR_GRAY "'", name, "iABC", a, b, c
     );
-    printValue(constant);
+    valueWrite(constant, &debugWriter);
     printf(CLR_RESET);
 }
 
diff --git a/vm/vm.c b/vm/vm.c
index ebbca3f..6589390 100644
--- a/vm/vm.c
+++ b/vm/vm.c
@@ -1,6 +1,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
+#include <string.h>
 #include <ctype.h>
 #include <math.h>
 #include <time.h>
@@ -48,6 +49,54 @@ static int normalizeSystemStatus(int status){
 }
 #endif
 
+static void defaultOWrite(const char* text, size_t length, void* userData){
+    (void)userData;
+    fwrite(text, 1, length, stdout);
+}
+
+static void defaultEWrite(const char* text, size_t length, void* userData){
+    (void)userData;
+    fwrite(text, 1, length, stderr);
+}
+
+void vmWrite(VM* vm, const char* text, size_t length){
+    if(vm == NULL || text == NULL || length == 0){
+        return;
+    }
+
+    if(vm->output.write == NULL){
+        defaultOWrite(text, length, NULL);
+        return;
+    }
+
+    writerW(&vm->output, text, length);
+}
+
+void vmWriteCString(VM* vm, const char* text){
+    if(text != NULL){
+        vmWrite(vm, text, strlen(text));
+    }
+}
+
+void vmWriteError(VM* vm, const char* text, size_t length){
+    if(vm == NULL || text == NULL || length == 0){
+        return;
+    }
+
+    if(vm->errOutput.write == NULL){
+        defaultEWrite(text, length, NULL);
+        return;
+    }
+
+    writerW(&vm->errOutput, text, length);
+}
+
+void vmWriteErrorCString(VM* vm, const char* text){
+    if(text != NULL){
+        vmWriteError(vm, text, strlen(text));
+    }
+}
+
 void resetStack(VM* vm){
     vm->stackTop = vm->stack;
 }
@@ -101,6 +150,18 @@ void initVM(VM* vm, int argc, const char* argv[]){
 
     vm->hadRuntimeError = false;
 
+    /*
+     * initVM() is also used directly by the CLI. The embedding API overrides this after initialization.
+    */
+
+    vm->allowProcessExit = true;
+    vm->lastError[0] = '\0';
+
+    vm->output.write = defaultOWrite;
+    vm->output.userData = NULL;
+    vm->errOutput.write = defaultEWrite;
+    vm->errOutput.userData = NULL;
+
     registerPrelude(vm);
 }
 
@@ -204,8 +265,15 @@ static void closeUpvalues(VM* vm, Value* last){
 }
 
 InterpreterStatus interpret(VM* vm, const char* code, const char* srcName){
+    vm->lastError[0] = '\0';
+
+    Value* stackBase = vm->stackTop;
     ObjectFunc* func = compile(vm, code, srcName);
-    if(func == NULL) return VM_COMPILE_ERROR;
+
+    if(func == NULL){
+        snprintf(vm->lastError, sizeof(vm->lastError), "Compilation failed.");
+        return VM_COMPILE_ERROR;
+    }
 
     push(vm, OBJECT_VAL(func));
 
@@ -222,7 +290,9 @@ InterpreterStatus interpret(VM* vm, const char* code, const char* srcName){
 
     if(status == VM_RUNTIME_ERROR){
         recover(vm);
-    }
+    }else{
+        vm->stackTop = stackBase;
+    }   // restore stack top to the base before the call
 
     return status;
 }
@@ -923,8 +993,8 @@ static InterpreterStatus run(VM* vm){
     DO_OP_PRINT:
     {
         int a = GET_ARG_A(instruction);
-        printValue(R(a));
-        printf("\n");
+        valueWrite(R(a), &vm->output);
+        vmWriteCString(vm, "\n");
     } DISPATCH();
 
     DO_OP_JMP:
@@ -1450,9 +1520,10 @@ static InterpreterStatus run(VM* vm){
         vm->frameCount--;
 
         if(vm->frameCount == 0){
-            pop(vm);
+            vm->stackTop = calleeBase;
+            push(vm, result);
             return VM_OK;
-        }
+        }   // save the result
 
         frame = &vm->frames[vm->frameCount - 1];
 
@@ -1556,12 +1627,76 @@ static bool callValue(VM* vm, Value callee, int argCnt){
     return false;
 }
 
+InterpreterStatus vmCallValue(
+    VM* vm,
+    Value callee,
+    int argCnt,
+    const Value* args,
+    Value* result
+){
+    if(vm->frameCount != 0){
+        runtimeError(vm, "PiCo VM calls are not reentrant.");
+        return VM_RUNTIME_ERROR;
+    }
+
+    if(argCnt < 0 || (argCnt > 0 && args == NULL)){
+        runtimeError(vm, "Invalid argument count or null arguments.");
+        return VM_RUNTIME_ERROR;
+    }
+
+    Value* stackBase = vm->stackTop;
+
+    push(vm, callee);
+
+    for(int i = 0; i < argCnt; i++){
+        push(vm, args[i]);
+    }
+
+    if(!callValue(vm, callee, argCnt)){
+        recover(vm);
+        return VM_RUNTIME_ERROR;
+    }
+
+    InterpreterStatus status = VM_OK;
+
+    /*
+     * Native C functions complete immediately, so we can return the result directly.
+     * PiCo closures push a new frame onto the stack, and we need to run the VM loop to execute it.
+    */
+
+    if(vm->frameCount > 0){
+        status = run(vm);
+    }
+
+    if(status == VM_RUNTIME_ERROR){
+        recover(vm);
+        return status;
+    }
+
+    if(vm->stackTop <= stackBase){
+        runtimeError(vm, "Stack underflow after PiCo function call.");
+        recover(vm);
+        return VM_RUNTIME_ERROR;
+    }
+
+    Value returnValue = pop(vm);
+    vm->stackTop = stackBase;  
+    // restore stack top to the base before the call
+
+    if(result != NULL){
+        *result = returnValue;
+    }
+
+    return VM_OK;
+}
+
 void runtimeError(VM* vm, const char* format, ...){
     va_list args;
     va_start(args, format);
-    vfprintf(stderr, format, args);
+    vsnprintf(vm->lastError, sizeof(vm->lastError), format, args);
     va_end(args);
-    fputs("\n", stderr);
+    vmWriteErrorCString(vm, vm->lastError);
+    vmWriteErrorCString(vm, "\n");
 
     #ifdef DEBUG_TRACE
     if(vm->frameCount > 0){
diff --git a/vm/vm.h b/vm/vm.h
index c919217..476c222 100644
--- a/vm/vm.h
+++ b/vm/vm.h
@@ -6,6 +6,8 @@
 #include "instruction.h"
 #include "gc_types.h"
 #include "global_env.h"
+#include "writer.h"
+
 #include <stddef.h>
 
 typedef struct Chunk Chunk;
@@ -17,6 +19,9 @@ typedef struct GCPolicy GCPolicy;
 #define STACK_MAX (FRAMES_MAX * 256)
 #define GLOBAL_STATCK_MAX 64
 #define MAX_DEFERS 255
+#define VM_ERROR_MESSAGE_MAX 512
+
+typedef void(*VMWriteFunc)(const char* text, size_t length, void* userData);
 
 typedef struct CallFrame{
     ObjectClosure* closure;
@@ -79,6 +84,22 @@ typedef struct VM{
     const char** argv;
 
     bool hadRuntimeError;
+
+    /*
+     * Whether script code may terminate the host process through os.exit().
+     * The CLI enables this to preserve its existing behavior.
+     * The public embedding API disables it.
+    */
+    bool allowProcessExit;
+
+    /*
+     * Most recent compilation or runtime error.
+     * The message remains available after recover().
+    */
+    char lastError[VM_ERROR_MESSAGE_MAX];
+
+    Writer output;
+    Writer errOutput;
 }VM;
 
 typedef enum{
@@ -99,11 +120,17 @@ static bool isTruthy(Value value);
 static bool checkAccess(VM* vm, ObjectClass* instanceKlass, ObjectString* fieldName);
 
 InterpreterStatus interpret(VM* vm, const char* code, const char* srcName);
+InterpreterStatus vmCallValue(VM* vm, Value callee, int argCount, const Value* args, Value* result);
 static InterpreterStatus run(VM* vm);
 
 static bool call(VM* vm, ObjectClosure* closure, int argCnt);
 static bool callValue(VM* vm, Value callee, int argCnt);
 
+void vmWrite(VM* vm, const char* text, size_t length);
+void vmWriteCString(VM* vm, const char* text);
+void vmWriteError(VM* vm, const char* text, size_t length);
+void vmWriteErrorCString(VM* vm, const char* text);
+
 void runtimeError(VM* vm, const char* format, ...);
 
 #endif // PICO_VM_H