diff --git a/src/assembler/asm.c b/src/assembler/asm.c
index 1187a451..2d33f37e 100644
--- a/src/assembler/asm.c
+++ b/src/assembler/asm.c
@@ -30,7 +30,7 @@
 /* Convert a slot to to an integer for bytecode */
 
 /* Types of instructions (some of them) */
-/* _0arg - op.---.--.-- (return-nil, noop, vararg arguments) 
+/* _0arg - op.---.--.-- (return-nil, noop, vararg arguments)
  * _s - op.src.--.-- (push1)
  * _l - op.XX.XX.XX (jump)
  * _ss - op.dest.XX.XX (move, swap)
@@ -200,7 +200,7 @@ static void dst_asm_errorv(DstAssembler *a, const uint8_t *m) {
 }
 
 /* Add a closure environment to the assembler. Sub funcdefs may need
- * to reference outer function environments, and may change the outer environment. 
+ * to reference outer function environments, and may change the outer environment.
  * Returns the index of the environment in the assembler's environments, or -1
  * if not found.  */
 static int32_t dst_asm_addenv(DstAssembler *a, Dst envname) {
@@ -360,7 +360,7 @@ static uint32_t doarg(
 
 /* Provide parsing methods for the different kinds of arguments */
 static uint32_t read_instruction(
-        DstAssembler *a, 
+        DstAssembler *a,
         const DstInstructionDef *idef,
         const Dst *argt) {
     uint32_t instr = idef->opcode;
@@ -516,7 +516,7 @@ static DstAssembleResult dst_asm1(DstAssembler *parent, Dst source, int flags) {
         return result;
     }
 
-    dst_asm_assert(&a, 
+    dst_asm_assert(&a,
             dst_checktype(s, DST_STRUCT) ||
             dst_checktype(s, DST_TABLE),
             "expected struct or table for assembly source");
@@ -547,7 +547,7 @@ static DstAssembleResult dst_asm1(DstAssembler *parent, Dst source, int flags) {
             Dst v = arr[i];
             if (dst_checktype(v, DST_TUPLE)) {
                 const Dst *t = dst_unwrap_tuple(v);
-                int32_t j; 
+                int32_t j;
                 for (j = 0; j < dst_tuple_length(t); j++) {
                     if (!dst_checktype(t[j], DST_SYMBOL))
                         dst_asm_error(&a, "slot names must be symbols");
@@ -681,7 +681,7 @@ static DstAssembleResult dst_asm1(DstAssembler *parent, Dst source, int flags) {
         dst_asm_error(&a, "bytecode expected");
     }
     a.errindex = -1;
-    
+
     /* Check for source mapping */
     x = dst_get(s, dst_csymbolv("sourcemap"));
     if (dst_seq_view(x, &arr, &count)) {
@@ -737,7 +737,7 @@ static const DstInstructionDef *dst_asm_reverse_lookup(uint32_t instr) {
     uint32_t opcode = instr & 0x7F;
     for (i = 0; i < sizeof(dst_ops)/sizeof(DstInstructionDef); i++) {
         const DstInstructionDef *def = dst_ops + i;
-        if (def->opcode == opcode) 
+        if (def->opcode == opcode)
             return def;
     }
     return NULL;
@@ -792,23 +792,23 @@ Dst dst_asm_decode_instruction(uint32_t instr) {
         case DIT_SC:
         case DIT_SU:
         case DIT_SD:
-            return tup3(name, 
+            return tup3(name,
                     dst_wrap_integer(oparg(1, 0xFF)),
                     dst_wrap_integer(oparg(2, 0xFFFF)));
         case DIT_SI:
         case DIT_SL:
-            return tup3(name, 
+            return tup3(name,
                     dst_wrap_integer(oparg(1, 0xFF)),
                     dst_wrap_integer((int32_t)instr >> 16));
         case DIT_SSS:
         case DIT_SES:
         case DIT_SSU:
-            return tup4(name, 
+            return tup4(name,
                     dst_wrap_integer(oparg(1, 0xFF)),
                     dst_wrap_integer(oparg(2, 0xFF)),
                     dst_wrap_integer(oparg(3, 0xFF)));
         case DIT_SSI:
-            return tup4(name, 
+            return tup4(name,
                     dst_wrap_integer(oparg(1, 0xFF)),
                     dst_wrap_integer(oparg(2, 0xFF)),
                     dst_wrap_integer((int32_t)instr >> 24));
@@ -825,7 +825,7 @@ Dst dst_disasm(DstFuncDef *def) {
     dst_table_put(ret, dst_csymbolv("arity"), dst_wrap_integer(def->arity));
     dst_table_put(ret, dst_csymbolv("bytecode"), dst_wrap_array(bcode));
     if (NULL != def->sourcepath) {
-        dst_table_put(ret, dst_csymbolv("sourcepath"), 
+        dst_table_put(ret, dst_csymbolv("sourcepath"),
                 dst_wrap_string(def->sourcepath));
     }
     if (NULL != def->source) {
diff --git a/src/compiler/boot.dst b/src/compiler/boot.dst
index 10080d98..4df5d219 100644
--- a/src/compiler/boot.dst
+++ b/src/compiler/boot.dst
@@ -950,7 +950,7 @@ onvalue."
     :pc pc
     :c c
     :name name
-    } (get st i))
+   } (get st i))
    (file.write stdout "  in")
    (when c (file.write stdout " cfunction"))
    (when name (file.write stdout (string " " name)))
@@ -978,48 +978,73 @@ environment is needed, use run-context."
   "./?/init.dst"
   "./dst_modules/?.dst"
   "./dst_modules/?/init.dst"
+  "/usr/local/dst/0.0.0/?.dst"
+  "/usr/local/dst/0.0.0/?/init.dst"
  ])
 
-(defn module.find
-  "Open a file given a module name."
-  [name]
-  (def normname (string.replace-all "." "/" name))
-  (defn checkmodule
-    [f testpath]
-    (if f f (do
-      (def p (string.replace-all "?" normname testpath))
-      (def p (string.replace-all "?" normname testpath))
-      (file.open p))))
-  (reduce checkmodule nil module.paths))
+(def module.native-paths @[
+  "./?.so"
+  "./dst_modules/?.so"
+  "/usr/local/dst/0.0.0/?.so"
+ ])
 
 (def require
  "Require a module with the given name. Will search all of the paths in
 module.paths, then the path as a raw file path. Returns the new environment
 returned from compiling and running the file."
  (do
- (def cache @{})
- (def loading @{})
- (fn [path]
+
+   (defn transform
+    [path paths]
+    (def normname (string.replace-all "." "/" path))
+    (array.push
+      (map (fn [x] (string.replace "?" normname x)) paths)
+      path))
+
+  (defn check-mod
+    [f testpath]
+    (if f f (file.open testpath)))
+
+  (defn find-mod [path]
+    (def paths (transform path module.paths))
+    (reduce check-mod nil paths))
+
+  (defn check-native
+    [p testpath]
+    (if p p (do
+      (def f (file.open testpath))
+      (if f (do (file.close f) testpath)))))
+
+  (defn find-native [path]
+    (def paths (transform path module.native-paths))
+    (reduce check-native nil paths))
+
+  (def cache @{})
+  (def loading @{})
+  (fn [path]
    (when (get loading path)
     (error (string "circular dependency: module " path " is loading")))
    (def check (get cache path))
    (if check check (do
-     (if (or
-          (= ".so" (string.slice path -3 -1))
-          (= ".dll" (string.slice path -4 -1)))
-      ((native path))
-      (do
-       (def newenv (make-env))
-       (put cache path newenv)
-       (put loading path true)
-       (def f (or (module.find path) (file.open path)))
-       (if (not f)
-         (error (string "could not open file for module " path)))
-       (defn chunks [buf] (file.read f 1024 buf))
-       (run-context newenv chunks identity default-error-handler)
-       (file.close f)
-       (put loading path nil)
-       newenv)))))))
+     (def newenv (make-env))
+     (put cache path newenv)
+     (put loading path true)
+
+     (def f (find-mod path))
+     (if f 
+       (do
+         # Normal dst module
+         (defn chunks [buf] (file.read f 1024 buf))
+         (run-context newenv chunks identity default-error-handler)
+         (file.close f)
+         (put loading path nil)
+         newenv)
+       (do 
+         # Try native module
+         (def n (find-native path))
+         (if (not n)
+           (error (string "could not open file for module " path)))
+         ((native n)))))))))
 
 (defn import* [env path & args]
  (def newenv (require path))
diff --git a/src/compiler/cfuns.c b/src/compiler/cfuns.c
index 6c7d6c0d..940c6e26 100644
--- a/src/compiler/cfuns.c
+++ b/src/compiler/cfuns.c
@@ -134,7 +134,7 @@ static const DstCFunOptimizer optimizers[] = {
 const DstCFunOptimizer *dstc_cfunopt(DstCFunction cfun) {
     size_t i;
     size_t n = sizeof(optimizers)/sizeof(DstCFunOptimizer);
-    for (i = 0; i < n; i++) 
+    for (i = 0; i < n; i++)
         if (optimizers[i].cfun == cfun)
             return optimizers + i;
     return NULL;
diff --git a/src/compiler/compile.c b/src/compiler/compile.c
index 1781b098..a7f2e5bd 100644
--- a/src/compiler/compile.c
+++ b/src/compiler/compile.c
@@ -112,7 +112,7 @@ static void slotalloci(DstCompiler *c, int32_t index) {
 void dstc_sfreei(DstCompiler *c, int32_t index) {
     DstScope *scope = &dst_v_last(c->scopes);
     /* Don't free the pre allocated slots */
-    if (index >= 0 && (index < 0xF0 || index > 0xFF) && 
+    if (index >= 0 && (index < 0xF0 || index > 0xFF) &&
             index < (dst_v_count(scope->slots) << 5))
         scope->slots[index >> 5] &= ~(1 << (index & 0x1F));
 }
@@ -182,7 +182,7 @@ void dstc_popscope(DstCompiler *c) {
     if (!(scope.flags & (DST_SCOPE_FUNCTION | DST_SCOPE_UNUSED)) && oldcount > 1) {
         int32_t i;
         DstScope *newscope = &dst_v_last(c->scopes);
-        if (newscope->smax < scope.smax) 
+        if (newscope->smax < scope.smax)
             newscope->smax = scope.smax;
 
         /* Keep upvalue slots */
@@ -320,7 +320,7 @@ DstSlot dstc_resolve(
         }
         scope++;
     }
-    
+
     ret.envindex = envindex;
     return ret;
 }
@@ -372,7 +372,7 @@ static void dstc_loadconst(DstCompiler *c, DstAst *ast, Dst k, int32_t dest) {
             {
                 int32_t i = dst_unwrap_integer(k);
                 if (i <= INT16_MAX && i >= INT16_MIN) {
-                    dstc_emit(c, ast, 
+                    dstc_emit(c, ast,
                             (i << 16) |
                             (dest << 8) |
                             DOP_LOAD_INTEGER);
@@ -384,7 +384,7 @@ static void dstc_loadconst(DstCompiler *c, DstAst *ast, Dst k, int32_t dest) {
         do_constant:
             {
                 int32_t cindex = dstc_const(c, ast, k);
-                dstc_emit(c, ast, 
+                dstc_emit(c, ast,
                         (cindex << 16) |
                         (dest << 8) |
                         DOP_LOAD_CONSTANT);
@@ -412,26 +412,26 @@ int32_t dstc_preread(
         dstc_loadconst(c, ast, s.constant, ret);
         /* If we also are a reference, deref the one element array */
         if (s.flags & DST_SLOT_REF) {
-            dstc_emit(c, ast, 
+            dstc_emit(c, ast,
                     (ret << 16) |
                     (ret << 8) |
                     DOP_GET_INDEX);
         }
     } else if (s.envindex >= 0 || s.index > max) {
         ret = dstc_lslotn(c, max, nth);
-        dstc_emit(c, ast, 
+        dstc_emit(c, ast,
                 ((uint32_t)(s.index) << 24) |
                 ((uint32_t)(s.envindex) << 16) |
                 ((uint32_t)(ret) << 8) |
                 DOP_LOAD_UPVALUE);
     } else if (s.index > max) {
         ret = dstc_lslotn(c, max, nth);
-        dstc_emit(c, ast, 
+        dstc_emit(c, ast,
                 ((uint32_t)(s.index) << 16) |
                 ((uint32_t)(ret) << 8) |
                     DOP_MOVE_NEAR);
     } else {
-        /* We have a normal slot that fits in the required bit width */            
+        /* We have a normal slot that fits in the required bit width */
         ret = s.index;
     }
     return ret;
@@ -517,7 +517,7 @@ void dstc_copy(
         }
         return;
     }
-    
+
     /* Process: src -> srclocal -> destlocal -> dest */
 
     /* src -> srclocal */
@@ -550,14 +550,14 @@ void dstc_copy(
                 DOP_MOVE_NEAR);
     }
 
-    /* destlocal -> dest */ 
+    /* destlocal -> dest */
     if (writeback == 1) {
         dstc_emit(c, ast,
                 (destlocal << 16) |
                 (reflocal << 8) |
                 DOP_PUT_INDEX);
     } else if (writeback == 2) {
-        dstc_emit(c, ast, 
+        dstc_emit(c, ast,
                 ((uint32_t)(dest.index) << 24) |
                 ((uint32_t)(dest.envindex) << 16) |
                 ((uint32_t)(destlocal) << 8) |
@@ -646,7 +646,7 @@ void dstc_pushslots(DstCompiler *c, DstAst *ast, DstSM *sms) {
         int32_t ls1 = dstc_preread(c, sms[i].map, 0xFF, 1, sms[i].slot);
         int32_t ls2 = dstc_preread(c, sms[i + 1].map, 0xFF, 2, sms[i + 1].slot);
         int32_t ls3 = dstc_preread(c, sms[i + 2].map, 0xFF, 3, sms[i + 2].slot);
-        dstc_emit(c, ast, 
+        dstc_emit(c, ast,
                 (ls3 << 24) |
                 (ls2 << 16) |
                 (ls1 << 8) |
@@ -658,7 +658,7 @@ void dstc_pushslots(DstCompiler *c, DstAst *ast, DstSM *sms) {
     if (i == dst_v_count(sms) - 2) {
         int32_t ls1 = dstc_preread(c, sms[i].map, 0xFF, 1, sms[i].slot);
         int32_t ls2 = dstc_preread(c, sms[i + 1].map, 0xFFFF, 2, sms[i + 1].slot);
-        dstc_emit(c, ast, 
+        dstc_emit(c, ast,
                 (ls2 << 16) |
                 (ls1 << 8) |
                 DOP_PUSH_2);
@@ -666,7 +666,7 @@ void dstc_pushslots(DstCompiler *c, DstAst *ast, DstSM *sms) {
         dstc_postread(c, sms[i + 1].slot, ls2);
     } else if (i == dst_v_count(sms) - 1) {
         int32_t ls1 = dstc_preread(c, sms[i].map, 0xFFFFFF, 1, sms[i].slot);
-        dstc_emit(c, ast, 
+        dstc_emit(c, ast,
                 (ls1 << 8) |
                 DOP_PUSH);
         dstc_postread(c, sms[i].slot, ls1);
@@ -694,7 +694,7 @@ void dstc_throwaway(DstFopts opts, Dst x) {
     dstc_popscope(c);
     if (NULL != c->buffer) {
         dst_v__cnt(c->buffer) = bufstart;
-        if (NULL != c->mapbuffer) 
+        if (NULL != c->mapbuffer)
             dst_v__cnt(c->mapbuffer) = mapbufstart;
     }
 }
@@ -762,7 +762,7 @@ DstSlot dstc_symbol(DstFopts opts, DstAst *ast, const uint8_t *sym) {
     } else {
         /* Keyword */
         return dstc_cslot(dst_wrap_symbol(sym));
-    } 
+    }
 }
 
 /* Compile a single value */
@@ -850,10 +850,10 @@ recur:
             }
             break;
         case DST_ARRAY:
-            ret = dstc_array(opts, ast, x); 
+            ret = dstc_array(opts, ast, x);
             break;
         case DST_STRUCT:
-            ret = dstc_tablector(opts, ast, x, dst_core_struct); 
+            ret = dstc_tablector(opts, ast, x, dst_core_struct);
             break;
         case DST_TABLE:
             ret = dstc_tablector(opts, ast, x, dst_core_table);
diff --git a/src/compiler/compile.h b/src/compiler/compile.h
index cc3d2e5a..b912a757 100644
--- a/src/compiler/compile.h
+++ b/src/compiler/compile.h
@@ -104,7 +104,7 @@ struct DstScope {
 struct DstCompiler {
     int recursion_guard;
     DstScope *scopes;
-    
+
     uint32_t *buffer;
     DstAst **mapbuffer;
 
diff --git a/src/core/array.c b/src/core/array.c
index 4e2bcfa3..3c1056d8 100644
--- a/src/core/array.c
+++ b/src/core/array.c
@@ -216,7 +216,7 @@ static int cfun_concat(DstArgs args) {
             case DST_ARRAY:
             case DST_TUPLE:
                 {
-                    int32_t j, len;       
+                    int32_t j, len;
                     const Dst *vals;
                     dst_seq_view(args.v[i], &vals, &len);
                     for (j = 0; j < len; j++)
diff --git a/src/core/buffer.c b/src/core/buffer.c
index a550a2a5..5c90b582 100644
--- a/src/core/buffer.c
+++ b/src/core/buffer.c
@@ -190,7 +190,7 @@ static int cfun_int(DstArgs args) {
     for (i = 1; i < args.n; i++) {
         int32_t integer;
         DST_ARG_INTEGER(integer, args, i);
-        if (dst_buffer_push_u32(buffer, (uint32_t) integer)) 
+        if (dst_buffer_push_u32(buffer, (uint32_t) integer))
             DST_THROW(args, "buffer overflow");
     }
     DST_RETURN(args, args.v[0]);
@@ -205,7 +205,7 @@ static int cfun_chars(DstArgs args) {
         int32_t len;
         const uint8_t *str;
         DST_ARG_BYTES(str, len, args, i);
-        if (dst_buffer_push_bytes(buffer, str, len)) 
+        if (dst_buffer_push_bytes(buffer, str, len))
             DST_THROW(args, "buffer overflow");
     }
     DST_RETURN(args, args.v[0]);
diff --git a/src/core/bytecode.c b/src/core/bytecode.c
index f64eb84e..90eba80d 100644
--- a/src/core/bytecode.c
+++ b/src/core/bytecode.c
@@ -191,7 +191,7 @@ int32_t dst_verify(DstFuncDef *def) {
         }
     }
 
-    /* Verify last instruction is either a jump, return, return-nil, or tailcall. Eventually, 
+    /* Verify last instruction is either a jump, return, return-nil, or tailcall. Eventually,
      * some real flow analysis would be ideal, but this should be very effective. Will completely
      * prevent running over the end of bytecode. However, valid functions with dead code will
      * be rejected. */
diff --git a/src/core/corelib.c b/src/core/corelib.c
index e4f9016c..4e2dc9ef 100644
--- a/src/core/corelib.c
+++ b/src/core/corelib.c
@@ -149,7 +149,7 @@ int dst_core_array(DstArgs args) {
 int dst_core_table(DstArgs args) {
     int32_t i;
     DstTable *table = dst_table(args.n >> 1);
-    if (args.n & 1) 
+    if (args.n & 1)
         DST_THROW(args, "expected even number of arguments");
     for (i = 0; i < args.n; i += 2) {
         dst_table_put(table, args.v[i], args.v[i + 1]);
diff --git a/src/core/gc.c b/src/core/gc.c
index 03a77608..b6a55b1b 100644
--- a/src/core/gc.c
+++ b/src/core/gc.c
@@ -189,7 +189,7 @@ recur:
     dst_gc_mark(fiber);
 
     dst_mark_function(fiber->root);
-    
+
     i = fiber->frame;
     j = fiber->stackstart - DST_FRAME_SIZE;
     while (i > 0) {
@@ -218,7 +218,7 @@ static void dst_deinit_block(DstGCMemoryHeader *block) {
     switch (block->flags & DST_MEM_TYPEBITS) {
         default:
         case DST_MEMORY_FUNCTION:
-            break; /* Do nothing for non gc types */ 
+            break; /* Do nothing for non gc types */
         case DST_MEMORY_SYMBOL:
             dst_symbol_deinit((const uint8_t *)mem + 2 * sizeof(int32_t));
             break;
@@ -233,7 +233,7 @@ static void dst_deinit_block(DstGCMemoryHeader *block) {
             break;
         case DST_MEMORY_BUFFER:
             dst_buffer_deinit((DstBuffer *) mem);
-            break; 
+            break;
         case DST_MEMORY_ABSTRACT:
             if (h->type->gc) {
                 if (h->type->gc((void *)(h + 1), h->size)) {
diff --git a/src/core/io.c b/src/core/io.c
index dfbbca2f..d10185be 100644
--- a/src/core/io.c
+++ b/src/core/io.c
@@ -228,7 +228,7 @@ static int dst_io_fread(DstArgs args) {
             DST_RETURN(args, dst_wrap_buffer(b));
         } else {
             DST_THROW(args, "expected one of :all, :line");
-        } 
+        }
     } else if (!dst_checktype(args.v[1], DST_INTEGER)) {
         DST_THROW(args, "expected positive integer");
     } else {
diff --git a/src/core/os.c b/src/core/os.c
index 326ae5e6..d03001f6 100644
--- a/src/core/os.c
+++ b/src/core/os.c
@@ -35,7 +35,7 @@
 
 static int os_execute(DstArgs args) {
     int nofirstarg = (args.n < 1 || !dst_checktype(args.v[0], DST_STRING));
-    const char *cmd = nofirstarg 
+    const char *cmd = nofirstarg
         ? NULL
         : (const char *) dst_unwrap_string(args.v[0]);
     int stat = system(cmd);
diff --git a/src/core/state.h b/src/core/state.h
index 3fb6c5bc..15ce6c05 100644
--- a/src/core/state.h
+++ b/src/core/state.h
@@ -32,7 +32,7 @@ extern "C" {
 #include <dst/dsttypes.h>
 
 /* The VM state. Rather than a struct that is passed
- * around, the vm state is global for simplicity. If 
+ * around, the vm state is global for simplicity. If
  * at some point a a global state object, or context,
  * is required to be passed around, this is waht would
  * be in it. However, thread local globals for interpreter
diff --git a/src/core/string.c b/src/core/string.c
index 70e26ddc..de3ff201 100644
--- a/src/core/string.c
+++ b/src/core/string.c
@@ -202,7 +202,7 @@ static void string_description_b(DstBuffer *buffer, const char *title, void *poi
     buffer->count += string_description_impl(buffer->data + buffer->count, title, pointer);
 }
 
-/* Describes a pointer with a title (string_description("bork",  myp) returns 
+/* Describes a pointer with a title (string_description("bork",  myp) returns
  * a string "<bork 0x12345678>") */
 static const uint8_t *string_description(const char *title, void *pointer) {
     uint8_t buf[BUFSIZE];
@@ -212,7 +212,7 @@ static const uint8_t *string_description(const char *title, void *pointer) {
 #undef HEX
 #undef BUFSIZE
 
-/* TODO - add more characters to escape. 
+/* TODO - add more characters to escape.
  *
  * When more escapes are added, they must correspond
  * to dst_escape_string_impl exactly or a buffer overrun could occur. */
@@ -282,7 +282,7 @@ const uint8_t *dst_escape_string(const uint8_t *str) {
     int32_t len = dst_string_length(str);
     int32_t elen = dst_escape_string_length(str, len);
     uint8_t *buf = dst_string_begin(elen);
-    dst_escape_string_impl(buf, str, len); 
+    dst_escape_string_impl(buf, str, len);
     return dst_string_end(buf);
 }
 
@@ -315,8 +315,8 @@ void dst_description_b(DstBuffer *buffer, Dst x) {
         integer_to_string_b(buffer, dst_unwrap_integer(x));
         return;
     case DST_SYMBOL:
-        dst_buffer_push_bytes(buffer, 
-                dst_unwrap_string(x), 
+        dst_buffer_push_bytes(buffer,
+                dst_unwrap_string(x),
                 dst_string_length(dst_unwrap_string(x)));
         return;
     case DST_STRING:
@@ -328,7 +328,7 @@ void dst_description_b(DstBuffer *buffer, Dst x) {
     case DST_ABSTRACT:
         {
             const char *n = dst_abstract_type(dst_unwrap_abstract(x))->name;
-            return string_description_b(buffer, 
+            return string_description_b(buffer,
                     n[0] == ':' ? n + 1 : n,
                     dst_unwrap_abstract(x));
         }
@@ -344,13 +344,13 @@ void dst_to_string_b(DstBuffer *buffer, Dst x) {
             dst_description_b(buffer, x);
             break;
         case DST_BUFFER:
-            dst_buffer_push_bytes(buffer, 
+            dst_buffer_push_bytes(buffer,
                     dst_unwrap_buffer(x)->data,
                     dst_unwrap_buffer(x)->count);
             break;
         case DST_STRING:
         case DST_SYMBOL:
-            dst_buffer_push_bytes(buffer, 
+            dst_buffer_push_bytes(buffer,
                     dst_unwrap_string(x),
                     dst_string_length(dst_unwrap_string(x)));
             break;
@@ -386,7 +386,7 @@ const uint8_t *dst_description(Dst x) {
     case DST_ABSTRACT:
         {
             const char *n = dst_abstract_type(dst_unwrap_abstract(x))->name;
-            return string_description( 
+            return string_description(
                     n[0] == ':' ? n + 1 : n,
                     dst_unwrap_abstract(x));
         }
@@ -418,7 +418,7 @@ const uint8_t *dst_formatc(const char *format, ...) {
     const uint8_t *ret;
     DstBuffer buffer;
     DstBuffer *bufp = &buffer;
-    
+
     /* Calculate length */
     while (format[len]) len++;
 
@@ -440,13 +440,13 @@ const uint8_t *dst_formatc(const char *format, ...) {
                 if (i + 1 >= len)
                     break;
                 switch (format[++i]) {
-                    default: 
+                    default:
                         dst_buffer_push_u8(bufp, format[i]);
                         break;
-                    case 'f': 
+                    case 'f':
                         real_to_string_b(bufp, va_arg(args, double));
                         break;
-                    case 'd': 
+                    case 'd':
                         integer_to_string_b(bufp, va_arg(args, int32_t));
                         break;
                     case 'S':
@@ -472,12 +472,12 @@ const uint8_t *dst_formatc(const char *format, ...) {
                         dst_buffer_push_cstring(bufp, dst_type_names[va_arg(args, DstType)] + 1);
                         break;
                     }
-                    case 'V': 
+                    case 'V':
                     {
                         dst_to_string_b(bufp, va_arg(args, Dst));
                         break;
                     }
-                    case 'v': 
+                    case 'v':
                     {
                         dst_description_b(bufp, va_arg(args, Dst));
                         break;
@@ -852,6 +852,39 @@ static int cfun_split(DstArgs args) {
     DST_RETURN_ARRAY(args, array);
 }
 
+static int cfun_checkset(DstArgs args) {
+    const uint8_t *set, *str;
+    int32_t setlen, strlen, i;
+    uint32_t bitset[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+    DST_MINARITY(args, 2);
+    DST_MAXARITY(args, 3);
+    DST_ARG_BYTES(set, setlen, args, 0);
+    DST_ARG_BYTES(str, strlen, args, 1);
+    /* Populate set */
+    for (i = 0; i < setlen; i++) {
+        int index = set[i] >> 5;
+        uint32_t mask = 1 << (set[i] & 7);
+        bitset[index] |= mask;
+    }
+    if (args.n == 3) {
+        int invert;
+        DST_ARG_BOOLEAN(invert, args, 2);
+        if (invert) {
+            for (i = 0; i < 8; i++)
+                bitset[i] = ~bitset[i];
+        }
+    }
+    /* Check set */
+    for (i = 0; i < strlen; i++) {
+        int index = str[i] >> 5;
+        uint32_t mask = 1 << (str[i] & 7);
+        if (!(bitset[index] & mask)) {
+            DST_RETURN_FALSE(args);
+        }
+    }
+    DST_RETURN_TRUE(args);
+}
+
 static const DstReg cfuns[] = {
     {"string.slice", cfun_slice},
     {"string.repeat", cfun_repeat},
@@ -865,6 +898,7 @@ static const DstReg cfuns[] = {
     {"string.replace", cfun_replace},
     {"string.replace-all", cfun_replaceall},
     {"string.split", cfun_split},
+    {"string.check-set", cfun_checkset},
     {NULL, NULL}
 };
 
diff --git a/src/core/strtod.c b/src/core/strtod.c
index de3c76cb..4bfdf4eb 100644
--- a/src/core/strtod.c
+++ b/src/core/strtod.c
@@ -29,7 +29,7 @@
  *
  * This version has been modified for much greater flexibility in parsing, such
  * as choosing the radix, supporting integer output, and returning Dsts
- * directly. 
+ * directly.
  *
  * Numbers are of the form [-+]R[rR]I.F[eE&][-+]X where R is the radix, I is
  * the integer part, F is the fractional part, and X is the exponent. All
@@ -117,7 +117,7 @@ static double convert(
             }
         }
     }
-    
+
     return negative
         ? -ldexp(mantissa, exponent2)
         : ldexp(mantissa, exponent2);
@@ -137,11 +137,11 @@ struct DstScanRes {
 
 /* Get the mantissa and exponent of decimal number. The
  * mantissa will be stored in a 64 bit unsigned integer (always positive).
- * The exponent will be in a signed 32 bit integer. Will also check if 
+ * The exponent will be in a signed 32 bit integer. Will also check if
  * the decimal point has been seen. Returns -1 if there is an invalid
  * number. */
 static struct DstScanRes dst_scan_impl(
-        const uint8_t *str, 
+        const uint8_t *str,
         int32_t len) {
 
     struct DstScanRes res;
@@ -257,11 +257,11 @@ static struct DstScanRes dst_scan_impl(
             seenadigit = 1;
         }
         if (eneg) res.ex -= ee; else res.ex += ee;
-    } 
+    }
 
     if (!seenadigit)
         goto error;
-    
+
     return res;
 
     error:
@@ -277,7 +277,7 @@ int32_t dst_scan_integer(
         int *err) {
     struct DstScanRes res = dst_scan_impl(str, len);
     int64_t i64;
-    if (res.error) goto error; 
+    if (res.error) goto error;
     if (res.seenpoint) goto error;
     if (res.ex < 0) goto error;
     i64 = res.neg ? -res.mant : res.mant;
diff --git a/src/core/struct.c b/src/core/struct.c
index e5b0bb2f..bc3d126d 100644
--- a/src/core/struct.c
+++ b/src/core/struct.c
@@ -60,7 +60,7 @@ const DstKV *dst_struct_find(const DstKV *st, Dst key) {
 
 /* Put a kv pair into a struct that has not yet been fully constructed.
  * Nil keys and values are ignored, extra keys are ignore, and duplicate keys are
- * ignored. 
+ * ignored.
  *
  * Runs will be in sorted order, as the collisions resolver essentially
  * preforms an in-place insertion sort. This ensures the internal structure of the
diff --git a/src/core/util.c b/src/core/util.c
index 66679df4..79b956fa 100644
--- a/src/core/util.c
+++ b/src/core/util.c
@@ -253,13 +253,13 @@ int dst_typemany_err(DstArgs args, int32_t n, int expected) {
 int dst_arity_err(DstArgs args, int32_t n, const char *prefix) {
     DST_THROWV(args,
             dst_wrap_string(dst_formatc(
-                    "expected %s%d argument%s, got %d", 
+                    "expected %s%d argument%s, got %d",
                     prefix, n, n == 1 ? "" : "s", args.n)));
 }
 
 int dst_typeabstract_err(DstArgs args, int32_t n, const DstAbstractType *at) {
     DST_THROWV(args,
             dst_wrap_string(dst_formatc(
-                    "bad slot #%d, expected %s, got %s", 
-                    n, at->name, typestr(args, n)))); 
+                    "bad slot #%d, expected %s, got %s",
+                    n, at->name, typestr(args, n))));
 }
diff --git a/src/core/value.c b/src/core/value.c
index 80cc978a..da853190 100644
--- a/src/core/value.c
+++ b/src/core/value.c
@@ -151,7 +151,7 @@ int dst_compare(Dst x, Dst y) {
                     return dst_unwrap_string(x) > dst_unwrap_string(y) ? 1 : -1;
                 }
         }
-    } 
+    }
     return (dst_type(x) < dst_type(y)) ? -1 : 1;
 }
 
@@ -198,7 +198,7 @@ Dst dst_get(Dst ds, Dst key) {
  * error message, and NULL if no error. */
 void dst_put(Dst ds, Dst key, Dst value) {
     switch (dst_type(ds)) {
-    case DST_ARRAY: 
+    case DST_ARRAY:
     {
         int32_t index;
         DstArray *array = dst_unwrap_array(ds);
diff --git a/src/core/vm.c b/src/core/vm.c
index bda273f8..aa653134 100644
--- a/src/core/vm.c
+++ b/src/core/vm.c
@@ -288,7 +288,7 @@ static void *op_lookup[255] = {
 
     VM_OP(DOP_SUBTRACT)
     vm_binop(-);
-        
+
     VM_OP(DOP_MULTIPLY_INTEGER)
     vm_binop_integer(*);
 
@@ -303,17 +303,17 @@ static void *op_lookup[255] = {
 
     VM_OP(DOP_DIVIDE_INTEGER)
     vm_assert(dst_unwrap_integer(stack[oparg(3, 0xFF)]) != 0, "integer divide error");
-    vm_assert(!(dst_unwrap_integer(stack[oparg(3, 0xFF)]) == -1 && 
+    vm_assert(!(dst_unwrap_integer(stack[oparg(3, 0xFF)]) == -1 &&
                 dst_unwrap_integer(stack[oparg(2, 0xFF)]) == INT32_MIN),
             "integer divide error");
     vm_binop_integer(/);
-    
+
     VM_OP(DOP_DIVIDE_IMMEDIATE)
     {
         int32_t op1 = dst_unwrap_integer(stack[oparg(2, 0xFF)]);
         int32_t op2 = *((int32_t *)pc) >> 24;
         /* Check for degenerate integer division (divide by zero, and dividing
-         * min value by -1). These checks could be omitted if the arg is not 
+         * min value by -1). These checks could be omitted if the arg is not
          * 0 or -1. */
         if (op2 == 0)
             vm_throw("integer divide error");
@@ -362,7 +362,7 @@ static void *op_lookup[255] = {
     VM_OP(DOP_BNOT)
     stack[oparg(1, 0xFF)] = dst_wrap_integer(~dst_unwrap_integer(stack[oparg(2, 0xFFFF)]));
     vm_next();
-        
+
     VM_OP(DOP_SHIFT_RIGHT_UNSIGNED)
     stack[oparg(1, 0xFF)] = dst_wrap_integer(
         (int32_t)(((uint32_t)dst_unwrap_integer(stack[oparg(2, 0xFF)]))
@@ -655,7 +655,7 @@ static void *op_lookup[255] = {
         stack[oparg(1, 0xFF)] = dst_wrap_function(fn);
         pc++;
         vm_checkgc_next();
-    } 
+    }
 
     VM_OP(DOP_PUSH)
         dst_fiber_push(fiber, stack[oparg(1, 0xFFFFFF)]);
@@ -664,7 +664,7 @@ static void *op_lookup[255] = {
         vm_checkgc_next();
 
     VM_OP(DOP_PUSH_2)
-        dst_fiber_push2(fiber, 
+        dst_fiber_push2(fiber,
                 stack[oparg(1, 0xFF)],
                 stack[oparg(2, 0xFFFF)]);
     pc++;
@@ -672,7 +672,7 @@ static void *op_lookup[255] = {
     vm_checkgc_next();
 
     VM_OP(DOP_PUSH_3)
-        dst_fiber_push3(fiber, 
+        dst_fiber_push3(fiber,
                 stack[oparg(1, 0xFF)],
                 stack[oparg(2, 0xFF)],
                 stack[oparg(3, 0xFF)]);
@@ -685,7 +685,7 @@ static void *op_lookup[255] = {
         const Dst *vals;
         int32_t len;
         if (dst_seq_view(stack[oparg(1, 0xFFFFFF)], &vals, &len)) {
-            dst_fiber_pushn(fiber, vals, len);        
+            dst_fiber_pushn(fiber, vals, len);
         } else {
             vm_throw("expected array/tuple");
         }
@@ -871,7 +871,7 @@ static void *op_lookup[255] = {
         dst_gcunroot(dst_wrap_fiber(fiber));
         dst_vm_fiber = old_vm_fiber;
         *out = retreg;
-        /* All statuses correspond to signals except new and alive, 
+        /* All statuses correspond to signals except new and alive,
          * which cannot be entered when exiting the vm loop.
          * DST_SIGNAL_OK -> DST_STATUS_DEAD
          * DST_SIGNAL_YIELD -> DST_STATUS_PENDING */
@@ -888,7 +888,7 @@ static void *op_lookup[255] = {
         stack[oparg(1, 0xFF)] = retreg;
         pc++;
         vm_checkgc_next();
-    }   
+    }
 
     VM_END()