Broken Pipe error on windows should just be end of stream.

Make sure all test logs go to the same stream.
Invert status check for (Read/Write)File
2025-11-14 14:27:13 +00:00 · 2020-11-14 16:03:51 -06:00 · 2020-11-14 15:56:48 -06:00 · 2020-11-14 15:52:01 -06:00 · 2020-11-14 15:48:21 -06:00 · 2020-11-14 15:44:19 -06:00
54 changed files with 3609 additions and 812 deletions
--- a/.gitattributes
+++ b/.gitattributes
@@ -1 +1,10 @@
 *.janet linguist-language=Clojure
+
+*.janet text eol=lf
+*.c text eol=lf
+*.h text eol=lf
+*.md text eol=lf
+*.yml text eol=lf
+*.build text eol=lf
+*.txt text eol=lf
+*.sh text eol=lf
--- a/.gitignore
+++ b/.gitignore
@@ -32,6 +32,9 @@ lockfile.janet
 # Local directory for testing
 local

+# Common test file I use.
+temp.janet
+
 # Emscripten
 *.bc
 janet.js
@@ -43,6 +46,7 @@ janet.wasm

 # Generate test files
 *.out
+.orig

 # Tools
 xxd
@@ -50,6 +54,7 @@ xxd.exe

 # VSCode
 .vs
+.clangd

 # Swap files
 *.swp
@@ -61,6 +66,10 @@ tags
 vgcore.*
 *.out.*

+# Wix artifacts
+*.msi
+*.wixpdb
+
 # Created by https://www.gitignore.io/api/c

 ### C ###
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,10 +2,29 @@
 All notable changes to this project will be documented in this file.

 ## Unreleased - ???
+- Add `janet_thread_current(void)` to C API
+- Add integer parsing forms to pegs. This makes parsing many binary protocols easier.
+- Lots of updates to networking code - now can use epoll (or poll) on linux and IOCP on windows.
+- Add `ev/` module. This exposes a fiber scheduler, queues, timeouts, and other functionality to users
+  for single threaded cooperative scheduling and asynchornous IO.
+- Add `net/accept-loop` and `net/listen`. These functions break down `net/server` into it's essential parts
+  and are more flexible. They also allow furter improvements to these utility functions.
+
+## 1.12.2 - 2020-09-20
+- Add janet\_try and janet\_restore to C API.
+- Fix `os/execute` regression on windows.
+- Add :pipe option to `os/spawn`.
+- Fix docstring typos.
+
+## 1.12.1 - 2020-09-07
+- Make `zero?`, `one?`, `pos?`, and `neg?` polymorphic.
+- Add C++ support to jpm and improve C++ interop in janet.h.
+- Add `%t` formatter to `printf`, `string/format`, and other formatter functions.
+- Expose `janet_cfuns_prefix` in C API.
 - Add `os/proc-wait` and `os/proc-kill` for interacting with processes.
 - Add `janet_getjfile` to C API.
- Allow redirection of stdin, stdout, and stderr by passing keywords in the env table.
- Add `:a` flag to `os/execute` to get a core/process back instead of an exit code.
+- Allow redirection of stdin, stdout, and stderr by passing keywords in the env table in `os/spawn` and `os/execute`.
+- Add `os/spawn` to get a core/process back instead of an exit code as in `os/execute`.
  When called like this, `os/execute` returns immediately.
 - Add `:x` flag to os/execute to raise error when exit code is non-zero.
 - Don't run `main` when flychecking.
--- a/16
+++ b/16
@@ -97,6 +97,7 @@ JANET_CORE_SOURCES=src/core/abstract.c \
 				   src/core/corelib.c \
 				   src/core/debug.c \
 				   src/core/emit.c \
+				   src/core/ev.c \
 				   src/core/fiber.c \
 				   src/core/gc.c \
 				   src/core/inttypes.c \
