diff --git a/README.md b/README.md
index 6d19c65..34f3193 100644
--- a/README.md
+++ b/README.md
@@ -12,19 +12,173 @@ JavaScript runtimes:
 
 Instead of using FFI and the libextism shared object, this library uses whatever Wasm runtime is already available with the JavaScript runtime.
 
+## Installation
 
-## Install
-
+Install via npm:
 ```
 npm install @extism/extism@1.0.0-rc1 --save
 ```
 
 > **Note**: Keep in mind we will possibly have breaking changes b/w rc versions until we hit 1.0.
 
-## API
+## Getting Started
+
+This guide should walk you through some of the concepts in Extism and this JS library.
+
+First you should import `createPlugin` and `ExtismPluginOptions` from Extism:
+```js
+// CommonJS
+const createPlugin = require("../dist/node/index")
+
+// ES Modules
+import createPlugin from '../src/deno/mod.ts'
+```
+
+## Creating A Plug-in
+
+The primary concept in Extism is the [plug-in](https://extism.org/docs/concepts/plug-in). You can think of a plug-in as a code module stored in a `.wasm` file.
+
+Plug-in code can come from a file on disk, object storage or any number of places. Since you may not have one handy let's load a demo plug-in from the web:
+
+```js
+const wasm = {
+    url: 'https://github.com/extism/plugins/releases/latest/download/count_vowels.wasm'
+}
+
+const plugin = await createPlugin(wasm, {
+    // NOTE: If you get an error like "TypeError: WebAssembly.instantiate(): Import #0 module="wasi_snapshot_preview1": module is not an object or function", then your plugin requires WASI support
+    useWasi: true,
+});
+```
+
+## Calling A Plug-in's Exports
+
+This plug-in was written in Rust and it does one thing, it counts vowels in a string. As such, it exposes one "export" function: `count_vowels`. We can call exports using `ExtismPlugin.call`:
+
+```js
+let out = await plugin.call("count_vowels", new TextEncoder().encode(input));
+console.log(new TextDecoder().decode(out.buffer))
+
+// => {"count": 3, "total": 3, "vowels": "aeiouAEIOU"}
+```
+
+All exports have a simple interface of optional bytes in, and optional bytes out. This plug-in happens to take a string and return a JSON encoded string with a report of results.
+
+### Plug-in State
+
+Plug-ins may be stateful or stateless. Plug-ins can maintain state b/w calls by the use of variables. Our count vowels plug-in remembers the total number of vowels it's ever counted in the "total" key in the result. You can see this by making subsequent calls to the export:
+
+```js
+let out = await plugin.call("count_vowels", new TextEncoder().encode("Hello, World!"));
+console.log(new TextDecoder().decode(out.buffer))
+
+// => {"count": 3, "total": 9, "vowels": "aeiouAEIOU"}
+
+out = await plugin.call("count_vowels", new TextEncoder().encode("Hello, World!"));
+console.log(new TextDecoder().decode(out.buffer))
+// => {"count": 3, "total": 9, "vowels": "aeiouAEIOU"}
+```
+
+These variables will persist until this plug-in is freed or you initialize a new one.
+
+### Configuration
 
-We'll be publishing more docs very soon. For the time being look at [these tests](src/tests/mod.test.ts)
-for up to date examples.
+Plug-ins may optionally take a configuration object. This is a static way to configure the plug-in. Our count-vowels plugin takes an optional configuration to change out which characters are considered vowels. Example:
+
+```js
+const wasm = {
+    url: 'https://github.com/extism/plugins/releases/latest/download/count_vowels.wasm'
+}
+
+let plugin = await createPlugin(wasm, {
+    useWasi: true,
+});
+
+let out = await plugin.call("count_vowels", new TextEncoder().encode("Yellow, World!"));
+console.log(new TextDecoder().decode(out.buffer))
+// => {"count": 3, "total": 3, "vowels": "aeiouAEIOU"}
+
+plugin = await createPlugin(wasm, {
+    useWasi: true,
+    config: { "vowels": "aeiouyAEIOUY" }
+});
+
+out = await plugin.call("count_vowels", new TextEncoder().encode("Yellow, World!"));
+console.log(new TextDecoder().decode(out.buffer))
+// => {"count": 4, "total": 4, "vowels": "aeiouAEIOUY"}
+```
+
+### Host Functions
+
+Let's extend our count-vowels example a little bit: Instead of storing the `total` in an ephemeral plug-in var, let's store it in a persistent key-value store!
+
+Wasm can't use our KV store on it's own. This is where [Host Functions](https://extism.org/docs/concepts/host-functions) come in.
+
+[Host functions](https://extism.org/docs/concepts/host-functions) allow us to grant new capabilities to our plug-ins from our application. They are simply some JS functions you write which can be passed down and invoked from any language inside the plug-in.
+
+Let's load the manifest like usual but load up this `count_vowels_kvstore` plug-in:
+
+```js
+const wasm = {
+    url: "https://github.com/extism/plugins/releases/latest/download/count_vowels_kvstore.wasm"
+}
+```
+
+> *Note*: The source code for this is [here](https://github.com/extism/plugins/blob/main/count_vowels_kvstore/src/lib.rs) and is written in rust, but it could be written in any of our PDK languages.
+
+Unlike our previous plug-in, this plug-in expects you to provide host functions that satisfy our its import interface for a KV store.
+
+We want to expose two functions to our plugin, `kv_write(key: string, value: Uint8Array)` which writes a bytes value to a key and `kv_read(key: string): Uint8Array` which reads the bytes at the given `key`.
+```js
+// pretend this is Redis or something :)
+let kvStore = new Map();
+
+const options = {
+    useWasi: true,
+    functions: {
+        "env": {
+            // NOTE: the first argument is always a CurrentPlugin
+            "kv_read": function (cp: CurrentPlugin, offs: bigint) {
+                const key = cp.readString(offs);
+                let value = kvStore.get(key) ?? new Uint8Array([0, 0, 0, 0]);
+                console.log(`Read ${new DataView(value.buffer).getUint32(0, true)} from key=${key}`);
+                return cp.writeBytes(value);
+            },
+            "kv_write": function (cp: CurrentPlugin, kOffs: bigint, vOffs: bigint) { // this: CurrentPlugin
+                const key = cp.readString(kOffs);
+                const value = cp.readBytes(vOffs);
+                console.log(`Writing value=${new DataView(value.buffer).getUint32(0, true)} from key=${key}`);
+
+                kvStore.set(key, value);
+            }
+        }
+    }
+};
+```
+
+> *Note*: In order to write host functions you should get familiar with the methods on the `CurrentPlugin` type. `this` is bound to an instance of `CurrentPlugin`.
+
+We need to pass these imports to the plug-in to create them. All imports of a plug-in must be satisfied for it to be initialized:
+
+```js
+const plugin = await createPlugin(wasm, options);
+```
+
+Now we can invoke the event:
+
+```js
+let out = await plugin.call("count_vowels", new TextEncoder().encode("Hello World!"));
+console.log(new TextDecoder().decode(out.buffer))
+// => Read from key=count-vowels"
+// => Writing value=3 from key=count-vowels"
+// => {"count": 3, "total": 3, "vowels": "aeiouAEIOU"}
+
+out = await plugin.call("count_vowels", new TextEncoder().encode("Hello World!"));
+console.log(new TextDecoder().decode(out.buffer))
+// => Read from key=count-vowels"
+// => Writing value=6 from key=count-vowels"
+// => {"count": 3, "total": 6, "vowels": "aeiouAEIOU"}
+```
 
 ## Run Examples:
 
@@ -33,15 +187,15 @@ npm run build
 
 node --experimental-wasi-unstable-preview1 ./examples/node.js wasm/config.wasm
 
-deno run -A ./examples/deno.js ./wasm/config.wasm
+deno run -A ./examples/deno.ts ./wasm/config.wasm
 
 bun run ./examples/node.js wasm/config.wasm
 ```
 
 ## Update `extism-kernel.wasm`:
 
-We are shipping an embedded kernel in base64 form in plugin.ts. To update it, you can run these commands:
+We are shipping an embedded kernel in base64 form in plugin.ts. To update it, you can run:
 
 ```
 make update-kernel
-```
+```
\ No newline at end of file
diff --git a/build.js b/build.js
index fa8c394..82d9817 100644
--- a/build.js
+++ b/build.js
@@ -1,6 +1,5 @@
 const { build } = require("esbuild");
 const { peerDependencies } = require('./package.json')
-const fs = require('fs')
 
 const sharedConfig = {
     bundle: true,
diff --git a/examples/deno.js b/examples/deno.js
deleted file mode 100644
index 6ab7ae9..0000000
--- a/examples/deno.js
+++ /dev/null
@@ -1,22 +0,0 @@
-import { ExtismPlugin, ExtismPluginOptions } from '../src/deno/mod.ts'
-
-async function main() {
-    const filename = Deno.args[0] || "wasm/hello.wasm";
-    const funcname = Deno.args[1] || "run_test";
-    const input = Deno.args[2] || "this is a test";
-    const wasm = {
-        path: filename
-    }
-
-    const options = new ExtismPluginOptions()
-        .withConfig("thing", "testing")
-        .withWasi();
-
-    const plugin = await ExtismPlugin.new(wasm, options);
-
-    const res = await plugin.call(funcname, new TextEncoder().encode(input));
-    const s = new TextDecoder().decode(res.buffer);
-    console.log(s)
-}
-
-main();
\ No newline at end of file
diff --git a/examples/deno.ts b/examples/deno.ts
new file mode 100644
index 0000000..5f061e7
--- /dev/null
+++ b/examples/deno.ts
@@ -0,0 +1,19 @@
+import createPlugin from '../src/deno/mod.ts'
+
+const filename = Deno.args[0] || "wasm/hello.wasm";
+const funcname = Deno.args[1] || "run_test";
+const input = Deno.args[2] || "this is a test";
+const wasm = {
+    url: filename
+}
+
+const plugin = await createPlugin(wasm, {
+    useWasi: true,
+    config: {
+        "thing": "testing"
+    }
+});
+
+const res = await plugin.call(funcname, new TextEncoder().encode(input));
+const s = new TextDecoder().decode(res.buffer);
+console.log(s)
\ No newline at end of file
diff --git a/examples/index.html b/examples/index.html
index 77f686a..dc27dff 100644
--- a/examples/index.html
+++ b/examples/index.html
@@ -58,6 +58,8 @@
     <script type="module" src="/dist/browser/index.mjs"></script>
 
     <script type="module">
+        import createPlugin from '/dist/browser/index.mjs';
+
         async function runPlugin() {
             // Get values from input fields
             const url = document.getElementById('url').value;
@@ -69,13 +71,11 @@
                 url: url
             }
 
-            const options = new ExtismPluginOptions()
-                .withConfig("thing", "Charles")
-                .withConfig("name", "Charles")
-                .withWasi()
-                .withAllowedHosts(hosts);
-
-            const plugin = await ExtismPlugin.new(wasm, options);
+            const plugin = await createPlugin(wasm, {
+                useWasi: true,
+                config: { "thing": "testing" },
+                allowedHosts: [ ...hosts ]
+            });
 
             const res = await plugin.call(funcname, new TextEncoder().encode(input));
             const s = new TextDecoder().decode(res.buffer);
diff --git a/examples/node.js b/examples/node.js
index 746ff11..6631deb 100644
--- a/examples/node.js
+++ b/examples/node.js
@@ -1,20 +1,19 @@
-const { ExtismPlugin, ExtismPluginOptions } = require("../dist/node/index")
-const { argv } = require("node:process");
+const createPlugin = require("../dist/node/index").default;
+const { argv } = require("process");
 
 async function main() {
     const filename = argv[2] || "wasm/hello.wasm";
     const funcname = argv[3] || "run_test";
     const input = argv[4] || "this is a test";
     const wasm = {
-        path: filename
+        url: filename
     }
 
-    const options = new ExtismPluginOptions()
-        .withConfig("thing", "testing")
-        .withWasi()
-        .withAllowedHost("*.typicode.com");
-
-    const plugin = await ExtismPlugin.new(wasm, options);
+    const plugin = await createPlugin(wasm, {
+        useWasi: true,
+        config: { "thing": "testing" },
+        withAllowedHosts: ["*.typicode.com"]
+    })
 
     const res = await plugin.call(funcname, new TextEncoder().encode(input));
     const s = new TextDecoder().decode(res.buffer);
diff --git a/src/browser/index.ts b/src/browser/index.ts
index ad50884..84773a8 100644
--- a/src/browser/index.ts
+++ b/src/browser/index.ts
@@ -7,40 +7,20 @@ import {
   Manifest,
   ManifestWasm,
   ManifestWasmData,
-  ManifestWasmFile,
   ManifestWasmUrl,
   HttpRequest,
   HttpResponse,
   embeddedRuntime,
-  embeddedRuntimeHash
+  embeddedRuntimeHash,
+  CurrentPlugin,
+  StreamingSource,
+  isURL,
 } from '../plugin';
 
-import { WASI, Fd } from '@bjorn3/browser_wasi_shim';
+import { WASI, Fd, File, OpenFile } from '@bjorn3/browser_wasi_shim';
 import { minimatch } from 'minimatch';
 
 class ExtismPlugin extends ExtismPluginBase {
-  /**
-   * Create a new plugin.
-   * @param manifestData An Extism manifest {@link Manifest} or a Wasm module.
-   * @param options Options for initializing the plugin.
-   * @returns {ExtismPlugin} An initialized plugin.
-   */
-  static async new(
-    manifestData: Manifest | ManifestWasm | Buffer,
-    options: ExtismPluginOptions,
-  ): Promise<ExtismPlugin> {
-    let moduleData = await fetchModuleData(manifestData, this.fetchWasm, this.calculateHash);
-
-    const runtimeWasm = options.runtime ?? {
-      data: this.toBytes(embeddedRuntime),
-      hash: embeddedRuntimeHash
-    };
-
-    let runtime = await instantiateExtismRuntime(runtimeWasm, this.fetchWasm, this.calculateHash);
-
-    return new ExtismPlugin(runtime, moduleData, options);
-  }
-
   protected supportsHttpRequests(): boolean {
     return true;
   }
@@ -95,6 +75,9 @@ class ExtismPlugin extends ExtismPluginBase {
     const args: Array<string> = [];
     const envVars: Array<string> = [];
     let fds: Fd[] = [
+      new OpenFile(new File([])), // stdin
+      new OpenFile(new File([])), // stdout
+      new OpenFile(new File([])), // stderr
     ];
 
     const wasi = new WASI(args, envVars, fds);
@@ -106,7 +89,7 @@ class ExtismPlugin extends ExtismPluginBase {
     const wrapper = {
       exports: {
         memory: instance.exports.memory as WebAssembly.Memory,
-        _start() {},
+        _start() { },
       },
     };
 
@@ -116,49 +99,77 @@ class ExtismPlugin extends ExtismPluginBase {
 
     wasi.start(wrapper);
   }
+}
 
-  private static async fetchWasm(wasm: ManifestWasm): Promise<ArrayBuffer> {
-    let data: ArrayBuffer;
+/**
+ * Create a new plugin.
+ * @param manifestData An Extism manifest {@link Manifest} or a Wasm module.
+ * @param options Options for initializing the plugin.
+ * @returns {ExtismPlugin} An initialized plugin.
+ */
+async function createPlugin(
+  manifestData: Manifest | ManifestWasm | ArrayBuffer | string | URL,
+  options: ExtismPluginOptions,
+): Promise<ExtismPlugin> {
+
+  if (typeof manifestData === "string" || manifestData instanceof URL) {
+    manifestData = {
+      url: manifestData as string | URL
+    }
+  }
+  
+  let moduleData = await fetchModuleData(manifestData, fetchWasm, calculateHash);
 
-    if ((wasm as ManifestWasmData).data) {
-      data = (wasm as ManifestWasmData).data;
-    } else if ((wasm as ManifestWasmFile).path) {
-      throw new Error(`Unsupported wasm source: ${wasm}`);
-    } else if ((wasm as ManifestWasmUrl).url) {
-      const response = await fetch((wasm as ManifestWasmUrl).url);
-      data = await response.arrayBuffer();
-    } else {
-      throw new Error(`Unrecognized wasm source: ${wasm}`);
+  const runtimeWasm = options.runtime ?? {
+    data: toBytes(embeddedRuntime),
+    hash: embeddedRuntimeHash
+  };
+
+  let runtime = await instantiateExtismRuntime(runtimeWasm, fetchWasm, calculateHash);
+
+  return new ExtismPlugin(runtime, moduleData, options);
+
+  function toBytes(base64: string): Uint8Array {
+    const binaryString = window.atob(base64);
+    const len = binaryString.length;
+    const bytes = new Uint8Array(len);
+
+    for (let i = 0; i < len; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
     }
 
-    return data;
+    return bytes;
   }
 
-  private static async calculateHash(data: ArrayBuffer) {
+  async function calculateHash(data: ArrayBuffer) {
     const hashBuffer = await crypto.subtle.digest('SHA-256', data);
     const hashArray = Array.from(new Uint8Array(hashBuffer));
     const hashHex = hashArray.map((byte) => byte.toString(16).padStart(2, '0')).join('');
     return hashHex;
   }
 
-  private static toBytes(base64: string): Uint8Array {
-    const binaryString = window.atob(base64);
-    const len = binaryString.length;
-    const bytes = new Uint8Array(len);
-  
-    for (let i = 0; i < len; i++) {
-      bytes[i] = binaryString.charCodeAt(i);
+  async function fetchWasm(wasm: ManifestWasm): Promise<StreamingSource> {
+    let data: ArrayBuffer;
+
+    if ((wasm as ManifestWasmData).data) {
+      data = (wasm as ManifestWasmData).data;
+    } else if ((wasm as ManifestWasmUrl).url) {
+      // In the browser, it's useful to support relative paths,
+      // so we assume the URL we get doesn't point to local files
+      const url = (wasm as ManifestWasmUrl).url;
+      return await fetch(url);
+    } else {
+      throw new Error(`Unrecognized wasm source: ${wasm}`);
     }
-  
-    return bytes;
+
+    return data;
   }
 }
 
 if (window) {
   // @ts-ignore
-  window.ExtismPlugin = ExtismPlugin;
-  // @ts-ignore
-  window.ExtismPluginOptions = ExtismPluginOptions;
+  window.createPlugin = createPlugin;
 }
 
-export { ExtismPlugin, ExtismPluginOptions, Manifest, ManifestWasm, ManifestWasmData, ManifestWasmFile, ManifestWasmUrl };
+export default createPlugin;
+export type { ExtismPlugin, CurrentPlugin, ExtismPluginOptions, Manifest, ManifestWasm, ManifestWasmData, ManifestWasmUrl };
diff --git a/src/deno/mod.ts b/src/deno/mod.ts
index 38e1af5..4114dab 100644
--- a/src/deno/mod.ts
+++ b/src/deno/mod.ts
@@ -7,41 +7,22 @@ import {
   Manifest,
   ManifestWasm,
   ManifestWasmData,
-  ManifestWasmFile,
   ManifestWasmUrl,
   HttpRequest,
   HttpResponse,
   embeddedRuntime,
-  embeddedRuntimeHash
+  embeddedRuntimeHash,
+  CurrentPlugin,
+  StreamingSource,
+  isURL,
 } from '../plugin.ts';
 import Context from 'https://deno.land/std@0.200.0/wasi/snapshot_preview1.ts';
 import minimatch from 'https://deno.land/x/minimatch@v3.0.4/index.js';
 import { createHash } from 'https://deno.land/std@0.108.0/hash/mod.ts';
 import { decode } from 'https://deno.land/std@0.201.0/encoding/base64.ts';
+import * as path from 'https://deno.land/std@0.102.0/path/mod.ts';
 
 class ExtismPlugin extends ExtismPluginBase {
-  /**
-   * Create a new plugin.
-   * @param manifestData An Extism manifest {@link Manifest} or a Wasm module.
-   * @param options Options for initializing the plugin.
-   * @returns {ExtismPlugin} An initialized plugin.
-   */
-  static async new(
-    manifestData: Manifest | ManifestWasm | ArrayBuffer,
-    options: ExtismPluginOptions,
-  ): Promise<ExtismPlugin> {
-    const moduleData = await fetchModuleData(manifestData, this.fetchWasm, this.calculateHash);
-
-    const runtimeWasm = options.runtime ?? {
-      data: decode(embeddedRuntime),
-      hash: embeddedRuntimeHash,
-    };
-
-    const runtime = await instantiateExtismRuntime(runtimeWasm, this.fetchWasm, this.calculateHash);
-
-    return new ExtismPlugin(runtime, moduleData, options);
-  }
-
   protected supportsHttpRequests(): boolean {
     return false;
   }
@@ -72,21 +53,53 @@ class ExtismPlugin extends ExtismPluginBase {
     context.start({
       exports: {
         memory,
-        _start: () => {},
+        _start: () => { },
       },
     });
   }
+}
+
+/**
+   * Create a new plugin.
+   * @param manifestData An Extism manifest {@link Manifest} or a Wasm module.
+   * @param options Options for initializing the plugin.
+   * @returns {ExtismPlugin} An initialized plugin.
+   */
+async function createPlugin(
+  manifestData: Manifest | ManifestWasm | ArrayBuffer | string | URL,
+  options: ExtismPluginOptions,
+): Promise<ExtismPlugin> {
+
+  if (typeof manifestData === "string" || manifestData instanceof URL) {
+    manifestData = {
+      url: manifestData as string | URL
+    }
+  }
+  
+  const moduleData = await fetchModuleData(manifestData, fetchWasm, calculateHash);
+
+  const runtimeWasm = options.runtime ?? {
+    data: decode(embeddedRuntime),
+    hash: embeddedRuntimeHash,
+  };
+
+  const runtime = await instantiateExtismRuntime(runtimeWasm, fetchWasm, calculateHash);
+
+  return new ExtismPlugin(runtime, moduleData, options);
 
-  private static async fetchWasm(wasm: ManifestWasm): Promise<ArrayBuffer> {
+  async function fetchWasm(wasm: ManifestWasm): Promise<StreamingSource> {
     let data: ArrayBuffer;
 
     if ((wasm as ManifestWasmData).data) {
       data = (wasm as ManifestWasmData).data;
-    } else if ((wasm as ManifestWasmFile).path) {
-      data = await Deno.readFile((wasm as ManifestWasmFile).path);
     } else if ((wasm as ManifestWasmUrl).url) {
-      const response = await fetch((wasm as ManifestWasmUrl).url);
-      data = await response.arrayBuffer();
+      const url = (wasm as ManifestWasmUrl).url;
+      if (isURL(url)) {
+        return await fetch(url);
+      } else {
+        const absolutePath = path.resolve(url as string);
+        return await fetch(`file://${absolutePath}`);
+      }
     } else {
       throw new Error(`Unrecognized wasm source: ${wasm}`);
     }
@@ -94,7 +107,7 @@ class ExtismPlugin extends ExtismPluginBase {
     return data;
   }
 
-  private static calculateHash(data: ArrayBuffer): Promise<string> {
+  function calculateHash(data: ArrayBuffer): Promise<string> {
     return new Promise<string>((resolve) => {
       const hasher = createHash('sha256');
       hasher.update(data);
@@ -103,6 +116,6 @@ class ExtismPlugin extends ExtismPluginBase {
   }
 }
 
-export { ExtismPlugin, ExtismPluginOptions };
+export default createPlugin;
 
-export type { Manifest, ManifestWasm, ManifestWasmData, ManifestWasmFile, ManifestWasmUrl };
+export type { ExtismPlugin, CurrentPlugin, ExtismPluginOptions, Manifest, ManifestWasm, ManifestWasmData, ManifestWasmUrl };
diff --git a/src/node/index.ts b/src/node/index.ts
index 6fcb02d..8c6ad19 100644
--- a/src/node/index.ts
+++ b/src/node/index.ts
@@ -7,43 +7,25 @@ import {
   Manifest,
   ManifestWasm,
   ManifestWasmData,
-  ManifestWasmFile,
   ManifestWasmUrl,
   HttpRequest,
   HttpResponse,
   embeddedRuntime,
   embeddedRuntimeHash,
+  CurrentPlugin,
+  StreamingSource,
+  isURL,
 } from '../plugin';
 import { WASI } from 'wasi';
 import { readFile } from 'fs';
 import { promisify } from 'util';
-import fetch from 'sync-fetch';
+import syncFetch from 'sync-fetch';
+import fetchPolyfill from 'node-fetch';
 import { minimatch } from 'minimatch';
 import { createHash } from 'crypto';
+import path from 'path';
 
 class ExtismPlugin extends ExtismPluginBase {
-  /**
-   * Create a new plugin.
-   * @param manifestData An Extism manifest {@link Manifest} or a Wasm module.
-   * @param options Options for initializing the plugin.
-   * @returns {ExtismPlugin} An initialized plugin.
-   */
-  static async new(
-    manifestData: Manifest | ManifestWasm | Buffer,
-    options: ExtismPluginOptions,
-  ): Promise<ExtismPlugin> {
-    let moduleData = await fetchModuleData(manifestData, this.fetchWasm, this.calculateHash);
-
-    const runtimeWasm = options.runtime ?? {
-      data: this.toBytes(embeddedRuntime),
-      hash: embeddedRuntimeHash
-    };
-
-    let runtime = await instantiateExtismRuntime(runtimeWasm, this.fetchWasm, this.calculateHash);
-
-    return new ExtismPlugin(runtime, moduleData, options);
-  }
-
   protected supportsHttpRequests(): boolean {
     return true;
   }
@@ -51,17 +33,17 @@ class ExtismPlugin extends ExtismPluginBase {
   protected httpRequest(request: HttpRequest, body: Uint8Array | null): HttpResponse {
     let b = body
       ? {
-          buffer: body,
-          byteLength: body.length,
-          byteOffset: 0,
-        }
+        buffer: body,
+        byteLength: body.length,
+        byteOffset: 0,
+      }
       : undefined;
 
     if (request.method == 'GET' || request.method == 'HEAD') {
       b = undefined;
     }
 
-    const response = fetch(request.url, {
+    const response = syncFetch(request.url, {
       headers: request.headers,
       method: request.method,
       body: b,
@@ -86,7 +68,7 @@ class ExtismPlugin extends ExtismPluginBase {
 
     return new PluginWasi(wasi, wasi.wasiImport, instance => this.initialize(wasi, instance));
   }
-  
+
   private initialize(wasi: WASI, instance: WebAssembly.Instance) {
     const memory = instance.exports.memory as WebAssembly.Memory;
 
@@ -97,40 +79,80 @@ class ExtismPlugin extends ExtismPluginBase {
     wasi.start({
       exports: {
         memory,
-        _start: () => {},
+        _start: () => { },
       },
     });
   }
+}
+
+/**
+ * Create a new plugin.
+ * @param manifestData An Extism manifest {@link Manifest} or a Wasm module.
+ * @param options Options for initializing the plugin.
+ * @returns {ExtismPlugin} An initialized plugin.
+ */
+async function createPlugin(
+  manifestData: Manifest | ManifestWasm | ArrayBuffer | string | URL,
+  options: ExtismPluginOptions,
+): Promise<ExtismPlugin> {
+
+  if (typeof manifestData === "string" || manifestData instanceof URL) {
+    manifestData = {
+      url: manifestData as string | URL
+    }
+  }
 
-  private static async fetchWasm(wasm: ManifestWasm): Promise<ArrayBuffer> {
-    let data: ArrayBuffer;
+  let moduleData = await fetchModuleData(manifestData, fetchWasm, calculateHash);
 
-    if ((wasm as ManifestWasmData).data) {
-      data = (wasm as ManifestWasmData).data;
-    } else if ((wasm as ManifestWasmFile).path) {
-      const readFileAsync = (path: string) => promisify(readFile)(path);
+  const runtimeWasm = options.runtime ?? {
+    data: toBytes(embeddedRuntime),
+    hash: embeddedRuntimeHash
+  };
+
+  let runtime = await instantiateExtismRuntime(runtimeWasm, fetchWasm, calculateHash);
 
-      data = await readFileAsync((wasm as ManifestWasmFile).path);
+  return new ExtismPlugin(runtime, moduleData, options);
+
+  async function fetchWasm(wasm: ManifestWasm): Promise<StreamingSource> {
+    if ((wasm as ManifestWasmData).data) {
+      return Promise.resolve((wasm as ManifestWasmData).data);
     } else if ((wasm as ManifestWasmUrl).url) {
-      const response = await fetch((wasm as ManifestWasmUrl).url);
-      data = await response.arrayBuffer();
+      const url = (wasm as ManifestWasmUrl).url;
+
+      let source: StreamingSource;
+      if (isURL(url)) {
+        const response = await fetch(url);
+
+        //@ts-ignore
+        if (WebAssembly.instantiateStreaming) {
+          source = response;
+        } else {
+          source = await response.arrayBuffer();
+        }
+      } else {
+        const readFileAsync = (path: string) => promisify(readFile)(path);
+        const buffer = await readFileAsync(url as string);
+        const array = new Uint8Array(buffer);
+        source = array.buffer.slice(array.byteOffset, array.byteOffset + array.byteLength);
+      }
+
+      return source;
     } else {
       throw new Error(`Unrecognized wasm source: ${wasm}`);
     }
-
-    return data;
   }
-  
-  private static async calculateHash(data: ArrayBuffer) {
+
+  async function calculateHash(data: ArrayBuffer) {
     const hasher = createHash('sha256');
     hasher.update(new Uint8Array(data));
     return new Promise<string>((resolve, _) => resolve(hasher.digest('hex')));
   }
 
-  private static toBytes(base64: string): Uint8Array {
+  function toBytes(base64: string): Uint8Array {
     const buffer = Buffer.from(base64, 'base64');
     return new Uint8Array(buffer);
   }
 }
 
-export { ExtismPlugin, ExtismPluginOptions, Manifest, ManifestWasm, ManifestWasmData, ManifestWasmFile, ManifestWasmUrl };
+export default createPlugin;
+export type { ExtismPlugin, CurrentPlugin, ExtismPluginOptions, Manifest, ManifestWasm, ManifestWasmData, ManifestWasmUrl };
\ No newline at end of file
diff --git a/src/plugin.ts b/src/plugin.ts
index 7577f3f..c69e159 100644
--- a/src/plugin.ts
+++ b/src/plugin.ts
@@ -1,8 +1,6 @@
-
 export abstract class ExtismPluginBase {
-  moduleData: ArrayBuffer;
-  allocator: Allocator;
-  vars: Record<string, Uint8Array>;
+  moduleData: ArrayBuffer | Response | PromiseLike<Response>;
+  currentPlugin: CurrentPlugin;
   input: Uint8Array;
   output: Uint8Array;
   module?: WebAssembly.WebAssemblyInstantiatedSource;
@@ -10,61 +8,13 @@ export abstract class ExtismPluginBase {
   lastStatusCode: number = 0;
   guestRuntime: GuestRuntime;
 
-  constructor(extism: WebAssembly.Instance, moduleData: ArrayBuffer, options: ExtismPluginOptions) {
+  constructor(extism: WebAssembly.Instance, moduleData: ArrayBuffer | Response | PromiseLike<Response>, options: ExtismPluginOptions) {
     this.moduleData = moduleData;
-    this.allocator = new Allocator(extism);
-    this.vars = {};
+    this.currentPlugin = new CurrentPlugin(this, extism);
     this.input = new Uint8Array();
     this.output = new Uint8Array();
     this.options = options;
-    this.guestRuntime = { type: GuestRuntimeType.None, init: () => {}, initialized: true };
-  }
-
-  setVar(name: string, value: Uint8Array | string | number): void {
-    if (value instanceof Uint8Array) {
-      this.vars[name] = value;
-    } else if (typeof value === 'string') {
-      this.vars[name] = new TextEncoder().encode(value);
-    } else if (typeof value === 'number') {
-      this.vars[name] = this.uintToLEBytes(value);
-    } else {
-      throw new Error('Unsupported value type');
-    }
-  }
-
-  getStringVar(name: string): string {
-    return new TextDecoder().decode(this.getVar(name));
-  }
-
-  getNumberVar(name: string): number {
-    const value = this.getVar(name);
-    if (value.length < 4) {
-      throw new Error(`Variable ${name} has incorrect length`);
-    }
-
-    return this.uintFromLEBytes(value);
-  }
-
-  getVar(name: string): Uint8Array {
-    const value = this.vars[name];
-    if (!value) {
-      throw new Error(`Variable ${name} not found`);
-    }
-
-    return value;
-  }
-
-  private uintToLEBytes(num: number): Uint8Array {
-    const bytes = new Uint8Array(4);
-    bytes[0] = num & 0xff;
-    bytes[1] = (num >> 8) & 0xff;
-    bytes[2] = (num >> 16) & 0xff;
-    bytes[3] = (num >> 24) & 0xff;
-    return bytes;
-  }
-
-  private uintFromLEBytes(bytes: Uint8Array): number {
-    return bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24);
+    this.guestRuntime = { type: GuestRuntimeType.None, init: () => { }, initialized: true };
   }
 
   async getExports(): Promise<WebAssembly.Exports> {
@@ -111,7 +61,7 @@ export abstract class ExtismPluginBase {
       throw new Error('Plugin error: input should be string or Uint8Array');
     }
 
-    this.allocator.reset();
+    this.currentPlugin.reset();
 
     let func = module.instance.exports[func_name];
     if (!func) {
@@ -158,7 +108,21 @@ export abstract class ExtismPluginBase {
       }
     }
 
-    this.module = await WebAssembly.instantiate(this.moduleData, imports);
+    for (const m in imports) {
+      if (m === "wasi_snapshot_preview1") {
+        continue;
+      }
+
+      for (const f in imports[m]) {
+        imports[m][f] = imports[m][f].bind(null, this.currentPlugin);
+      }
+    }
+
+    if (this.moduleData instanceof ArrayBuffer || ArrayBuffer.isView(this.moduleData)) {
+      this.module = await WebAssembly.instantiate(this.moduleData, imports);
+    } else {
+      this.module = await WebAssembly.instantiateStreaming(this.moduleData, imports);
+    }
 
     if (this.module.instance.exports._start) {
       pluginWasi?.initialize(this.module.instance);
@@ -170,52 +134,52 @@ export abstract class ExtismPluginBase {
   }
 
   private makeEnv(): any {
-    const plugin = this;
+    let plugin = this;
     var env: any = {
-      extism_alloc(n: bigint): bigint {
-        const response = plugin.allocator.alloc(n);
+      extism_alloc(cp: CurrentPlugin, n: bigint): bigint {
+        const response = cp.alloc(n);
         return response;
       },
-      extism_free(n: bigint) {
-        plugin.allocator.free(n);
+      extism_free(cp: CurrentPlugin, n: bigint) {
+        cp.free(n);
       },
-      extism_load_u8(n: bigint): number {
-        return plugin.allocator.getMemoryBuffer()[Number(n)];
+      extism_load_u8(cp: CurrentPlugin, n: bigint): number {
+        return cp.getMemoryBuffer()[Number(n)];
       },
-      extism_load_u64(n: bigint): bigint {
-        let cast = new DataView(plugin.allocator.getMemory().buffer, Number(n));
+      extism_load_u64(cp: CurrentPlugin, n: bigint): bigint {
+        let cast = new DataView(cp.getMemory().buffer, Number(n));
         return cast.getBigUint64(0, true);
       },
-      extism_store_u8(offset: bigint, n: number) {
-        plugin.allocator.getMemoryBuffer()[Number(offset)] = Number(n);
+      extism_store_u8(cp: CurrentPlugin, offset: bigint, n: number) {
+        cp.getMemoryBuffer()[Number(offset)] = Number(n);
       },
-      extism_store_u64(offset: bigint, n: bigint) {
-        const tmp = new DataView(plugin.allocator.getMemory().buffer, Number(offset));
+      extism_store_u64(cp: CurrentPlugin, offset: bigint, n: bigint) {
+        const tmp = new DataView(cp.getMemory().buffer, Number(offset));
         tmp.setBigUint64(0, n, true);
       },
       extism_input_length(): bigint {
         return BigInt(plugin.input.length);
       },
-      extism_input_load_u8(i: bigint): number {
+      extism_input_load_u8(cp: CurrentPlugin, i: bigint): number {
         return plugin.input[Number(i)];
       },
-      extism_input_load_u64(idx: bigint): bigint {
+      extism_input_load_u64(cp: CurrentPlugin, idx: bigint): bigint {
         let cast = new DataView(plugin.input.buffer, Number(idx));
         return cast.getBigUint64(0, true);
       },
-      extism_output_set(offset: bigint, length: bigint) {
+      extism_output_set(cp: CurrentPlugin, offset: bigint, length: bigint) {
         const offs = Number(offset);
         const len = Number(length);
-        plugin.output = plugin.allocator.getMemoryBuffer().slice(offs, offs + len);
+        plugin.output = cp.getMemoryBuffer().slice(offs, offs + len);
       },
-      extism_error_set(i: bigint) {
-        throw new Error(`Call error: ${plugin.allocator.getString(i)}`);
+      extism_error_set(cp: CurrentPlugin, i: bigint) {
+        throw new Error(`Call error: ${cp.readString(i)}`);
       },
-      extism_config_get(i: bigint): bigint {
+      extism_config_get(cp: CurrentPlugin, i: bigint): bigint {
         if (typeof plugin.options.config === 'undefined') {
           return BigInt(0);
         }
-        const key = plugin.allocator.getString(i);
+        const key = cp.readString(i);
         if (key === null) {
           return BigInt(0);
         }
@@ -223,38 +187,38 @@ export abstract class ExtismPluginBase {
         if (typeof value === 'undefined') {
           return BigInt(0);
         }
-        return plugin.allocator.allocString(value);
+        return cp.writeString(value);
       },
-      extism_var_get(i: bigint): bigint {
-        const key = plugin.allocator.getString(i);
+      extism_var_get(cp: CurrentPlugin, i: bigint): bigint {
+        const key = cp.readString(i);
         if (key === null) {
           return BigInt(0);
         }
-        const value = plugin.vars[key];
+        const value = cp.vars[key];
         if (typeof value === 'undefined') {
           return BigInt(0);
         }
-        return plugin.allocator.allocBytes(value);
+        return cp.writeBytes(value);
       },
-      extism_var_set(n: bigint, i: bigint) {
-        const key = plugin.allocator.getString(n);
+      extism_var_set(cp: CurrentPlugin, n: bigint, i: bigint) {
+        const key = cp.readString(n);
         if (key === null) {
           return;
         }
-        const value = plugin.allocator.getBytes(i);
+        const value = cp.readBytes(i);
         if (value === null) {
           return;
         }
-        plugin.vars[key] = value;
+        cp.vars[key] = value;
       },
-      extism_http_request(requestOffset: bigint, bodyOffset: bigint): bigint {
+      extism_http_request(cp: CurrentPlugin, requestOffset: bigint, bodyOffset: bigint): bigint {
         if (!plugin.supportsHttpRequests()) {
-          plugin.allocator.free(bodyOffset);
-          plugin.allocator.free(requestOffset);
+          cp.free(bodyOffset);
+          cp.free(requestOffset);
           throw new Error('Call error: http requests are not supported.');
         }
 
-        const requestJson = plugin.allocator.getString(requestOffset);
+        const requestJson = cp.readString(requestOffset);
         if (requestJson == null) {
           throw new Error('Call error: Invalid request.');
         }
@@ -264,7 +228,7 @@ export abstract class ExtismPluginBase {
         // The actual code starts here
         const url = new URL(request.url);
         let hostMatches = false;
-        for (const allowedHost of plugin.options.allowedHosts) {
+        for (const allowedHost of (plugin.options.allowedHosts ?? [])) {
           if (allowedHost === url.hostname) {
             hostMatches = true;
             break;
@@ -283,37 +247,37 @@ export abstract class ExtismPluginBase {
         }
 
         // TODO: limit number of bytes read to 50 MiB
-        const body = plugin.allocator.getBytes(bodyOffset);
-        plugin.allocator.free(bodyOffset);
-        plugin.allocator.free(requestOffset);
+        const body = cp.readBytes(bodyOffset);
+        cp.free(bodyOffset);
+        cp.free(requestOffset);
 
         const response = plugin.httpRequest(request, body);
         plugin.lastStatusCode = response.status;
 
-        const offset = plugin.allocator.allocBytes(response.body);
+        const offset = cp.writeBytes(response.body);
 
         return offset;
       },
       extism_http_status_code(): number {
         return plugin.lastStatusCode;
       },
-      extism_length(i: bigint): bigint {
-        return plugin.allocator.getLength(i);
+      extism_length(cp: CurrentPlugin, i: bigint): bigint {
+        return cp.getLength(i);
       },
-      extism_log_warn(i: bigint) {
-        const s = plugin.allocator.getString(i);
+      extism_log_warn(cp: CurrentPlugin, i: bigint) {
+        const s = cp.readString(i);
         console.warn(s);
       },
-      extism_log_info(i: bigint) {
-        const s = plugin.allocator.getString(i);
+      extism_log_info(cp: CurrentPlugin, i: bigint) {
+        const s = cp.readString(i);
         console.log(s);
       },
-      extism_log_debug(i: bigint) {
-        const s = plugin.allocator.getString(i);
+      extism_log_debug(cp: CurrentPlugin, i: bigint) {
+        const s = cp.readString(i);
         console.debug(s);
       },
-      extism_log_error(i: bigint) {
-        const s = plugin.allocator.getString(i);
+      extism_log_error(cp: CurrentPlugin, i: bigint) {
+        const s = cp.readString(i);
         console.error(s);
       },
     };
@@ -322,15 +286,6 @@ export abstract class ExtismPluginBase {
   }
 }
 
-/**
- * Represents a path to a WASM module
- */
-export type ManifestWasmFile = {
-  path: string;
-  name?: string;
-  hash?: string;
-};
-
 /**
  * Represents the raw bytes of a WASM file loaded into memory
  */
@@ -344,7 +299,7 @@ export type ManifestWasmData = {
  * Represents a url to a WASM module
  */
 export type ManifestWasmUrl = {
-  url: string;
+  url: URL | string;
   name?: string;
   hash?: string;
 };
@@ -357,7 +312,7 @@ export type PluginConfig = { [key: string]: string };
 /**
  * The WASM to load as bytes, a path, or a url
  */
-export type ManifestWasm = ManifestWasmUrl | ManifestWasmFile | ManifestWasmData;
+export type ManifestWasm = ManifestWasmUrl | ManifestWasmData;
 
 /**
  * The manifest which describes the {@link ExtismPlugin} code and
@@ -374,122 +329,14 @@ export type Manifest = {
 
 /**
  * Options for initializing an Extism plugin.
- *
- * @class ExtismPluginOptions
  */
-export class ExtismPluginOptions {
-  useWasi: boolean;
-  runtime: ManifestWasm | null;
-  functions: { [key: string]: { [key: string]: any } };
-  allowedPaths: { [key: string]: string };
-  allowedHosts: string[];
-  config: PluginConfig;
-
-  constructor() {
-    this.useWasi = false;
-    this.functions = {};
-    this.runtime = null;
-    this.allowedPaths = {};
-    this.config = {};
-    this.allowedHosts = [];
-  }
-
-  /**
-   * Enable/Disable WASI.
-   */
-  withWasi(value: boolean = true) {
-    this.useWasi = value;
-    return this;
-  }
-
-  /**
-   * Overrides the Extism Runtime.
-   * @param runtime A Wasm source.
-   * @returns ExtismPluginOptions
-   */
-  withRuntime(runtime: ManifestWasm) {
-    this.runtime = runtime;
-    return this;
-  }
-
-  /**
-   * Adds or updates a host function under a specified module name.
-   * @param {string} moduleName - The name of the module.
-   * @param {string} funcName - The name of the function.
-   * @param {any} func - The host function callback.
-   * @returns {this} Returns the current instance for chaining.
-   */
-  withFunction(moduleName: string, funcName: string, func: any) {
-    const x = this.functions[moduleName] ?? {};
-    x[funcName] = func;
-    this.functions[moduleName] = x;
-
-    return this;
-  }
-
-  /**
-   * Adds or updates an allowed path.
-   * If WASI is enabled, the plugin will have access to all allowed paths.
-   * @param {string} dest - The destination path.
-   * @param {string|null} src - The source path. Defaults to the destination if null.
-   * @returns {this} Returns the current instance for chaining.
-   */
-  withAllowedPath(dest: string, src: string | null) {
-    this.allowedPaths[dest] = src || dest;
-    return this;
-  }
-
-  /**
-   * Sets a configuration value that's accessible to the plugin.
-   * The plugin can't change configuration values.
-   * @param {string} key - The configuration key.
-   * @param {string} value - The configuration value.
-   * @returns {this} Returns the current instance for chaining.
-   */
-  withConfig(key: string, value: string) {
-    this.config[key] = value;
-
-    return this;
-  }
-
-  /**
-   * Sets multiple configuration values.
-   * @param {{ [key: string]: string }} configs - An object containing configuration key-value pairs.
-   * @returns {this} Returns the current instance for chaining.
-   */
-  withConfigs(configs: { [key: string]: string }) {
-    for (let key in configs) {
-      this.config[key] = configs[key];
-    }
-
-    return this;
-  }
-
-  /**
-   * Adds a host pattern to the allowed hosts list.
-   * The plugin will be able to make HTTP requests to all allowed hosts.
-   * By default, all hosts are denied.
-   * @param {string} pattern - The host pattern to allow.
-   * @returns {this} Returns the current instance for chaining.
-   */
-  withAllowedHost(pattern: string) {
-    this.allowedHosts.push(pattern.trim());
-
-    return this;
-  }
-
-  /**
-   * Adds multiple host patterns to the allowed hosts list.
-   * @param {string[]} patterns - An array of host patterns to allow.
-   * @returns {this} Returns the current instance for chaining.
-   */
-  withAllowedHosts(patterns: string[]) {
-    for (const pattern of patterns) {
-      this.withAllowedHost(pattern);
-    }
-
-    return this;
-  }
+export interface ExtismPluginOptions {
+  useWasi?: boolean | undefined;
+  runtime?: ManifestWasm | undefined;
+  functions?: { [key: string]: { [key: string]: any } } | undefined;
+  allowedPaths?: { [key: string]: string } | undefined;
+  allowedHosts?: string[] | undefined;
+  config?: PluginConfig | undefined;
 }
 
 /**
@@ -527,12 +374,18 @@ type GuestRuntime = {
   type: GuestRuntimeType;
 };
 
+export type StreamingSource = ArrayBuffer | Response
+
+export function isURL(url: URL | string) {
+  return url instanceof URL || url.includes("://");
+}
+
 export async function fetchModuleData(
   manifestData: Manifest | ManifestWasm | ArrayBuffer,
-  fetchWasm: (wasm: ManifestWasm) => Promise<ArrayBuffer>,
+  fetchWasm: (wasm: ManifestWasm) => Promise<StreamingSource>,
   calculateHash: (buffer: ArrayBuffer) => Promise<string>,
 ) {
-  let moduleData: ArrayBuffer | null = null;
+  let moduleData: StreamingSource | null = null;
 
   if (manifestData instanceof ArrayBuffer) {
     moduleData = manifestData;
@@ -544,17 +397,40 @@ export async function fetchModuleData(
     moduleData = await fetchWasm(wasm);
   } else if (
     (manifestData as ManifestWasmData).data ||
-    (manifestData as ManifestWasmFile).path ||
     (manifestData as ManifestWasmUrl).url
   ) {
     moduleData = await fetchWasm(manifestData as ManifestWasm);
 
+    if (moduleData instanceof Response) {
+      // HACK: WebAssembly.instantiateStreaming only works when the content-type is application/wasm
+      // This can be problematic because a lot of object storages store the content-type
+      // as application/octet-stream by default
+      if (moduleData.headers.get('Content-Type') === 'application/octet-stream') {
+        const headers = new Headers(moduleData.headers);
+        headers.set('Content-Type', 'application/wasm');
+
+        moduleData = new Response(moduleData.body, {
+          status: moduleData.status,
+          statusText: moduleData.statusText,
+          headers: headers,
+        })
+      }
+    }
+
     const expected = (manifestData as ManifestWasm).hash;
 
     if (expected) {
-      const actual = await calculateHash(moduleData);
+      let actual: string;
+      if (moduleData instanceof ArrayBuffer || moduleData instanceof Uint8Array) {
+        actual = await calculateHash(moduleData);
+      } else {
+        // Download the content to check its hash
+        moduleData = await moduleData.arrayBuffer();
+        actual = await calculateHash(moduleData);
+      }
+
       if (actual != expected) {
-        throw new Error('Plugin error: hash mismatch');
+        throw new Error(`Plugin error: hash mismatch. Expected: ${expected}. Actual: ${actual}`);
       }
     }
   }
@@ -616,13 +492,13 @@ function wasiRuntime(module: WebAssembly.Instance): GuestRuntime | null {
 }
 
 function detectGuestRuntime(module: WebAssembly.Instance): GuestRuntime {
-  const none = { init: () => {}, type: GuestRuntimeType.None, initialized: true };
+  const none = { init: () => { }, type: GuestRuntimeType.None, initialized: true };
   return haskellRuntime(module) ?? wasiRuntime(module) ?? none;
 }
 
 export async function instantiateExtismRuntime(
   runtime: ManifestWasm | null,
-  fetchWasm: (wasm: ManifestWasm) => Promise<ArrayBuffer>,
+  fetchWasm: (wasm: ManifestWasm) => Promise<StreamingSource>,
   calculateHash: (buffer: ArrayBuffer) => Promise<string>,
 ): Promise<WebAssembly.Instance> {
   if (!runtime) {
@@ -630,8 +506,13 @@ export async function instantiateExtismRuntime(
   }
 
   const extismWasm = await fetchModuleData(runtime, fetchWasm, calculateHash);
-  const extismModule = new WebAssembly.Module(extismWasm);
-  const extismInstance = new WebAssembly.Instance(extismModule, {});
+
+  let extismInstance: WebAssembly.Instance;
+  if (extismWasm instanceof Response) {
+    extismInstance = (await WebAssembly.instantiateStreaming(extismWasm)).instance;
+  } else {
+    extismInstance = (await WebAssembly.instantiate(extismWasm)).instance;
+  }
 
   return extismInstance;
 }
@@ -651,23 +532,69 @@ export const embeddedRuntime = 'AGFzbQEAAAABMApgAX8AYAN/f38Bf2ACf38AYAF+AX5gAX4A
 
 export const embeddedRuntimeHash = 'aab40a25b5edda3fc5c9d1de1bf17af9ce5d02cbac1bacf5bdfa495b4ab9fc39'
 
-class Allocator {
+export class CurrentPlugin {
+  vars: Record<string, Uint8Array>;
+  plugin: ExtismPluginBase;
   #extism: WebAssembly.Instance;
 
-  /**
-   * Constructs an allocator instance.
-   * @param {WebAssembly.Instance} extism - WebAssembly instance.
-   */
-  constructor(extism: WebAssembly.Instance) {
+  constructor(plugin: ExtismPluginBase, extism: WebAssembly.Instance) {
+    this.vars = {};
+    this.plugin = plugin;
     this.#extism = extism;
   }
 
+  setVar(name: string, value: Uint8Array | string | number): void {
+    if (value instanceof Uint8Array) {
+      this.vars[name] = value;
+    } else if (typeof value === 'string') {
+      this.vars[name] = new TextEncoder().encode(value);
+    } else if (typeof value === 'number') {
+      this.vars[name] = this.uintToLEBytes(value);
+    } else {
+      const typeName = (value as any)?.constructor.name || (value === null ? 'null' : typeof value);
+      throw new TypeError(`Invalid plugin variable type. Expected Uint8Array, string, or number, got ${typeName}`);
+    }
+  }
+
+  readStringVar(name: string): string {
+    return new TextDecoder().decode(this.getVar(name));
+  }
+
+  getNumberVar(name: string): number {
+    const value = this.getVar(name);
+    if (value.length < 4) {
+      throw new Error(`Variable "${name}" has incorrect length`);
+    }
+
+    return this.uintFromLEBytes(value);
+  }
+
+  getVar(name: string): Uint8Array {
+    const value = this.vars[name];
+    if (!value) {
+      throw new Error(`Variable ${name} not found`);
+    }
+
+    return value;
+  }
+
+  private uintToLEBytes(num: number): Uint8Array {
+    const bytes = new Uint8Array(4);
+    new DataView(bytes.buffer).setUint32(0, num, true);
+
+    return bytes;
+  }
+
+  private uintFromLEBytes(bytes: Uint8Array): number {
+    return new DataView(bytes.buffer).getUint32(0, true);
+  }
+
   /**
    * Resets Extism memory.
    * @returns {void}
    */
   reset() {
-    return (this.#extism.exports.extism_reset as Function).call(undefined);
+    return (this.#extism.exports.extism_reset as Function)();
   }
 
   /**
@@ -676,7 +603,7 @@ class Allocator {
    * @returns {bigint} Offset in the memory.
    */
   alloc(length: bigint): bigint {
-    return (this.#extism.exports.extism_alloc as Function).call(undefined, length);
+    return (this.#extism.exports.extism_alloc as Function)(length);
   }
 
   /**
@@ -700,7 +627,7 @@ class Allocator {
    * @param {bigint} offset - Memory offset.
    * @returns {Uint8Array | null} Byte array or null if offset is zero.
    */
-  getBytes(offset: bigint): Uint8Array | null {
+  readBytes(offset: bigint): Uint8Array | null {
     if (offset == BigInt(0)) {
       return null;
     }
@@ -708,7 +635,7 @@ class Allocator {
     const length = this.getLength(offset);
 
     const buffer = new Uint8Array(this.getMemory().buffer, Number(offset), Number(length));
-    
+
     // Copy the buffer because `this.getMemory().buffer` returns a write-through view
     return new Uint8Array(buffer);
   }
@@ -718,8 +645,8 @@ class Allocator {
    * @param {bigint} offset - Memory offset.
    * @returns {string | null} Decoded string or null if offset is zero.
    */
-  getString(offset: bigint): string | null {
-    const bytes = this.getBytes(offset);
+  readString(offset: bigint): string | null {
+    const bytes = this.readBytes(offset);
     if (bytes === null) {
       return null;
     }
@@ -732,7 +659,7 @@ class Allocator {
    * @param {Uint8Array} data - Byte array to allocate.
    * @returns {bigint} Memory offset.
    */
-  allocBytes(data: Uint8Array): bigint {
+  writeBytes(data: Uint8Array): bigint {
     const offs = this.alloc(BigInt(data.length));
     const buffer = new Uint8Array(this.getMemory().buffer, Number(offs), data.length);
     buffer.set(data);
@@ -744,9 +671,9 @@ class Allocator {
    * @param {string} data - String to allocate.
    * @returns {bigint} Memory offset.
    */
-  allocString(data: string): bigint {
+  writeString(data: string): bigint {
     const bytes = new TextEncoder().encode(data);
-    return this.allocBytes(bytes);
+    return this.writeBytes(bytes);
   }
 
   /**
@@ -755,7 +682,11 @@ class Allocator {
    * @returns {bigint} Length of the memory block.
    */
   getLength(offset: bigint): bigint {
-    return (this.#extism.exports.extism_length as Function).call(undefined, offset);
+    return (this.#extism.exports.extism_length as Function)(offset);
+  }
+
+  inputLength(): bigint {
+    return (this.#extism.exports.extism_input_length as Function)();
   }
 
   /**
@@ -768,6 +699,6 @@ class Allocator {
       return;
     }
 
-    (this.#extism.exports.extism_free as Function).call(undefined, offset);
+    (this.#extism.exports.extism_free as Function)(offset);
   }
-}
+}
\ No newline at end of file
diff --git a/tests/index.test.ts b/tests/index.test.ts
index 35dc7a1..b9bcb63 100644
--- a/tests/index.test.ts
+++ b/tests/index.test.ts
@@ -1,28 +1,29 @@
-import { ExtismPlugin, ExtismPluginOptions, Manifest, ManifestWasm } from '../src/node/index';
+import createPlugin, { CurrentPlugin, ExtismPlugin, ExtismPluginOptions, Manifest, ManifestWasm } from '../src/node/index';
 
 async function newPlugin(
   moduleName: string | Manifest | ManifestWasm | Buffer,
   optionsConfig?: (opts: ExtismPluginOptions) => void): Promise<ExtismPlugin> {
-  let options = new ExtismPluginOptions()
-    .withRuntime({
-      path: 'wasm/extism-runtime.wasm',
-    })
-    .withWasi();
+  const options: ExtismPluginOptions = {
+    useWasi: true,
+    runtime: {
+      url: 'wasm/extism-runtime.wasm',
+    },
+  }
 
   if (optionsConfig) {
     optionsConfig(options);
   }
 
-  let module : Manifest | ManifestWasm | Buffer;
+  let module: Manifest | ManifestWasm | Buffer;
   if (typeof moduleName == 'string') {
     module = {
-      path: `wasm/${moduleName}`,
+      url: `wasm/${moduleName}`,
     };
   } else {
     module = moduleName;
   }
 
-  const plugin = await ExtismPlugin.new(module, options);
+  const plugin = await createPlugin(module, options);
   return plugin;
 }
 
@@ -32,7 +33,15 @@ function decode(buffer: Uint8Array) {
 }
 
 describe('test extism', () => {
-  test('can create plugin from url', async () => {
+  test('can create plugin from string', async () => {
+    const plugin = await createPlugin("wasm/code.wasm", {
+      useWasi: true
+    });
+    
+    expect(await plugin.functionExists('count_vowels')).toBe(true);
+  });
+
+  test('can create plugin from url with hash check', async () => {
     const plugin = await newPlugin({
       url: "https://raw.githubusercontent.com/extism/extism/main/wasm/code.wasm",
       hash: "7def5bb4aa3843a5daf5d6078f1e8540e5ef10b035a9d9387e9bd5156d2b2565"
@@ -41,23 +50,31 @@ describe('test extism', () => {
     expect(await plugin.functionExists('count_vowels')).toBe(true);
   });
 
+  test('can create plugin from url', async () => {
+    const plugin = await newPlugin({
+      url: "https://raw.githubusercontent.com/extism/extism/main/wasm/code.wasm",
+    });
+
+    expect(await plugin.functionExists('count_vowels')).toBe(true);
+  });
+
   test('fails on hash mismatch', async () => {
     await expect(newPlugin({
-      path: "wasm/code.wasm",
+      url: "wasm/code.wasm",
       name: "code",
       hash: "-----------"
     })).rejects.toThrow(/Plugin error/);
   });
 
   test('can use embedded runtime', async () => {
-    const options = new ExtismPluginOptions().withWasi();
-
     let module = {
-      path: `wasm/code.wasm`,
+      url: `wasm/code.wasm`,
     };
-  
-    const plugin = await ExtismPlugin.new(module, options);
-  
+
+    const plugin = await createPlugin(module, {
+      useWasi: true
+    });
+
     let output = await plugin.call('count_vowels', 'this is a test');
 
     let result = JSON.parse(decode(output));
@@ -104,12 +121,15 @@ describe('test extism', () => {
 
   test('host functions works', async () => {
     const plugin = await newPlugin('code-functions.wasm', options => {
-      options.withFunction("env", "hello_world", (off: bigint) => {
-        let result = JSON.parse(plugin.allocator.getString(off) ?? "");
-        result['message'] = "hello from host!";
-
-        return plugin.allocator.allocString(JSON.stringify(result));
-      });
+      options.functions = {
+        "env": {
+          "hello_world": function (cp: CurrentPlugin, off: bigint) {
+            const result = JSON.parse(cp.readString(off) ?? '');
+            result['message'] = 'hello from host!';
+            return plugin.currentPlugin.writeString(JSON.stringify(result));
+          }
+        }
+      }
     });
 
     const output = await plugin.call('count_vowels', 'aaa');
@@ -128,12 +148,12 @@ describe('test extism', () => {
 
   test('can allow http requests', async () => {
     const plugin = await newPlugin('http.wasm', options => {
-      options.withAllowedHost("*.typicode.com");
+      options.allowedHosts = ['*.typicode.com'];
     });
-    
+
     const output = await plugin.call("run_test", "");
     const result = JSON.parse(decode(output));
-    
+
     expect(result.id).toBe(1);
   });
 
@@ -142,64 +162,51 @@ describe('test extism', () => {
     console.warn = jest.fn();
     console.error = jest.fn();
     console.debug = jest.fn();
-    
+
     const plugin = await newPlugin('log.wasm', options => {
-      options.withAllowedHost("*.typicode.com");
+      options.allowedHosts = ['*.typicode.com'];
     });
-    
+
     const _ = await plugin.call("run_test", "");
-    
+
     expect(console.log).toHaveBeenCalledWith("this is an info log");
     expect(console.warn).toHaveBeenCalledWith("this is a warning log");
     expect(console.error).toHaveBeenCalledWith("this is an erorr log");
     expect(console.debug).toHaveBeenCalledWith("this is a debug log");
   });
 
-  test('can get and set vars', async () => {
-    const plugin = await newPlugin('var.wasm');
-    plugin.setVar("a", 10);
-    
-    const _ = await plugin.call("run_test", "");
-
-    expect(plugin.getNumberVar("a")).toBe(20);
-
-    const __ = await plugin.call("run_test", "");
-
-    expect(plugin.getNumberVar("a")).toBe(40);
-  });
-  
   test('can initialize haskell runtime', async () => {
     console.trace = jest.fn();
-    
+
     const plugin = await newPlugin('hello_haskell.wasm', options => {
-      options.withConfig("greeting", "Howdy");
+      options.config = { 'greeting': 'Howdy' };
     });
-    
+
     {
       const output = await plugin.call("testing", "John");
       const result = decode(output);
-      
+
       expect(result).toBe("Howdy, John")
     }
-    
+
     {
       const output = await plugin.call("testing", "Ben");
       const result = decode(output);
-      
+
       expect(result).toBe("Howdy, Ben")
     }
-    
+
     expect(console.debug).toHaveBeenCalledWith("Haskell (normal) runtime detected.");
   });
 
   test('can read file', async () => {
     const plugin = await newPlugin('fs.wasm', options => {
-      options.withAllowedPath("/mnt", "tests/data")
+      options.allowedPaths = { '/mnt': 'tests/data' };
     });
-  
+
     const output = await plugin.call("run_test", "");
     const result = decode(output);
-  
+
     expect(result).toBe("hello world!");
   });
 });
diff --git a/tests/mod.test.ts b/tests/mod.test.ts
index ba26c7c..23abc03 100644
--- a/tests/mod.test.ts
+++ b/tests/mod.test.ts
@@ -1,16 +1,18 @@
 import { assertEquals, assertRejects } from 'https://deno.land/std@0.200.0/assert/mod.ts';
 import { assertSpyCalls, spy } from 'https://deno.land/std@0.200.0/testing/mock.ts';
-import { ExtismPlugin, ExtismPluginOptions, Manifest, ManifestWasm } from '../src/deno/mod.ts';
+import createPlugin, { CurrentPlugin, ExtismPlugin, ExtismPluginOptions, Manifest, ManifestWasm } from '../src/deno/mod.ts';
 
 async function newPlugin(
   moduleName: string | Manifest | ManifestWasm,
   optionsConfig?: (opts: ExtismPluginOptions) => void,
 ): Promise<ExtismPlugin> {
-  const options = new ExtismPluginOptions()
-    .withRuntime({
-      path: 'wasm/extism-runtime.wasm',
-    })
-    .withWasi();
+
+  const options: ExtismPluginOptions = {
+    useWasi: true,
+    runtime: {
+      url: 'wasm/extism-runtime.wasm',
+    },
+  }
 
   if (optionsConfig) {
     optionsConfig(options);
@@ -19,13 +21,13 @@ async function newPlugin(
   let module: Manifest | ManifestWasm;
   if (typeof moduleName == 'string') {
     module = {
-      path: `wasm/${moduleName}`,
+      url: `wasm/${moduleName}`,
     };
   } else {
     module = moduleName;
   }
 
-  const plugin = await ExtismPlugin.new(module, options);
+  const plugin = await createPlugin(module, options);
   return plugin;
 }
 
@@ -34,6 +36,14 @@ function decode(buffer: Uint8Array) {
   return decoder.decode(buffer);
 }
 
+Deno.test('can create plugin from string', async () => {
+  const plugin = await createPlugin("wasm/code.wasm", {
+    useWasi: true
+  });
+  
+  assertEquals(await plugin.functionExists('count_vowels'), true);
+});
+
 Deno.test('can create plugin from url', async () => {
   const plugin = await newPlugin({
     url: 'https://raw.githubusercontent.com/extism/extism/main/wasm/code.wasm',
@@ -47,7 +57,7 @@ Deno.test('fails on hash mismatch', async () => {
   await assertRejects(
     () =>
       newPlugin({
-        path: 'wasm/code.wasm',
+        url: 'wasm/code.wasm',
         hash: '----',
       }),
     Error,
@@ -56,13 +66,13 @@ Deno.test('fails on hash mismatch', async () => {
 });
 
 Deno.test('can use embedded runtime', async () => {
-  const options = new ExtismPluginOptions().withWasi();
-
   let module = {
-    path: `wasm/code.wasm`,
+    url: `wasm/code.wasm`,
   };
 
-  const plugin = await ExtismPlugin.new(module, options);
+  const plugin = await createPlugin(module, {
+    useWasi: true
+  });
 
   let output = await plugin.call('count_vowels', 'this is a test');
   let result = JSON.parse(decode(output));
@@ -107,11 +117,15 @@ Deno.test('errors when function is not known', async () => {
 
 Deno.test('host functions works', async () => {
   const plugin = await newPlugin('code-functions.wasm', (options) => {
-    options.withFunction('env', 'hello_world', (off: bigint) => {
-      const result = JSON.parse(plugin.allocator.getString(off) ?? '');
-      result['message'] = 'hello from host!';
-      return plugin.allocator.allocString(JSON.stringify(result));
-    });
+    options.functions = {
+      "env": {
+        "hello_world": function (cp: CurrentPlugin, off: bigint) {
+          const result = JSON.parse(cp.readString(off) ?? '');
+          result['message'] = 'hello from host!';
+          return plugin.currentPlugin.writeString(JSON.stringify(result));
+        }
+      }
+    }
   });
 
   const output = await plugin.call('count_vowels', 'aaa');
@@ -142,7 +156,7 @@ Deno.test('can deny http requests', async () => {
 
 Deno.test('can allow http requests', async () => {
   const plugin = await newPlugin('http.wasm', (options) => {
-    options.withAllowedHost('*.typicode.com');
+    options.allowedHosts = ['*.typicode.com'];
   });
 
   // http is not supported in Deno
@@ -171,22 +185,9 @@ Deno.test('can log messages', async () => {
   assertSpyCalls(debugSpy, 1);
 });
 
-Deno.test('can get and set vars', async () => {
-  const plugin = await newPlugin('var.wasm');
-  plugin.setVar('a', 10);
-
-  const _ = await plugin.call('run_test', '');
-
-  assertEquals(plugin.getNumberVar('a'), 20);
-
-  const __ = await plugin.call('run_test', '');
-
-  assertEquals(plugin.getNumberVar('a'), 40);
-});
-
 Deno.test('can initialize Haskell runtime', async () => {
   const plugin = await newPlugin('hello_haskell.wasm', (options) => {
-    options.withConfig('greeting', 'Howdy');
+    options.config = { 'greeting': 'Howdy' };
   });
 
   let output = await plugin.call('testing', 'John');
@@ -200,7 +201,7 @@ Deno.test('can initialize Haskell runtime', async () => {
 
 Deno.test('can access fs', async () => {
   const plugin = await newPlugin('fs.wasm', (options) => {
-    options.withAllowedPath('/mnt', 'tests/data');
+    options.allowedPaths = { '/mnt': 'tests/data' };
   });
 
   const output = await plugin.call('run_test', '');