@@ -141,7 +142,7 @@ JANET_BOOT_OBJECTS=$(patsubst src/%.c,build/%.boot.o,$(JANET_CORE_SOURCES) $(JAN

 $(JANET_BOOT_OBJECTS): $(JANET_BOOT_HEADERS)

-build/%.boot.o: src/%.c $(JANET_HEADERS) $(JANET_LOCAL_HEADERS)
+build/%.boot.o: src/%.c $(JANET_HEADERS) $(JANET_LOCAL_HEADERS) Makefile
 	$(CC) $(BOOT_CFLAGS) -o $@ -c $<

 build/janet_boot: $(JANET_BOOT_OBJECTS)
@@ -149,13 +150,14 @@ build/janet_boot: $(JANET_BOOT_OBJECTS)

 # Now the reason we bootstrap in the first place
 build/janet.c: build/janet_boot src/boot/boot.janet
-	build/janet_boot . JANET_PATH '$(JANET_PATH)' JANET_HEADERPATH '$(INCLUDEDIR)/janet' > $@
+	build/janet_boot . JANET_PATH '$(JANET_PATH)' > $@
+	cksum $@

 ########################
 ##### Amalgamation #####
 ########################

-SONAME=libjanet.so.1.11
+SONAME=libjanet.so.1.12

 build/shell.c: src/mainclient/shell.c
 	cp $< $@
@@ -260,7 +262,7 @@ build/janet.pc: $(JANET_TARGET)
 	echo 'Libs: -L$${libdir} -ljanet' >> $@
 	echo 'Libs.private: $(CLIBS)' >> $@

-install: $(JANET_TARGET) build/janet.pc build/jpm
+install: $(JANET_TARGET) $(JANET_LIBRARY) $(JANET_STATIC_LIBRARY) build/janet.pc build/jpm
 	mkdir -p '$(DESTDIR)$(BINDIR)'
 	cp $(JANET_TARGET) '$(DESTDIR)$(BINDIR)/janet'
 	mkdir -p '$(DESTDIR)$(INCLUDEDIR)/janet'
@@ -300,6 +302,10 @@ grammar: build/janet.tmLanguage
 build/janet.tmLanguage: tools/tm_lang_gen.janet $(JANET_TARGET)
 	$(JANET_TARGET) $< > $@

+compile-commands:
+	# Requires pip install copmiledb
+	compiledb make
+
 clean:
 	-rm -rf build vgcore.* callgrind.*
 	-rm -rf test/install/build test/install/modpath
@@ -341,4 +347,4 @@ help:
 	@echo

 .PHONY: clean install repl debug valgrind test \
-	valtest dist uninstall docs grammar format help
+	valtest dist uninstall docs grammar format help compile-commands
--- a/README.md
+++ b/README.md
@@ -14,9 +14,9 @@ lisp-like language, but lists are replaced
 by other data structures (arrays, tables (hash table), struct (immutable hash table), tuples).
 The language also supports bridging to native code written in C, meta-programming with macros, and bytecode assembly.

-There is a repl for trying out the language, as well as the ability
+There is a REPL for trying out the language, as well as the ability
 to run script files. This client program is separate from the core runtime, so
-Janet can be embedded into other programs. Try Janet in your browser at
+Janet can be embedded in other programs. Try Janet in your browser at
 [https://janet-lang.org](https://janet-lang.org).

 <br>
@@ -30,23 +30,23 @@ Lua, but smaller than GNU Guile or Python.
 ## Features

 * Minimal setup - one binary and you are good to go!
-* First class closures
+* First-class closures
 * Garbage collection
-* First class green threads (continuations)
-* Python style generators (implemented as a plain macro)
+* First-class green threads (continuations)
+* Python-style generators (implemented as a plain macro)
 * Mutable and immutable arrays (array/tuple)
 * Mutable and immutable hashtables (table/struct)
 * Mutable and immutable strings (buffer/string)
 * Macros
 * Byte code interpreter with an assembly interface, as well as bytecode verification
-* Tailcall Optimization
+* Tail call Optimization
 * Direct interop with C via abstract types and C functions
 * Dynamically load C libraries
 * Functional and imperative standard library
 * Lexical scoping
 * Imperative programming as well as functional
 * REPL
-* Parsing Expression Grammars built in to the core library
+* Parsing Expression Grammars built into the core library
 * 400+ functions and macros in the core library
 * Embedding Janet in other programs
 * Interactive environment with detailed stack traces
@@ -56,7 +56,7 @@ Lua, but smaller than GNU Guile or Python.
 * For a quick tutorial, see [the introduction](https://janet-lang.org/docs/index.html) for more details.
 * For the full API for all functions in the core library, see [the core API doc](https://janet-lang.org/api/index.html)

-Documentation is also available locally in the repl.
+Documentation is also available locally in the REPL.
 Use the `(doc symbol-name)` macro to get API
 documentation for symbols in the core library. For example,
 ```
@@ -66,7 +66,7 @@ Shows documentation for the doc macro.

 To get a list of all bindings in the default
 environment, use the `(all-bindings)` function. You
-can also use the `(doc)` macro with no arguments if you are in the repl
+can also use the `(doc)` macro with no arguments if you are in the REPL
 to show bound symbols.

 ## Source
@@ -92,7 +92,7 @@ Find out more about the available make targets by running `make help`.

 ### 32-bit Haiku

-32-bit Haiku build instructions are the same as the unix-like build instructions,
+32-bit Haiku build instructions are the same as the UNIX-like build instructions,
 but you need to specify an alternative compiler, such as `gcc-x86`.

 ```
@@ -104,7 +104,7 @@ make repl

 ### FreeBSD

-FreeBSD build instructions are the same as the unix-like build instuctions,
+FreeBSD build instructions are the same as the UNIX-like build instructions,
 but you need `gmake` to compile. Alternatively, install directly from
 packages, using `pkg install lang/janet`.

@@ -117,7 +117,7 @@ gmake repl

 ### NetBSD

-NetBSD build instructions are the same as the FreeBSD build instuctions.
+NetBSD build instructions are the same as the FreeBSD build instructions.
 Alternatively, install directly from packages, using `pkgin install janet`.

 ### Windows
@@ -136,11 +136,11 @@ Now you should have an `.msi`. You can run `build_win install` to install the `.

 ### Meson

-Janet also has a build file for [Meson](https://mesonbuild.com/), a cross platform build
-system. Although Meson has a python dependency, Meson is a very complete build system that
+Janet also has a build file for [Meson](https://mesonbuild.com/), a cross-platform build
+system. Although Meson has a Python dependency, Meson is a very complete build system that
 is maybe more convenient and flexible for integrating into existing pipelines.
 Meson also provides much better IDE integration than Make or batch files, as well as support
-for cross compilation.
+for cross-compilation.

 For the impatient, building with Meson is as follows. The options provided to
 `meson setup` below emulate Janet's Makefile.
@@ -177,11 +177,11 @@ to try out the language, you don't need to install anything. You can also move t

 ## Usage

-A repl is launched when the binary is invoked with no arguments. Pass the -h flag
+A REPL is launched when the binary is invoked with no arguments. Pass the -h flag
 to display the usage information. Individual scripts can be run with `./janet myscript.janet`

 If you are looking to explore, you can print a list of all available macros, functions, and constants
-by entering the command `(all-bindings)` into the repl.
+by entering the command `(all-bindings)` into the REPL.

 ```
 $ janet
@@ -199,13 +199,13 @@ Options are:
  -v : Print the version string
  -s : Use raw stdin instead of getline like functionality
  -e code : Execute a string of janet
-  -r : Enter the repl after running all scripts
-  -p : Keep on executing if there is a top level error (persistent)
-  -q : Hide prompt, logo, and repl output (quiet)
+  -r : Enter the REPL after running all scripts
+  -p : Keep on executing if there is a top-level error (persistent)
+  -q : Hide prompt, logo, and REPL output (quiet)
  -k : Compile scripts but do not execute (flycheck)
  -m syspath : Set system path for loading global modules
  -c source output : Compile janet source code into an image
-  -n : Disable ANSI color output in the repl
+  -n : Disable ANSI color output in the REPL
  -l path : Execute code in a file before running the main script
  -- : Stop handling options
 ```
@@ -232,16 +232,16 @@ See the examples directory for some example janet code.

 ## Discussion

-Feel free to ask questions and join discussion on the [Janet Gitter Channel](https://gitter.im/janet-language/community).
+Feel free to ask questions and join the discussion on the [Janet Gitter Channel](https://gitter.im/janet-language/community).
 Alternatively, check out [the #janet channel on Freenode](https://webchat.freenode.net/)

 ## FAQ

-### Why is my terminal spitting out junk when I run the repl?
+### Why is my terminal spitting out junk when I run the REPL?

 Make sure your terminal supports ANSI escape codes. Most modern terminals will
 support these, but some older terminals, Windows consoles, or embedded terminals
-will not. If your terminal does not support ANSI escape codes, run the repl with
+will not. If your terminal does not support ANSI escape codes, run the REPL with
 the `-n` flag, which disables color output. You can also try the `-s` if further issues
 ensue.

--- a/build_win.bat
+++ b/build_win.bat
@@ -102,6 +102,7 @@ exit /b 0
 mkdir dist
 janet.exe tools\gendoc.janet > dist\doc.html
 janet.exe tools\removecr.janet dist\doc.html
+janet.exe tools\removecr.janet build\janet.c

 copy build\janet.c dist\janet.c
 copy src\mainclient\shell.c dist\shell.c
--- a/examples/assembly.janet
+++ b/examples/assembly.janet
@@ -1,23 +1,22 @@
 # Example of dst bytecode assembly

 # Fibonacci sequence, implemented with naive recursion.
-(def fibasm (asm '{
-  arity 1
-  bytecode [
-    (ltim 1 0 0x2)      # $1 = $0 < 2
-    (jmpif 1 :done)     # if ($1) goto :done
-    (lds 1)             # $1 = self
-    (addim 0 0 -0x1)    # $0 = $0 - 1
-    (push 0)            # push($0), push argument for next function call
-    (call 2 1)          # $2 = call($1)
-    (addim 0 0 -0x1)    # $0 = $0 - 1
-    (push 0)            # push($0)
-    (call 0 1)          # $0 = call($1)
-    (add 0 0 2)        # $0 = $0 + $2 (integers)
-    :done
-    (ret 0)             # return $0
-  ]
-}))
+(def fibasm
+  (asm
+    '{:arity 1
+      :bytecode @[(ltim 1 0 0x2)   # $1 = $0 < 2
+                  (jmpif 1 :done)  # if ($1) goto :done
+                  (lds 1)          # $1 = self
+                  (addim 0 0 -0x1) # $0 = $0 - 1
+                  (push 0)         # push($0), push argument for next function call
+                  (call 2 1)       # $2 = call($1)
+                  (addim 0 0 -0x1) # $0 = $0 - 1
+                  (push 0)         # push($0)
+                  (call 0 1)       # $0 = call($1)
+                  (add 0 0 2)      # $0 = $0 + $2 (integers)
+                  :done
+                  (ret 0)          # return $0
+]}))

 # Test it

--- a/examples/channel.janet
+++ b/examples/channel.janet
@@ -0,0 +1,15 @@
+(def c (ev/chan 4))
+
+(defn writer []
+  (for i 0 10
+    (ev/sleep 0.1)
+    (print "writer giving item " i "...")
+    (ev/give c (string "item " i))))
+
+(defn reader [name]
+  (forever
+    (print "reader " name " got " (ev/take c))))
+
+(ev/call writer)
+(each letter [:a :b :c :d :e :f :g]
+  (ev/call reader letter))
--- a/examples/echoclient.janet
+++ b/examples/echoclient.janet
@@ -0,0 +1,5 @@
+(with [conn (net/connect "127.0.0.1" 8000)]
+  (print "writing abcdefg...")
+  (:write conn "abcdefg")
+  (print "reading...")
+  (printf "got: %v" (:read conn 1024)))
--- a/examples/echoserve.janet
+++ b/examples/echoserve.janet
@@ -0,0 +1,15 @@
+(defn handler
+  "Simple handler for connections."
+  [stream]
+  (defer (:close stream)
+    (def id (gensym))
+    (def b @"")
+    (print "Connection " id "!")
+    (while (:read stream 1024 b)
+      (printf " %v -> %v" id b)
+      (:write stream b)
+      (buffer/clear b))
+    (printf "Done %v!" id)
+    (ev/sleep 0.5)))
+
+(net/server "127.0.0.1" "8000" handler)
--- a/examples/evsleep.janet
+++ b/examples/evsleep.janet
@@ -0,0 +1,12 @@
+(defn worker
+  "Run for a number of iterations."
+  [name iterations]
+  (for i 0 iterations
+    (ev/sleep 1)
+    (print "worker " name " iteration " i)))
+
+(ev/call worker :a 10)
+(ev/sleep 0.2)
+(ev/call worker :b 5)
+(ev/sleep 0.3)
+(ev/call worker :c 12)
--- a/examples/select.janet
+++ b/examples/select.janet
@@ -0,0 +1,23 @@
+(def channels
+  (seq [:repeat 5] (ev/chan 4)))
+
+(defn writer [c]
+  (for i 0 3
+    (def item (string i ":" (mod (hash c) 999)))
+    (ev/sleep 0.1)
+    (print "writer giving item " item " to " c "...")
+    (ev/give c item))
+  (print "Done!"))
+
+(defn reader [name]
+  (forever
+    (def [_ c x] (ev/rselect ;channels))
+    (print "reader " name " got " x " from " c)))
+
+# Readers
+(each letter [:a :b :c :d :e :f :g]
+  (ev/call reader letter))
+
+# Writers
+(each c channels
+  (ev/call writer c))
--- a/examples/select2.janet
+++ b/examples/select2.janet
@@ -0,0 +1,37 @@
+###
+### examples/select2.janet
+###
+### Mix reads and writes in select.
+###
+
+(def c1 (ev/chan 40))
+(def c2 (ev/chan 40))
+(def c3 (ev/chan 40))
+(def c4 (ev/chan 40))
+
+(def c5 (ev/chan 4))
+
+(defn worker
+  [c n x]
+  (forever
+    (ev/sleep n)
+    (ev/give c x)))
+
+(defn writer-worker
+  [c]
+  (forever
+    (ev/sleep 0.2)
+    (print "writing " (ev/take c))))
+
+(ev/call worker c1 1 :item1)
+(ev/sleep 0.2)
+(ev/call worker c2 1 :item2)
+(ev/sleep 0.1)
+(ev/call worker c3 1 :item3)
+(ev/sleep 0.2)
+(ev/call worker c4 1 :item4)
+(ev/sleep 0.1)
+(ev/call worker c4 1 :item5)
+(ev/call writer-worker c5)
+
+(forever (pp (ev/rselect c1 c2 c3 c4 [c5 :thing])))
--- a/examples/tcpserver.janet
+++ b/examples/tcpserver.janet
@@ -6,8 +6,15 @@
    (def b @"")
    (print "Connection " id "!")
    (while (:read stream 1024 b)
+      (repeat 10 (print "work for " id " ...") (ev/sleep 0.1))
      (:write stream b)
      (buffer/clear b))
    (printf "Done %v!" id)))

-(net/server "127.0.0.1" "8000" handler)
+# Run server.
+(let [server (net/server "127.0.0.1" "8000")]
+  (print "Starting echo server on 127.0.0.1:8000")
+  (forever
+    (if-let [conn (:accept server)]
+      (ev/call handler conn)
+      (print "no new connections"))))
--- a/examples/udpclient.janet
+++ b/examples/udpclient.janet
@@ -0,0 +1,5 @@
+(def conn (net/connect "127.0.0.1" "8009" :datagram))
+(:write conn (string/format "%q" (os/cryptorand 16)))
+(def x (:read conn 1024))
+(pp x)
+
--- a/examples/udpserver.janet
+++ b/examples/udpserver.janet
@@ -0,0 +1,6 @@
+(def server (net/server "127.0.0.1" "8009" nil :datagram))
+(while true
+  (def buf @"")
+  (def who (:recv-from server 1024 buf))
+  (printf "got %q from %v, echoing!" buf who)
+  (:send-to server who buf))
--- a/136
+++ b/136
@@ -132,6 +132,15 @@
  "Convert url with potential bad characters into a file path element."
  (peg/compile ~(% (any (+ (/ '(set "<>:\"/\\|?*") "_") '1)))))

+(def- entry-replacer
+  "Convert url with potential bad characters into an entry-name"
+  (peg/compile ~(% (any (+ '(range "AZ" "az" "09" "__") (/ '1 ,|(string "_" ($ 0) "_")))))))
+
+(defn entry-replace
+  "Escape special characters in the entry-name"
+  [name]
+  (get (peg/match entry-replacer name) 0))
+
 (defn filepath-replace
  "Remove special characters from a string or path
  to make it into a path segment."
@@ -323,7 +332,9 @@
 #

 (def default-compiler (or (os/getenv "CC") (if is-win "cl.exe" "cc")))
+(def default-cpp-compiler (or (os/getenv "CXX") (if is-win "cl.exe" "c++")))
 (def default-linker (or (os/getenv "CC") (if is-win "link.exe" "cc")))
+(def default-cpp-linker (or (os/getenv "CXX") (if is-win "link.exe" "c++")))
 (def default-archiver (or (os/getenv "AR") (if is-win "lib.exe" "ar")))

 # Detect threads
@@ -352,6 +363,10 @@
  (if is-win
    ["/nologo" "/MD"]
    ["-std=c99" "-Wall" "-Wextra"]))
+(def default-cppflags
+  (if is-win
+    ["/nologo" "/MD" "/EHsc"]
+    ["-std=c++11" "-Wall" "-Wextra"]))
 (def default-ldflags [])

 # Required flags for dynamic libraries. These
@@ -424,29 +439,54 @@
    (string "-I" (dyn :headerpath JANET_HEADERPATH))
    (string "-O" (opt opts :optimize 2))])

+(defn- getcppflags
+  "Generate the cpp flags from the input options."
+  [opts]
+  @[;(opt opts :cppflags default-cppflags)
+    (string "-I" (dyn :headerpath JANET_HEADERPATH))
+    (string "-O" (opt opts :optimize 2))])
+
 (defn- entry-name
  "Name of symbol that enters static compilation of a module."
  [name]
-  (string "janet_module_entry_" (filepath-replace name)))
+  (string "janet_module_entry_" (entry-replace name)))

 (defn- compile-c
  "Compile a C file into an object file."
  [opts src dest &opt static?]
  (def cc (opt opts :compiler default-compiler))
  (def cflags [;(getcflags opts) ;(if static? [] dynamic-cflags)])
-  (def entry-defines (if-let [n (opts :entry-name)]
+  (def entry-defines (if-let [n (and static? (opts :entry-name))]
                       [(make-define "JANET_ENTRY_NAME" n)]
                       []))
  (def defines [;(make-defines (opt opts :defines {})) ;entry-defines])
  (def headers (or (opts :headers) []))
  (rule dest [src ;headers]
        (check-cc)
-        (print "compiling " dest "...")
+        (print "compiling " src " to " dest "...")
        (create-dirs dest)
        (if is-win
          (shell cc ;defines "/c" ;cflags (string "/Fo" dest) src)
          (shell cc "-c" src ;defines ;cflags "-o" dest))))

+(defn- compile-cpp
+  "Compile a C++ file into an object file."
+  [opts src dest &opt static?]
+  (def cpp (opt opts :cpp-compiler default-cpp-compiler))
+  (def cflags [;(getcppflags opts) ;(if static? [] dynamic-cflags)])
+  (def entry-defines (if-let [n (and static? (opts :entry-name))]
+                       [(make-define "JANET_ENTRY_NAME" n)]
+                       []))
+  (def defines [;(make-defines (opt opts :defines {})) ;entry-defines])
+  (def headers (or (opts :headers) []))
+  (rule dest [src ;headers]
+        (check-cc)
+        (print "compiling " src " to " dest "...")
+        (create-dirs dest)
+        (if is-win
+          (shell cpp ;defines "/c" ;cflags (string "/Fo" dest) src)
+          (shell cpp "-c" src ;defines ;cflags "-o" dest))))
+
 (defn- libjanet
  "Find libjanet.a (or libjanet.lib on windows) at compile time"
  []
@@ -466,7 +506,7 @@
  (string hpath `\\janet.lib`))

 (defn- link-c
-  "Link object files together to make a native module."
+  "Link C object files together to make a native module."
  [opts target & objects]
  (def linker (opt opts (if is-win :linker :compiler) default-linker))
  (def cflags (getcflags opts))
@@ -481,6 +521,22 @@
          (shell linker ;ldflags (string "/OUT:" target) ;objects (win-import-library) ;lflags)
          (shell linker ;cflags ;ldflags `-o` target ;objects ;lflags))))

+(defn- link-cpp
+  "Link C++ object files together to make a native module."
+  [opts target & objects]
+  (def linker (opt opts (if is-win :cpp-linker :cpp-compiler) default-cpp-linker))
+  (def cflags (getcppflags opts))
+  (def lflags [;(opt opts :lflags default-lflags)
+               ;(if (opts :static) [] dynamic-lflags)])
+  (def ldflags [;(opt opts :ldflags [])])
+  (rule target objects
+        (check-cc)
+        (print "linking " target "...")
+        (create-dirs target)
+        (if is-win
+          (shell linker ;ldflags (string "/OUT:" target) ;objects (win-import-library) ;lflags)
+          (shell linker ;cflags ;ldflags `-o` target ;objects ;lflags))))
+
 (defn- archive-c
  "Link object files together to make a static library."
  [opts target & objects]
@@ -655,10 +711,12 @@ int main(int argc, const char **argv) {
          (table/setproto m oldproto))

        # Find static modules
+        (var has-cpp false)
        (def declarations @"")
        (def lookup-into-invocations @"")
        (loop [[prefix name] :pairs prefixes]
          (def meta (eval-string (slurp (modpath-to-meta name))))
+          (if (meta :cpp) (set has-cpp true))
          (buffer/push-string lookup-into-invocations
                              "    temptab = janet_table(0);\n"
                              "    temptab->proto = env;\n"
@@ -681,17 +739,33 @@ int main(int argc, const char **argv) {
        (create-buffer-c-impl image cimage_dest "janet_payload_image")
        # Append main function
        (spit cimage_dest (make-bin-source declarations lookup-into-invocations) :ab)
+        (def oimage_dest (out-path cimage_dest ".c" ".o"))
        # Compile and link final exectable
        (unless no-compile
-          (def cc (opt opts :compiler default-compiler))
          (def ldflags [;dep-ldflags ;(opt opts :ldflags []) ;janet-ldflags])
          (def lflags [;static-libs (libjanet) ;dep-lflags ;(opt opts :lflags default-lflags) ;janet-lflags])
-          (def cflags [;(getcflags opts) ;janet-cflags])
          (def defines (make-defines (opt opts :defines {})))
-          (print "compiling and linking " dest "...")
+          (def cc (opt opts :compiler default-compiler))
+          (def cflags [;(getcflags opts) ;janet-cflags])
+          (check-cc)
+          (print "compiling " cimage_dest " to " oimage_dest "...")
+          (create-dirs oimage_dest)
          (if is-win
-            (shell cc ;cflags ;ldflags cimage_dest ;lflags `/link` (string "/OUT:" dest))
-            (shell cc ;cflags ;ldflags `-o` dest cimage_dest ;lflags)))))
+            (shell cc ;defines "/c" ;cflags (string "/Fo" oimage_dest) cimage_dest)
+            (shell cc "-c" cimage_dest ;defines ;cflags "-o" oimage_dest))
+          (if has-cpp
+            (let [linker (opt opts (if is-win :cpp-linker :cpp-compiler) default-cpp-linker)
+                  cppflags [;(getcppflags opts) ;janet-cflags]]
+              (print "linking " dest "...")
+              (if is-win
+                (shell linker ;ldflags (string "/OUT:" dest) oimage_dest ;lflags)
+                (shell linker ;cppflags ;ldflags `-o` dest oimage_dest ;lflags)))
+            (let [linker (opt opts (if is-win :linker :compiler) default-linker)]
+              (print "linking " dest "...")
+              (create-dirs dest)
+              (if is-win
+                (shell linker ;ldflags (string "/OUT:" dest) oimage_dest ;lflags)
+                (shell linker ;cflags ;ldflags `-o` dest oimage_dest ;lflags)))))))

 #
 # Installation and Dependencies
@@ -853,9 +927,23 @@ int main(int argc, const char **argv) {

  # Make dynamic module
  (def lname (string "build" sep name modext))
-  (loop [src :in sources]
-    (compile-c opts src (out-path src ".c" objext)))
-  (def objects (map (fn [path] (out-path path ".c" objext)) sources))
+
+  # Get objects to build with
+  (var has-cpp false)
+  (def objects
+    (seq [src :in sources]
+      (cond
+        (string/has-suffix? ".cpp" src)
+        (let [op (out-path src ".cpp" objext)]
+          (compile-cpp opts src op)
+          (set has-cpp true)
+          op)
+        (string/has-suffix? ".c" src)
+        (let [op (out-path src ".c" objext)]
+          (compile-c opts src op)
+          op)
+        (errorf "unknown source file type: %s, expected .c or .cpp"))))
+
  (when-let [embedded (opts :embedded)]
    (loop [src :in embedded]
      (def c-src (out-path src ".janet" ".janet.c"))
@@ -863,7 +951,7 @@ int main(int argc, const char **argv) {
      (array/push objects o-src)
      (create-buffer-c src c-src (embed-name src))
      (compile-c opts c-src o-src)))
-  (link-c opts lname ;objects)
+  ((if has-cpp link-cpp link-c) opts lname ;objects)
  (add-dep "build" lname)
  (install-rule lname path)

@@ -876,6 +964,7 @@ int main(int argc, const char **argv) {
                         "# Metadata for static library %s\n\n%.20p"
                         (string name statext)
                         {:static-entry ename
+                          :cpp has-cpp
                          :ldflags ~',(opts :ldflags)
                          :lflags ~',(opts :lflags)})))
  (add-dep "build" metaname)
@@ -887,9 +976,21 @@ int main(int argc, const char **argv) {
    (def opts (merge @{:entry-name ename} opts))
    (def sobjext (string ".static" objext))
    (def sjobjext (string ".janet" sobjext))
-    (loop [src :in sources]
-      (compile-c opts src (out-path src ".c" sobjext) true))
-    (def sobjects (map (fn [path] (out-path path ".c" sobjext)) sources))
+
+    # Get static objects
+    (def sobjects
+      (seq [src :in sources]
+        (cond
+          (string/has-suffix? ".cpp" src)
+          (let [op (out-path src ".cpp" sobjext)]
+            (compile-cpp opts src op true)
+            op)
+          (string/has-suffix? ".c" src)
+          (let [op (out-path src ".c" sobjext)]
+            (compile-c opts src op true)
+            op)
+          (errorf "unknown source file type: %s, expected .c or .cpp"))))
+
    (when-let [embedded (opts :embedded)]
      (loop [src :in embedded]
        (def c-src (out-path src ".janet" ".janet.c"))
@@ -1139,7 +1240,8 @@ Keys are:
  --binpath : The directory to install binaries and scripts. Defaults to $JANET_BINPATH.
  --libpath : The directory containing janet C libraries (libjanet.*). Defaults to $JANET_LIBPATH.
  --compiler : C compiler to use for natives. Defaults to $CC or cc (cl.exe on windows).
-  --archiver : C compiler to use for static libraries. Defaults to $AR ar (lib.exe on windows).
+  --cpp-compiler : C++ compiler to use for natives. Defaults to $CXX or c++ (cl.exe on windows).
+  --archiver : C archiver to use for static libraries. Defaults to $AR ar (lib.exe on windows).
  --linker : C linker to use for linking natives. Defaults to link.exe on windows, not used on
             other platforms.
  --pkglist : URL of git repository for package listing. Defaults to $JANET_PKGLIST or https://github.com/janet-lang/pkgs.git
--- a/jpm.1
+++ b/jpm.1
@@ -71,9 +71,14 @@ $JANET_LIBPATH, or a reasonable default. See JANET_LIBPATH for more.

 .TP
 .BR \-\-compiler=$CC
-Sets the compiler used for compiling native modules and standalone executables. Defaults
+Sets the C compiler used for compiling native modules and standalone executables. Defaults
 to cc.

+.TP
+.BR \-\-cpp\-compiler=$CXX
+Sets the C++ compiler used for compiling native modules and standalone executables. Defaults
+to c++..
+
 .TP
 .BR \-\-linker
 Sets the linker used to create native modules and executables. Only used on windows, where
@@ -101,7 +106,6 @@ be created in the ./build/ directory.

 .TP
 .BR install\ [\fBrepo...\fR]
-
 When run with no arguments, installs all installable artifacts in the current project to
 the current JANET_MODPATH for modules and JANET_BINPATH for executables and scripts. Can also
 take an optional git repository URL and will install all artifacts in that repository instead.
@@ -111,7 +115,7 @@ install multiple dependencies in one command.
 .TP
 .BR uninstall\ [\fBname...\fR]
 Uninstall a project installed with install. uninstall expects the name of the project, not the
-repository url, path to installed file or executable name. The name of the project must be specified
+repository url, path to installed file, or executable name. The name of the project must be specified
 at the top of the project.janet file in the declare-project form. If no name is given, uninstalls
 the current project if installed. Will also uninstall multiple packages in one command.

@@ -144,7 +148,7 @@ required.
 List all installed packages in the current syspath.

 .TP
-.BR list-pkgs [\fBsearch\fR]
+.BR list-pkgs\ [\fBsearch\fR]
 List all package aliases in the current package listing that contain the given search string.
 If no search string is given, prints the entire listing.

@@ -168,7 +172,7 @@ like make. run will run a single rule or build a single file.
 List all rules that can be run via run. This is useful for exploring rules in the project.

 .TP
-.BR rule-tree\ [\fBroot\fR] [\fdepth\fR]
+.BR rule-tree\ [\fBroot\fR]\ [\fBdepth\fR]
 Show rule dependency tree in a pretty format. Optionally provide a rule to use as the tree
 root, as well as a max depth to print. By default, prints the full tree for all rules. This
 can be quite long, so it is recommended to give a root rule.
@@ -182,7 +186,7 @@ Show all of the paths used when installing and building artifacts.
 Update the package listing by installing the 'pkgs' package. Same as jpm install pkgs

 .TP
-.BR quickbin [\fBentry\fR] [\fBexecutable\fR]
+.BR quickbin\ [\fBentry\fR]\ [\fBexecutable\fR]
 Create a standalone, statically linked executable from a Janet source file that contains a main function.
 The main function is the entry point of the program and will receive command line arguments
 as function arguments. The entry file can import other modules, including native C modules, and
@@ -218,7 +222,7 @@ the default location set at compile time, which can be determined with (dyn :sys
 .RS
 The location that jpm will use to install libraries to. Defaults to JANET_PATH, but you could
 set this to a different directory if you want to. Doing so would let you import Janet modules
-on the normal system path (JANET_PATH or (dyn :syspath)), but install to a different directory. It is also a more reliable way to install
+on the normal system path (JANET_PATH or (dyn :syspath)), but install to a different directory. It is also a more reliable way to install.
 This variable is overwritten by the --modpath=/some/path if it is provided.
 .RE

@@ -234,7 +238,7 @@ variable.
 .B JANET_LIBPATH
 .RS
 Similar to JANET_HEADERPATH, this path is where jpm will look for
-libjanet.a for creating standalong executables. This does not need to be
+libjanet.a for creating standalone executables. This does not need to be
 set on a normal install. 
 If not provided, this will default to <jpm script location>/../lib.
 The --libpath=/some/path option will override this variable.
@@ -253,11 +257,13 @@ The --binpath=/some/path will override this variable.
 The git repository URL that contains a listing of packages. This allows installing packages with shortnames, which
 is mostly a convenience. However, package dependencies can use short names, package listings
 can be used to choose a particular set of dependency versions for a whole project.
+.RE

 .B JANET_GIT
 .RS
 An optional path to a git executable to use to clone git dependencies. By default, uses "git" on the current $PATH. You shouldn't need to set this
 if you have a normal install of git.
+.RE

 .SH AUTHOR
 Written by Calvin Rose <calsrose@gmail.com>
--- a/meson.build
+++ b/meson.build
@@ -20,7 +20,7 @@

 project('janet', 'c',
  default_options : ['c_std=c99', 'b_lundef=false', 'default_library=both'],
-  version : '1.11.4')
+  version : '1.13.0')

 # Global settings
 janet_path = join_paths(get_option('prefix'), get_option('libdir'), 'janet')
@@ -60,6 +60,7 @@ conf.set('JANET_NO_SOURCEMAPS', not get_option('sourcemaps'))
 conf.set('JANET_NO_ASSEMBLER', not get_option('assembler'))
 conf.set('JANET_NO_PEG', not get_option('peg'))
 conf.set('JANET_NO_NET', not get_option('net'))
+conf.set('JANET_NO_EV', not get_option('ev'))
 conf.set('JANET_REDUCED_OS', get_option('reduced_os'))
 conf.set('JANET_NO_TYPED_ARRAY', not get_option('typed_array'))
 conf.set('JANET_NO_INT_TYPES', not get_option('int_types'))
@@ -71,6 +72,7 @@ conf.set('JANET_STACK_MAX', get_option('stack_max'))
 conf.set('JANET_NO_UMASK', not get_option('umask'))
 conf.set('JANET_NO_REALPATH', not get_option('realpath'))
 conf.set('JANET_NO_PROCESSES', not get_option('processes'))
+conf.set('JANET_SIMPLE_GETLINE', get_option('simple_getline'))
 if get_option('os_name') != ''
  conf.set('JANET_OS_NAME', get_option('os_name'))
 endif
@@ -110,6 +112,7 @@ core_src = [
  'src/core/corelib.c',
  'src/core/debug.c',
  'src/core/emit.c',
+  'src/core/ev.c',
  'src/core/fiber.c',
  'src/core/gc.c',
  'src/core/inttypes.c',
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -12,9 +12,11 @@ option('typed_array', type : 'boolean', value : true)
 option('int_types', type : 'boolean', value : true)
 option('prf', type : 'boolean', value : false)
 option('net', type : 'boolean', value : true)
+option('ev', type : 'boolean', value : true)
 option('processes', type : 'boolean', value : true)
 option('umask', type : 'boolean', value : true)
 option('realpath', type : 'boolean', value : true)
+option('simple_getline', type : 'boolean', value : false)

 option('recursion_guard', type : 'integer', min : 10, max : 8000, value : 1024)
 option('max_proto_depth', type : 'integer', min : 10, max : 8000, value : 200)
--- a/src/boot/boot.janet
+++ b/src/boot/boot.janet
@@ -7,6 +7,8 @@
 ###
 ###

+(def root-env "The root environment used to create environments with (make-env)" _env)
+
 (def defn :macro
  "(defn name & more)\n\nDefine a function. Equivalent to (def name (fn name [args] ...))."
  (fn defn [name & more]
@@ -81,10 +83,6 @@
 (defn nan? "Check if x is NaN" [x] (not= x x))
 (defn even? "Check if x is even." [x] (= 0 (mod x 2)))
 (defn odd? "Check if x is odd." [x] (= 1 (mod x 2)))
-(defn zero? "Check if x is zero." [x] (= x 0))
-(defn pos? "Check if x is greater than 0." [x] (> x 0))
-(defn neg? "Check if x is less than 0." [x] (< x 0))
-(defn one? "Check if x is equal to 1." [x] (= x 1))
 (defn number? "Check if x is a number." [x] (= (type x) :number))
 (defn fiber? "Check if x is a fiber." [x] (= (type x) :fiber))
 (defn string? "Check if x is a string." [x] (= (type x) :string))
@@ -567,15 +565,6 @@
  [head & body]
  (loop1 body head 0))

-(put _env 'loop1 nil)
-(put _env 'check-indexed nil)
-(put _env 'for-template nil)
-(put _env 'for-var-template nil)
-(put _env 'iterate-template nil)
-(put _env 'each-template nil)
-(put _env 'range-template nil)
-(put _env 'loop-fiber-template nil)
-
 (defmacro seq
  "Similar to loop, but accumulates the loop body into an array and returns that.
  See loop for details."
@@ -594,6 +583,16 @@
  [& body]
  (tuple fiber/new (tuple 'fn '[] ;body) :yi))

+(defmacro- undef
+  "Remove binding from root-env"
+  [& syms]
+  ~(do ,;(seq [s :in syms] ~(put root-env ',s nil))))
+
+(undef _env)
+
+(undef loop1 check-indexed for-template for-var-template iterate-template
+       each-template range-template loop-fiber-template)
+
 (defn sum
  "Returns the sum of xs. If xs is empty, returns 0."
  [xs]
@@ -619,7 +618,7 @@
  the fal form. Bindings have the same syntax as the let macro."
  [bindings tru &opt fal]
  (def len (length bindings))
-  (if (zero? len) (error "expected at least 1 binding"))
+  (if (= 0 len) (error "expected at least 1 binding"))
  (if (odd? len) (error "expected an even number of bindings"))
  (defn aux [i]
    (if (>= i len)
@@ -749,7 +748,12 @@
  [& xs]
  (compare-reduce >= xs))

-(put _env 'compare-reduce nil)
+(defn zero? "Check if x is zero." [x] (= (compare x 0) 0))
+(defn pos? "Check if x is greater than 0." [x] (= (compare x 0) 1))
+(defn neg? "Check if x is less than 0." [x] (= (compare x 0) -1))
+(defn one? "Check if x is equal to 1." [x] (= (compare x 1) 0))
+
+(undef compare-reduce)

 ###
 ###
@@ -785,8 +789,8 @@
  [a &opt by]
  (sort-help a 0 (- (length a) 1) (or by <)))

-(put _env 'sort-part nil)
-(put _env 'sort-help nil)
+(undef sort-part)
+(undef sort-help)

 (defn sort-by
  "Returns a new sorted array that compares elements by invoking
@@ -1137,11 +1141,14 @@
    :table (walk-dict f form)
    :struct (table/to-struct (walk-dict f form))
    :array (walk-ind f form)
-    :tuple (tuple/slice (walk-ind f form))
+    :tuple (let [x (walk-ind f form)]
+             (if (= :parens (tuple/type form))
+               (tuple/slice x)
+               (tuple/brackets ;x)))
    form))

-(put _env 'walk-ind nil)
-(put _env 'walk-dict nil)
+(undef walk-ind)
+(undef walk-dict)

 (defn postwalk
  "Do a post-order traversal of a data structure and call (f x)
@@ -1350,7 +1357,7 @@
  [tab & colls]
  (loop [c :in colls
         key :keys c]
-    (set (tab key) (in c key)))
+    (put tab key (in c key)))
  tab)

 (defn merge
@@ -1361,7 +1368,7 @@
  (def container @{})
  (loop [c :in colls
         key :keys c]
-    (set (container key) (in c key)))
+    (put container key (in c key)))
  container)

 (defn keys
@@ -1385,7 +1392,7 @@
  arr)

 (defn pairs
-  "Get the values of an associative data structure."
+  "Get the key-value pairs of an associative data structure."
  [x]
  (def arr (array/new (length x)))
  (var k (next x nil))
@@ -1615,9 +1622,9 @@
                          ,(aux (+ 2 i))
                          ,$res)))) 0)))

-(put _env 'sentinel nil)
-(put _env 'match-1 nil)
-(put _env 'with-idemp nil)
+(undef sentinel)
+(undef match-1)
+(undef with-idemp)

 ###
 ###
@@ -1698,7 +1705,7 @@
  (print (doc-format (string "Bindings:\n\n" (string/join bindings " "))))
  (print)
  (print (doc-format (string "Dynamics:\n\n" (string/join dynamics " "))))
-  (print))
+  (print "\n    Use (doc sym) for more information on a binding.\n"))

 (defn doc*
  "Get the documentation for a symbol in a given environment. Function form of doc."
@@ -1742,8 +1749,8 @@
  [&opt sym]
  ~(,doc* ',sym))

-(put _env 'env-walk nil)
-(put _env 'print-index nil)
+(undef env-walk)
+(undef print-index)

 ###
 ###
@@ -1877,7 +1884,7 @@
    (case tx
      :tuple (or (not= (length x) (length y)) (some identity (map deep-not= x y)))
      :array (or (not= (length x) (length y)) (some identity (map deep-not= x y)))
-      :struct (deep-not= (pairs x) (pairs y))
+      :struct (deep-not= (kvs x) (kvs y))
      :table (deep-not= (table/to-struct x) (table/to-struct y))
      :buffer (not= (string x) (string y))
      (not= x y))))
@@ -2032,7 +2039,7 @@
  will inherit bindings from the parent environment, but new
  bindings will not pollute the parent environment."
  [&opt parent]
-  (def parent (if parent parent _env))
+  (def parent (if parent parent root-env))
  (def newenv (table/setproto @{} parent))
  newenv)

@@ -2248,10 +2255,11 @@
  by make-image, such that (load-image bytes) is the same as (unmarshal bytes load-image-dict)."
  @{})

-(def comptime
+(defmacro comptime
  "(comptime x)\n\n
  Evals x at compile time and returns the result. Similar to a top level unquote."
-  :macro eval)
+  [x]
+  (eval x))

 (defn make-image
  "Create an image from an environment returned by require.
@@ -2305,7 +2313,7 @@
 (module/add-paths ".jimage" :image)

 # Version of fexists that works even with a reduced OS
-(if-let [has-stat (_env 'os/stat)]
+(if-let [has-stat (root-env 'os/stat)]
  (let [stat (has-stat :value)]
    (defglobal "fexists" (fn fexists [path] (= :file (stat path :mode)))))
  (defglobal "fexists"
@@ -2352,10 +2360,10 @@
          str-parts (interpose "\n    " paths)]
      [nil (string "could not find module " path ":\n    " ;str-parts)])))

-(put _env 'fexists nil)
-(put _env 'mod-filter nil)
-(put _env 'check-. nil)
-(put _env 'not-check-. nil)
+(undef fexists)
+(undef mod-filter)
+(undef check-.)
+(undef not-check-.)

 (def module/cache
  "Table mapping loaded module identifiers to their environments."
@@ -2463,7 +2471,7 @@
    (def newv (table/setproto @{:private (not ep)} v))
    (put env (symbol prefix k) newv)))

-(put _env 'require-1 nil)
+(undef require-1)

 (defmacro import
  "Import a module. First requires the module, and then merges its
@@ -2480,7 +2488,7 @@
  (tuple import* (string path) ;argm))

 (defmacro use
-  "Similar to import, but imported bindings are not prefixed with a namespace
+  "Similar to import, but imported bindings are not prefixed with a module
  identifier. Can also import multiple modules in one shot."
  [& modules]
  ~(do ,;(map |~(,import* ,(string $) :prefix "") modules)))
@@ -2530,7 +2538,7 @@
  (in (.slots frame-idx) (or nth 0)))

 # Conditional compilation for disasm
-(def disasm-alias (if-let [x (_env 'disasm)] (x :value)))
+(def disasm-alias (if-let [x (root-env 'disasm)] (x :value)))

 (defn .disasm
  "Gets the assembly for the current function."
@@ -2592,13 +2600,9 @@
    (debug/unfbreak fun i))
  (print "Cleared " (length bytecode) " breakpoints in " fun))

-(unless (get _env 'disasm)
-  (put _env '.disasm nil)
-  (put _env '.bytecode nil)
-  (put _env '.breakall nil)
-  (put _env '.clearall nil)
-  (put _env '.ppasm nil))
-(put _env 'disasm-alias nil)
+(unless (get root-env 'disasm)
+  (undef .disasm .bytecode .breakall .clearall .ppasm))
+(undef disasm-alias)

 (defn .source
  "Show the source code for the function being debugged."
@@ -2652,9 +2656,9 @@
  "An environment that contains dot prefixed functions for debugging."
  @{})

-(def- debugger-keys (filter (partial string/has-prefix? ".") (keys _env)))
-(each k debugger-keys (put debugger-env k (_env k)) (put _env k nil))
-(put _env 'debugger-keys nil)
+(def- debugger-keys (filter (partial string/has-prefix? ".") (keys root-env)))
+(each k debugger-keys (put debugger-env k (root-env k)) (put root-env k nil))
+(undef debugger-keys)

 ###
 ###
@@ -2718,6 +2722,37 @@
                :on-status (or onsignal (make-onsignal env 1))
                :source "repl"}))

+###
+###
+### Extras
+###
+###
+
+(defmacro- guarddef
+  [sym form]
+  (if (dyn sym)
+    form))
+
+(guarddef ev/go
+  (defmacro ev/spawn
+    "Run some code in a new fiber. This is shorthand for (ev/call (fn [] ;body))."
+    [& body]
+    ~(,ev/call (fn [] ,;body))))
+
+(guarddef net/listen
+  (defn net/server
+    "Start a server asynchornously with net/listen and net/accept-loop. Returns the new server stream."
+    [host port &opt handler type]
+    (def s (net/listen host port type))
+    (if handler
+      (ev/call (fn [] (net/accept-loop s handler))))
+    s))
+
+(guarddef ev/close
+  (defn net/close "Alias for ev/close." [stream] (ev/close stream)))
+
+(undef guarddef)
+
 ###
 ###
 ### CLI Tool Main
@@ -2725,7 +2760,7 @@
 ###

 (defn- no-side-effects
-  "Check if form may have side effects. If returns true, then the src
+  "Check if form may have side effects. If rturns true, then the src
  must not have side effects, such as calling a C function."
  [src]
  (cond
@@ -2750,7 +2785,7 @@
  (each a args (import* (string a) :prefix "" :evaluator evaluator)))

 # conditional compilation for reduced os
-(def- getenv-alias (if-let [entry (in _env 'os/getenv)] (entry :value) (fn [&])))
+(def- getenv-alias (if-let [entry (in root-env 'os/getenv)] (entry :value) (fn [&])))

 (defn cli-main
  "Entrance for the Janet CLI tool. Call this functions with the command line
@@ -2782,14 +2817,14 @@
  -v : Print the version string
  -s : Use raw stdin instead of getline like functionality
  -e code : Execute a string of janet
-  -d : Set the debug flag in the repl
-  -r : Enter the repl after running all scripts
-  -p : Keep on executing if there is a top level error (persistent)
+  -d : Set the debug flag in the REPL
+  -r : Enter the REPL after running all scripts
+  -p : Keep on executing if there is a top-level error (persistent)
  -q : Hide logo (quiet)
  -k : Compile scripts but do not execute (flycheck)
  -m syspath : Set system path for loading global modules
  -c source output : Compile janet source code into an image
-  -n : Disable ANSI color output in the repl
+  -n : Disable ANSI color output in the REPL
  -l lib : Import a module before processing more arguments
  -- : Stop handling options`)
           (os/exit 0)
@@ -2867,7 +2902,7 @@

  (when (and (not *compile-only*) (or *should-repl* *no-file*))
    (if-not *quiet*
-      (print "Janet " janet/version "-" janet/build " " (os/which) "/" (os/arch)))
+      (print "Janet " janet/version "-" janet/build " " (os/which) "/" (os/arch) " - '(doc)' for help"))
    (flush)
    (defn getprompt [p]
      (def [line] (parser/where p))
@@ -2885,12 +2920,7 @@
    (setdyn :err-color (if *colorize* true))
    (repl getchunk nil env)))

-(put _env 'no-side-effects nil)
-(put _env 'is-safe-def nil)
-(put _env 'safe-forms nil)
-(put _env 'importers nil)
-(put _env 'use-2 nil)
-(put _env 'getenv-alias nil)
+(undef no-side-effects is-safe-def safe-forms importers use-2 getenv-alias)

 ###
 ###
@@ -2898,12 +2928,13 @@
 ###
 ###

-(def root-env "The root environment used to create environments with (make-env)" _env)
-
 (do
-  (put _env 'boot/opts nil)
-  (put _env '_env nil)
-  (def load-dict (env-lookup _env))
+  (undef boot/opts undef)
+  (def load-dict (env-lookup root-env))
+  (put load-dict 'boot/config nil)
+  (put load-dict 'boot/args nil)
+  (each [k v] (pairs load-dict)
+    (if (number? v) (put load-dict k nil)))
  (merge-into load-image-dict load-dict)
  (merge-into make-image-dict (invert load-dict)))

@@ -2924,25 +2955,29 @@
        (put into k (x k))))
    into)

-  (def env (fiber/getenv (fiber/current)))
-
  # Modify env based on some options.
-  (loop [[k v] :pairs env
+  (loop [[k v] :pairs root-env
         :when (symbol? k)]
    (def flat (proto-flatten @{} v))
    (when (boot/config :no-docstrings)
      (put flat :doc nil))
    (when (boot/config :no-sourcemaps)
      (put flat :source-map nil))
-    (put env k flat))
+    (put root-env k flat))

-  (put env 'boot/config nil)
-  (put env 'boot/args nil)
-  (def image (let [env-pairs (pairs (env-lookup env))
+  (put root-env 'boot/config nil)
+  (put root-env 'boot/args nil)
+
+  (def image (let [env-pairs (pairs (env-lookup root-env))
                   essential-pairs (filter (fn [[k v]] (or (cfunction? v) (abstract? v))) env-pairs)
                   lookup (table ;(mapcat identity essential-pairs))
                   reverse-lookup (invert lookup)]
-               (marshal env reverse-lookup)))
+               # Check no duplicate values
+               (def temp @{})
+               (eachp [k v] lookup
+                 (if (in temp v) (errorf "duplicate value: %v" v))
+                 (put temp v k))
+               (marshal root-env reverse-lookup)))

  # Create amalgamation

@@ -2971,6 +3006,7 @@
     "src/core/corelib.c"
     "src/core/debug.c"
     "src/core/emit.c"
+     "src/core/ev.c"
     "src/core/fiber.c"
     "src/core/gc.c"
     "src/core/inttypes.c"
--- a/src/boot/system_test.c
+++ b/src/boot/system_test.c
@@ -23,6 +23,7 @@
 #include <janet.h>
 #include <assert.h>
 #include <stdio.h>
+#include <math.h>

 #include "tests.h"

@@ -44,6 +45,11 @@ int system_test() {
    assert(janet_equals(janet_wrap_integer(INT32_MIN), janet_wrap_integer(INT32_MIN)));
    assert(janet_equals(janet_wrap_number(1.4), janet_wrap_number(1.4)));
    assert(janet_equals(janet_wrap_number(3.14159265), janet_wrap_number(3.14159265)));
+#ifdef NAN
+    assert(janet_checktype(janet_wrap_number(NAN), JANET_NUMBER));
+#else
+    assert(janet_checktype(janet_wrap_number(0.0 / 0.0), JANET_NUMBER));
+#endif

    assert(NULL != &janet_wrap_nil);

--- a/src/conf/janetconf.h
+++ b/src/conf/janetconf.h
@@ -27,10 +27,10 @@
 #define JANETCONF_H

 #define JANET_VERSION_MAJOR 1
-#define JANET_VERSION_MINOR 11
-#define JANET_VERSION_PATCH 4
+#define JANET_VERSION_MINOR 13
+#define JANET_VERSION_PATCH 0
 #define JANET_VERSION_EXTRA "-dev"
-#define JANET_VERSION "1.11.4-dev"
+#define JANET_VERSION "1.13.0-dev"

 /* #define JANET_BUILD "local" */

@@ -52,6 +52,7 @@
 /* #define JANET_NO_NET */
 /* #define JANET_NO_TYPED_ARRAY */
 /* #define JANET_NO_INT_TYPES */
+/* #define JANET_NO_EV */
 /* #define JANET_NO_REALPATH */
 /* #define JANET_NO_SYMLINKS */
 /* #define JANET_NO_UMASK */
@@ -69,6 +70,7 @@
 /* #define JANET_STACK_MAX 16384 */
 /* #define JANET_OS_NAME my-custom-os */
 /* #define JANET_ARCH_NAME pdp-8 */
+/* #define JANET_EV_EPOLL */

 /* Main client settings, does not affect library code */
 /* #define JANET_SIMPLE_GETLINE */
--- a/src/core/array.c
+++ b/src/core/array.c
@@ -344,16 +344,16 @@ static const JanetReg array_cfuns[] = {
    {
        "array/concat", cfun_array_concat,
        JDOC("(array/concat arr & parts)\n\n"
-             "Concatenates a variadic number of arrays (and tuples) into the first argument "
-             "which must an array. If any of the parts are arrays or tuples, their elements will "
+             "Concatenates a variable number of arrays (and tuples) into the first argument "
+             "which must be an array. If any of the parts are arrays or tuples, their elements will "
             "be inserted into the array. Otherwise, each part in parts will be appended to arr in order. "
             "Return the modified array arr.")
    },
    {
        "array/insert", cfun_array_insert,
        JDOC("(array/insert arr at & xs)\n\n"
-             "Insert all of xs into array arr at index at. at should be an integer "
-             "0 and the length of the array. A negative value for at will index from "
+             "Insert all xs into array arr at index at. at should be an integer between "
+             "0 and the length of the array. A negative value for at will index backwards from "
             "the end of the array, such that inserting at -1 appends to the array. "
             "Returns the array.")
    },
--- a/src/core/asm.c
+++ b/src/core/asm.c
@@ -988,7 +988,7 @@ static const JanetReg asm_cfuns[] = {
    {
        "disasm", cfun_disasm,
        JDOC("(disasm func &opt field)\n\n"
-             "Returns assembly that could be used be compile the given function.\n"
+             "Returns assembly that could be used to compile the given function.\n"
             "func must be a function, not a c function. Will throw on error on a badly\n"
             "typed argument. If given a field name, will only return that part of the function assembly.\n"
             "Possible fields are:\n\n"
--- a/src/core/corelib.c
+++ b/src/core/corelib.c
@@ -1034,6 +1034,9 @@ static void janet_load_libs(JanetTable *env) {
 #ifdef JANET_THREADS
    janet_lib_thread(env);
 #endif
+#ifdef JANET_EV
+    janet_lib_ev(env);
+#endif
 #ifdef JANET_NET
    janet_lib_net(env);
 #endif
@@ -1218,7 +1221,7 @@ JanetTable *janet_core_env(JanetTable *replacements) {
    }

    /* Load core cfunctions (and some built in janet assembly functions) */
-    JanetTable *dict = janet_table(300);
+    JanetTable *dict = janet_table(512);
    janet_load_libs(dict);

    /* Add replacements */
--- a/src/core/ev.c
+++ b/src/core/ev.c
--- a/src/core/fiber.c
+++ b/src/core/fiber.c
@@ -37,6 +37,10 @@ static void fiber_reset(JanetFiber *fiber) {
    fiber->child = NULL;
    fiber->flags = JANET_FIBER_MASK_YIELD | JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP;
    fiber->env = NULL;
+#ifdef JANET_EV
+    fiber->waiting = NULL;
+    fiber->sched_id = 0;
+#endif
    janet_fiber_set_status(fiber, JANET_STATUS_NEW);
 }

@@ -77,6 +81,7 @@ JanetFiber *janet_fiber_reset(JanetFiber *fiber, JanetFunction *callee, int32_t
    }
    if (janet_fiber_funcframe(fiber, callee)) return NULL;
    janet_fiber_frame(fiber)->flags |= JANET_STACKFRAME_ENTRANCE;
+    fiber->waiting = NULL;
    return fiber;
 }

@@ -103,12 +108,15 @@ static void janet_fiber_refresh_memory(JanetFiber *fiber) {

 /* Ensure that the fiber has enough extra capacity */
 void janet_fiber_setcapacity(JanetFiber *fiber, int32_t n) {
+    int32_t old_size = fiber->capacity;
+    int32_t diff = n - old_size;
    Janet *newData = realloc(fiber->data, sizeof(Janet) * n);
    if (NULL == newData) {
        JANET_OUT_OF_MEMORY;
    }
    fiber->data = newData;
    fiber->capacity = n;
+    janet_vm_next_collection += sizeof(Janet) * diff;
 }

 /* Grow fiber if needed */
--- a/src/core/fiber.h
+++ b/src/core/fiber.h
@@ -46,8 +46,9 @@
 #define JANET_FIBER_MASK_USERN(N) (16 << (N))
 #define JANET_FIBER_MASK_USER 0x3FF0

-#define JANET_FIBER_RESUME_SIGNAL 0x800000
-#define JANET_FIBER_STATUS_MASK 0x7F0000
+#define JANET_FIBER_STATUS_MASK 0x3F0000
+#define JANET_FIBER_FLAG_SCHEDULED 0x800000
+#define JANET_FIBER_RESUME_SIGNAL 0x400000
 #define JANET_FIBER_STATUS_OFFSET 16

 #define JANET_FIBER_BREAKPOINT       0x1000000
@@ -77,4 +78,8 @@ void janet_fiber_popframe(JanetFiber *fiber);
 void janet_env_maybe_detach(JanetFuncEnv *env);
 int janet_env_valid(JanetFuncEnv *env);

+#ifdef JANET_EV
+void janet_fiber_did_resume(JanetFiber *fiber);
+#endif
+
 #endif
--- a/src/core/gc.c
+++ b/src/core/gc.c
@@ -28,6 +28,7 @@
 #include "gc.h"
 #include "util.h"
 #include "fiber.h"
+#include "vector.h"
 #endif

 struct JanetScratch {
@@ -400,9 +401,10 @@ void janet_collect(void) {
        janet_vm_gc_interval = janet_vm_block_count * sizeof(JanetGCObject);
    }
    orig_rootcount = janet_vm_root_count;
-#ifdef JANET_NET
-    janet_net_markloop();
+#ifdef JANET_EV
+    janet_ev_mark();
 #endif
+    janet_mark_fiber(janet_vm_root_fiber);
    for (i = 0; i < orig_rootcount; i++)
        janet_mark(janet_vm_roots[i]);
    while (orig_rootcount < janet_vm_root_count) {
--- a/src/core/io.c
+++ b/src/core/io.c
@@ -299,8 +299,8 @@ static Janet cfun_io_fclose(int32_t argc, Janet *argv) {
            janet_panic("could not close file");
        }
        iof->flags |= JANET_FILE_CLOSED;
-        return janet_wrap_nil();
    }
+    return janet_wrap_nil();
 }

 /* Seek a file */
@@ -777,7 +777,7 @@ static const JanetReg io_cfuns[] = {
 #ifndef JANET_NO_PROCESSES
    {
        "file/popen", cfun_io_popen,
-        JDOC("(file/popen path &opt mode)\n\n"
+        JDOC("(file/popen command &opt mode)\n\n"
             "Open a file that is backed by a process. The file must be opened in either "
             "the :r (read) or the :w (write) mode. In :r mode, the stdout of the "
             "process can be read from the file. In :w mode, the stdin of the process "
@@ -799,6 +799,10 @@ FILE *janet_getfile(const Janet *argv, int32_t n, int *flags) {
    return iof->file;
 }

+JanetFile *janet_makejfile(FILE *f, int flags) {
+    return makef(f, flags);
+}
+
 Janet janet_makefile(FILE *f, int flags) {
    return janet_wrap_abstract(makef(f, flags));
 }
--- a/src/core/marsh.c
+++ b/src/core/marsh.c
@@ -285,8 +285,8 @@ static void marshal_one_def(MarshalState *st, JanetFuncDef *def, int flags) {
 }

 #define JANET_FIBER_FLAG_HASCHILD (1 << 29)
-#define JANET_FIBER_FLAG_HASENV (1 << 28)
-#define JANET_STACKFRAME_HASENV (1 << 30)
+#define JANET_FIBER_FLAG_HASENV   (1 << 30)
+#define JANET_STACKFRAME_HASENV   (1 << 31)

 /* Marshal a fiber */
 static void marshal_one_fiber(MarshalState *st, JanetFiber *fiber, int flags) {
@@ -934,6 +934,10 @@ static const uint8_t *unmarshal_one_fiber(
    fiber->data = NULL;
    fiber->child = NULL;
    fiber->env = NULL;
+#ifdef JANET_EV
+    fiber->waiting = NULL;
+    fiber->sched_id = 0;
+#endif

    /* Push fiber to seen stack */
    janet_v_push(st->lookup, janet_wrap_fiber(fiber));
@@ -1048,6 +1052,11 @@ static const uint8_t *unmarshal_one_fiber(
    fiber->maxstack = fiber_maxstack;
    fiber->env = fiber_env;

+    int status = janet_fiber_status(fiber);
+    if (status < 0 || status > JANET_STATUS_ALIVE) {
+        janet_panic("invalid fiber status");
+    }
+
    /* Return data */
    *out = fiber;
    return data;
--- a/src/core/net.c
+++ b/src/core/net.c
--- a/src/core/os.c
+++ b/src/core/os.c
@@ -221,7 +221,8 @@ static char **os_execute_env(int32_t argc, const Janet *argv) {
    return envp;
 }

-/* Free memory from os_execute */
+/* Free memory from os_execute. Not actually needed, but doesn't pressure the GC
+   in the happy path. */
 static void os_execute_cleanup(char **envp, const char **child_argv) {
 #ifdef JANET_WINDOWS
    (void) child_argv;
@@ -322,7 +323,7 @@ typedef struct {
    int flags;
 #ifdef JANET_WINDOWS
    HANDLE pHandle;
-	HANDLE tHandle;
+    HANDLE tHandle;
 #else
    int pid;
 #endif
@@ -332,6 +333,25 @@ typedef struct {
    JanetFile *err;
 } JanetProc;

+static int janet_proc_gc(void *p, size_t s) {
+    (void) s;
+    JanetProc *proc = (JanetProc *) p;
+#ifdef JANET_WINDOWS
+    if (!(proc->flags & JANET_PROC_CLOSED)) {
+        CloseHandle(proc->pHandle);
+        CloseHandle(proc->tHandle);
+    }
+#else
+    if (!(proc->flags & JANET_PROC_WAITED)) {
+        /* Kill and wait to prevent zombies */
+        kill(proc->pid, SIGKILL);
+        int status;
+        waitpid(proc->pid, &status, 0);
+    }
+#endif
+    return 0;
+}
+
 static int janet_proc_mark(void *p, size_t s) {
    (void) s;
    JanetProc *proc = (JanetProc *)p;
@@ -350,10 +370,10 @@ static Janet os_proc_wait_impl(JanetProc *proc) {
 #ifdef JANET_WINDOWS
    WaitForSingleObject(proc->pHandle, INFINITE);
    GetExitCodeProcess(proc->pHandle, &status);
-	if (!(proc->flags & JANET_PROC_CLOSED)) {
-		proc->flags |= JANET_PROC_CLOSED;
-		CloseHandle(proc->pHandle);
-		CloseHandle(proc->tHandle);
+    if (!(proc->flags & JANET_PROC_CLOSED)) {
+        proc->flags |= JANET_PROC_CLOSED;
+        CloseHandle(proc->pHandle);
+        CloseHandle(proc->tHandle);
    }
 #else
    waitpid(proc->pid, &status, 0);
@@ -371,13 +391,16 @@ static Janet os_proc_wait(int32_t argc, Janet *argv) {
 static Janet os_proc_kill(int32_t argc, Janet *argv) {
    janet_arity(argc, 1, 2);
    JanetProc *proc = janet_getabstract(argv, 0, &ProcAT);
+    if (proc->flags & JANET_PROC_WAITED) {
+        janet_panicf("cannot kill process that has already finished");
+    }
 #ifdef JANET_WINDOWS
    if (proc->flags & JANET_PROC_CLOSED) {
        janet_panicf("cannot close process handle that is already closed");
    }
    proc->flags |= JANET_PROC_CLOSED;
-	CloseHandle(proc->pHandle);
-	CloseHandle(proc->tHandle);
+    CloseHandle(proc->pHandle);
+    CloseHandle(proc->tHandle);
 #else
    int status = kill(proc->pid, SIGKILL);
    if (status) {
@@ -392,6 +415,69 @@ static Janet os_proc_kill(int32_t argc, Janet *argv) {
    }
 }

+static void swap_handles(JanetHandle *handles) {
+    JanetHandle temp = handles[0];
+    handles[0] = handles[1];
+    handles[1] = temp;
+}
+
+static void close_handle(JanetHandle handle) {
+#ifdef JANET_WINDOWS
+    CloseHandle(handle);
+#else
+    close(handle);
+#endif
+}
+
+/* Create piped file for os/execute and os/spawn. Need to be careful that we mark
+   the error flag if we can't create pipe and don't leak handles. *handle will be cleaned
+   up by the calling function. If everything goes well, *handle is owned by the calling function,
+   (if it is set) and the returned JanetFile owns the other end of the pipe, which will be closed
+   on GC or fclose. */
+static JanetFile *make_pipes(JanetHandle *handle, int reverse, int *errflag) {
+    JanetHandle handles[2];
+#ifdef JANET_WINDOWS
+    SECURITY_ATTRIBUTES saAttr;
+    memset(&saAttr, 0, sizeof(saAttr));
+    saAttr.nLength = sizeof(saAttr);
+    saAttr.bInheritHandle = TRUE;
+    if (!CreatePipe(handles, handles + 1, &saAttr, 0)) goto error_pipe;
+    if (reverse) swap_handles(handles);
+    /* Don't inherit the side of the pipe owned by this process */
+    if (!SetHandleInformation(handles[0], HANDLE_FLAG_INHERIT, 0)) goto error_set_handle_info;
+    *handle = handles[1];
+    int fd = _open_osfhandle((intptr_t) handles[0], reverse ? _O_WRONLY : _O_RDONLY);
+    if (fd == -1) goto error_open_osfhandle;
+    FILE *f = _fdopen(fd, reverse ? "w" : "r");
+    if (NULL == f) goto error_fdopen;
+    return janet_makejfile(f, reverse ? JANET_FILE_WRITE : JANET_FILE_READ);
+error_fdopen:
+    _close(fd); /* we need to close the fake file descriptor instead of the handle, as ownership has been transfered. */
+    *errflag = 1;
+    return NULL;
+error_set_handle_info:
+error_open_osfhandle:
+    close_handle(handles[0]);
+    /* fallthrough */
+error_pipe:
+    *errflag = 1;
+    return NULL;
+#else
+    if (pipe(handles)) goto error_pipe;
+    if (reverse) swap_handles(handles);
+    *handle = handles[1];
+    FILE *f = fdopen(handles[0], reverse ? "w" : "r");
+    if (NULL == f) goto error_fdopen;
+    return janet_makejfile(f, reverse ? JANET_FILE_WRITE : JANET_FILE_READ);
+error_fdopen:
+    close_handle(handles[0]);
+    /* fallthrough */
+error_pipe:
+    *errflag = 1;
+    return NULL;
+#endif
+}
+
 static const JanetMethod proc_methods[] = {
    {"wait", os_proc_wait},
    {"kill", os_proc_kill},
@@ -422,22 +508,23 @@ static int janet_proc_get(void *p, Janet key, Janet *out) {

 static const JanetAbstractType ProcAT = {
    "core/process",
-    NULL,
+    janet_proc_gc,
    janet_proc_mark,
    janet_proc_get,
    JANET_ATEND_GET
 };

-static Janet os_execute(int32_t argc, Janet *argv) {
+static Janet os_execute_impl(int32_t argc, Janet *argv, int is_async) {
    janet_arity(argc, 1, 3);

    /* Get flags */
    uint64_t flags = 0;
    if (argc > 1) {
-        flags = janet_getflags(argv, 1, "epxa");
+        flags = janet_getflags(argv, 1, "epx");
    }

    /* Get environment */
+    int use_environ = !janet_flag_at(flags, 0);
    char **envp = os_execute_env(argc, argv);

    /* Get arguments */
@@ -448,6 +535,8 @@ static Janet os_execute(int32_t argc, Janet *argv) {

    /* Optional stdio redirections */
    JanetFile *new_in = NULL, *new_out = NULL, *new_err = NULL;
+    JanetHandle pipe_in = JANET_HANDLE_NONE, pipe_out = JANET_HANDLE_NONE, pipe_err = JANET_HANDLE_NONE;
+    int pipe_errflag = 0; /* Track errors setting up pipes */

    /* Get optional redirections */
    if (argc > 2) {
@@ -455,24 +544,47 @@ static Janet os_execute(int32_t argc, Janet *argv) {
        Janet maybe_stdin = janet_dictionary_get(tab.kvs, tab.cap, janet_ckeywordv("in"));
        Janet maybe_stdout = janet_dictionary_get(tab.kvs, tab.cap, janet_ckeywordv("out"));
        Janet maybe_stderr = janet_dictionary_get(tab.kvs, tab.cap, janet_ckeywordv("err"));
-        if (!janet_checktype(maybe_stdin, JANET_NIL)) new_in = janet_getjfile(&maybe_stdin, 0);
-        if (!janet_checktype(maybe_stdout, JANET_NIL)) new_out = janet_getjfile(&maybe_stdout, 0);
-        if (!janet_checktype(maybe_stderr, JANET_NIL)) new_err = janet_getjfile(&maybe_stderr, 0);
+        if (janet_keyeq(maybe_stdin, "pipe")) {
+            new_in = make_pipes(&pipe_in, 1, &pipe_errflag);
+        } else if (!janet_checktype(maybe_stdin, JANET_NIL)) {
+            new_in = janet_getjfile(&maybe_stdin, 0);
+        }
+        if (janet_keyeq(maybe_stdout, "pipe")) {
+            new_out = make_pipes(&pipe_out, 0, &pipe_errflag);
+        } else if (!janet_checktype(maybe_stdout, JANET_NIL)) {
+            new_out = janet_getjfile(&maybe_stdout, 0);
+        }
+        if (janet_keyeq(maybe_stderr, "err")) {
+            new_err = make_pipes(&pipe_err, 0, &pipe_errflag);
+        } else if (!janet_checktype(maybe_stderr, JANET_NIL)) {
+            new_err = janet_getjfile(&maybe_stderr, 0);
+        }
+    }
+
+    /* Clean up if any of the pipes have any issues */
+    if (pipe_errflag) {
+        if (pipe_in != JANET_HANDLE_NONE) close_handle(pipe_in);
+        if (pipe_out != JANET_HANDLE_NONE) close_handle(pipe_out);
+        if (pipe_err != JANET_HANDLE_NONE) close_handle(pipe_err);
+        janet_panic("failed to create pipes");
    }

    /* Result */
    int status = 0;
-    int is_async = janet_flag_at(flags, 3);

 #ifdef JANET_WINDOWS

    HANDLE pHandle, tHandle;
-	PROCESS_INFORMATION processInfo;
-	STARTUPINFO startupInfo;
-	memset(&processInfo, 0, sizeof(processInfo));
-	memset(&startupInfo, 0, sizeof(startupInfo));
-	startupInfo.cb = sizeof(startupInfo);
-	startupInfo.dwFlags |= STARTF_USESTDHANDLES;
+    SECURITY_ATTRIBUTES saAttr;
+    PROCESS_INFORMATION processInfo;
+    STARTUPINFO startupInfo;
+    memset(&saAttr, 0, sizeof(saAttr));
+    memset(&processInfo, 0, sizeof(processInfo));
+    memset(&startupInfo, 0, sizeof(startupInfo));
+    startupInfo.cb = sizeof(startupInfo);
+    startupInfo.dwFlags |= STARTF_USESTDHANDLES;
+    saAttr.nLength = sizeof(saAttr);
+    saAttr.bInheritHandle = TRUE;

    JanetBuffer *buf = os_exec_escape(exargs);
    if (buf->count > 8191) {
@@ -480,42 +592,72 @@ static Janet os_execute(int32_t argc, Janet *argv) {
    }
    const char *path = (const char *) janet_unwrap_string(exargs.items[0]);

-	/* Do IO redirection */
-	startupInfo.hStdInput = (HANDLE) _get_osfhandle((new_in == NULL) ? 0 : _fileno(new_in->file));
-	startupInfo.hStdOutput = (HANDLE) _get_osfhandle((new_out == NULL) ? 1 : _fileno(new_out->file));
-	startupInfo.hStdError = (HANDLE) _get_osfhandle((new_err == NULL) ? 2 : _fileno(new_err->file));
+    /* Do IO redirection */
+
+    if (pipe_in != JANET_HANDLE_NONE) {
+        startupInfo.hStdInput = pipe_in;
+    } else if (new_in != NULL) {
+        startupInfo.hStdInput = (HANDLE) _get_osfhandle(_fileno(new_in->file));
+    } else {
+        startupInfo.hStdInput = (HANDLE) _get_osfhandle(0);
+    }
+
+
+    if (pipe_out != JANET_HANDLE_NONE) {
+        startupInfo.hStdOutput = pipe_out;
+    } else if (new_out != NULL) {
+        startupInfo.hStdOutput = (HANDLE) _get_osfhandle(_fileno(new_out->file));
+    } else {
+        startupInfo.hStdOutput = (HANDLE) _get_osfhandle(1);
+    }
+
+    if (pipe_err != JANET_HANDLE_NONE) {
+        startupInfo.hStdError = pipe_err;
+    } else if (new_err != NULL) {
+        startupInfo.hStdError = (HANDLE) _get_osfhandle(_fileno(new_err->file));
+    } else {
+        startupInfo.hStdError = (HANDLE) _get_osfhandle(2);
+    }

    /* Use _spawn family of functions. */
    /* Windows docs say do this before any spawns. */
    _flushall();

-	/* TODO - redirection, :p flag */
-	if(!CreateProcess(janet_flag_at(flags, 1) ? NULL : path, /* NULL? */
-		(char *) buf->data, /* Single CLI argument */
-        NULL, /* no proc inheritance */
-        NULL, /* no thread inheritance */
-        TRUE, /* handle inheritance */
-        0, /* flags */
-        envp, /* pass in environment */
-        NULL, /* use parents starting directory */
-        &startupInfo,
-        &processInfo))  {
-        janet_panic("failed to create process");
+    int cp_failed = 0;
+    if (!CreateProcess(janet_flag_at(flags, 1) ? NULL : path,
+                       (char *) buf->data, /* Single CLI argument */
+                       &saAttr, /* no proc inheritance */
+                       &saAttr, /* no thread inheritance */
+                       TRUE, /* handle inheritance */
+                       0, /* flags */
+                       use_environ ? NULL : envp, /* pass in environment */
+                       NULL, /* use parents starting directory */
+                       &startupInfo,
+                       &processInfo)) {
+        cp_failed = 1;
    }
-	
-	pHandle = processInfo.hProcess;
-	tHandle = processInfo.hThread;
+
+    if (pipe_in != JANET_HANDLE_NONE) CloseHandle(pipe_in);
+    if (pipe_out != JANET_HANDLE_NONE) CloseHandle(pipe_out);
+    if (pipe_err != JANET_HANDLE_NONE) CloseHandle(pipe_err);

    os_execute_cleanup(envp, NULL);

-	/* Wait and cleanup immedaitely */
+    if (cp_failed)  {
+        janet_panic("failed to create process");
+    }
+
+    pHandle = processInfo.hProcess;
+    tHandle = processInfo.hThread;
+
+    /* Wait and cleanup immedaitely */
    if (!is_async) {
-		DWORD code;
-		WaitForSingleObject(pHandle, INFINITE);
-		GetExitCodeProcess(pHandle, &code);
+        DWORD code;
+        WaitForSingleObject(pHandle, INFINITE);
+        GetExitCodeProcess(pHandle, &code);
        status = (int) code;
-		CloseHandle(pHandle);
-		CloseHandle(tHandle);
+        CloseHandle(pHandle);
+        CloseHandle(tHandle);
    }
 #else

@@ -529,8 +671,6 @@ static Janet os_execute(int32_t argc, Janet *argv) {

    /* Use posix_spawn to spawn new process */

-    int use_environ = !janet_flag_at(flags, 0);
-
    if (use_environ) {
        janet_lock_environ();
    }
@@ -538,13 +678,19 @@ static Janet os_execute(int32_t argc, Janet *argv) {
    /* Posix spawn setup */
    posix_spawn_file_actions_t actions;
    posix_spawn_file_actions_init(&actions);
-    if (new_in != NULL) {
+    if (pipe_in != JANET_HANDLE_NONE) {
+        posix_spawn_file_actions_adddup2(&actions, pipe_in, 0);
+    } else if (new_in != NULL) {
        posix_spawn_file_actions_adddup2(&actions, fileno(new_in->file), 0);
    }
-    if (new_out != NULL) {
+    if (pipe_out != JANET_HANDLE_NONE) {
+        posix_spawn_file_actions_adddup2(&actions, pipe_out, 1);
+    } else if (new_out != NULL) {
        posix_spawn_file_actions_adddup2(&actions, fileno(new_out->file), 1);
    }
-    if (new_err != NULL) {
+    if (pipe_err != JANET_HANDLE_NONE) {
+        posix_spawn_file_actions_adddup2(&actions, pipe_err, 2);
+    } else if (new_err != NULL) {
        posix_spawn_file_actions_adddup2(&actions, fileno(new_err->file), 2);
    }

@@ -561,6 +707,10 @@ static Janet os_execute(int32_t argc, Janet *argv) {

    posix_spawn_file_actions_destroy(&actions);

+    if (pipe_in != JANET_HANDLE_NONE) close(pipe_in);
+    if (pipe_out != JANET_HANDLE_NONE) close(pipe_out);
+    if (pipe_err != JANET_HANDLE_NONE) close(pipe_err);
+
    if (use_environ) {
        janet_unlock_environ();
    }
@@ -569,7 +719,7 @@ static Janet os_execute(int32_t argc, Janet *argv) {
    if (status) {
        os_execute_cleanup(envp, child_argv);
        janet_panicf("%p: %s", argv[0], strerror(errno));
-    } else if (janet_flag_at(flags, 3)) {
+    } else if (is_async) {
        /* Get process handle */
        os_execute_cleanup(envp, child_argv);
    } else {
@@ -591,10 +741,10 @@ static Janet os_execute(int32_t argc, Janet *argv) {
        JanetProc *proc = janet_abstract(&ProcAT, sizeof(JanetProc));
        proc->return_code = -1;
 #ifdef JANET_WINDOWS
-		proc->pHandle = pHandle;
-		proc->tHandle = tHandle;
+        proc->pHandle = pHandle;
+        proc->tHandle = tHandle;
 #else
-	    proc->pid = pid;
+        proc->pid = pid;
 #endif
        proc->in = new_in;
        proc->out = new_out;
@@ -608,6 +758,14 @@ static Janet os_execute(int32_t argc, Janet *argv) {
    }
 }

+static Janet os_execute(int32_t argc, Janet *argv) {
+    return os_execute_impl(argc, argv, 0);
+}
+
+static Janet os_spawn(int32_t argc, Janet *argv) {
+    return os_execute_impl(argc, argv, 1);
+}
+
 static Janet os_shell(int32_t argc, Janet *argv) {
    janet_arity(argc, 0, 1);
    const char *cmd = argc
@@ -1522,17 +1680,39 @@ static const JanetReg os_cfuns[] = {
             "\t:p - allows searching the current PATH for the binary to execute. "
             "Without this flag, binaries must use absolute paths.\n"
             "\t:x - raise error if exit code is non-zero.\n"
-             "\t:a - Runs the process asynchronously and returns a core/process.\n\n"
             "env is a table or struct mapping environment variables to values. It can also "
             "contain the keys :in, :out, and :err, which allow redirecting stdio in the subprocess. "
             "These arguments should be core/file values. "
-             "Returns the exit status of the program, or a core/process object if the :a flag is given.")
+             "One can also pass in the :pipe keyword "
+             "for these arguments to create files that will read (for :err and :out) or write (for :in) "
+             "to the file descriptor of the subprocess. This is only useful in os/spawn, which takes "
+             "the same parameters as os/execute, but will return an object that contains references to these "
+             "files via (return-value :in), (return-value :out), and (return-value :err). "
+             "Returns the exit status of the program.")
+    },
+    {
+        "os/spawn", os_spawn,
+        JDOC("(os/spawn args &opts flags env)\n\n"
+             "Execute a program on the system and return a handle to the process. Otherwise, the "
+             "same arguments as os/execute. Does not wait for the process.")
    },
    {
        "os/shell", os_shell,
        JDOC("(os/shell str)\n\n"
             "Pass a command string str directly to the system shell.")
    },
+    {
+        "os/proc-wait", os_proc_wait,
+        JDOC("(os/proc-wait proc)\n\n"
+             "Block until the subprocess completes. Returns the subprocess return code.")
+    },
+    {
+        "os/proc-kill", os_proc_kill,
+        JDOC("(os/proc-kill proc &opt wait)\n\n"
+             "Kill a subprocess by sending SIGKILL to it on posix systems, or by closing the process "
+             "handle on windows. If wait is truthy, will wait for the process to finsih and "
+             "returns the exit code. Otherwise, returns proc.")
+    },
 #endif
    {
        "os/setenv", os_setenv,
@@ -1563,8 +1743,8 @@ static const JanetReg os_cfuns[] = {
    },
    {
        "os/sleep", os_sleep,
-        JDOC("(os/sleep nsec)\n\n"
-             "Suspend the program for nsec seconds. 'nsec' can be a real number. Returns "
+        JDOC("(os/sleep n)\n\n"
+             "Suspend the program for n seconds. 'nsec' can be a real number. Returns "
             "nil.")
    },
    {
@@ -1618,18 +1798,6 @@ static const JanetReg os_cfuns[] = {
        JDOC("(os/perm-int bytes)\n\n"
             "Parse a 9 character permission string and return an integer that can be used by chmod.")
    },
-    {
-        "os/proc-wait", os_proc_wait,
-        JDOC("(os/proc-wait proc)\n\n"
-             "Block until the subprocess completes. Returns the subprocess return code.")
-    },
-    {
-        "os/proc-kill", os_proc_kill,
-        JDOC("(os/proc-kill proc &opt wait)\n\n"
-             "Kill a subprocess by sending SIGKILL to it on posix systems, or by closing the process "
-             "handle on windows. If wait is truthy, will wait for the process to finsih and "
-             "returns the exit code. Otherwise, returns proc.")
-    },
 #endif
    {NULL, NULL, NULL}
 };
--- a/src/core/peg.c
+++ b/src/core/peg.c
@@ -87,6 +87,12 @@ static void pushcap(PegState *s, Janet capture, uint32_t tag) {
    }
 }

+/* Convert a uint64_t to a int64_t by wrapping to a maximum number of bytes */
+static int64_t peg_convert_u64_s64(uint64_t from, int width) {
+    int shift = 8 * (8 - width);
+    return ((int64_t)(from << shift)) >> shift;
+}
+
 /* Prevent stack overflow */
 #define down1(s) do { \
    if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \
@@ -469,6 +475,47 @@ tail:
            return next_text;
        }

+        case RULE_READINT: {
+            uint32_t tag = rule[2];
+            uint32_t signedness = rule[1] & 0x10;
+            uint32_t endianess = rule[1] & 0x20;
+            int width = (int)(rule[1] & 0xF);
+            if (text + width > s->text_end) return NULL;
+            uint64_t accum = 0;
+            if (endianess) {
+                /* BE */
+                for (int i = 0; i < width; i++) accum = (accum << 8) | text[i];
+            } else {
+                /* LE */
+                for (int i = width - 1; i >= 0; i--) accum = (accum << 8) | text[i];
+            }
+
+            Janet capture_value;
+            /* We can only parse integeres of greater than 6 bytes reliable if int-types are enabled.
+             * Otherwise, we may lose precision, so 6 is the maximum size when int-types are disabled. */
+#ifdef JANET_INT_TYPES
+            if (width > 6) {
+                if (signedness) {
+                    capture_value = janet_wrap_s64(peg_convert_u64_s64(accum, width));
+                } else {
+                    capture_value = janet_wrap_u64(accum);
+                }
+            } else
+#endif
+            {
+                double double_value;
+                if (signedness) {
+                    double_value = (double)(peg_convert_u64_s64(accum, width));
+                } else {
+                    double_value = (double)accum;
+                }
+                capture_value = janet_wrap_number(double_value);
+            }
+
+            pushcap(s, capture_value, tag);
+            return text + width;
+        }
+
    }
 }

@@ -876,6 +923,36 @@ static void spec_matchtime(Builder *b, int32_t argc, const Janet *argv) {
    emit_3(r, RULE_MATCHTIME, subrule, cindex, tag);
 }

+#ifdef JANET_INT_TYPES
+#define JANET_MAX_READINT_WIDTH 8
+#else
+#define JANET_MAX_READINT_WIDTH 6
+#endif
+
+static void spec_readint(Builder *b, int32_t argc, const Janet *argv, uint32_t mask) {
+    peg_arity(b, argc, 1, 2);
+    Reserve r = reserve(b, 3);
+    uint32_t tag = (argc == 2) ? emit_tag(b, argv[3]) : 0;
+    int32_t width = peg_getnat(b, argv[0]);
+    if ((width < 0) || (width > JANET_MAX_READINT_WIDTH)) {
+        peg_panicf(b, "width must be between 0 and %d, got %d", JANET_MAX_READINT_WIDTH, width);
+    }
+    emit_2(r, RULE_READINT, mask | ((uint32_t) width), tag);
+}
+
+static void spec_uint_le(Builder *b, int32_t argc, const Janet *argv) {
+    spec_readint(b, argc, argv, 0x0u);
+}
+static void spec_int_le(Builder *b, int32_t argc, const Janet *argv) {
+    spec_readint(b, argc, argv, 0x10u);
+}
+static void spec_uint_be(Builder *b, int32_t argc, const Janet *argv) {
+    spec_readint(b, argc, argv, 0x20u);
+}
+static void spec_int_be(Builder *b, int32_t argc, const Janet *argv) {
+    spec_readint(b, argc, argv, 0x30u);
+}
+
 /* Special compiler form */
 typedef void (*Special)(Builder *b, int32_t argc, const Janet *argv);
 typedef struct {
@@ -912,6 +989,8 @@ static const SpecialPair peg_specials[] = {
    {"group", spec_group},
    {"if", spec_if},
    {"if-not", spec_ifnot},
+    {"int", spec_int_le},
+    {"int-be", spec_int_be},
    {"lenprefix", spec_lenprefix},
    {"look", spec_look},
    {"not", spec_not},
@@ -926,6 +1005,8 @@ static const SpecialPair peg_specials[] = {
    {"some", spec_some},
    {"thru", spec_thru},
    {"to", spec_to},
+    {"uint", spec_uint_le},
+    {"uint-be", spec_uint_be},
 };

 /* Compile a janet value into a rule and return the rule index. */
@@ -1226,6 +1307,11 @@ static void *peg_unmarshal(JanetMarshalContext *ctx) {
                op_flags[rule[1]] |= 0x01;
                i += 2;
                break;
+            case RULE_READINT:
+                /* [ width | (endianess << 5) | (signedness << 6), tag ] */
+                if (rule[1] > JANET_MAX_READINT_WIDTH) goto bad;
+                i += 3;
+                break;
            default:
                goto bad;
        }
--- a/src/core/pp.c
+++ b/src/core/pp.c
@@ -454,7 +454,7 @@ static const char *janet_pretty_colors[] = {
    "\x1B[36m",
    "\x1B[36m",
    "\x1B[36m",
-    "\x1B[36m"
+    "\x1B[36m",
    "\x1B[35m",
    "\x1B[36m",
    "\x1B[36m",
@@ -955,6 +955,9 @@ void janet_buffer_format(
                    janet_description_b(b, argv[arg]);
                    break;
                }
+                case 't':
+                    janet_buffer_push_cstring(b, typestr(argv[arg]));
+                    break;
                case 'M':
                case 'm':
                case 'N':
--- a/src/core/state.h
+++ b/src/core/state.h
@@ -101,4 +101,14 @@ void janet_threads_init(void);
 void janet_threads_deinit(void);
 #endif

+#ifdef JANET_NET
+void janet_net_init(void);
+void janet_net_deinit(void);
+#endif
+
+#ifdef JANET_EV
+void janet_ev_init(void);
+void janet_ev_deinit(void);
+#endif
+
 #endif /* JANET_STATE_H_defined */
--- a/src/core/table.c
+++ b/src/core/table.c
@@ -256,7 +256,7 @@ static void janet_table_mergekv(JanetTable *table, const JanetKV *kvs, int32_t c
    }
 }

-/* Merge a table other into another table */
+/* Merge a table into another table */
 void janet_table_merge_table(JanetTable *table, JanetTable *other) {
    janet_table_mergekv(table, other->data, other->capacity);
 }
--- a/src/core/thread.c
+++ b/src/core/thread.c
@@ -585,6 +585,14 @@ void janet_threads_deinit(void) {
    janet_vm_thread_decode = NULL;
 }

+JanetThread *janet_thread_current(void) {
+    if (NULL == janet_vm_thread_current) {
+        janet_vm_thread_current = janet_make_thread(janet_vm_mailbox, janet_get_core_table("make-image-dict"));
+        janet_gcroot(janet_wrap_abstract(janet_vm_thread_current));
+    }
+    return janet_vm_thread_current;
+}
+
 /*
 * Cfuns
 */
@@ -592,11 +600,7 @@ void janet_threads_deinit(void) {
 static Janet cfun_thread_current(int32_t argc, Janet *argv) {
    (void) argv;
    janet_fixarity(argc, 0);
-    if (NULL == janet_vm_thread_current) {
-        janet_vm_thread_current = janet_make_thread(janet_vm_mailbox, janet_get_core_table("make-image-dict"));
-        janet_gcroot(janet_wrap_abstract(janet_vm_thread_current));
-    }
-    return janet_wrap_abstract(janet_vm_thread_current);
+    return janet_wrap_abstract(janet_thread_current());
 }

 static Janet cfun_thread_new(int32_t argc, Janet *argv) {
@@ -724,15 +728,18 @@ static const JanetReg threadlib_cfuns[] = {
    },
    {
        "thread/send", cfun_thread_send,
-        JDOC("(thread/send thread msg)\n\n"
-             "Send a message to the thread. This will never block and returns thread immediately. "
+        JDOC("(thread/send thread msgi &opt timeout)\n\n"
+             "Send a message to the thread. By default, the timeout is 1 second, but an optional timeout "
+             "in seconds can be provided. Use math/inf for no timeout. "
             "Will throw an error if there is a problem sending the message.")
    },
    {
        "thread/receive", cfun_thread_receive,
        JDOC("(thread/receive &opt timeout)\n\n"
-             "Get a message sent to this thread. If timeout is provided, an error will be thrown after the timeout has elapsed but "
-             "no messages are received.")
+             "Get a message sent to this thread. If timeout (in seconds) is provided, an error "
+             "will be thrown after the timeout has elapsed but "
+             "no messages are received. The default timeout is 1 second, and math/inf cam be passed to "
+             "turn off the timeout.")
    },
    {
        "thread/close", cfun_thread_close,
--- a/src/core/util.c
+++ b/src/core/util.c
@@ -449,7 +449,8 @@ void janet_cfuns(JanetTable *env, const char *regprefix, const JanetReg *cfuns)

 void janet_register_abstract_type(const JanetAbstractType *at) {
    Janet sym = janet_csymbolv(at->name);
-    if (!(janet_checktype(janet_table_get(janet_vm_abstract_registry, sym), JANET_NIL))) {
+    Janet check = janet_table_get(janet_vm_abstract_registry, sym);
+    if (!janet_checktype(check, JANET_NIL) && at != janet_unwrap_pointer(check)) {
        janet_panicf("cannot register abstract type %s, "
                     "a type with the same name exists", at->name);
    }
@@ -680,6 +681,8 @@ int janet_cryptorand(uint8_t *out, size_t n) {
    arc4random_buf(out, n);
    return 0;
 #else
+    (void) n;
+    (void) out;
    return -1;
 #endif
 }
--- a/src/core/util.h
+++ b/src/core/util.h
@@ -140,8 +140,11 @@ void janet_lib_thread(JanetTable *env);
 #endif
 #ifdef JANET_NET
 void janet_lib_net(JanetTable *env);
-void janet_net_deinit(void);
-void janet_net_markloop(void);
+extern const JanetAbstractType janet_address_type;
+#endif
+#ifdef JANET_EV
+void janet_lib_ev(JanetTable *env);
+void janet_ev_mark(void);
 #endif

 #endif
--- a/src/core/value.c
+++ b/src/core/value.c
@@ -271,14 +271,12 @@ int32_t janet_hash(Janet x) {
        }
        /* fallthrough */
        default:
-            /* TODO - test performance with different hash functions */
            if (sizeof(double) == sizeof(void *)) {
                /* Assuming 8 byte pointer */
                uint64_t i = janet_u64(x);
-                hash = (int32_t)(i & 0xFFFFFFFF);
-                /* Get a bit more entropy by shifting the low bits out */
-                hash >>= 3;
-                hash ^= (int32_t)(i >> 32);
+                uint32_t lo = (uint32_t)(i & 0xFFFFFFFF);
+                uint32_t hi = (uint32_t)(i >> 32);
+                hash = (int32_t)(hi ^ (lo >> 3));
            } else {
                /* Assuming 4 byte pointer (or smaller) */
                hash = (int32_t)((char *)janet_unwrap_pointer(x) - (char *)0);
--- a/src/core/vm.c
+++ b/src/core/vm.c
@@ -1315,11 +1315,32 @@ static JanetSignal janet_check_can_resume(JanetFiber *fiber, Janet *out) {
    return JANET_SIGNAL_OK;
 }

+void janet_try_init(JanetTryState *state) {
+    state->stackn = janet_vm_stackn++;
+    state->gc_handle = janet_vm_gc_suspend;
+    state->vm_fiber = janet_vm_fiber;
+    state->vm_jmp_buf = janet_vm_jmp_buf;
+    state->vm_return_reg = janet_vm_return_reg;
+    janet_vm_return_reg = &(state->payload);
+    janet_vm_jmp_buf = &(state->buf);
+}
+
+void janet_restore(JanetTryState *state) {
+    janet_vm_stackn = state->stackn;
+    janet_vm_gc_suspend = state->gc_handle;
+    janet_vm_fiber = state->vm_fiber;
+    janet_vm_jmp_buf = state->vm_jmp_buf;
+    janet_vm_return_reg = state->vm_return_reg;
+}
+
 static JanetSignal janet_continue_no_check(JanetFiber *fiber, Janet in, Janet *out) {
-    jmp_buf buf;

    JanetFiberStatus old_status = janet_fiber_status(fiber);

+#ifdef JANET_EV
+    janet_fiber_did_resume(fiber);
+#endif
+
    /* Continue child fiber if it exists */
    if (fiber->child) {
        if (janet_vm_root_fiber == NULL) janet_vm_root_fiber = fiber;
@@ -1349,45 +1370,21 @@ static JanetSignal janet_continue_no_check(JanetFiber *fiber, Janet in, Janet *o
    }

    /* Save global state */
-    int32_t oldn = janet_vm_stackn++;
-    int handle = janet_vm_gc_suspend;
-    JanetFiber *old_vm_fiber = janet_vm_fiber;
-    jmp_buf *old_vm_jmp_buf = janet_vm_jmp_buf;
-    Janet *old_vm_return_reg = janet_vm_return_reg;
-
-    /* Setup fiber */
-    if (janet_vm_root_fiber == NULL) janet_vm_root_fiber = fiber;
-    janet_vm_fiber = fiber;
-    janet_gcroot(janet_wrap_fiber(fiber));
-    janet_fiber_set_status(fiber, JANET_STATUS_ALIVE);
-    janet_vm_return_reg = out;
-    janet_vm_jmp_buf = &buf;
-
-    /* Run loop */
-    JanetSignal signal;
-    int jmpsig;
-#if defined(JANET_BSD) || defined(JANET_APPLE)
-    jmpsig = _setjmp(buf);
-#else
-    jmpsig = setjmp(buf);
-#endif
-    if (jmpsig) {
-        signal = (JanetSignal) jmpsig;
-    } else {
+    JanetTryState tstate;
+    JanetSignal signal = janet_try(&tstate);
+    if (!signal) {
+        /* Normal setup */
+        if (janet_vm_root_fiber == NULL) janet_vm_root_fiber = fiber;
+        janet_vm_fiber = fiber;
+        janet_fiber_set_status(fiber, JANET_STATUS_ALIVE);
        signal = run_vm(fiber, in);
    }

-    /* Tear down fiber */
-    janet_fiber_set_status(fiber, signal);
-    janet_gcunroot(janet_wrap_fiber(fiber));
-
-    /* Restore global state */
+    /* Restore */
    if (janet_vm_root_fiber == fiber) janet_vm_root_fiber = NULL;
-    janet_vm_gc_suspend = handle;
-    janet_vm_fiber = old_vm_fiber;
-    janet_vm_stackn = oldn;
-    janet_vm_return_reg = old_vm_return_reg;
-    janet_vm_jmp_buf = old_vm_jmp_buf;
+    janet_fiber_set_status(fiber, signal);
+    janet_restore(&tstate);
+    *out = tstate.payload;

    return signal;
 }
@@ -1484,6 +1481,12 @@ int janet_init(void) {
    /* Threads */
 #ifdef JANET_THREADS
    janet_threads_init();
+#endif
+#ifdef JANET_EV
+    janet_ev_init();
+#endif
+#ifdef JANET_NET
+    janet_net_init();
 #endif
    return 0;
 }
@@ -1506,6 +1509,9 @@ void janet_deinit(void) {
 #ifdef JANET_THREADS
    janet_threads_deinit();
 #endif
+#ifdef JANET_EV
+    janet_ev_deinit();
+#endif
 #ifdef JANET_NET
    janet_net_deinit();
 #endif
--- a/src/include/janet.h
+++ b/src/include/janet.h
@@ -177,8 +177,13 @@ extern "C" {
 #define JANET_TYPED_ARRAY
 #endif

+/* Enable or disable event loop */
+#if !defined(JANET_NO_EV) && !defined(__EMSCRIPTEN__)
+#define JANET_EV
+#endif
+
 /* Enable or disable networking */
-#if !defined(JANET_NO_NET) && !defined(__EMSCRIPTEN__)
+#if defined(JANET_EV) && !defined(JANET_NO_NET) && !defined(__EMSCRIPTEN__)
 #define JANET_NET
 #endif

@@ -201,7 +206,7 @@ extern "C" {
 #ifdef JANET_WINDOWS
 #define JANET_NO_RETURN __declspec(noreturn)
 #else
-#define JANET_NO_RETURN __attribute__ ((noreturn))
+#define JANET_NO_RETURN __attribute__((noreturn))
 #endif
 #endif

@@ -267,11 +272,22 @@ typedef struct {
 } JanetBuildConfig;

 /* Get config of current compilation unit. */
+#ifdef __cplusplus
+/* C++11 syntax */
+#define janet_config_current() (JanetBuildConfig { \
+    JANET_VERSION_MAJOR, \
+    JANET_VERSION_MINOR, \
+    JANET_VERSION_PATCH, \
+    JANET_CURRENT_CONFIG_BITS })
+#else
+/* C99 syntax */
 #define janet_config_current() ((JanetBuildConfig){ \
    JANET_VERSION_MAJOR, \
    JANET_VERSION_MINOR, \
    JANET_VERSION_PATCH, \
    JANET_CURRENT_CONFIG_BITS })
+#endif
+

 /***** END SECTION CONFIG *****/

@@ -299,6 +315,15 @@ JANET_API extern const char *const janet_type_names[16];
 JANET_API extern const char *const janet_signal_names[14];
 JANET_API extern const char *const janet_status_names[16];

+/* For various IO routines, we want to use an int on posix and HANDLE on windows */
+#ifdef JANET_WINDOWS
+typedef void *JanetHandle;
+#define JANET_HANDLE_NONE NULL
+#else
+typedef int JanetHandle;
+#define JANET_HANDLE_NONE (-1)
+#endif
+
 /* Fiber signals */
 typedef enum {
    JANET_SIGNAL_OK,
@@ -472,6 +497,75 @@ typedef void *JanetAbstract;
 #define JANET_TFLAG_CALLABLE (JANET_TFLAG_FUNCTION | JANET_TFLAG_CFUNCTION | \
        JANET_TFLAG_LENGTHABLE | JANET_TFLAG_ABSTRACT)

+/* Event Loop Types */
+#ifdef JANET_EV
+
+#define JANET_STREAM_CLOSED 0x1
+#define JANET_STREAM_SOCKET 0x2
+#define JANET_STREAM_IOCP 0x4
+#define JANET_STREAM_READABLE 0x200
+#define JANET_STREAM_WRITABLE 0x400
+#define JANET_STREAM_ACCEPTABLE 0x800
+#define JANET_STREAM_UDPSERVER 0x1000
+
+typedef enum {
+    JANET_ASYNC_EVENT_INIT,
+    JANET_ASYNC_EVENT_MARK,
+    JANET_ASYNC_EVENT_DEINIT,
+    JANET_ASYNC_EVENT_CLOSE,
+    JANET_ASYNC_EVENT_ERR,
+    JANET_ASYNC_EVENT_HUP,
+    JANET_ASYNC_EVENT_READ,
+    JANET_ASYNC_EVENT_WRITE,
+    JANET_ASYNC_EVENT_TIMEOUT,
+    JANET_ASYNC_EVENT_COMPLETE, /* Used on windows for IOCP */
+    JANET_ASYNC_EVENT_USER
+} JanetAsyncEvent;
+
+#define JANET_ASYNC_LISTEN_READ (1 << JANET_ASYNC_EVENT_READ)
+#define JANET_ASYNC_LISTEN_WRITE (1 << JANET_ASYNC_EVENT_WRITE)
+
+typedef enum {
+    JANET_ASYNC_STATUS_NOT_DONE,
+    JANET_ASYNC_STATUS_DONE
+} JanetAsyncStatus;
+
+/* Typedefs */
+typedef struct JanetListenerState JanetListenerState;
+typedef struct JanetStream JanetStream;
+typedef JanetAsyncStatus(*JanetListener)(JanetListenerState *state, JanetAsyncEvent event);
+
+/* Wrapper around file descriptors and HANDLEs that can be polled. */
+struct JanetStream {
+    JanetHandle handle;
+    uint32_t flags;
+    /* Linked list of all in-flight IO routines for this stream */
+    JanetListenerState *state;
+    const void *methods; /* Methods for this stream */
+    /* internal - used to disallow multiple concurrent reads / writes on the same stream.
+     * this constraint may be lifted later but allowing such would require more internal book keeping
+     * for some implementations. You can read and write at the same time on the same stream, though. */
+    int _mask;
+};
+
+/* Interface for state machine based event loop */
+struct JanetListenerState {
+    JanetListener machine;
+    JanetFiber *fiber;
+    JanetStream *stream;
+    void *event; /* Used to pass data from asynchronous IO event. Contents depend on both
+                    implementation of the event loop and the particular event. */
+#ifdef JANET_WINDOWS
+    void *tag; /* Used to associate listeners with an overlapped structure */
+    int bytes; /* Used to track how many bytes were transfered. */
+#endif
+    /* internal */
+    int _index; /* not used in all implementations */
+    int _mask;
+    JanetListenerState *_next;
+};
+#endif
+
 /* We provide three possible implementations of Janets. The preferred
 * nanboxing approach, for 32 or 64 bits, and the standard C version. Code in the rest of the
 * application must interact through exposed interface. */
@@ -561,14 +655,14 @@ JANET_API Janet janet_wrap_integer(int32_t x);
 #define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47)
 #define janet_type(x) \
    (isnan((x).number) \
-        ? (((x).u64 >> 47) & 0xF) \
+        ? (JanetType) (((x).u64 >> 47) & 0xF) \
        : JANET_NUMBER)

 #define janet_nanbox_checkauxtype(x, type) \
    (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type)))

 #define janet_nanbox_isnumber(x) \
-    (!isnan((x).number) || janet_nanbox_checkauxtype((x), JANET_NUMBER))
+    (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER))

 #define janet_checktype(x, t) \
    (((t) == JANET_NUMBER) \
@@ -640,7 +734,7 @@ JANET_API Janet janet_nanbox_from_bits(uint64_t bits);
 #define JANET_DOUBLE_OFFSET 0xFFFF

 #define janet_u64(x) ((x).u64)
-#define janet_type(x) (((x).tagged.type < JANET_DOUBLE_OFFSET) ? (x).tagged.type : JANET_NUMBER)
+#define janet_type(x) (((x).tagged.type < JANET_DOUBLE_OFFSET) ? (JanetType)((x).tagged.type) : JANET_NUMBER)
 #define janet_checktype(x, t) ((t) == JANET_NUMBER \
        ? (x).tagged.type >= JANET_DOUBLE_OFFSET \
        : (x).tagged.type == (t))
@@ -739,11 +833,15 @@ struct JanetFiber {
    int32_t frame; /* Index of the stack frame */
    int32_t stackstart; /* Beginning of next args */
    int32_t stacktop; /* Top of stack. Where values are pushed and popped from. */
-    int32_t capacity;
+    int32_t capacity; /* How big is the stack memory */
    int32_t maxstack; /* Arbitrary defined limit for stack overflow */
    JanetTable *env; /* Dynamic bindings table (usually current environment). */
-    Janet *data;
+    Janet *data; /* Dynamically resized stack memory */
    JanetFiber *child; /* Keep linked list of fibers for restarting pending fibers */
+#ifdef JANET_EV
+    JanetListenerState *waiting;
+    uint32_t sched_id; /* Increment everytime fiber is scheduled by event loop */
+#endif
 };

 /* Mark if a stack frame is a tail call for debugging */
@@ -1010,6 +1108,19 @@ struct JanetFile {
    int32_t flags;
 };

+/* For janet_try and janet_restore */
+typedef struct {
+    /* old state */
+    int32_t stackn;
+    int gc_handle;
+    JanetFiber *vm_fiber;
+    jmp_buf *vm_jmp_buf;
+    Janet *vm_return_reg;
+    /* new state */
+    jmp_buf buf;
+    Janet payload;
+} JanetTryState;
+
 /* Thread types */
 #ifdef JANET_THREADS
 typedef struct JanetThread JanetThread;
@@ -1142,9 +1253,59 @@ extern enum JanetInstructionType janet_instructions[JOP_INSTRUCTION_COUNT];

 /***** START SECTION MAIN *****/

-/* Event Loop */
-#ifdef JANET_NET
+#ifdef JANET_EV
+
+extern JANET_API const JanetAbstractType janet_stream_type;
+
+/* Run the event loop */
 JANET_API void janet_loop(void);
+
+/* Wrapper around streams */
+JANET_API JanetStream *janet_stream(JanetHandle handle, uint32_t flags, const JanetMethod *methods);
+JANET_API void janet_stream_close(JanetStream *stream);
+JANET_API Janet janet_cfun_stream_close(int32_t argc, Janet *argv);
+JANET_API Janet janet_cfun_stream_read(int32_t argc, Janet *argv);
+JANET_API Janet janet_cfun_stream_chunk(int32_t argc, Janet *argv);
+JANET_API Janet janet_cfun_stream_write(int32_t argc, Janet *argv);
+JANET_API void janet_stream_flags(JanetStream *stream, uint32_t flags);
+
+/* Queue a fiber to run on the event loop */
+JANET_API void janet_schedule(JanetFiber *fiber, Janet value);
+JANET_API void janet_cancel(JanetFiber *fiber, Janet value);
+JANET_API void janet_schedule_signal(JanetFiber *fiber, Janet value, JanetSignal sig);
+
+/* Start a state machine listening for events from a stream */
+JANET_API JanetListenerState *janet_listen(JanetStream *stream, JanetListener behavior, int mask, size_t size, void *user);
+
+/* Shorthand for yielding to event loop in C */
+JANET_NO_RETURN JANET_API void janet_await(void);
+
+/* For use inside listeners - adds a timeout to the current fiber, such that
+ * it will be resumed after sec seconds if no other event schedules the current fiber. */
+JANET_API void janet_addtimeout(double sec);
+
+/* Get last error from a an IO operation */
+JANET_API Janet janet_ev_lasterr(void);
+
+/* Read async from a stream */
+JANET_API void janet_ev_read(JanetStream *stream, JanetBuffer *buf, int32_t nbytes);
+JANET_API void janet_ev_readchunk(JanetStream *stream, JanetBuffer *buf, int32_t nbytes);
+#ifdef JANET_NET
+JANET_API void janet_ev_recv(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags);
+JANET_API void janet_ev_recvchunk(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags);
+JANET_API void janet_ev_recvfrom(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags);
+#endif
+
+/* Write async to a stream */
+JANET_API void janet_ev_write_buffer(JanetStream *stream, JanetBuffer *buf);
+JANET_API void janet_ev_write_string(JanetStream *stream, JanetString str);
+#ifdef JANET_NET
+JANET_API void janet_ev_send_buffer(JanetStream *stream, JanetBuffer *buf, int flags);
+JANET_API void janet_ev_send_string(JanetStream *stream, JanetString str, int flags);
+JANET_API void janet_ev_sendto_buffer(JanetStream *stream, JanetBuffer *buf, void *dest, int flags);
+JANET_API void janet_ev_sendto_string(JanetStream *stream, JanetString str, void *dest, int flags);
+#endif
+
 #endif

 /* Parsing */
@@ -1391,6 +1552,13 @@ JANET_API JanetBuffer *janet_pretty(JanetBuffer *buffer, int depth, int flags, J
 #define JANET_HASH_KEY_SIZE 16
 JANET_API void janet_init_hash_key(uint8_t key[JANET_HASH_KEY_SIZE]);
 #endif
+JANET_API void janet_try_init(JanetTryState *state);
+#if defined(JANET_BSD) || defined(JANET_APPLE)
+#define janet_try(state) (janet_try_init(state), (JanetSignal) _setjmp((state)->buf))
+#else
+#define janet_try(state) (janet_try_init(state), (JanetSignal) setjmp((state)->buf))
+#endif
+JANET_API void janet_restore(JanetTryState *state);
 JANET_API int janet_equals(Janet x, Janet y);
 JANET_API int32_t janet_hash(Janet x);
 JANET_API int janet_compare(Janet x, Janet y);
@@ -1439,6 +1607,7 @@ typedef enum {
 JANET_API void janet_def(JanetTable *env, const char *name, Janet val, const char *documentation);
 JANET_API void janet_var(JanetTable *env, const char *name, Janet val, const char *documentation);
 JANET_API void janet_cfuns(JanetTable *env, const char *regprefix, const JanetReg *cfuns);
+JANET_API void janet_cfuns_prefix(JanetTable *env, const char *regprefix, const JanetReg *cfuns);
 JANET_API JanetBindingType janet_resolve(JanetTable *env, JanetSymbol sym, Janet *out);
 JANET_API void janet_register(const char *name, JanetCFunction cfun);

@@ -1447,15 +1616,23 @@ JANET_API Janet janet_resolve_core(const char *name);

 /* New C API */

+/* Shorthand for janet C function declarations */
+#define JANET_CFUN(name) Janet name (int32_t argc, Janet *argv)
+
 /* Allow setting entry name for static libraries */
+#ifdef __cplusplus
+#define JANET_MODULE_PREFIX extern "C"
+#else
+#define JANET_MODULE_PREFIX
+#endif
 #ifndef JANET_ENTRY_NAME
 #define JANET_MODULE_ENTRY \
-    JANET_API JanetBuildConfig _janet_mod_config(void) { \
+    JANET_MODULE_PREFIX JANET_API JanetBuildConfig _janet_mod_config(void) { \
        return janet_config_current(); \
    } \
-    JANET_API void _janet_init
+    JANET_MODULE_PREFIX JANET_API void _janet_init
 #else
-#define JANET_MODULE_ENTRY JANET_API void JANET_ENTRY_NAME
+#define JANET_MODULE_ENTRY JANET_MODULE_PREFIX JANET_API void JANET_ENTRY_NAME
 #endif

 JANET_NO_RETURN JANET_API void janet_signalv(JanetSignal signal, Janet message);
@@ -1543,6 +1720,7 @@ extern JANET_API const JanetAbstractType janet_file_type;
 #define JANET_FILE_NONIL 512

 JANET_API Janet janet_makefile(FILE *f, int32_t flags);
+JANET_API JanetFile *janet_makejfile(FILE *f, int32_t flags);
 JANET_API FILE *janet_getfile(const Janet *argv, int32_t n, int32_t *flags);
 JANET_API FILE *janet_dynfile(const char *name, FILE *def);
 JANET_API JanetFile *janet_getjfile(const Janet *argv, int32_t n);
@@ -1605,6 +1783,7 @@ typedef enum {
    RULE_TO,           /* [rule] */
    RULE_THRU,         /* [rule] */
    RULE_LENPREFIX,    /* [rule_a, rule_b (repeat rule_b rule_a times)] */
+    RULE_READINT,      /* [(signedness << 4) | (endianess << 5) | bytewidth, tag] */
 } JanetPegOpcode;

 typedef struct {
--- a/src/mainclient/shell.c
+++ b/src/mainclient/shell.c
@@ -763,7 +763,7 @@ static int line() {

        switch (c) {
            default:
-                if (c < 0x20) break;
+                if ((unsigned char) c < 0x20) break;
                if (insert(c, 1)) return -1;
                break;
            case 1:     /* ctrl-a */
@@ -1064,7 +1064,7 @@ int main(int argc, char **argv) {
        janet_stacktrace(fiber, out);
    }

-#ifdef JANET_NET
+#ifdef JANET_EV
    status = JANET_SIGNAL_OK;
    janet_loop();
 #endif
--- a/test/helper.janet
+++ b/test/helper.janet
@@ -3,7 +3,6 @@
 (var num-tests-passed 0)
 (var num-tests-run 0)
 (var suite-num 0)
-(var numchecks 0)
 (var start-time 0)

 (defn assert
@@ -12,17 +11,12 @@
  (default e "assert error")
  (++ num-tests-run)
  (when x (++ num-tests-passed))
+  (def str (string e))
+  (def truncated
+    (if (> (length e) 40) (string (string/slice e 0 35) "...") (string e)))
  (if x
-    (do
-      (when (= numchecks 25)
-        (set numchecks 0)
-        (print))
-      (++ numchecks)
-      (file/write stdout "\e[32m✔\e[0m"))
-    (do
-      (file/write stdout "\n\e[31m✘\e[0m  ")
-      (set numchecks 0)
-      (print e)))
+    (eprintf "\e[32m✔\e[0m %s: %v" truncated x)
+    (eprintf "\n\e[31m✘\e[0m %s: %v" truncated x))
  x)

 (defmacro assert-error
@@ -38,10 +32,10 @@
 (defn start-suite [x]
  (set suite-num x)
  (set start-time (os/clock))
-  (print "\nRunning test suite " x " tests...\n  "))
+  (eprint "\nRunning test suite " x " tests...\n  "))

 (defn end-suite []
  (def delta (- (os/clock) start-time))
-  (printf "\n\nTest suite %d finished in %.3f seconds" suite-num delta)
-  (print num-tests-passed " of " num-tests-run " tests passed.\n")
+  (eprintf "\n\nTest suite %d finished in %.3f seconds" suite-num delta)
+  (eprint num-tests-passed " of " num-tests-run " tests passed.\n")
  (if (not= num-tests-passed num-tests-run) (os/exit 1)))
--- a/test/install/project.janet
+++ b/test/install/project.janet
@@ -9,6 +9,14 @@
    :name "testmod2"
    :source @["testmod2.c"])

+(declare-native
+    :name "testmod3"
+    :source @["testmod3.cpp"])
+
+(declare-native
+    :name "test-mod-4"
+    :source @["testmod4.c"])
+
 (declare-executable
  :name "testexec"
  :entry "testexec.janet")
--- a/test/install/testexec.janet
+++ b/test/install/testexec.janet
@@ -1,6 +1,8 @@
 (use build/testmod)
 (use build/testmod2)
+(use build/testmod3)
+(use build/test-mod-4)

 (defn main [&]
  (print "Hello from executable!")
-  (print (+ (get5) (get6))))
+  (print (+ (get5) (get6) (get7) (get8))))
--- a/test/install/testmod3.cpp
+++ b/test/install/testmod3.cpp
@@ -0,0 +1,42 @@
+/*
+* Copyright (c) 2020 Calvin Rose and contributors
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to
+* deal in the Software without restriction, including without limitation the
+* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+* sell copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+* IN THE SOFTWARE.
+*/
+
+/* A very simple native module */
+
+#include <janet.h>
+#include <iostream>
+
+static Janet cfun_get_seven(int32_t argc, Janet *argv) {
+    (void) argv;
+    janet_fixarity(argc, 0);
+    std::cout << "Hello!" << std::endl;
+    return janet_wrap_number(7.0);
+}
+
+static const JanetReg array_cfuns[] = {
+    {"get7", cfun_get_seven, NULL},
+    {NULL, NULL, NULL}
+};
+
+JANET_MODULE_ENTRY(JanetTable *env) {
+    janet_cfuns(env, NULL, array_cfuns);
+}
--- a/test/install/testmod4.c
+++ b/test/install/testmod4.c
@@ -0,0 +1,40 @@
+/*
+* Copyright (c) 2020 Calvin Rose and contributors
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to
+* deal in the Software without restriction, including without limitation the
+* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+* sell copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+* IN THE SOFTWARE.
+*/
+
+/* A very simple native module */
+
+#include <janet.h>
+
+static Janet cfun_get_eight(int32_t argc, Janet *argv) {
+    (void) argv;
+    janet_fixarity(argc, 0);
+    return janet_wrap_number(8.0);
+}
+
+static const JanetReg array_cfuns[] = {
+    {"get8", cfun_get_eight, NULL},
+    {NULL, NULL, NULL}
+};
+
+JANET_MODULE_ENTRY(JanetTable *env) {
+    janet_cfuns(env, NULL, array_cfuns);
+}
--- a/test/suite0003.janet
+++ b/test/suite0003.janet
@@ -443,4 +443,26 @@
 (check-match redef-b "aabeef" false)
 (check-match redef-b "aaaaaa" false)

+# Integer parsing
+
+(check-deep '(int 1) "a" @[(chr "a")])
+(check-deep '(uint 1) "a" @[(chr "a")])
+(check-deep '(int-be 1) "a" @[(chr "a")])
+(check-deep '(uint-be 1) "a" @[(chr "a")])
+(check-deep '(int 1) "\xFF" @[-1])
+(check-deep '(uint 1) "\xFF" @[255])
+(check-deep '(int-be 1) "\xFF" @[-1])
+(check-deep '(uint-be 1) "\xFF" @[255])
+(check-deep '(int 2) "\xFF\x7f" @[0x7fff])
+(check-deep '(int-be 2) "\x7f\xff" @[0x7fff])
+(check-deep '(uint 2) "\xff\x7f" @[0x7fff])
+(check-deep '(uint-be 2) "\x7f\xff" @[0x7fff])
+(check-deep '(uint-be 2) "\x7f\xff" @[0x7fff])
+(check-deep '(uint 8) "\xff\x7f\x00\x00\x00\x00\x00\x00" @[(int/u64 0x7fff)])
+(check-deep '(int 8) "\xff\x7f\x00\x00\x00\x00\x00\x00" @[(int/s64 0x7fff)])
+(check-deep '(uint 7) "\xff\x7f\x00\x00\x00\x00\x00" @[(int/u64 0x7fff)])
+(check-deep '(int 7) "\xff\x7f\x00\x00\x00\x00\x00" @[(int/s64 0x7fff)])
+
+(check-deep '(* (int 2) -1) "123" nil)
+
 (end-suite)
--- a/test/suite0008.janet
+++ b/test/suite0008.janet
@@ -224,7 +224,7 @@ neldb\0\0\0\xD8\x05printG\x01\0\xDE\xDE\xDE'\x03\0marshal_tes/\x02
 # No segfault, valgrind clean.

 (def x @"\xCC\xCD.nd\x80\0\r\x1C\xCDg!\0\x07\xCC\xCD\r\x1Ce\x10\0\r;\xCDb\x04\xFF9\xFF\x80\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04uu\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\0\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04}\x04\x04\x04\x04\x04\x04\x04\x04#\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\0\x01\0\0\x03\x04\x04\x04\xE2\x03\x04\x04\x04\x04\x04\x04\x04\x04\x04\x14\x1A\x04\x04\x04\x04\x04\x18\x04\x04!\x04\xE2\x03\x04\x04\x04\x04\x04\x04$\x04\x04\x04\x04\x04\x04\x04\x04\x04\x80\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04A\0\0\0\x03\0\0!\xBF\xFF")
-(unmarshal x load-image-dict)
+(assert-error "bad fiber status" (unmarshal x load-image-dict))
 (gccollect)
 (marshal x make-image-dict)

--- a/test/suite0009.janet
+++ b/test/suite0009.janet
@@ -48,4 +48,19 @@

 (:close s)

+# Create pipe
+
+(var pipe-counter 0)
+(def [reader writer] (ev/pipe))
+(ev/spawn
+  (while (ev/read reader 3)
+    (++ pipe-counter))
+  (assert (= 20 pipe-counter) "ev/pipe 1"))
+
+(for i 0 10
+  (ev/write writer "xxx---"))
+
+(ev/close writer)
+(ev/sleep 0.1)
+
 (end-suite)
--- a/test/suite0010.janet
+++ b/test/suite0010.janet
@@ -61,4 +61,8 @@
 (assert-no-error "import macro 1" (macex '(import a :as b :fresh maybe)))
 (assert (deep= ~(,import* "a" :as "b" :fresh maybe) (macex '(import a :as b :fresh maybe))) "import macro 2")

+# #477 walk preserving bracket type
+(assert (= :brackets (tuple/type (postwalk identity '[]))) "walk square brackets 1")
+(assert (= :brackets (tuple/type (walk identity '[]))) "walk square brackets 2")
+
 (end-suite)
Author	SHA1	Message	Date
Calvin Rose	d199c817dc	Broken Pipe error on windows should just be end of stream.	2020-11-14 16:03:51 -06:00
Calvin Rose	dc51bd09f7	Make sure all test logs go to the same stream.	2020-11-14 15:56:48 -06:00
Calvin Rose	139e3fab25	Invert status check for (Read/Write)File	2020-11-14 15:52:01 -06:00
Calvin Rose	7a98f9aa02	Improve windows error messages on write failures.	2020-11-14 15:48:21 -06:00
Calvin Rose	b53dd67e74	Use custom pipe implementation for overlapped io.	2020-11-14 15:44:19 -06:00
Calvin Rose	e546731093	ev_lasterr -> janet_ev_lasterr	2020-11-14 15:24:13 -06:00
Calvin Rose	d50c4ef6da	Try again for windows build.	2020-11-14 15:01:52 -06:00
Calvin Rose	7d0b1955a2	typo	2020-11-14 14:55:26 -06:00
Calvin Rose	16cf7681f0	Fix some windows issues.	2020-11-14 14:40:39 -06:00
Calvin Rose	12f09ad2d7	Add ev/pipe and move stream code into ev.c Also adds a lot to the C API and changes things up.	2020-11-14 14:29:11 -06:00
Calvin Rose	b3e88a8d80	Move read/write functions into ev.c from net.c This code can also be used for non-network streams.	2020-11-14 11:48:23 -06:00
Calvin Rose	761273bcc4	Add janet_thread_current() to C api.	2020-11-12 18:42:41 -06:00
Calvin Rose	1a75f68cb2	Fix windows build.	2020-11-12 14:52:02 -06:00
Calvin Rose	1b0edf54f1	Fix gc leak. Rather than trying to be clever with pinning/unpinning, always mark the root fiber and that should serve as thei singular common root in almost all cases.	2020-11-12 14:29:38 -06:00
Calvin Rose	caa6576719	Fix formatting.	2020-11-11 15:35:44 -06:00
Calvin Rose	93bd2c11fa	Merge pull request #502 from pepe/fix-net-server-fiber Fix net server fiber	2020-11-11 15:33:42 -06:00
Josef Pospíšil	2be09790a9	Change fix with ev/call	2020-11-10 10:39:33 +01:00
Josef Pospíšil	bf6eae711a	Fix adding handler to loop with fiber	2020-11-10 10:32:47 +01:00
Calvin Rose	69b68c0091	Update changelog.	2020-11-09 11:24:28 -06:00
Calvin Rose	6f1d5d3b73	Add net/listen and net/accept-loop. These are the elements that make up net/server, which has been moved into pure Janet instead.	2020-11-09 11:18:09 -06:00
Calvin Rose	099a912992	Fix posix regression.	2020-11-08 19:48:44 -06:00
Calvin Rose	56b1ea3726	Include math.h to fix some bugs on 32 bit windows.	2020-11-08 19:06:35 -06:00
Calvin Rose	d6391f2d70	Get windows IOCP working for accept. This also changes the api of servers slightly - in light of having support for ev tasks, it is probably better to remove the "simple" server code and replace it with some Janet or remove it all together. While convenient, it has issues with error handling and rigidity.	2020-11-08 18:56:13 -06:00
Calvin Rose	07910272e2	Get socket reads and writes working with IOCP.	2020-11-08 10:38:28 -06:00
Calvin Rose	1092013c2b	Merge branch 'master' into ev	2020-11-07 14:36:25 -06:00
Calvin Rose	0db83bd787	Merge pull request #498 from pepe/fix-asm-example Fix asm example	2020-11-07 14:35:39 -06:00
Calvin Rose	f55316eabc	Merge pull request #494 from harryvederci/patch-1 Fix typo	2020-11-07 14:34:43 -06:00
Calvin Rose	840f59934e	Merge pull request #497 from ahungry/bugfix/Adjust-popen-doc Fix function doc to match that of C POPEN	2020-11-07 14:34:11 -06:00
Calvin Rose	75a9c59ad8	Merge pull request #499 from sogaiu/disasm-doc-typo Tweak disasm doc	2020-11-07 14:33:53 -06:00
sogaiu	adfccd33ae	Tweak disasm doc	2020-11-05 13:56:42 +09:00
Josef Pospíšil	9d41243c15	Fix comments formating	2020-11-04 10:18:31 +01:00
Josef Pospíšil	e33e182eb0	Fix assembly example	2020-11-04 10:16:02 +01:00
Matthew Carter	4dffd662f0	Fix function doc to match that of C POPEN It may be misleading to some user to believe it is taking a path to a file, when it is executing an arbitrary shell command for the first argument.	2020-11-03 20:52:02 -05:00
Calvin Rose	5064d579d4	Add net header instead of ifdef check.	2020-11-03 17:49:09 -06:00
Calvin Rose	540425a41b	Make docstring less confusing - Fix #493 .	2020-11-02 09:09:22 -06:00
Calvin Rose	4d21b582c7	Improve reading and writing from streams. Handle errors earlier, and allow 0 length packets from UDP but not from TCP. This should more closely follow the exact specs of send and recv calls.	2020-11-02 09:06:31 -06:00
Calvin Rose	f288bc1790	Merge pull request #492 from drkameleon/master Copy editing & fixing typos	2020-11-02 08:29:49 -06:00
Calvin Rose	8942e348bd	Small change to windows ev.	2020-11-02 08:27:45 -06:00
Calvin Rose	9f27336827	Update windows ev code.	2020-11-02 08:19:53 -06:00
Calvin Rose	f517cccf7b	Fix unix domain sockets. Also allow abstract unix domain sockets on Linux (prefixed with '@' as is customary).	2020-11-02 08:16:28 -06:00
Harry Prins	3a937ace51	Fix typo	2020-10-29 08:45:04 +00:00
Yanis Zafirópulos	b8661f8bff	Update README.md Co-authored-by: Michael Camilleri <mike@inqk.net>	2020-10-26 16:21:06 +01:00
Yanis Zafirópulos	51828ab5f8	Copy editing :)	2020-10-26 14:46:31 +01:00
Yanis Zafirópulos	84fe5d7f34	Copy editing :)	2020-10-26 14:44:17 +01:00
Calvin Rose	2891d2b260	Address #489 Add gc pressure when resizing fiber stack.	2020-10-18 18:41:18 -05:00
Calvin Rose	edfb861a5f	Disable epoll by default for evloop.	2020-10-11 15:05:27 -05:00
Calvin Rose	88c1cf3ee7	Reformat files.	2020-10-11 09:33:07 -05:00
Calvin Rose	813e3fdcfd	Merge branch 'windows-ev' into ev	2020-10-11 09:32:17 -05:00
Calvin Rose	bbe10e4938	Add another select example.	2020-10-11 09:14:31 -05:00
Calvin Rose	cb4903fa86	Overhaul of poll loop, redo ev/select.	2020-10-11 09:14:14 -05:00
Calvin Rose	ea45165db8	Merge branch 'master' into ev	2020-10-10 09:04:05 -05:00
Calvin Rose	1fba699ed4	Merge branch 'master' of github.com:janet-lang/janet into master	2020-10-08 12:35:16 -05:00
Calvin Rose	ce3d574c41	Update docstring.	2020-10-08 12:34:08 -05:00
Calvin Rose	7a601a7eb2	Merge pull request #481 from sogaiu/remove-namespace-reference Use "module" instead of "namespace" in docstring	2020-10-07 17:43:56 -05:00
sogaiu	9ec66ab826	Use "module" instead of "namespace" in docstring	2020-10-07 18:18:28 +09:00
Calvin Rose	ebfa07f8ce	Registering an abstract type is idemptotent.	2020-10-06 19:11:29 -05:00
Calvin Rose	964a800d51	More work on windows event loop code.	2020-10-06 19:07:29 -05:00
Calvin Rose	5c05dec65a	Merge pull request #479 from andrewchambers/mf Add missing Makefile dependencies for install.	2020-10-06 18:26:16 -05:00
Andrew Chambers	bf6ebc4a68	Add missing Makefile dependencies for install.	2020-10-07 10:19:49 +13:00
Calvin Rose	2e944931b3	Update timestamp function to work on windows.	2020-10-04 15:18:31 -05:00
Calvin Rose	db67538311	Work on getting ev support on windows.	2020-10-04 12:46:15 -05:00
Calvin Rose	307c7e00e2	Merge branch 'master' into ev	2020-10-03 11:09:21 -05:00
Calvin Rose	45feb55483	Add integer parsing to pegs.	2020-09-27 12:19:00 -05:00
Calvin Rose	0a1d902f46	Fix #477 Make the walk function preserve bracket type, which should fix threading macro behavior when threading into bracketed expressions.	2020-09-26 13:28:29 -05:00
Calvin Rose	959a577b5f	Merge branch 'master' into ev	2020-09-26 11:50:13 -05:00
Calvin Rose	b91fe8be5a	Update CHANGELOG.md	2020-09-20 12:03:59 -05:00
Calvin Rose	d1f0a13ddc	janet_try macro and janet_restore function. This allows catching panics without using pcall.	2020-09-19 18:47:47 -05:00
Calvin Rose	c455bdad11	Get ready for 1.12.2 release.	2020-09-19 16:54:56 -05:00
Calvin Rose	bc1ef813c2	Fix whitespace.	2020-09-19 16:53:35 -05:00
Calvin Rose	603791c0ba	Add more help text to doc macro and default repl.	2020-09-19 16:40:07 -05:00
Calvin Rose	8091b1289f	Merge branch 'master' of github.com:janet-lang/janet into master	2020-09-19 16:35:43 -05:00
Calvin Rose	cc0035b1d7	Add help text to repl line.	2020-09-19 16:35:32 -05:00
Calvin Rose	ceba1ba4ee	Merge pull request #472 from uvtc/patch-1 fix jpm.1 typos	2020-09-18 20:19:22 -05:00
John Gabriele	468e13501c	Update jpm.1 Fix some typos.	2020-09-15 00:06:09 -04:00
Calvin Rose	32bf70571a	Fix os/spawn piping on windows and free handles on errors.	2020-09-13 20:49:38 -05:00
Calvin Rose	95f4bd8e23	Merge branch 'master' into ev	2020-09-13 11:24:27 -05:00
Calvin Rose	4c9624db64	Update CHANGELOG.md	2020-09-13 11:06:49 -05:00
Calvin Rose	2cbf4d8ad1	Update documentation for thread/send and thread/receive.	2020-09-13 08:38:37 -05:00
Calvin Rose	524c9b50d4	Add windows implementation for piping.	2020-09-12 19:56:48 -05:00
Calvin Rose	d3147b661b	Add :pipe to os/spawn for piping to subprocess. Similar to Python's subprocess.PIPE, this creates and manages pipes automatically for the caller.	2020-09-12 19:48:12 -05:00
Calvin Rose	d3182dce51	Merge branch 'master' into ev	2020-09-12 10:02:01 -05:00
Calvin Rose	8763df1cd0	Fix some typos.	2020-09-12 09:38:29 -05:00
Calvin Rose	15e05b692c	Windows CI remove those pesky carriage returns.	2020-09-07 16:32:31 -05:00
Calvin Rose	2bf5e341d3	Update for 1.12.1	2020-09-07 16:10:33 -05:00
Calvin Rose	b53890ddae	Make some changes for WASM build.	2020-09-07 16:08:43 -05:00
Calvin Rose	93602ad9ea	Prepare 1.12.0 Release.	2020-09-07 15:28:46 -05:00
Calvin Rose	191d0001f4	Add header on BSDs.	2020-09-07 15:22:18 -05:00
Calvin Rose	1a04ce33f1	Conditionally include epoll headers.	2020-09-07 13:13:28 -05:00
Calvin Rose	babfe50550	Merge branch 'master' into ev Also add poll implementation for ev.	2020-09-07 12:52:50 -05:00
Calvin Rose	ff57b3eb72	Make zero?, one?, neg? and pos? polymorphic.	2020-09-06 19:05:58 -05:00
Calvin Rose	1837e89fe4	Address #470 - hyphen's in native module names.	2020-09-06 15:23:24 -05:00
Calvin Rose	24b8b0e382	Fix NaNboxing bug that cause flaky builds. The macro janet_checktype(x, JANET_NUMBER) was incorrect when x was NaN. This caused the initial unmarshalling dictionary to be missing entries in certain cases.	2020-09-06 14:59:29 -05:00
Calvin Rose	321a758ab9	Change hash implementation for pointers.	2020-09-06 11:41:45 -05:00
Calvin Rose	1a9c14acde	Add checksum to build/janet.c to check for inconsistent builds.	2020-09-06 11:04:07 -05:00
Calvin Rose	e8734c77b4	Fix bug by casting to unsigned char. Higher unciode codepoints where being read as negative char values. We need to cast to unsigned char before comparing to 0x20 to check for unprintable characters.	2020-09-06 10:47:05 -05:00
Calvin Rose	1eb00a9f74	Remove restriction on bytes being input to getline.	2020-09-06 10:36:38 -05:00
Calvin Rose	922a21d359	Run make format.	2020-09-05 21:26:21 -05:00
Calvin Rose	4a4f314768	Update changelog.	2020-09-05 20:23:55 -05:00
Calvin Rose	3c64596ea1	Add %t formatter to janet. Was not present in printf and family.	2020-09-05 20:21:49 -05:00
Calvin Rose	33283b1b6e	Change linking process for standalone executables. We separate compilation and linking so that mixed C/C++ binaries will work.	2020-09-05 10:19:34 -05:00
Calvin Rose	2f89bdc672	Conditional compilation on some c99 syntax in header. If the header is in a C++11 compilation unit, use C++11 aggregate initialization syntax instead.	2020-09-05 09:45:34 -05:00
Calvin Rose	2d275c4782	Enable exception handling for C++ with MSVC.	2020-09-04 21:43:34 -05:00
Calvin Rose	25156eb83e	For #469 - Add support for C++ and mixed C/C++ WIP and for native modules. Required a few changes to headers and some changes to JPM.	2020-09-04 17:41:36 -05:00
Calvin Rose	39032b45c9	Remove extra file.	2020-09-04 14:55:47 -05:00
Calvin Rose	821a8dca3b	Fix os/spawn - os/execute switch.	2020-09-04 14:54:58 -05:00
Calvin Rose	0145b133a1	Add os/spawn instead of os/execute with :a	2020-09-04 08:09:05 -05:00
Calvin Rose	b0b137d7f0	Apply formatting to windows changes.	2020-09-02 19:12:27 -05:00
Calvin Rose	17d0b7a985	Improve import's handling of non constant args. Be much more conservative about which arguments are cast to strings.	2020-08-27 07:40:51 -05:00
Calvin Rose	86e00e865e	Merge branch 'master' into ev	2020-08-23 11:25:04 -05:00
Calvin Rose	30522bbf7d	Merge branch 'master' into ev	2020-08-16 17:52:36 -05:00
Calvin Rose	fb26c9b2c4	Add ev/select and ev/rselect initial implementation. Getting closer to a CSP implmententation. Probably useful to move scheduling fields outside of fibers and into an external table.	2020-08-09 00:20:27 -05:00
Calvin Rose	78ffb63429	Disallow mutlitple state machines waiting for a single fiber. A 'select' operator will be channel based, not state machine based.	2020-08-08 07:51:46 -05:00
Calvin Rose	1213990b7d	Merge branch 'master' into ev	2020-08-07 19:51:37 -05:00
Calvin Rose	cb898fabf4	Set default channel size to 0.	2020-08-03 07:57:02 -05:00
Calvin Rose	5899671d96	Merge branch 'master' into ev	2020-08-03 07:54:53 -05:00
Calvin Rose	742c5bb639	Use a common queue implementation. Queues occur in three places, so we use a single implementation rather than three separate ones. This also has the result that janet_vm_spawn will not overflow in the case of channel-heavy, IO-light operation.	2020-08-01 14:20:58 -05:00
Calvin Rose	297de01d95	Add preliminary channel implementation.	2020-08-01 13:13:58 -05:00
Calvin Rose	2eb2dddb59	Begin work on channels.	2020-07-26 23:45:25 -05:00
Calvin Rose	0403e306ed	Silence warnings from some compilers.	2020-07-26 08:48:22 -05:00
Calvin Rose	d393fbf360	Merge branch 'master' into ev	2020-07-25 14:07:47 -05:00
Calvin Rose	3960d0f6de	Merge branch 'master' into ev	2020-07-25 13:17:05 -05:00
Calvin Rose	553b4d9428	Add timeouts to net functions. Further debugging of the general timeout system, as well as having a single fiber wait on multiple state machines (select).	2020-07-19 19:41:12 -05:00
Calvin Rose	df145f4bc9	Merge branch 'master' into ev	2020-07-19 17:20:43 -05:00
Calvin Rose	cd197e8be3	Add ev/call. This is a common operation, and making fibers manually can be tedious.	2020-07-06 19:13:32 -05:00
Calvin Rose	51cf6465ff	Merge branch 'master' into ev	2020-07-06 17:22:38 -05:00
Calvin Rose	bd95f742c0	Merge branch 'master' into ev	2020-07-05 23:14:49 -05:00
Calvin Rose	9ba94d2c6b	More work on timeouts and racing listeners. When two listeners are racing to resume the same fiber, the first should cancel out the other.	2020-07-05 17:26:17 -05:00
Calvin Rose	a4de83b3a3	Merge branch 'master' into ev	2020-07-05 10:11:23 -05:00
Calvin Rose	37a430c97c	Move declarations around.	2020-07-03 13:47:48 -05:00
Calvin Rose	f264cb0b18	Merge branch 'master' into ev	2020-07-03 12:26:01 -05:00
Calvin Rose	a0abf307b4	Merge branch 'master' into ev	2020-07-03 12:14:48 -05:00
Calvin Rose	328ee94412	Merge branch 'master' into ev	2020-06-22 22:25:44 -05:00
Calvin Rose	b1a4f05b5a	Explicitly disallow handler for datagram server.	2020-06-13 08:29:48 -05:00
Calvin Rose	ce2079104a	Merge branch 'master' into ev	2020-06-11 19:20:51 -05:00
Calvin Rose	d64e9b6263	Remove snapcraft.	2020-06-06 10:31:16 -05:00
Calvin Rose	123710078d	Add unix domain socket support to net. Code is a bit messy, as getaddrinfo does not support unix domain sockets directly. We require a keyword :unix instead of the usual hostname string, and the port is the path to unix domain socket. The UDS should support both stream and datagram sockets.	2020-06-03 00:53:17 -05:00
Calvin Rose	ec0d0ba368	Initial UDP implementation.	2020-06-02 19:47:50 -05:00
Calvin Rose	3f434f2a44	Add backpressure capability to net.	2020-05-31 15:46:01 -05:00
Calvin Rose	71d8e6b4cd	Merge branch 'master' into ev	2020-05-30 11:35:19 -05:00
Calvin Rose	a78af0a7fb	Do not explicitly free state machines, instead return a status. This makes it harder to have some kind of use after free issue.	2020-05-30 11:31:05 -05:00
Calvin Rose	117ae196fd	Add net/flush. Useful for simple TCP protocols (netrepl), which benefit from being able to immediately send a message.	2020-05-28 19:22:38 -05:00
Calvin Rose	4c211c8dce	More updates to the ev library.	2020-05-28 16:51:11 -05:00
Calvin Rose	c10d9b9d9d	Merge branch 'master' into asyncio	2020-05-28 10:57:10 -05:00
Calvin Rose	b68b0a256e	Start with ev module.	2020-05-28 10:39:40 -05:00