Merge branch 'master' into compile-opt

Start setting up a test suite for sysir and work towards emitting jitted
x86 machine code.

.builds/openbsd.yml

@@ -1,4 +1,4 @@
-image: openbsd/7.7
+image: openbsd/7.6
 sources:
 - https://git.sr.ht/~bakpakin/janet
 packages:
@@ -10,17 +10,13 @@ tasks:
     gmake
     gmake test
     doas gmake install
+    gmake test-install
     doas gmake uninstall
 - meson_min: |
     cd janet
     meson setup build_meson_min --buildtype=release -Dsingle_threaded=true -Dnanbox=false -Ddynamic_modules=false -Ddocstrings=false -Dnet=false -Dsourcemaps=false -Dpeg=false -Dassembler=false -Dint_types=false -Dreduced_os=true -Dffi=false
     cd build_meson_min
     ninja
-- meson_reduced: |
-    cd janet
-    meson setup build_meson_reduced --buildtype=release -Dreduced_os=true
-    cd build_meson_reduced
-    ninja
 - meson_prf: |
     cd janet
     meson setup build_meson_prf --buildtype=release -Dprf=true

.github/workflows/test.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ ubuntu-latest, macos-latest, macos-14 ]
+        os: [ ubuntu-latest, macos-latest, macos-13 ]
     steps:
       - name: Checkout the repository
         uses: actions/checkout@master

.gitignore

@@ -37,6 +37,7 @@ temp.janet
 temp.c
 temp*janet
 temp*.c
+temp.*
 scratch.janet
 scratch.c
 

CHANGELOG.md

@@ -2,19 +2,6 @@
 All notable changes to this project will be documented in this file.
 
 ## Unreleased - ???
-- Add `janet_optuinteger` and `janet_optuinteger64` to the C API.
-- Add `cms` combinator to PEGs.
-- Add `thaw-keep-keys` as a variant of thaw
-- The `repl` function now respects the `*repl-prompt*` dynamic binding by default.
-- Allow matching exact lengths of datastructures with the `match` macro using a dollar suffix.
-- Add initial support for Plan 9. Some modules (e.g. ev) are not yet enabled.
-- Allow specifying `:flycheck` for individual defines to annotate that they are safe to evaluate for flychecking.
-
-## 1.40.1 - 2025-11-16
-- Fix `JANET_REDUCED_OS` build regression caused by `os/posix-chroot`.
-- Code formatting
-
-## 1.40.0 - 2025-11-15
 - Add `os/posix-chroot`
 - Fix `ev/deadline` with interrupt race condition bug on Windows.
 - Improve `flycheck` by allowing functions and macros to define their own flycheck behavior via the metadata `:flycheck`.

CONTRIBUTING.md

@@ -61,7 +61,7 @@ ensure a consistent code style for C.
 
 ## Janet style
 
-All janet code in the project should be formatted similar to the code in src/boot/boot.janet.
+All janet code in the project should be formatted similar to the code in core.janet.
 The auto formatting from janet.vim will work well.
 
 ## Typo Fixing and One-Line changes

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2026 Calvin Rose and contributors
+Copyright (c) 2025 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

Makefile

@@ -1,4 +1,4 @@
-# Copyright (c) 2026 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -53,7 +53,7 @@ STRIPFLAGS=-x -S
 HOSTCC?=$(CC)
 HOSTAR?=$(AR)
 # Symbols are (optionally) removed later, keep -g as default!
-CFLAGS?=-O2 -g
+CFLAGS?=-O0 -g
 LDFLAGS?=-rdynamic
 LIBJANET_LDFLAGS?=$(LDFLAGS)
 RUN:=$(RUN)
@@ -138,7 +138,8 @@ JANET_LOCAL_HEADERS=src/core/features.h \
 					src/core/regalloc.h \
 					src/core/compile.h \
 					src/core/emit.h \
-					src/core/symcache.h
+					src/core/symcache.h \
+					src/core/sysir.h
 
 JANET_CORE_SOURCES=src/core/abstract.c \
 				   src/core/array.c \
@@ -173,6 +174,9 @@ JANET_CORE_SOURCES=src/core/abstract.c \
 				   src/core/strtod.c \
 				   src/core/struct.c \
 				   src/core/symcache.c \
+				   src/core/sysir.c \
+				   src/core/sysir_c.c \
+				   src/core/sysir_x86.c \
 				   src/core/table.c \
 				   src/core/tuple.c \
 				   src/core/util.c \
@@ -261,7 +265,6 @@ $(JANET_STATIC_LIBRARY): $(JANET_TARGET_OBJECTS)
 # Testing assumes HOSTCC=CC
 
 TEST_SCRIPTS=$(wildcard test/suite*.janet)
-EXAMPLE_SCRIPTS=$(wildcard examples/*.janet)
 
 repl: $(JANET_TARGET)
 	$(RUN) ./$(JANET_TARGET)
@@ -269,26 +272,21 @@ repl: $(JANET_TARGET)
 debug: $(JANET_TARGET)
 	$(DEBUGGER) ./$(JANET_TARGET)
 
-VALGRIND_COMMAND=$(RUN) valgrind --leak-check=full --quiet
-CALLGRIND_COMMAND=$(RUN) valgrind --tool=callgrind
+VALGRIND_COMMAND=valgrind --leak-check=full --quiet
 
 valgrind: $(JANET_TARGET)
 	$(VALGRIND_COMMAND) ./$(JANET_TARGET)
 
-test: $(JANET_TARGET) $(TEST_SCRIPTS) $(EXAMPLE_SCRIPTS)
+test: $(JANET_TARGET) $(TEST_PROGRAMS)
 	for f in test/suite*.janet; do $(RUN) ./$(JANET_TARGET) "$$f" || exit; done
 	for f in examples/*.janet; do $(RUN) ./$(JANET_TARGET) -k "$$f"; done
 
-valtest: $(JANET_TARGET) $(TEST_SCRIPTS) $(EXAMPLE_SCRIPTS)
+valtest: $(JANET_TARGET) $(TEST_PROGRAMS)
 	for f in test/suite*.janet; do $(VALGRIND_COMMAND) ./$(JANET_TARGET) "$$f" || exit; done
-	for f in examples/*.janet; do $(VALGRIND_COMMAND) ./$(JANET_TARGET) -k "$$f"; done
+	for f in examples/*.janet; do ./$(JANET_TARGET) -k "$$f"; done
 
 callgrind: $(JANET_TARGET)
-	$(CALLGRIND_COMMAND) ./$(JANET_TARGET)
-
-calltest: $(JANET_TARGET) $(TEST_SCRIPTS) $(EXAMPLE_SCRIPTS)
-	for f in test/suite*.janet; do $(CALLGRIND_COMMAND) ./$(JANET_TARGET) "$$f" || exit; done
-	for f in examples/*.janet; do $(CALLGRIND_COMMAND) ./$(JANET_TARGET) -k "$$f"; done
+	for f in test/suite*.janet; do valgrind --tool=callgrind ./$(JANET_TARGET) "$$f" || exit; done
 
 ########################
 ##### Distribution #####
@@ -347,7 +345,6 @@ build/janet.pc: $(JANET_TARGET)
 	echo 'Libs.private: $(CLIBS)' >> $@
 
 install: $(JANET_TARGET) $(JANET_LIBRARY) $(JANET_STATIC_LIBRARY) build/janet.pc build/janet.h
-	$(eval JANET_VERSION := $(shell $(JANET_TARGET) -e '(print janet/version)'))
 	mkdir -p '$(DESTDIR)$(BINDIR)'
 	cp $(JANET_TARGET) '$(DESTDIR)$(BINDIR)/janet'
 	strip $(STRIPFLAGS) '$(DESTDIR)$(BINDIR)/janet'
@@ -357,13 +354,13 @@ install: $(JANET_TARGET) $(JANET_LIBRARY) $(JANET_STATIC_LIBRARY) build/janet.pc
 	mkdir -p '$(DESTDIR)$(JANET_PATH)'
 	mkdir -p '$(DESTDIR)$(LIBDIR)'
 	if test $(UNAME) = Darwin ; then \
-		cp $(JANET_LIBRARY) '$(DESTDIR)$(LIBDIR)/libjanet.$(JANET_VERSION).dylib' ; \
+		cp $(JANET_LIBRARY) '$(DESTDIR)$(LIBDIR)/libjanet.$(shell $(JANET_TARGET) -e '(print janet/version)').dylib' ; \
 		ln -sf $(SONAME) '$(DESTDIR)$(LIBDIR)/libjanet.dylib' ; \
-		ln -sf libjanet.$(JANET_VERSION).dylib $(DESTDIR)$(LIBDIR)/$(SONAME) ; \
+		ln -sf libjanet.$(shell $(JANET_TARGET) -e '(print janet/version)').dylib $(DESTDIR)$(LIBDIR)/$(SONAME) ; \
 	else \
-		cp $(JANET_LIBRARY) '$(DESTDIR)$(LIBDIR)/libjanet.so.$(JANET_VERSION)' ; \
+		cp $(JANET_LIBRARY) '$(DESTDIR)$(LIBDIR)/libjanet.so.$(shell $(JANET_TARGET) -e '(print janet/version)')' ; \
 		ln -sf $(SONAME) '$(DESTDIR)$(LIBDIR)/libjanet.so' ; \
-		ln -sf libjanet.so.$(JANET_VERSION) $(DESTDIR)$(LIBDIR)/$(SONAME) ; \
+		ln -sf libjanet.so.$(shell $(JANET_TARGET) -e '(print janet/version)') $(DESTDIR)$(LIBDIR)/$(SONAME) ; \
 	fi
 	cp $(JANET_STATIC_LIBRARY) '$(DESTDIR)$(LIBDIR)/libjanet.a'
 	mkdir -p '$(DESTDIR)$(JANET_MANPATH)'
@@ -420,6 +417,9 @@ clean:
 	-rm -rf build vgcore.* callgrind.*
 	-rm -rf test/install/build test/install/modpath
 
+test-install:
+	echo "JPM has been removed from default install."
+
 help:
 	@echo
 	@echo 'Janet: A Dynamic Language & Bytecode VM'
@@ -431,8 +431,7 @@ help:
 	@echo '   make test       Test a built Janet'
 	@echo '   make valgrind   Assess Janet with Valgrind'
 	@echo '   make callgrind  Assess Janet with Valgrind, using Callgrind'
-	@echo '   make valtest    Run the test suite and examples with Valgrind to check for memory leaks'
-	@echo '   make calltest   Run the test suite and examples with Callgrind'
+	@echo '   make valtest    Run the test suite with Valgrind to check for memory leaks'
 	@echo '   make dist       Create a distribution tarball'
 	@echo '   make docs       Generate documentation'
 	@echo '   make debug      Run janet with GDB or LLDB'
@@ -442,9 +441,6 @@ help:
 	@echo "   make format     Format Janet's own source files"
 	@echo '   make grammar    Generate a TextMate language grammar'
 	@echo
-	@echo '   make install-jpm-git   Install jpm into the current filesystem'
-	@echo '   make install-spork-git Install spork into the current filesystem'
-	@echo
 
-.PHONY: clean install install-jpm-git install-spork-git repl debug valgrind test \
-	valtest callgrind callgrind-test dist uninstall docs grammar format help compile-commands
+.PHONY: clean install repl debug valgrind test \
+	valtest dist uninstall docs grammar format help compile-commands

build_win.bat

@@ -20,11 +20,11 @@
 @setlocal
 
 @rem Example use asan
-@rem set JANET_COMPILE=cl /nologo /Isrc\include /Isrc\conf /c /O2 /W3 /D_CRT_SECURE_NO_WARNINGS /MD /fsanitize=address /Zi
-@rem set JANET_LINK=link /nologo clang_rt.asan_dynamic-x86_64.lib clang_rt.asan_dynamic_runtime_thunk-x86_64.lib
+@set JANET_COMPILE=cl /nologo /Isrc\include /Isrc\conf /c /O2 /W3 /D_CRT_SECURE_NO_WARNINGS /MD /fsanitize=address /Zi /DEBUG
+@set JANET_LINK=link /nologo clang_rt.asan_dynamic-x86_64.lib clang_rt.asan_dynamic_runtime_thunk-x86_64.lib /DEBUG
 
-@set JANET_COMPILE=cl /nologo /Isrc\include /Isrc\conf /c /O2 /W3 /D_CRT_SECURE_NO_WARNINGS /MD
-@set JANET_LINK=link /nologo
+@rem set JANET_COMPILE=cl /nologo /Isrc\include /Isrc\conf /c /O2 /W3 /D_CRT_SECURE_NO_WARNINGS /MD
+@rem set JANET_LINK=link /nologo
 
 @set JANET_LINK_STATIC=lib /nologo
 
@@ -49,7 +49,7 @@ for %%f in (src\boot\*.c) do (
 )
 %JANET_LINK% /out:build\janet_boot.exe build\boot\*.obj
 @if errorlevel 1 goto :BUILDFAIL
-@rem note that there is no default syspath being baked in
+@rem note that there is no default sysroot being baked in
 build\janet_boot . > build\c\janet.c
 @if errorlevel 1 goto :BUILDFAIL
 

examples/sample-bad-bundle1/info.jdn

@@ -1,3 +0,0 @@
-@{
-  :name "sample-bad-bundle1"
-}

examples/sample-bad-bundle2/info.jdn

@@ -1,3 +0,0 @@
-@{
-  :name "sample-bad-bundle2"
-}

examples/sysir/drawing.janet

@@ -0,0 +1,71 @@
+###
+### Create a .bmp file on linux.
+###
+
+# Quick run and view on Linux:
+# build/janet examples/sysir/drawing.janet > temp.c && cc temp.c && ./a.out > temp.bmp && feh temp.bmp
+
+(use ./frontend)
+
+(defn-external write:void [fd:int mem:pointer size:uint])
+(defn-external exit:void [x:int])
+
+# assume 128x128 32 bit color image
+#   Size : 128 * 128 * 4 + align(14 + 40, 4) = 65592
+#   dib offset : align(14 + 40, 4) = 56
+
+(defsys write_32:void [x:uint]
+  (write 1 (address x) 4)
+  (return))
+
+(defsys write_16:void [x:uint]
+  (write 1 (address x) 2)
+  (return))
+
+(defsys write_header:void [w:uint h:uint]
+  (write 1 "BM" 2)
+  (def size:uint (+ 56 (* w h 4)))
+  (write_32 size)
+  (write_32 0)
+  (write_32 56) # pixel array offset
+  # Begin DIB
+  (write_32 40) # dib size
+  (write_32 w)
+  (write_32 h)
+  (write_16 1) # color panes - must be 1
+  (write_16 32) # bits per pixel
+  (write_32 0) # compression method - no compression
+  (write_32 0) # image size - not needed when no compression, 0 should be fine
+  (write_32 4096) # pixels per meter - horizontal resolution
+  (write_32 4096) # pixels per meter - vertical resolution
+  (write_32 0) # number of colors in palette - no palette so 0
+  (write_32 0) # number of "important colors" ignored in practice
+  (write_16 0) # add "gap 1" to align pixel array to multiple of 4 bytes
+  (return))
+
+(defsys draw:void [w:uint h:uint]
+  (def red:uint 0xFFFF0000)
+  (def blue:uint 0xFF0000FF)
+  (def size:uint (* w h 4))
+  (var y:uint 0)
+  (while (< y h)
+    (var x:uint 0)
+    (while (< x w)
+      (write_32 (if (> y 64) blue red))
+      (set x (+ 1 x)))
+    (set y (+ y 1)))
+  (return))
+
+(defsys main:int []
+  (def w:uint 512)
+  (def h:uint 512)
+  (write_header w h)
+  (draw w h)
+  (return 0))
+
+####
+
+#(dump)
+(print "#include <unistd.h>")
+(dumpc)
+#(dumpx64)

examples/sysir/drawing2.janet

@@ -0,0 +1,86 @@
+###
+### Create a .bmp file on linux.
+###
+
+# Quick run and view on Linux:
+# build/janet examples/sysir/drawing2.janet > temp.c && cc temp.c && ./a.out > temp.bmp && feh temp.bmp
+
+(use ./frontend)
+
+(setdyn :verbose true)
+
+# Pointer types
+(defpointer p32 uint)
+(defpointer p16 u16)
+(defpointer cursor p32)
+
+# External
+(defn-external write:void [fd:int mem:pointer size:uint])
+(defn-external exit:void [x:int])
+(defn-external malloc:p32 [size:uint])
+
+(defsys w32:void [c:cursor x:uint]
+  (def p:p32 (load c))
+  (store p x)
+  (store c (the p32 (pointer-add p 1)))
+  (return))
+
+(defsys w16:void [c:cursor x:uint]
+  # Casting needs revisiting
+  (def p:p16 (cast (the p32 (load c))))
+  (store p (the u16 (cast x)))
+  (store c (the p32 (cast (the p16 (pointer-add p 1)))))
+  (return))
+
+(defsys makebmp:p32 [w:uint h:uint]
+  (def size:uint (+ 56 (* w h 4)))
+  (def mem:p32 (malloc size))
+  (def c:cursor (cast (malloc 4)))
+  #(def cursor_data:p32 mem)
+  #(def c:cursor (address cursor_data))
+  (store c mem)
+  (w16 c 0x4D42) # ascii "BM"
+  (w32 c size)
+  (w32 c 0)
+  (w32 c 56)
+  (w32 c 40)
+  (w32 c w)
+  (w32 c h)
+  (w16 c 1)
+  (w16 c 32)
+  (w32 c 0)
+  (w32 c 0)
+  (w32 c 4096)
+  (w32 c 4096)
+  (w32 c 0)
+  (w32 c 0)
+  (w16 c 0) # padding
+  # Draw
+  (def red:uint 0xFFFF0000)
+  (def blue:uint 0xFF0000FF)
+  (def green:uint 0xFF00FF00)
+  (var y:uint 0)
+  (while (< y h)
+    (var x:uint 0)
+    (while (< x w)
+      (def d2:uint (+ (* x x) (* y y)))
+      (if (> d2 100000)
+        (if (> d2 200000) (w32 c green) (w32 c blue))
+        (w32 c red))
+      (set x (+ 1 x)))
+    (set y (+ y 1)))
+  (write 1 mem size)
+  (return mem))
+
+(defsys main:int []
+  (def w:uint 512)
+  (def h:uint 512)
+  (makebmp w h)
+  (return 0))
+
+####
+
+(dumpx64)
+
+#(print "#include <unistd.h>")
+#(dumpc)

examples/sysir/frontend.janet

@@ -0,0 +1,567 @@
+# Make a language frontend for the sysir.
+# Dialect:
+# TODO -
+# * arrays (declaration, loads, stores)
+
+(defdyn *ret-type* "Current function return type")
+
+(def slot-to-name @[])
+(def name-to-slot @{})
+(def type-to-name @[])
+(def name-to-type @{})
+(def slot-types @{})
+(def functions @{})
+(def type-fields @{})
+(def syscalls @{})
+
+(defn get-slot
+  [&opt new-name]
+  (def next-slot (length slot-to-name))
+  (array/push slot-to-name new-name)
+  (if new-name (put name-to-slot new-name next-slot))
+  next-slot)
+
+(defn named-slot
+  [name]
+  (assert (get name-to-slot name)))
+
+(defn make-type
+  [&opt new-name]
+  (def next-type (length type-to-name))
+  (array/push type-to-name new-name)
+  (if new-name (put name-to-type new-name next-type))
+  next-type)
+
+(defn named-type
+  [name]
+  (def t (get name-to-type name))
+  (assert t)
+  t)
+
+(defn binding-type
+  [name]
+  (def slot (assert (get name-to-slot name)))
+  (assert (get slot-types slot)))
+
+(defn slot-type
+  [slot]
+  (assert (get slot-types slot)))
+
+(defn assign-type
+  [name typ]
+  (def slot (get name-to-slot name))
+  (put slot-types slot typ))
+
+(defn assign-slot-type
+  [slot typ]
+  (put slot-types slot typ))
+
+(defn setup-default-types
+  [ctx]
+  (def into @[])
+  (defn add-prim-type
+    [name native-name]
+    (array/push into ~(type-prim ,name ,native-name))
+    (make-type name))
+  (add-prim-type 'float 'f32)
+  (add-prim-type 'double 'f64)
+  (add-prim-type 'int 's32)
+  (add-prim-type 'uint 'u32)
+  (add-prim-type 'long 's64)
+  (add-prim-type 'ulong 'u64)
+  (add-prim-type 'boolean 'boolean)
+  (add-prim-type 's16 's16)
+  (add-prim-type 'u16 'u16)
+  (add-prim-type 'byte 'u8)
+  (add-prim-type 'void 'void)
+  (array/push into ~(type-pointer pointer void))
+  (make-type 'pointer)
+  (sysir/asm ctx into)
+  ctx)
+
+(defn type-extract
+  "Given a symbol:type combination, extract the proper name and the type separately"
+  [combined-name &opt default-type]
+  (def parts (string/split ":" combined-name 0 2))
+  (def [name tp] parts)
+  [(symbol name) (symbol (or tp default-type))])
+
+(var do-binop nil)
+(var do-comp nil)
+
+###
+### Inside functions
+###
+
+(defn visit1
+  "Take in a form and compile code and put it into `into`. Return result slot."
+  [code into &opt no-return type-hint]
+  (def subresult
+      (cond
+
+      # Compile a constant
+      (string? code) ~(pointer ,code)
+      (boolean? code) ~(boolean ,code)
+      (number? code) ~(,(or type-hint 'double) ,code) # TODO - should default to double
+
+      # Needed?
+      (= :core/u64 (type code)) ~(ulong ,code)
+      (= :core/s64 (type code)) ~(long ,code)
+
+      # Binding
+      (symbol? code)
+      (named-slot code)
+
+      # Array literals
+      (and (tuple? code) (= :brackets (tuple/type code)))
+      (do
+        (assert type-hint (string/format "unknown type for array literal %v" code))
+        ~(,type-hint ,code))
+
+      # Compile forms
+      (and (tuple? code) (= :parens (tuple/type code)))
+      (do
+        (assert (> (length code) 0))
+        (def [op & args] code)
+        (case op
+
+          # Arithmetic
+          '+ (do-binop 'add args into type-hint)
+          '- (do-binop 'subtract args into type-hint)
+          '* (do-binop 'multiply args into type-hint)
+          '/ (do-binop 'divide args into type-hint)
+          '<< (do-binop 'shl args into type-hint)
+          '>> (do-binop 'shr args into type-hint)
+
+          # Comparison
+          '= (do-comp 'eq args into)
+          'not= (do-comp 'neq args into)
+          '< (do-comp 'lt args into)
+          '<= (do-comp 'lte args into)
+          '> (do-comp 'gt args into)
+          '>= (do-comp 'gte args into)
+
+          # Pointers
+          'pointer-add
+          (do
+            (assert (= 2 (length args)))
+            (def [base offset] args)
+            (def base-slot (visit1 base into false type-hint))
+            (def offset-slot (visit1 offset into false 'int))
+            (def slot (get-slot))
+            (when type-hint (array/push into ~(bind ,slot ,type-hint)))
+            (array/push into ~(pointer-add ,slot ,base-slot ,offset-slot))
+            slot)
+
+          'pointer-sub
+          (do
+            (assert (= 2 (length args)))
+            (def [base offset] args)
+            (def base-slot (visit1 base into false type-hint))
+            (def offset-slot (visit1 offset into false 'int))
+            (def slot (get-slot))
+            (when type-hint (array/push into ~(bind ,slot ,type-hint)))
+            (array/push into ~(pointer-subtract ,slot ,base-slot ,offset-slot))
+            slot)
+
+          # Type hinting
+          'the
+          (do
+            (assert (= 2 (length args)))
+            (def [xtype x] args)
+            (def result (visit1 x into false xtype))
+            (if (tuple? result) # constant
+              (let [[t y] result]
+                (assertf (= t xtype) "type mismatch, %p doesn't match %p" t xtype)
+                [xtype y])
+              (do
+                (array/push into ~(bind ,result ,xtype))
+                result)))
+
+          # Casting
+          'cast
+          (do
+            (assert (= 1 (length args)))
+            (assert type-hint) # should we add an explicit cast type?
+            (def [x] args)
+            (def slot (get-slot))
+            (def result (visit1 x into false))
+            (array/push into ~(bind ,slot ,type-hint))
+            (array/push into ~(cast ,slot ,result))
+            slot)
+
+          # Named bindings
+          'def
+          (do
+            (assert (= 2 (length args)))
+            (def [full-name value] args)
+            (assert (symbol? full-name))
+            (def [name tp] (type-extract full-name 'int))
+            (def result (visit1 value into false tp))
+            (def slot (get-slot name))
+            (assign-type name tp)
+            (array/push into ~(bind ,slot ,tp))
+            (array/push into ~(move ,slot ,result))
+            slot)
+
+          # Named variables
+          'var
+          (do
+            (assert (= 2 (length args)))
+            (def [full-name value] args)
+            (assert (symbol? full-name))
+            (def [name tp] (type-extract full-name 'int))
+            (def result (visit1 value into false tp))
+            (def slot (get-slot name))
+            (assign-type name tp)
+            (array/push into ~(bind ,slot ,tp))
+            (array/push into ~(move ,slot ,result))
+            slot)
+
+          # Address of (& operator in C)
+          'address
+          (do
+            (assert (= 1 (length args)))
+            (def [thing] args)
+            (def [name tp] (type-extract thing 'int))
+            (def result (visit1 thing into false tp))
+            (def slot (get-slot))
+            # 
+            (array/push into ~(bind ,slot ,type-hint))
+            (array/push into ~(address ,slot ,result))
+            slot)
+
+          'load
+          (do
+            (assert (= 1 (length args)))
+            (assert type-hint)
+            (def [thing] args)
+            # (def [name tp] (type-extract thing 'pointer))
+            (def result (visit1 thing into false))
+            (def slot (get-slot))
+            (def ptype type-hint)
+            (array/push into ~(bind ,slot ,ptype))
+            (array/push into ~(load ,slot ,result))
+            slot)
+
+          'store
+          (do
+            (assert (= 2 (length args)))
+            (def [dest value] args)
+            # (def [name tp] (type-extract dest 'pointer))
+            (def dest-r (visit1 dest into false))
+            (def value-r (visit1 value into false))
+            (array/push into ~(store ,dest-r ,value-r))
+            value-r)
+
+          # Assignment
+          'set
+          (do
+            (assert (= 2 (length args)))
+            (def [to x] args)
+            (def type-hint (binding-type to))
+            (def result (visit1 x into false type-hint))
+            (def toslot (named-slot to))
+            (array/push into ~(move ,toslot ,result))
+            toslot)
+
+          # Return
+          'return
+          (do
+            (assert (>= 1 (length args)))
+            (if (empty? args)
+              (array/push into '(return))
+              (do
+                (def [x] args)
+                (array/push into ~(return ,(visit1 x into false (dyn *ret-type*))))))
+            nil)
+
+          # Sequence of operations
+          'do
+          (do
+            (each form (slice args 0 -2) (visit1 form into true))
+            (visit1 (last args) into false type-hint))
+
+          # While loop
+          'while
+          (do
+            (def lab-test (keyword (gensym)))
+            (def lab-exit (keyword (gensym)))
+            (assert (< 1 (length args)))
+            (def [cnd & body] args)
+            (array/push into lab-test)
+            (def condition-slot (visit1 cnd into false 'boolean))
+            (array/push into ~(branch-not ,condition-slot ,lab-exit))
+            (each code body
+              (visit1 code into true))
+            (array/push into ~(jump ,lab-test))
+            (array/push into lab-exit)
+            nil)
+
+          # Branch
+          'if
+          (do
+            (def lab (keyword (gensym)))
+            (def lab-end (keyword (gensym)))
+            (assert (< 2 (length args) 4))
+            (def [cnd tru fal] args)
+            (def condition-slot (visit1 cnd into false 'boolean))
+            (def ret (if type-hint (get-slot)))
+            (when type-hint (array/push into ~(bind ,ret ,type-hint)))
+            (array/push into ~(branch ,condition-slot ,lab))
+            # false path
+            (if type-hint
+              (array/push into ~(move ,ret ,(visit1 fal into false type-hint)))
+              (visit1 fal into true))
+            (array/push into ~(jump ,lab-end))
+            (array/push into lab)
+            # true path
+            (if type-hint
+              (array/push into ~(move ,ret ,(visit1 tru into false type-hint)))
+              (visit1 tru into true))
+            (array/push into lab-end)
+            ret)
+
+          # Insert IR
+          'ir
+          (do
+            (assert no-return)
+            (array/push into ;args)
+            nil)
+
+          # Assume function call or syscall
+          (do
+            (def slots @[])
+            (def signature (get functions op))
+            (def is-syscall (get syscalls op))
+            (assert signature (string "unknown function " op))
+            (def ret (if no-return nil (get-slot)))
+            (when ret
+              (array/push into ~(bind ,ret ,(first signature)))
+              (assign-type ret (first signature)))
+            (each [arg-type arg] (map tuple (drop 1 signature) args)
+              (array/push slots (visit1 arg into false arg-type)))
+            (if is-syscall
+              (array/push into ~(syscall :default ,ret (int ,is-syscall) ,;slots))
+              (array/push into ~(call :default ,ret [pointer ,op] ,;slots)))
+            ret)))
+
+      (errorf "cannot compile %q" code)))
+
+  # Check type-hint matches return type
+  (if type-hint
+    (when-let [t (first subresult)] # TODO - Disallow empty types
+      (assert (= type-hint t) (string/format "%j, expected type %v, got %v" code type-hint t))))
+
+  subresult)
+
+(varfn do-binop
+  "Emit an operation such as (+ x y).
+  Extended to support any number of arguments such as (+ x y z ...)"
+  [opcode args into type-hint]
+  (var typ type-hint)
+  (var final nil)
+  (def slots @[])
+  (each arg args
+    (def right (visit1 arg into false typ))
+    (when (number? right) (array/push slots right))
+
+    # If we don't have a type hint, infer types from bottom up
+    (when (nil? typ)
+      (when-let [new-typ (get slot-types right)]
+        (set typ new-typ)))
+
+    (set final
+         (if final
+           (let [result (get-slot)]
+             (array/push slots result)
+             (array/push into ~(,opcode ,result ,final ,right))
+             result)
+           right)))
+  (assert typ (string "unable to infer type for %j" [opcode ;args]))
+  (each slot (distinct slots)
+    (array/push into ~(bind ,slot ,typ)))
+  (assert final))
+
+(varfn do-comp
+  "Emit a comparison form such as (= x y z ...)"
+  [opcode args into]
+  (def result (get-slot))
+  (def needs-temp (> 2 (length args)))
+  (def temp-result (if needs-temp (get-slot) nil))
+  (array/push into ~(bind ,result boolean))
+  (when needs-temp
+    (array/push into ~(bind ,temp-result boolean)))
+  (var left nil)
+  (var first-compare true)
+  (var typ nil)
+  (each arg args
+    (def right (visit1 arg into false typ))
+    # If we don't have a type hint, infer types from bottom up
+    (when (nil? typ)
+      (when-let [new-typ (get slot-types right)]
+        (set typ new-typ)))
+    (when left
+      (if first-compare
+        (array/push into ~(,opcode ,result ,left ,right))
+        (do
+          (array/push into ~(,opcode ,temp-result ,left ,right))
+          (array/push into ~(and ,result ,temp-result ,result))))
+      (set first-compare false))
+    (set left right))
+  result)
+
+###
+### Top level
+###
+
+(defn top
+  "Visit and emit code for a top level form."
+  [ctx form]
+  (assert (tuple? form))
+  (def [head & rest] form)
+  (case head
+
+    # Declare a struct
+    'defstruct
+    (do
+      (def into @[])
+      (def [name & fields] rest)
+      (assert (even? (length fields)) "expected an even number of fields for struct definition")
+      (def field-types @[])
+      (each [field-name typ] (partition 2 fields)
+        # TODO - don't ignore field names
+        (array/push field-types typ))
+      (array/push into ~(type-struct ,name ,;field-types))
+      # (eprintf "%.99M" into)
+      (sysir/asm ctx into))
+
+    # Declare a union
+    'defunion
+    (do
+      (def into @[])
+      (def [name & fields] rest)
+      (assert (even? (length fields)) "expected an even number of fields for struct definition")
+      (def field-types @[])
+      (each [field-name typ] (partition 2 fields)
+        # TODO - don't ignore field names
+        (array/push field-types typ))
+      (array/push into ~(type-union ,name ,;field-types))
+      # (eprintf "%.99M" into)
+      (sysir/asm ctx into))
+
+    # Declare a pointer type
+    'defpointer
+    (do
+      (def into @[])
+      (def [name element] rest)
+      (def field-types @[])
+      (array/push into ~(type-pointer ,name ,element))
+      # (eprintf "%.99M" into)
+      (sysir/asm ctx into))
+
+    # Declare an array type
+    'defarray
+    (do
+      (def into @[])
+      (def [name element cnt] rest)
+      (assert (and (pos? cnt) (int? cnt)) "expected positive integer for array count")
+      (array/push into ~(type-array ,name ,element ,cnt))
+      # (eprintf "%.99M" into)
+      (sysir/asm ctx into))
+    
+    # External function
+    'defn-external
+    (do
+      (def [name args] rest)
+      (assert (tuple? args))
+      (def [fn-name fn-tp] (type-extract name 'void))
+      (def pcount (length args)) #TODO - more complicated signatures
+      (def signature @[fn-tp])
+      (each arg args
+        (def [name tp] (type-extract arg 'int))
+        (array/push signature tp))
+      (put functions fn-name (freeze signature)))
+
+    # External syscall
+    'defn-syscall
+    (do
+      (def [name sysnum args] rest)
+      (assert (tuple? args))
+      (def [fn-name fn-tp] (type-extract name 'void))
+      (def pcount (length args)) #TODO - more complicated signatures
+      (def signature @[fn-tp])
+      (each arg args
+        (def [name tp] (type-extract arg 'int))
+        (array/push signature tp))
+      (put syscalls fn-name sysnum)
+      (put functions fn-name (freeze signature)))
+
+    # Top level function definition
+    'defn
+    (do
+      # TODO doc strings
+      (table/clear name-to-slot)
+      (table/clear slot-types)
+      (array/clear slot-to-name)
+      (def [name args & body] rest)
+      (assert (tuple? args))
+      (def [fn-name fn-tp] (type-extract name 'void))
+      (def pcount (length args)) #TODO - more complicated signatures
+      (def ir-asm
+        @[~(link-name ,(string fn-name))
+          ~(parameter-count ,pcount)])
+      (def signature @[fn-tp])
+      (each arg args
+        (def [name tp] (type-extract arg 'int))
+        (def slot (get-slot name))
+        (assign-type name tp)
+        (array/push signature tp)
+        (array/push ir-asm ~(bind ,slot ,tp)))
+      (with-dyns [*ret-type* fn-tp]
+        (each part body
+          (visit1 part ir-asm true)))
+      (put functions fn-name (freeze signature))
+      (when (dyn :verbose) (eprintf "%.99M" ir-asm))
+      (sysir/asm ctx ir-asm))
+
+    (errorf "unknown form %p" form)))
+
+###
+### Setup
+###
+
+(def ctx (sysir/context))
+(setup-default-types ctx)
+
+(defn compile1
+  [x]
+  (top ctx x))
+
+(defn dump
+  []
+  (eprintf "%.99M\n" (sysir/to-ir ctx)))
+
+(defn dumpx64
+  []
+  (print (sysir/to-x64 ctx)))
+
+(defn dumpx64-windows
+  []
+  (print (sysir/to-x64 ctx @"" :windows)))
+
+(defn dumpc
+  []
+  (print (sysir/to-c ctx)))
+
+###
+### Top Level aliases
+###
+
+(defmacro defstruct [& args] [compile1 ~',(keep-syntax! (dyn *macro-form*) ~(defstruct ,;args))])
+(defmacro defunion [& args] [compile1 ~',(keep-syntax! (dyn *macro-form*) ~(defunion ,;args))])
+(defmacro defarray [& args] [compile1 ~',(keep-syntax! (dyn *macro-form*) ~(defarray ,;args))])
+(defmacro defpointer [& args] [compile1 ~',(keep-syntax! (dyn *macro-form*) ~(defpointer ,;args))])
+(defmacro defn-external [& args] [compile1 ~',(keep-syntax! (dyn *macro-form*) ~(defn-external ,;args))])
+(defmacro defn-syscall [& args] [compile1 ~',(keep-syntax! (dyn *macro-form*) ~(defn-syscall ,;args))])
+(defmacro defsys [& args] [compile1 ~',(keep-syntax! (dyn *macro-form*) ~(defn ,;args))])

examples/sysir/hello.janet

@@ -0,0 +1,16 @@
+(use ./frontend)
+
+(defn-external printf:int [fmt:pointer])
+(defn-external exit:void [x:int])
+
+(defsys _start:void []
+  (printf "hello, world!\n")
+  (exit (the int 0))
+  (return))
+
+(defn main [& args]
+  (def [_ what] args)
+  (eprint "MODE: " what)
+  (case what
+    "c" (dumpc)
+    "x64" (dumpx64)))

examples/sysir/run_drawing.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+valgrind build/janet examples/sysir/drawing.janet > temp.c
+cc temp.c
+./a.out > temp.bmp
+feh temp.bmp

examples/sysir/run_drawing2.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+valgrind build/janet examples/sysir/drawing2.janet > temp.nasm
+nasm -felf64 temp.nasm -l temp.lst -o temp.o
+ld -o temp.bin -dynamic-linker /lib64/ld-linux-x86-64.so.2 -lc temp.o
+valgrind ./temp.bin

examples/sysir/run_samples.bat

@@ -0,0 +1,4 @@
+janet.exe examples/sysir/windows_samples.janet > temp.nasm
+nasm -fwin64 temp.nasm -l temp.lst -o temp.o
+link /entry:Start /subsystem:windows kernel32.lib user32.lib temp.o /out:temp.exe
+temp.exe

examples/sysir/run_samples.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+valgrind build/janet examples/sysir/samples.janet > temp.nasm
+nasm -felf64 temp.nasm -l temp.lst -o temp.o
+ld -o temp.bin -dynamic-linker /lib64/ld-linux-x86-64.so.2 -lc temp.o
+valgrind ./temp.bin

examples/sysir/samples.janet

@@ -0,0 +1,72 @@
+(use ./frontend)
+
+(defstruct vec3
+   a float
+   b float
+   c float)
+
+(defunion myunion
+  a float
+  b double
+  c long)
+
+(defarray myvec float 4)
+(defarray mymat myvec 4)
+
+(defn-external printf:int [fmt:pointer x:int]) # TODO varargs
+
+(defn-external exit:void [x:int])
+
+(defsys square:int
+  [num:int]
+  (return (* 1 num num)))
+
+(defsys simple:int [x:int]
+  (def xyz:int (+ 1 2 3))
+  (return (* x 2 x)))
+
+(defsys myprog:int []
+  (def xyz:int (+ 1 2 3))
+  (def abc:int (* 4 5 6))
+  (def x:boolean (= xyz 5))
+  (var i:int 0)
+  (while (< i 10)
+    (set i (+ 1 i))
+    (printf "i = %d\n" i))
+  (printf "hello, world!\n%d\n" (if x abc xyz))
+  (return (simple (* abc xyz))))
+
+(defsys doloop [x:int y:int]
+  (var i:int x)
+  (while (< i y)
+    (set i (+ 1 i))
+    (printf "i = %d\n" i))
+  (myprog)
+  (return x))
+
+(defsys _start:void []
+  #(syscall 1 1 "Hello, world!\n" 14)
+  (doloop 10 20)
+  (exit (the int 0))
+  (return))
+
+(defsys test_inttypes:ulong []
+  (def x:ulong 123:u)
+  (return (+ x x)))
+
+(defsys test_arrays:myvec [a:myvec b:myvec]
+  (return (+ a b)))
+
+'(defsys make_array:myvec []
+  (def vec:myvec [0 0 0 0])
+  (return vec))
+
+'(defsys make_mat:mymat []
+  (def mat:mymat [[1 0 0 0] [0 1 0 0] [0 0 1 0] [0 0 0 1]])
+  (return mat))
+
+####
+
+#(dump)
+#(dumpc)
+(dumpx64)

examples/sysir/typeerr1.janet

@@ -0,0 +1,10 @@
+(def ir-asm
+  '((link-name "redefine_type_fail")
+    (type-prim Real f32)
+    (type-prim 1 s32)
+    (bind bob Real)
+    (return bob)))
+
+(def ctx (sysir/context))
+(sysir/asm ctx ir-asm)
+(print (sysir/to-c ctx))

examples/sysir/windows_samples.janet

@@ -0,0 +1,14 @@
+(use ./frontend)
+
+(def winmain
+  '(defn Start:void []
+     (MessageBoxExA (the pointer 0) "Hello, world!" "Test" 0 (the s16 0))
+     (ExitProcess (the int 0))
+     (return)))
+
+####
+
+(compile1 winmain)
+#(dump)
+#(dumpc)
+(dumpx64-windows)

examples/sysir/x64.janet

@@ -0,0 +1,24 @@
+(use ./frontend)
+
+(defn-external printf:int [fmt:pointer x:int])
+(defn-external exit:void [x:int])
+
+(defsys doloop [x:int y:int]
+  (var i:int x)
+  (printf "initial i = %d\n" i)
+  (while (< i y)
+    (set i (+ 1 i))
+    (printf "i = %d\n" i))
+  (return x))
+
+(defsys _start:void []
+  (doloop 10 20)
+  (exit (the int 0))
+  (return))
+
+(defn main [& args]
+  (def [_ what] args)
+  (eprint "MODE: " what)
+  (case what
+    "c" (dumpc)
+    "x64" (dumpx64)))

meson.build

@@ -1,4 +1,4 @@
-# Copyright (c) 2026 Calvin Rose and contributors
+# Copyright (c) 2025 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
@@ -20,7 +20,7 @@
 
 project('janet', 'c',
   default_options : ['c_std=c99', 'build.c_std=c99', 'b_lundef=false', 'default_library=both'],
-  version : '1.40.1')
+  version : '1.40.0')
 
 # Global settings
 janet_path = join_paths(get_option('prefix'), get_option('libdir'), 'janet')
@@ -126,7 +126,8 @@ core_headers = [
   'src/core/regalloc.h',
   'src/core/compile.h',
   'src/core/emit.h',
-  'src/core/symcache.h'
+  'src/core/symcache.h',
+  'src/core/sysir.h',
 ]
 
 core_src = [
@@ -163,6 +164,9 @@ core_src = [
   'src/core/strtod.c',
   'src/core/struct.c',
   'src/core/symcache.c',
+  'src/core/sysir.c',
+  'src/core/sysir_c.c',
+  'src/core/sysir_x86.c',
   'src/core/table.c',
   'src/core/tuple.c',
   'src/core/util.c',
@@ -297,6 +301,7 @@ test_files = [
   'test/suite-strtod.janet',
   'test/suite-struct.janet',
   'test/suite-symcache.janet',
+  'test/suite-sysir.janet',
   'test/suite-table.janet',
   'test/suite-tuple.janet',
   'test/suite-unknown.janet',

mkfile

@@ -1,49 +0,0 @@
-</$objtype/mkfile
-
-TARG=janet
-HFILES=src/include/janet.h src/conf/janetconf.h
-JANET_PATH=/sys/lib/janet
-BIN=/$objtype/bin/
-DISABLED=EV NET ASSEMBLER FFI UTC_MKTIME REALPATH DYNAMIC_MODULES THREADS SYMLINKS LOCALES UMASK SPAWN
-JANET_CONFIG=JANET_SINGLE_THREADED JANET_OS_NAME=plan9 JANET_ARCH_NAME=$objtype JANET_API='' JANET_NO_RETURN='' JANET_SIMPLE_GETLINE `{echo JANET_NO_^$DISABLED} PLAN9_`{echo -n $objtype}
-CFLAGS=-FTVBNcwp -D _POSIX_SOURCE -DJANET_PLAN9 -D_BSD_EXTENSION -D_LIMITS_EXTENSION -Isrc/include -Isrc/conf -I/sys/include/npe -Dtypestr=janettypestr -DJANET_API `{echo '-D'^$JANET_CONFIG}
-BOOT_CFLAGS=$CFLAGS -DJANET_BOOTSTRAP
-
-JANET_CORE_HEADERS=`{ls src/core/*.h}
-JANET_CORE_SOURCES=`{ls src/core/*.c}
-
-JANET_BOOT_SOURCES=src/boot/array_test.c \
-				   src/boot/boot.c \
-				   src/boot/buffer_test.c \
-				   src/boot/number_test.c \
-				   src/boot/system_test.c \
-				   src/boot/table_test.c
-JANET_BOOT_HEADERS=src/boot/tests.h
-JANET_BOOT_OBJECTS=`{echo $JANET_CORE_SOURCES $JANET_BOOT_SOURCES | sed -e 's/\.c/.boot.'$O'/g'}
-
-OFILES=janet.$O src/mainclient/shell.$O
-
-default:V:all
-
-src/%.boot.$O: src/%.c $JANET_HEADERS $JANET_CORE_HEADERS $JANET_BOOT_HEADERS
-	$CC $BOOT_CFLAGS  -o $target $prereq(1)
-
-src/mainclient/shell.$O: src/mainclient/shell.c
-	$CC $BOOT_CFLAGS  -o $target $prereq(1)
-
-$O.janetboot: $JANET_BOOT_OBJECTS
-	$LD $LDFLAGS -o $target $prereq
-
-janet.c: $O.janetboot src/boot/boot.janet
-	$prereq(1) . JANET_PATH $JANET_PATH >$target
-
-build/janet.$O: build/c/janet.c src/conf/janetconf.h src/include/janet.h
-	$CC $CFLAGS -D^$JANET_CONFIG -o $target $prereq(1)
-
-build/shell.$O: src/mainclient/shell.c src/conf/janetconf.h src/include/janet.h
-	$CC $CFLAGS -D^$JANET_CONFIG -o $target $prereq(1)
-
-</sys/src/cmd/mkone
-
-clean:V:
-	rm -f src/core/*.[$OS] src/boot/*.[$OS] *.a[$OS] y.tab.? lex.yy.c y.debug y.output [$OS].??* $TARG janet.[$OS] janet.c src/mainclient/shell.[$OS]

src/boot/array_test.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/boot/boot.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/boot/boot.janet

@@ -348,15 +348,12 @@
   [body catch]
   (assert (and (not (empty? catch)) (indexed? (catch 0))) "the first element of `catch` must be a tuple or array")
   (let [[err fib] (catch 0)
-        r (gensym)
-        f (gensym)]
+        r (or err (gensym))
+        f (or fib (gensym))]
     ~(let [,f (,fiber/new (fn :try [] ,body) :ie)
            ,r (,resume ,f)]
        (if (,= (,fiber/status ,f) :error)
-         (do
-           ,(if err ~(def ,err ,r))
-           ,(if fib ~(def ,fib ,f))
-           ,;(tuple/slice catch 1))
+         (do ,;(tuple/slice catch 1))
          ,r))))
 
 (defmacro with-syms
@@ -1457,12 +1454,6 @@
     (put ret (f k) (f (in form k))))
   ret)
 
-(defn- walk-dict-values [f form]
-  (def ret @{})
-  (loop [k :keys form]
-    (put ret k (f (in form k))))
-  ret)
-
 (defn walk
   ``Iterate over the values in ast and apply `f`
   to them. Collect the results in a data structure. If ast is not a
@@ -1812,8 +1803,8 @@
   (flatten-into @[] xs))
 
 (defn kvs
-  ``Takes a table or struct and returns a new array of key value pairs
-  like `@[k v k v ...]`.``
+  ``Takes a table or struct and returns and array of key value pairs
+  like `@[k v k v ...]`. Returns a new array.``
   [dict]
   (def ret @[])
   (loop [k :keys dict] (array/push ret k (in dict k)))
@@ -2028,11 +2019,6 @@
 
             (put b2g (pattern (inc i)) @[[slice s i]])
             (break))
-          (when (= sub-pattern '$)
-            (when (not= (length pattern) (inc i))
-              (error "expected $ to be last symbol in pattern"))
-            (break))
-
           (visit-pattern-1 b2g s i sub-pattern)))
 
       # match global unification
@@ -2052,10 +2038,11 @@
     (def isarr (or (= t :array) (and (= t :tuple) (= (tuple/type pattern) :brackets))))
     (when isarr
       (array/push anda (get-length-sym s))
-      (def amp-index (find-index (fn [x] (= x '&)) pattern))
-      (def dollar-index (find-index (fn [x] (= x '$)) pattern))
-      (def pattern-len (or dollar-index amp-index (length pattern)))
-      (array/push anda [(if dollar-index = <=) pattern-len (get-length-sym s)]))
+      (def pattern-len
+        (if-let [rest-idx (find-index (fn [x] (= x '&)) pattern)]
+          rest-idx
+          (length pattern)))
+      (array/push anda [<= pattern-len (get-length-sym s)]))
     (cond
 
       # match data structure template
@@ -2067,7 +2054,7 @@
       isarr
       (eachp [i sub-pattern] pattern
         # stop recursing to sub-patterns if the rest sigil is found
-        (when (or (= sub-pattern '$) (= sub-pattern '&))
+        (when (= sub-pattern '&)
           (break))
         (visit-pattern-2 anda gun preds s i sub-pattern))
 
@@ -2304,11 +2291,9 @@
     x))
 
 (defn thaw
-  ```
-  Thaw an object (make it mutable) and do a deep copy, making
+  `Thaw an object (make it mutable) and do a deep copy, making
   child values also mutable. Closures, fibers, and abstract
-  types will not be recursively thawed, but all other types will.
-  ```
+  types will not be recursively thawed, but all other types will.`
   [ds]
   (case (type ds)
     :array (walk-ind thaw ds)
@@ -2318,19 +2303,6 @@
     :string (buffer ds)
     ds))
 
-(defn thaw-keep-keys
-  ```
-  Similar to `thaw`, but do not modify table or struct keys.
-  ```
-  [ds]
-  (case (type ds)
-    :array (walk-ind thaw-keep-keys ds)
-    :tuple (walk-ind thaw-keep-keys ds)
-    :table (walk-dict-values thaw-keep-keys (table/proto-flatten ds))
-    :struct (walk-dict-values thaw-keep-keys (struct/proto-flatten ds))
-    :string (buffer ds)
-    ds))
-
 (defn deep-not=
   ``Like `not=`, but mutable types (arrays, tables, buffers) are considered
   equal if they have identical structure. Much slower than `not=`.``
@@ -3824,16 +3796,13 @@
   (default env (make-env))
   (default chunks
     (fn :chunks [buf p]
-      (def custom-prompt (get env *repl-prompt*))
-      (def repl-prompt
-        (if custom-prompt
-          (custom-prompt p)
-          (string
-            "repl:"
-            ((:where p) 0)
-            ":"
-            (:state p :delimiters) "> ")))
-      (getline repl-prompt buf env)))
+      (getline
+        (string
+          "repl:"
+          ((:where p) 0)
+          ":"
+          (:state p :delimiters) "> ")
+        buf env)))
   (run-context {:env env
                 :chunks chunks
                 :on-status (or onsignal (debugger-on-status env 1 true))
@@ -4083,6 +4052,7 @@
   Other arguments to `flycheck` are the same as `dofile`. Returns nil.
   ```
   [path &keys kwargs]
+  (def mc @{})
   (def new-env (make-env (get kwargs :env)))
   (put new-env *flychecking* true)
   (put new-env *module-cache* @{})
@@ -4110,17 +4080,8 @@
     true))
 
 (defn- is-safe-def [thunk source env where]
-  (if-let [ve (get env (source 1))
-           fc (get ve :flycheck)]
-    (cond
-      # Sometimes safe form
-      (function? fc)
-      (fc thunk source env where)
-      # Always safe form
-      fc
-      (thunk))
-    (if (no-side-effects (last source))
-      (thunk))))
+  (if (no-side-effects (last source))
+    (thunk)))
 
 (defn- flycheck-importer
   [thunk source env where]
@@ -4233,7 +4194,7 @@
     (spit manifest-name b))
 
   (defn bundle/manifest
-    "Get the manifest for a given installed bundle."
+    "Get the manifest for a give installed bundle"
     [bundle-name]
     (def name (get-manifest-filename bundle-name))
     (assertf (fexists name) "no bundle %v found" bundle-name)
@@ -4258,15 +4219,7 @@
       (put new-env *syspath* fixed-syspath)
       (with-env new-env
         (put new-env :bundle-dir (bundle-dir bundle-name)) # get the syspath right
-        (try
-          (require (string "@syspath/bundle/" bundle-name))
-          ([e f]
-           (def pfx "could not find module @syspath/bundle/")
-           (def msg (if (and (string? e)
-                             (string/has-prefix? pfx e))
-                      "bundle must contain bundle.janet or bundle/init.janet"
-                      e))
-           (propagate msg f))))))
+        (require (string "@syspath/bundle/" bundle-name)))))
 
   (defn- do-hook
     [module bundle-name hook & args]
@@ -4303,9 +4256,7 @@
     nil)
 
   (defn bundle/uninstall
-    ``Remove a bundle from the current syspath. There is 1 hook called during
-    uninstallation (uninstall). A user can register a hook by defining a
-    function with the same name in the bundle script.``
+    "Remove a bundle from the current syspath"
     [bundle-name]
     (def breakage @{})
     (each b (bundle/list)
@@ -4341,8 +4292,8 @@
     order)
 
   (defn bundle/prune
-    ``Remove all orphaned bundles from the current syspath. An orphaned bundle is a
-    bundle that is marked for :auto-remove and is not depended on by any other bundle.``
+    "Remove all orphaned bundles from the syspath. An orphaned bundle is a bundle that is
+     marked for :auto-remove and is not depended on by any other bundle."
     []
     (def topo (bundle/topolist))
     (def rtopo (reverse topo))
@@ -4371,44 +4322,33 @@
     (not (not (os/stat (bundle-dir bundle-name) :mode))))
 
   (defn bundle/install
-    ``Install a bundle from the local filesystem. The name of the bundle is
-    the value mapped to :name in either `config` or the info file. There are
-    5 hooks called during installation (postdeps, clean, build, install and
-    check). A user can register a hook by defining a function with the same name
-    in the bundle script.``
+    "Install a bundle from the local filesystem. The name of the bundle will be inferred from the bundle, or passed as a parameter :name in `config`."
     [path &keys config]
     (def path (bundle-rpath path))
     (def s (sep))
     # Detect bundle name
     (def infofile-src1 (string path s "bundle" s "info.jdn"))
     (def infofile-src2 (string path s "info.jdn"))
-    (def infofile-src (cond
-                        (fexists infofile-src1) infofile-src1
+    (def infofile-src (cond (fexists infofile-src1) infofile-src1
                         (fexists infofile-src2) infofile-src2))
     (def info (-?> infofile-src slurp parse))
     (def bundle-name (get config :name (get info :name)))
-    (assertf bundle-name
-             "unable to infer bundle name for %v, use :name argument or add :name to info file" path)
+    (assertf bundle-name "unable to infer bundle name for %v, use :name argument" path)
     (assertf (not (string/check-set "\\/" bundle-name))
              "bundle name %v cannot contain path separators" bundle-name)
     (assert (next bundle-name) "cannot use empty bundle-name")
     (assertf (not (fexists (get-manifest-filename bundle-name)))
              "bundle %v is already installed" bundle-name)
-    # Check bscript
-    (def bscript-src1 (string path s "bundle" s "init.janet"))
-    (def bscript-src2 (string path s "bundle.janet"))
-    (def bscript-src (cond
-                        (fexists bscript-src1) bscript-src1
-                        (fexists bscript-src2) bscript-src2))
     # Setup installed paths
     (prime-bundle-paths)
     (os/mkdir (bundle-dir bundle-name))
-    # Copy aliased infofile
-    (when (fexists infofile-src2)
-      (copyfile infofile-src2 (bundle-file bundle-name "info.jdn")))
-    # Copy aliased bscript
-    (when (fexists bscript-src2)
-      (copyfile bscript-src2 (bundle-file bundle-name "init.janet")))
+    # Copy infofile
+    (def infofile-dest (bundle-file bundle-name "info.jdn"))
+    (when infofile-src (copyfile infofile-src infofile-dest))
+    # Copy aliased initfile
+    (def initfile-alias (string path s "bundle.janet"))
+    (def initfile-dest (bundle-file bundle-name "init.janet"))
+    (when (fexists initfile-alias) (copyfile initfile-alias initfile-dest))
     # Copy some files into the new location unconditionally
     (def implicit-sources (string path s "bundle"))
     (when (= :directory (os/stat implicit-sources :mode))
@@ -4417,7 +4357,8 @@
     (merge-into man config)
     (sync-manifest man)
     (edefer (do (print "installation error, uninstalling") (bundle/uninstall bundle-name))
-      (when info
+      (when (os/stat infofile-dest :mode)
+        (def info (-> infofile-dest slurp parse))
         (def deps (seq [d :in (get info :dependencies @[])]
                     (string (if (dictionary? d) (get d :name) d))))
         (def missing (filter (complement bundle/installed?) deps))
@@ -4425,13 +4366,12 @@
           (error (string "missing dependencies " (string/join missing ", "))))
         (put man :dependencies deps)
         (put man :info info))
-      (def module (get-bundle-module bundle-name))
       (def clean (get config :clean))
       (def check (get config :check))
+      (def module (get-bundle-module bundle-name))
       (def all-hooks (seq [[k v] :pairs module :when (symbol? k) :unless (get v :private)] (keyword k)))
       (put man :hooks all-hooks)
-      (do-hook module bundle-name :dependencies man) # deprecated, use :postdeps
-      (do-hook module bundle-name :postdeps man)
+      (do-hook module bundle-name :dependencies man)
       (when clean
         (do-hook module bundle-name :clean man))
       (do-hook module bundle-name :build man)
@@ -4441,21 +4381,15 @@
       (when check
         (do-hook module bundle-name :check man)))
     (print "installed " bundle-name)
-    (when (or (get man :has-exe)
-              # remove eventually
-              (get man :has-bin-script))
+    (when (get man :has-bin-script)
       (def binpath (string (dyn *syspath*) s "bin"))
-      (eprintf "executable files have been installed to %s" binpath))
-    (when (get man :has-man)
-      (def manpath (string (dyn *syspath*) s "man"))
-      (eprintf "man pages have been installed to %s" manpath))
+      (eprintf "executable scripts have been installed to %s" binpath))
     bundle-name)
 
   (defn- bundle/pack
-    ``Take an installed bundle and create a bundle source directory that can be
-    used to reinstall the bundle on a compatible system. This is used to create
-    backups for installed bundles without rebuilding, or make a prebuilt bundle
-    for other systems.``
+    "Take an installed bundle and create a bundle source directory that can be used to
+     reinstall the bundle on a compatible system. This is used to create backups for installed
+     bundles without rebuilding, or make a prebuilt bundle for other systems."
     [bundle-name dest-dir &opt is-backup]
     (var i 0)
     (def man (bundle/manifest bundle-name))
@@ -4485,9 +4419,9 @@
     dest-dir)
 
   (defn bundle/replace
-    ``Reinstall an existing bundle from a new directory. Similar to
-    bundle/reinstall, but installs the replacement bundle from any directory.
-    This is necessary to replace a package without breaking any dependencies.``
+    "Reinstall an existing bundle from a new directory. Similar to bundle/reinstall,
+     but installs the replacement bundle from any directory. This is necesarry to replace a package without
+     breaking any dependencies."
     [bundle-name path &keys new-config]
     (def manifest (bundle/manifest bundle-name))
     (def config (get manifest :config @{}))
@@ -4514,7 +4448,7 @@
     bundle-name)
 
   (defn bundle/add-directory
-    "Add a directory during an install relative to `(dyn *syspath*)`."
+    "Add a directory during the install process relative to `(dyn *syspath*)`"
     [manifest dest &opt chmod-mode]
     (def files (get-files manifest))
     (def s (sep))
@@ -4542,7 +4476,7 @@
     ret)
 
   (defn bundle/add-file
-    "Add a file during an install relative to `(dyn *syspath*)`."
+    "Add files during an install relative to `(dyn *syspath*)`"
     [manifest src &opt dest chmod-mode]
     (default dest src)
     (def files (get-files manifest))
@@ -4559,9 +4493,9 @@
     absdest)
 
   (defn bundle/add
-    ``Add a file or directory during an install relative to `(dyn *syspath*)`.
-    Added files and directories will be recorded in the bundle manifest such
-    that they are properly tracked and removed during an upgrade or uninstall.``
+    "Add files and directories during a bundle install relative to `(dyn *syspath*)`.
+     Added files and directories will be recorded in the bundle manifest such that they are properly tracked
+     and removed during an upgrade or uninstall."
     [manifest src &opt dest chmod-mode]
     (default dest src)
     (def s (sep))
@@ -4576,31 +4510,20 @@
       (errorf "bad path %s - file is a %s" src mode)))
 
   (defn bundle/add-bin
-    ``Add a file to the "bin" subdirectory of the current syspath. By default,
-    files will be set to be executable.``
-    [manifest src &opt filename chmod-mode]
+    ``
+    Shorthand for adding scripts during an install. Scripts will be installed to
+    `(string (dyn *syspath*) "/bin")` by default and will be set to be executable.
+    ``
+    [manifest src &opt dest chmod-mode]
     (def s (sep))
-    (default filename (last (string/split s src)))
+    (default dest (last (string/split s src)))
     (default chmod-mode 8r755)
     (os/mkdir (string (dyn *syspath*) s "bin"))
-    (put manifest :has-exe true)
-    (put manifest :has-bin-script true) # remove eventually
-    (bundle/add-file manifest src (string "bin" s filename) chmod-mode))
-
-  (defn bundle/add-manpage
-    ``Add a file to the man subdirectory of the current syspath. Files are
-    copied inside a directory `mansec`. By default, `mansec` is "man1".``
-    [manifest src &opt mansec]
-    (def s (sep))
-    (default mansec "man1")
-    (def filename (last (string/split s src)))
-    (os/mkdir (string (dyn *syspath*) s "man"))
-    (os/mkdir (string (dyn *syspath*) s "man" s mansec))
-    (put manifest :has-man true)
-    (bundle/add-file manifest src (string "man" s mansec s filename)))
+    (put manifest :has-bin-script true)
+    (bundle/add-file manifest src (string "bin" s dest) chmod-mode))
 
   (defn bundle/update-all
-    "Reinstall all bundles."
+    "Reinstall all bundles"
     [&keys configs]
     (each bundle (bundle/topolist)
       (bundle/reinstall bundle ;(kvs configs)))))
@@ -4612,10 +4535,7 @@
 ###
 
 # conditional compilation for reduced os
-(def- getenv-raw (if-let [entry (in root-env 'os/getenv)] (entry :value) (fn [&])))
-(defn- getenv-alias [env-var &opt dflt]
-  (def x (getenv-raw env-var dflt))
-  (if (= x "") nil x)) # empty string is coerced to nil
+(def- getenv-alias (if-let [entry (in root-env 'os/getenv)] (entry :value) (fn [&])))
 
 (defn- run-main
   [env subargs arg]
@@ -4945,7 +4865,8 @@
      "src/core/regalloc.h"
      "src/core/compile.h"
      "src/core/emit.h"
-     "src/core/symcache.h"])
+     "src/core/symcache.h"
+     "src/core/sysir.h"])
 
   (def core-sources
     ["src/core/abstract.c"
@@ -4981,6 +4902,9 @@
      "src/core/strtod.c"
      "src/core/struct.c"
      "src/core/symcache.c"
+     "src/core/sysir.c"
+     "src/core/sysir_c.c"
+     "src/core/sysir_x86.c"
      "src/core/table.c"
      "src/core/tuple.c"
      "src/core/util.c"
@@ -4990,15 +4914,14 @@
      "src/core/wrap.c"])
 
   # Print janet.c to stdout
-  (def image-only (has-value? boot/args "image-only"))
-  (print "/* " (if image-only "Image-only" "Amalgamated") " build - DO NOT EDIT */")
+  (print "/* Amalgamated build - DO NOT EDIT */")
   (print "/* Generated from janet version " janet/version "-" janet/build " */")
   (print "#define JANET_BUILD \"" janet/build "\"")
   (print ```#define JANET_AMALG```)
 
   (defn do-one-file
     [fname]
-    (unless image-only
+    (unless (has-value? boot/args "image-only")
       (print "\n/* " fname " */")
       (print "#line 0 \"" fname "\"\n")
       (def source (slurp fname))

src/boot/buffer_test.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/boot/number_test.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -44,9 +44,7 @@ static void test_valid_str(const char *str) {
 }
 
 int number_test() {
-#ifdef JANET_PLAN9
-    return 0;
-#endif
+
     test_valid_str("1.0");
     test_valid_str("1");
     test_valid_str("2.1");

src/boot/system_test.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -51,10 +51,6 @@ int system_test() {
     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
-#ifdef JANET_PLAN9
-    // Plan 9 traps NaNs by default; disable that.
-    setfcr(0);
-#endif
     assert(janet_checktype(janet_wrap_number(NAN), JANET_NUMBER));
 #else
     assert(janet_checktype(janet_wrap_number(0.0 / 0.0), JANET_NUMBER));

src/boot/table_test.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/conf/janetconf.h

@@ -5,9 +5,9 @@
 
 #define JANET_VERSION_MAJOR 1
 #define JANET_VERSION_MINOR 40
-#define JANET_VERSION_PATCH 1
+#define JANET_VERSION_PATCH 0
 #define JANET_VERSION_EXTRA ""
-#define JANET_VERSION "1.40.1"
+#define JANET_VERSION "1.40.0"
 
 /* #define JANET_BUILD "local" */
 

src/core/abstract.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -164,7 +164,7 @@ void janet_os_mutex_lock(JanetOSMutex *mutex) {
 
 void janet_os_mutex_unlock(JanetOSMutex *mutex) {
     int ret = pthread_mutex_unlock((pthread_mutex_t *) mutex);
-    if (ret) janet_panic("cannot release lock");
+    if (ret) janet_panicf("cannot release lock: %s", strerror(ret));
 }
 
 void janet_os_rwlock_init(JanetOSRWLock *rwlock) {

src/core/array.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/asm.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/buffer.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/bytecode.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/capi.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -557,18 +557,6 @@ void *janet_optabstract(const Janet *argv, int32_t argc, int32_t n, const JanetA
     return janet_getabstract(argv, n, at);
 }
 
-uint32_t janet_optuinteger(const Janet *argv, int32_t argc, int32_t n, uint32_t dflt) {
-    if (argc <= n) return dflt;
-    if (janet_checktype(argv[n], JANET_NIL)) return dflt;
-    return janet_getuinteger(argv, n);
-}
-
-uint64_t janet_optuinteger64(const Janet *argv, int32_t argc, int32_t n, uint64_t dflt) {
-    if (argc <= n) return dflt;
-    if (janet_checktype(argv[n], JANET_NIL)) return dflt;
-    return janet_getuinteger64(argv, n);
-}
-
 /* Atomic refcounts */
 
 JanetAtomicInt janet_atomic_inc(JanetAtomicInt volatile *x) {
@@ -576,8 +564,6 @@ JanetAtomicInt janet_atomic_inc(JanetAtomicInt volatile *x) {
     return _InterlockedIncrement(x);
 #elif defined(JANET_USE_STDATOMIC)
     return atomic_fetch_add_explicit(x, 1, memory_order_relaxed) + 1;
-#elif defined(JANET_PLAN9)
-    return aincl((void*)x, 1);
 #else
     return __atomic_add_fetch(x, 1, __ATOMIC_RELAXED);
 #endif
@@ -588,8 +574,6 @@ JanetAtomicInt janet_atomic_dec(JanetAtomicInt volatile *x) {
     return _InterlockedDecrement(x);
 #elif defined(JANET_USE_STDATOMIC)
     return atomic_fetch_add_explicit(x, -1, memory_order_acq_rel) - 1;
-#elif defined(JANET_PLAN9)
-    return aincl((void*)x, -1);
 #else
     return __atomic_add_fetch(x, -1, __ATOMIC_ACQ_REL);
 #endif
@@ -598,8 +582,6 @@ JanetAtomicInt janet_atomic_dec(JanetAtomicInt volatile *x) {
 JanetAtomicInt janet_atomic_load(JanetAtomicInt volatile *x) {
 #ifdef _MSC_VER
     return _InterlockedOr(x, 0);
-#elif defined(JANET_PLAN9)
-    return agetl((void*)x);
 #elif defined(JANET_USE_STDATOMIC)
     return atomic_load_explicit(x, memory_order_acquire);
 #else
@@ -610,8 +592,6 @@ JanetAtomicInt janet_atomic_load(JanetAtomicInt volatile *x) {
 JanetAtomicInt janet_atomic_load_relaxed(JanetAtomicInt volatile *x) {
 #ifdef _MSC_VER
     return _InterlockedOr(x, 0);
-#elif defined(JANET_PLAN9)
-    return agetl((void*)x);
 #elif defined(JANET_USE_STDATOMIC)
     return atomic_load_explicit(x, memory_order_relaxed);
 #else

src/core/cfuns.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/compile.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -1127,4 +1127,5 @@ void janet_lib_compile(JanetTable *env) {
         JANET_REG_END
     };
     janet_core_cfuns_ext(env, NULL, cfuns);
+    janet_lib_sysir(env);
 }

src/core/compile.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -268,6 +268,9 @@ JanetSlot janetc_cslot(Janet x);
 /* Search for a symbol */
 JanetSlot janetc_resolve(JanetCompiler *c, const uint8_t *sym);
 
+/* Load the system dialect IR */
+void janet_lib_sysir(JanetTable *env);
+
 /* Bytecode optimization */
 void janet_bytecode_movopt(JanetFuncDef *def);
 void janet_bytecode_remove_noops(JanetFuncDef *def);

src/core/corelib.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -997,11 +997,11 @@ static void make_apply(JanetTable *env) {
     janet_quick_asm(env, JANET_FUN_APPLY | JANET_FUNCDEF_FLAG_VARARG,
                     "apply", 1, 1, INT32_MAX, 6, apply_asm, sizeof(apply_asm),
                     JDOC("(apply f & args)\n\n"
-                         "Applies a function f to a variable number of arguments. Each "
-                         "element in args is used as an argument to f, except the last "
-                         "element in args, which is expected to be an array or a tuple. "
-                         "Each element in this last argument is then also pushed as an "
-                         "argument to f."));
+         "Applies a function f to a variable number of arguments. Each "
+         "element in args is used as an argument to f, except the last "
+         "element in args, which is expected to be an array or a tuple. "
+         "Each element in this last argument is then also pushed as an "
+         "argument to f."));
 }
 
 static const uint32_t error_asm[] = {
@@ -1154,82 +1154,82 @@ JanetTable *janet_core_env(JanetTable *replacements) {
     janet_quick_asm(env, JANET_FUN_CMP,
                     "cmp", 2, 2, 2, 2, cmp_asm, sizeof(cmp_asm),
                     JDOC("(cmp x y)\n\n"
-                         "Returns -1 if x is strictly less than y, 1 if y is strictly greater "
-                         "than x, and 0 otherwise. To return 0, x and y must be the exact same type."));
+         "Returns -1 if x is strictly less than y, 1 if y is strictly greater "
+         "than x, and 0 otherwise. To return 0, x and y must be the exact same type."));
     janet_quick_asm(env, JANET_FUN_NEXT,
                     "next", 2, 1, 2, 2, next_asm, sizeof(next_asm),
                     JDOC("(next ds &opt key)\n\n"
-                         "Gets the next key in a data structure. Can be used to iterate through "
-                         "the keys of a data structure in an unspecified order. Keys are guaranteed "
-                         "to be seen only once per iteration if the data structure is not mutated "
-                         "during iteration. If key is nil, next returns the first key. If next "
-                         "returns nil, there are no more keys to iterate through."));
+         "Gets the next key in a data structure. Can be used to iterate through "
+         "the keys of a data structure in an unspecified order. Keys are guaranteed "
+         "to be seen only once per iteration if the data structure is not mutated "
+         "during iteration. If key is nil, next returns the first key. If next "
+         "returns nil, there are no more keys to iterate through."));
     janet_quick_asm(env, JANET_FUN_PROP,
                     "propagate", 2, 2, 2, 2, propagate_asm, sizeof(propagate_asm),
                     JDOC("(propagate x fiber)\n\n"
-                         "Propagate a signal from a fiber to the current fiber and "
-                         "set the last value of the current fiber to `x`.  The signal "
-                         "value is then available as the status of the current fiber. "
-                         "The resulting stack trace from the current fiber will include "
-                         "frames from fiber. If fiber is in a state that can be resumed, "
-                         "resuming the current fiber will first resume `fiber`. "
-                         "This function can be used to re-raise an error without losing "
-                         "the original stack trace."));
+         "Propagate a signal from a fiber to the current fiber and "
+         "set the last value of the current fiber to `x`.  The signal "
+         "value is then available as the status of the current fiber. "
+         "The resulting stack trace from the current fiber will include "
+         "frames from fiber. If fiber is in a state that can be resumed, "
+         "resuming the current fiber will first resume `fiber`. "
+         "This function can be used to re-raise an error without losing "
+         "the original stack trace."));
     janet_quick_asm(env, JANET_FUN_DEBUG,
                     "debug", 1, 0, 1, 1, debug_asm, sizeof(debug_asm),
                     JDOC("(debug &opt x)\n\n"
-                         "Throws a debug signal that can be caught by a parent fiber and used to inspect "
-                         "the running state of the current fiber. Returns the value passed in by resume."));
+         "Throws a debug signal that can be caught by a parent fiber and used to inspect "
+         "the running state of the current fiber. Returns the value passed in by resume."));
     janet_quick_asm(env, JANET_FUN_ERROR,
                     "error", 1, 1, 1, 1, error_asm, sizeof(error_asm),
                     JDOC("(error e)\n\n"
-                         "Throws an error e that can be caught and handled by a parent fiber."));
+         "Throws an error e that can be caught and handled by a parent fiber."));
     janet_quick_asm(env, JANET_FUN_YIELD,
                     "yield", 1, 0, 1, 2, yield_asm, sizeof(yield_asm),
                     JDOC("(yield &opt x)\n\n"
-                         "Yield a value to a parent fiber. When a fiber yields, its execution is paused until "
-                         "another thread resumes it. The fiber will then resume, and the last yield call will "
-                         "return the value that was passed to resume."));
+         "Yield a value to a parent fiber. When a fiber yields, its execution is paused until "
+         "another thread resumes it. The fiber will then resume, and the last yield call will "
+         "return the value that was passed to resume."));
     janet_quick_asm(env, JANET_FUN_CANCEL,
                     "cancel", 2, 2, 2, 2, cancel_asm, sizeof(cancel_asm),
                     JDOC("(cancel fiber err)\n\n"
-                         "Resume a fiber but have it immediately raise an error. This lets a programmer unwind a pending fiber. "
-                         "Returns the same result as resume."));
+         "Resume a fiber but have it immediately raise an error. This lets a programmer unwind a pending fiber. "
+         "Returns the same result as resume."));
     janet_quick_asm(env, JANET_FUN_RESUME,
                     "resume", 2, 1, 2, 2, resume_asm, sizeof(resume_asm),
                     JDOC("(resume fiber &opt x)\n\n"
-                         "Resume a new or suspended fiber and optionally pass in a value to the fiber that "
-                         "will be returned to the last yield in the case of a pending fiber, or the argument to "
-                         "the dispatch function in the case of a new fiber. Returns either the return result of "
-                         "the fiber's dispatch function, or the value from the next yield call in fiber."));
+         "Resume a new or suspended fiber and optionally pass in a value to the fiber that "
+         "will be returned to the last yield in the case of a pending fiber, or the argument to "
+         "the dispatch function in the case of a new fiber. Returns either the return result of "
+         "the fiber's dispatch function, or the value from the next yield call in fiber."));
     janet_quick_asm(env, JANET_FUN_IN,
                     "in", 3, 2, 3, 4, in_asm, sizeof(in_asm),
                     JDOC("(in ds key &opt dflt)\n\n"
-                         "Get value in ds at key, works on associative data structures. Arrays, tuples, tables, structs, "
-                         "strings, symbols, and buffers are all associative and can be used. Arrays, tuples, strings, buffers, "
-                         "and symbols must use integer keys that are in bounds or an error is raised. Structs and tables can "
-                         "take any value as a key except nil and will return nil or dflt if not found."));
+         "Get value in ds at key, works on associative data structures. Arrays, tuples, tables, structs, "
+         "strings, symbols, and buffers are all associative and can be used. Arrays, tuples, strings, buffers, "
+         "and symbols must use integer keys that are in bounds or an error is raised. Structs and tables can "
+         "take any value as a key except nil and will return nil or dflt if not found."));
     janet_quick_asm(env, JANET_FUN_GET,
                     "get", 3, 2, 3, 4, get_asm, sizeof(in_asm),
                     JDOC("(get ds key &opt dflt)\n\n"
-                         "Get the value mapped to key in data structure ds, and return dflt or nil if not found. "
-                         "Similar to in, but will not throw an error if the key is invalid for the data structure "
-                         "unless the data structure is an abstract type. In that case, the abstract type getter may throw "
-                         "an error."));
+         "Get the value mapped to key in data structure ds, and return dflt or nil if not found. "
+         "Similar to in, but will not throw an error if the key is invalid for the data structure "
+         "unless the data structure is an abstract type. In that case, the abstract type getter may throw "
+         "an error."));
     janet_quick_asm(env, JANET_FUN_PUT,
                     "put", 3, 3, 3, 3, put_asm, sizeof(put_asm),
                     JDOC("(put ds key value)\n\n"
-                         "Associate a key with a value in any mutable associative data structure. Indexed data structures "
-                         "(arrays and buffers) only accept non-negative integer keys, and will expand if an out of bounds "
-                         "value is provided. In an array, extra space will be filled with nils, and in a buffer, extra "
-                         "space will be filled with 0 bytes. In a table, putting a key that is contained in the table prototype "
-                         "will hide the association defined by the prototype, but will not mutate the prototype table. Putting "
-                         "a value nil into a table will remove the key from the table. Returns the data structure ds."));
+         "Associate a key with a value in any mutable associative data structure. Indexed data structures "
+         "(arrays and buffers) only accept non-negative integer keys, and will expand if an out of bounds "
+         "value is provided. In an array, extra space will be filled with nils, and in a buffer, extra "
+         "space will be filled with 0 bytes. In a table, putting a key that is contained in the table prototype "
+         "will hide the association defined by the prototype, but will not mutate the prototype table. Putting "
+         "a value nil into a table will remove the key from the table. Returns the data structure ds."));
     janet_quick_asm(env, JANET_FUN_LENGTH,
                     "length", 1, 1, 1, 1, length_asm, sizeof(length_asm),
                     JDOC("(length ds)\n\n"
-                         "Returns the length or count of a data structure in constant time as an integer. For "
-                         "structs and tables, returns the number of key-value pairs in the data structure."));
+         "Returns the length or count of a data structure in constant time as an integer. For "
+         "structs and tables, returns the number of key-value pairs in the data structure."));
     janet_quick_asm(env, JANET_FUN_BNOT,
                     "bnot", 1, 1, 1, 1, bnot_asm, sizeof(bnot_asm),
                     JDOC("(bnot x)\n\nReturns the bit-wise inverse of integer x."));
@@ -1238,74 +1238,74 @@ JanetTable *janet_core_env(JanetTable *replacements) {
     /* Variadic ops */
     templatize_varop(env, JANET_FUN_ADD, "+", 0, 0, JOP_ADD,
                      JDOC("(+ & xs)\n\n"
-                          "Returns the sum of all xs. If xs is empty, return 0."));
+         "Returns the sum of all xs. xs must be integers or real numbers only. If xs is empty, return 0."));
     templatize_varop(env, JANET_FUN_SUBTRACT, "-", 0, 0, JOP_SUBTRACT,
                      JDOC("(- & xs)\n\n"
-                          "Returns the difference of xs. If xs is empty, returns 0. If xs has one element, returns the "
-                          "negative value of that element. Otherwise, returns the first element in xs minus the sum of "
-                          "the rest of the elements."));
+         "Returns the difference of xs. If xs is empty, returns 0. If xs has one element, returns the "
+         "negative value of that element. Otherwise, returns the first element in xs minus the sum of "
+         "the rest of the elements."));
     templatize_varop(env, JANET_FUN_MULTIPLY, "*", 1, 1, JOP_MULTIPLY,
                      JDOC("(* & xs)\n\n"
-                          "Returns the product of all elements in xs. If xs is empty, returns 1."));
+         "Returns the product of all elements in xs. If xs is empty, returns 1."));
     templatize_varop(env, JANET_FUN_DIVIDE, "/", 1, 1, JOP_DIVIDE,
                      JDOC("(/ & xs)\n\n"
-                          "Returns the quotient of xs. If xs is empty, returns 1. If xs has one value x, returns "
-                          "the reciprocal of x. Otherwise return the first value of xs repeatedly divided by the remaining "
-                          "values."));
+         "Returns the quotient of xs. If xs is empty, returns 1. If xs has one value x, returns "
+         "the reciprocal of x. Otherwise return the first value of xs repeatedly divided by the remaining "
+         "values."));
     templatize_varop(env, JANET_FUN_DIVIDE_FLOOR, "div", 1, 1, JOP_DIVIDE_FLOOR,
                      JDOC("(div & xs)\n\n"
-                          "Returns the floored division of xs. If xs is empty, returns 1. If xs has one value x, returns "
-                          "the reciprocal of x. Otherwise return the first value of xs repeatedly divided by the remaining "
-                          "values."));
+         "Returns the floored division of xs. If xs is empty, returns 1. If xs has one value x, returns "
+         "the reciprocal of x. Otherwise return the first value of xs repeatedly divided by the remaining "
+         "values."));
     templatize_varop(env, JANET_FUN_MODULO, "mod", 0, 1, JOP_MODULO,
                      JDOC("(mod & xs)\n\n"
-                          "Returns the result of applying the modulo operator on the first value of xs with each remaining value. "
-                          "`(mod x 0)` is defined to be `x`."));
+         "Returns the result of applying the modulo operator on the first value of xs with each remaining value. "
+         "`(mod x 0)` is defined to be `x`."));
     templatize_varop(env, JANET_FUN_REMAINDER, "%", 0, 1, JOP_REMAINDER,
                      JDOC("(% & xs)\n\n"
-                          "Returns the remainder of dividing the first value of xs by each remaining value."));
+         "Returns the remainder of dividing the first value of xs by each remaining value."));
     templatize_varop(env, JANET_FUN_BAND, "band", -1, -1, JOP_BAND,
                      JDOC("(band & xs)\n\n"
-                          "Returns the bit-wise and of all values in xs. Each x in xs must be an integer."));
+         "Returns the bit-wise and of all values in xs. Each x in xs must be an integer."));
     templatize_varop(env, JANET_FUN_BOR, "bor", 0, 0, JOP_BOR,
                      JDOC("(bor & xs)\n\n"
-                          "Returns the bit-wise or of all values in xs. Each x in xs must be an integer."));
+         "Returns the bit-wise or of all values in xs. Each x in xs must be an integer."));
     templatize_varop(env, JANET_FUN_BXOR, "bxor", 0, 0, JOP_BXOR,
                      JDOC("(bxor & xs)\n\n"
-                          "Returns the bit-wise xor of all values in xs. Each x in xs must be an integer."));
+         "Returns the bit-wise xor of all values in xs. Each in xs must be an integer."));
     templatize_varop(env, JANET_FUN_LSHIFT, "blshift", 1, 1, JOP_SHIFT_LEFT,
                      JDOC("(blshift x & shifts)\n\n"
-                          "Returns the value of x bit shifted left by the sum of all values in shifts. x "
-                          "and each element in shift must be an integer."));
+         "Returns the value of x bit shifted left by the sum of all values in shifts. x "
+         "and each element in shift must be an integer."));
     templatize_varop(env, JANET_FUN_RSHIFT, "brshift", 1, 1, JOP_SHIFT_RIGHT,
                      JDOC("(brshift x & shifts)\n\n"
-                          "Returns the value of x bit shifted right by the sum of all values in shifts. x "
-                          "and each element in shift must be an integer."));
+         "Returns the value of x bit shifted right by the sum of all values in shifts. x "
+         "and each element in shift must be an integer."));
     templatize_varop(env, JANET_FUN_RSHIFTU, "brushift", 1, 1, JOP_SHIFT_RIGHT_UNSIGNED,
                      JDOC("(brushift x & shifts)\n\n"
-                          "Returns the value of x bit shifted right by the sum of all values in shifts. x "
-                          "and each element in shift must be an integer. The sign of x is not preserved, so "
-                          "for positive shifts the return value will always be positive."));
+         "Returns the value of x bit shifted right by the sum of all values in shifts. x "
+         "and each element in shift must be an integer. The sign of x is not preserved, so "
+         "for positive shifts the return value will always be positive."));
 
     /* Variadic comparators */
     templatize_comparator(env, JANET_FUN_GT, ">", 0, JOP_GREATER_THAN,
                           JDOC("(> & xs)\n\n"
-                               "Check if xs is in descending order. Returns a boolean."));
+         "Check if xs is in descending order. Returns a boolean."));
     templatize_comparator(env, JANET_FUN_LT, "<", 0, JOP_LESS_THAN,
                           JDOC("(< & xs)\n\n"
-                               "Check if xs is in ascending order. Returns a boolean."));
+         "Check if xs is in ascending order. Returns a boolean."));
     templatize_comparator(env, JANET_FUN_GTE, ">=", 0, JOP_GREATER_THAN_EQUAL,
                           JDOC("(>= & xs)\n\n"
-                               "Check if xs is in non-ascending order. Returns a boolean."));
+         "Check if xs is in non-ascending order. Returns a boolean."));
     templatize_comparator(env, JANET_FUN_LTE, "<=", 0, JOP_LESS_THAN_EQUAL,
                           JDOC("(<= & xs)\n\n"
-                               "Check if xs is in non-descending order. Returns a boolean."));
+         "Check if xs is in non-descending order. Returns a boolean."));
     templatize_comparator(env, JANET_FUN_EQ, "=", 0, JOP_EQUALS,
                           JDOC("(= & xs)\n\n"
-                               "Check if all values in xs are equal. Returns a boolean."));
+         "Check if all values in xs are equal. Returns a boolean."));
     templatize_comparator(env, JANET_FUN_NEQ, "not=", 1, JOP_EQUALS,
                           JDOC("(not= & xs)\n\n"
-                               "Check if any values in xs are not equal. Returns a boolean."));
+         "Check if any values in xs are not equal. Returns a boolean."));
 
     /* Platform detection */
     janet_def(env, "janet/version", janet_cstringv(JANET_VERSION),
@@ -1314,7 +1314,7 @@ JanetTable *janet_core_env(JanetTable *replacements) {
               JDOC("The build identifier of the running janet program."));
     janet_def(env, "janet/config-bits", janet_wrap_integer(JANET_CURRENT_CONFIG_BITS),
               JDOC("The flag set of config options from janetconf.h which is used to check "
-                   "if native modules are compatible with the host program."));
+         "if native modules are compatible with the host program."));
 
     /* Allow references to the environment */
     janet_def(env, "root-env", janet_wrap_table(env),

src/core/debug.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/emit.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/emit.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/ev.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -699,7 +699,7 @@ static DWORD WINAPI janet_timeout_body(LPVOID ptr) {
     DWORD duration = (DWORD)round(tto.sec * 1000);
     DWORD res = WAIT_TIMEOUT;
     JanetTimestamp wait_end = ts_now();
-    for (DWORD i = 1; res == WAIT_TIMEOUT && (wait_end - wait_begin) < duration; i++) {
+    for (size_t i = 1; res == WAIT_TIMEOUT && (wait_end - wait_begin) < duration; i++) {
         res = WaitForSingleObject(tto.cancel_event, (duration + i));
         wait_end = ts_now();
     }
@@ -1082,7 +1082,7 @@ static int janet_channel_pop_with_lock(JanetChannel *channel, Janet *item, int i
     int is_threaded = janet_chan_is_threaded(channel);
     if (janet_q_pop(&channel->items, item, sizeof(Janet))) {
         /* Queue empty */
-        if (is_choice == 2) return 0; /* Skip pending read */
+        if (is_choice == 2) return 0; // Skip pending read
         JanetChannelPending pending;
         pending.thread = &janet_vm;
         pending.fiber = janet_vm.root_fiber,

src/core/features.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/ffi.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -1344,15 +1344,6 @@ typedef double (win64_variant_f_ffif)(double, double, uint64_t, double);
 typedef double (win64_variant_f_fffi)(double, double, double, uint64_t);
 typedef double (win64_variant_f_ffff)(double, double, double, double);
 
-/* MSVC stack frame runtime error checking (/RTCs) prepends alloca() allocations with an _RTC_ALLOCA_NODE
- * header; misalligning stack-based FFI arguments and causing the memmove() (by stack_shift) to corrupt
- * the _RTC_ALLOCA_NODE header.
- *
- * We turn off the RTC-instrumented alloca() and adding of _RTC_CheckStackVars to function prologue just
- * for janet_ffi_win64() */
-#ifdef __MSVC_RUNTIME_CHECKS
-#pragma runtime_checks( "s", off )
-#endif
 static Janet janet_ffi_win64(JanetFFISignature *signature, void *function_pointer, const Janet *argv) {
     union {
         uint64_t integer;
@@ -1502,10 +1493,6 @@ static Janet janet_ffi_win64(JanetFFISignature *signature, void *function_pointe
 
     return janet_ffi_read_one(ret_mem, signature->ret.type, JANET_FFI_MAX_RECUR);
 }
-#ifdef __MSVC_RUNTIME_CHECKS
-// Restore stack frame runtime error checking (/RTCs) if it was enabled.
-#pragma runtime_checks ( "s", restore )
-#endif
 
 #endif
 

src/core/fiber.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/fiber.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/filewatch.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -573,7 +573,7 @@ static const JanetAbstractType janet_filewatch_at = {
 };
 
 JANET_CORE_FN(cfun_filewatch_make,
-              "(filewatch/new channel & default-flags)",
+              "(filewatch/new channel &opt default-flags)",
               "Create a new filewatcher that will give events to a channel channel. See `filewatch/add` for available flags.\n\n"
               "When an event is triggered by the filewatcher, a struct containing information will be given to channel as with `ev/give`. "
               "The contents of the channel depend on the OS, but will contain some common keys:\n\n"
@@ -597,7 +597,7 @@ JANET_CORE_FN(cfun_filewatch_make,
 }
 
 JANET_CORE_FN(cfun_filewatch_add,
-              "(filewatch/add watcher path flag & more-flags)",
+              "(filewatch/add watcher path &opt flags)",
               "Add a path to the watcher. Available flags depend on the current OS, and are as follows:\n\n"
               "Windows/MINGW (flags correspond to `FILE_NOTIFY_CHANGE_*` flags in win32 documentation):\n\n"
               "* `:all` - trigger an event for all of the below triggers.\n\n"

src/core/gc.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -132,7 +132,7 @@ static void janet_mark_many(const Janet *values, int32_t n) {
     }
 }
 
-/* Mark a bunch of key values items in memory */
+/* Mark only the keys from a sequence of key-value pairs */
 static void janet_mark_keys(const JanetKV *kvs, int32_t n) {
     const JanetKV *end = kvs + n;
     while (kvs < end) {
@@ -141,7 +141,7 @@ static void janet_mark_keys(const JanetKV *kvs, int32_t n) {
     }
 }
 
-/* Mark a bunch of key values items in memory */
+/* Mark only the values from a sequence of key-value pairs */
 static void janet_mark_values(const JanetKV *kvs, int32_t n) {
     const JanetKV *end = kvs + n;
     while (kvs < end) {
@@ -150,7 +150,7 @@ static void janet_mark_values(const JanetKV *kvs, int32_t n) {
     }
 }
 
-/* Mark a bunch of key values items in memory */
+/* Mark key-value pairs */
 static void janet_mark_kvs(const JanetKV *kvs, int32_t n) {
     const JanetKV *end = kvs + n;
     while (kvs < end) {

src/core/gc.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/inttypes.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose & contributors
+* Copyright (c) 2025 Calvin Rose & contributors
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/io.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -113,7 +113,7 @@ static void *makef(FILE *f, int32_t flags) {
     JanetFile *iof = (JanetFile *) janet_abstract(&janet_file_type, sizeof(JanetFile));
     iof->file = f;
     iof->flags = flags;
-#if !(defined(JANET_WINDOWS) || defined(JANET_PLAN9))
+#ifndef JANET_WINDOWS
     /* While we would like fopen to set cloexec by default (like O_CLOEXEC) with the e flag, that is
      * not standard. */
     if (!(flags & JANET_FILE_NOT_CLOSEABLE))
@@ -165,7 +165,7 @@ JANET_CORE_FN(cfun_io_fopen,
     }
     FILE *f = fopen((const char *)fname, (const char *)fmode);
     if (f != NULL) {
-#if !(defined(JANET_WINDOWS) || defined(JANET_PLAN9))
+#ifndef JANET_WINDOWS
         struct stat st;
         fstat(fileno(f), &st);
         if (S_ISDIR(st.st_mode)) {
@@ -249,9 +249,9 @@ JANET_CORE_FN(cfun_io_fread,
 
 /* Write bytes to a file */
 JANET_CORE_FN(cfun_io_fwrite,
-              "(file/write f & bytes)",
-              "Writes to a file `f`. Each value of `bytes` must be a "
-              "string, buffer, symbol, or keyword. Returns the file.") {
+              "(file/write f bytes)",
+              "Writes to a file. 'bytes' must be string, buffer, or symbol. Returns the "
+              "file.") {
     janet_arity(argc, 1, -1);
     JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type);
     if (iof->flags & JANET_FILE_CLOSED)

src/core/marsh.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/math.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -271,30 +271,28 @@ JANET_DEFINE_MATHOP(cosh, "Returns the hyperbolic cosine of x.")
 JANET_DEFINE_MATHOP(acosh, "Returns the hyperbolic arccosine of x.")
 JANET_DEFINE_MATHOP(sin, "Returns the sine of x.")
 JANET_DEFINE_MATHOP(sinh, "Returns the hyperbolic sine of x.")
+JANET_DEFINE_MATHOP(asinh, "Returns the hyperbolic arcsine of x.")
 JANET_DEFINE_MATHOP(tan, "Returns the tangent of x.")
 JANET_DEFINE_MATHOP(tanh, "Returns the hyperbolic tangent of x.")
+JANET_DEFINE_MATHOP(atanh, "Returns the hyperbolic arctangent of x.")
 JANET_DEFINE_MATHOP(exp, "Returns e to the power of x.")
 JANET_DEFINE_MATHOP(exp2, "Returns 2 to the power of x.")
-JANET_DEFINE_MATHOP(log1p, "Returns (log base e of x) + 1 more accurately than (+ (math/log x) 1)")
-#ifndef JANET_PLAN9
 JANET_DEFINE_MATHOP(expm1, "Returns e to the power of x minus 1.")
-JANET_DEFINE_MATHOP(cbrt, "Returns the cube root of x.")
-JANET_DEFINE_MATHOP(erf, "Returns the error function of x.")
-JANET_DEFINE_MATHOP(erfc, "Returns the complementary error function of x.")
-JANET_DEFINE_NAMED_MATHOP("log-gamma", lgamma, "Returns log-gamma(x).")
-JANET_DEFINE_NAMED_MATHOP("gamma", tgamma, "Returns gamma(x).")
-JANET_DEFINE_MATHOP(atanh, "Returns the hyperbolic arctangent of x.")
-JANET_DEFINE_MATHOP(asinh, "Returns the hyperbolic arcsine of x.")
-#endif
 JANET_DEFINE_MATHOP(log, "Returns the natural logarithm of x.")
 JANET_DEFINE_MATHOP(log10, "Returns the log base 10 of x.")
 JANET_DEFINE_MATHOP(log2, "Returns the log base 2 of x.")
 JANET_DEFINE_MATHOP(sqrt, "Returns the square root of x.")
+JANET_DEFINE_MATHOP(cbrt, "Returns the cube root of x.")
 JANET_DEFINE_MATHOP(ceil, "Returns the smallest integer value number that is not less than x.")
 JANET_DEFINE_MATHOP(floor, "Returns the largest integer value number that is not greater than x.")
 JANET_DEFINE_MATHOP(trunc, "Returns the integer between x and 0 nearest to x.")
 JANET_DEFINE_MATHOP(round, "Returns the integer nearest to x.")
+JANET_DEFINE_MATHOP(log1p, "Returns (log base e of x) + 1 more accurately than (+ (math/log x) 1)")
+JANET_DEFINE_MATHOP(erf, "Returns the error function of x.")
+JANET_DEFINE_MATHOP(erfc, "Returns the complementary error function of x.")
+JANET_DEFINE_NAMED_MATHOP("log-gamma", lgamma, "Returns log-gamma(x).")
 JANET_DEFINE_NAMED_MATHOP("abs", fabs, "Return the absolute value of x.")
+JANET_DEFINE_NAMED_MATHOP("gamma", tgamma, "Returns gamma(x).")
 
 #define JANET_DEFINE_MATH2OP(name, fop, signature, doc)\
 JANET_CORE_FN(janet_##name, signature, doc) {\
@@ -307,9 +305,7 @@ JANET_CORE_FN(janet_##name, signature, doc) {\
 JANET_DEFINE_MATH2OP(atan2, atan2, "(math/atan2 y x)", "Returns the arctangent of y/x. Works even when x is 0.")
 JANET_DEFINE_MATH2OP(pow, pow, "(math/pow a x)", "Returns a to the power of x.")
 JANET_DEFINE_MATH2OP(hypot, hypot, "(math/hypot a b)", "Returns c from the equation c^2 = a^2 + b^2.")
-#ifndef JANET_PLAN9
 JANET_DEFINE_MATH2OP(nextafter, nextafter,  "(math/next x y)", "Returns the next representable floating point value after x in the direction of y.")
-#endif
 
 JANET_CORE_FN(janet_not, "(not x)", "Returns the boolean inverse of x.") {
     janet_fixarity(argc, 1);
@@ -390,17 +386,7 @@ void janet_lib_math(JanetTable *env) {
         JANET_CORE_REG("math/log10", janet_log10),
         JANET_CORE_REG("math/log2", janet_log2),
         JANET_CORE_REG("math/sqrt", janet_sqrt),
-#ifndef JANET_PLAN9
         JANET_CORE_REG("math/cbrt", janet_cbrt),
-        JANET_CORE_REG("math/gamma", janet_tgamma),
-        JANET_CORE_REG("math/log-gamma", janet_lgamma),
-        JANET_CORE_REG("math/erfc", janet_erfc),
-        JANET_CORE_REG("math/erf", janet_erf),
-        JANET_CORE_REG("math/expm1", janet_expm1),
-        JANET_CORE_REG("math/atanh", janet_atanh),
-        JANET_CORE_REG("math/asinh", janet_asinh),
-        JANET_CORE_REG("math/next", janet_nextafter),
-#endif
         JANET_CORE_REG("math/floor", janet_floor),
         JANET_CORE_REG("math/ceil", janet_ceil),
         JANET_CORE_REG("math/pow", janet_pow),
@@ -408,6 +394,8 @@ void janet_lib_math(JanetTable *env) {
         JANET_CORE_REG("math/sinh", janet_sinh),
         JANET_CORE_REG("math/cosh", janet_cosh),
         JANET_CORE_REG("math/tanh", janet_tanh),
+        JANET_CORE_REG("math/atanh", janet_atanh),
+        JANET_CORE_REG("math/asinh", janet_asinh),
         JANET_CORE_REG("math/acosh", janet_acosh),
         JANET_CORE_REG("math/atan2", janet_atan2),
         JANET_CORE_REG("math/rng", cfun_rng_make),
@@ -417,8 +405,14 @@ void janet_lib_math(JanetTable *env) {
         JANET_CORE_REG("math/hypot", janet_hypot),
         JANET_CORE_REG("math/exp2", janet_exp2),
         JANET_CORE_REG("math/log1p", janet_log1p),
+        JANET_CORE_REG("math/gamma", janet_tgamma),
+        JANET_CORE_REG("math/log-gamma", janet_lgamma),
+        JANET_CORE_REG("math/erfc", janet_erfc),
+        JANET_CORE_REG("math/erf", janet_erf),
+        JANET_CORE_REG("math/expm1", janet_expm1),
         JANET_CORE_REG("math/trunc", janet_trunc),
         JANET_CORE_REG("math/round", janet_round),
+        JANET_CORE_REG("math/next", janet_nextafter),
         JANET_CORE_REG("math/gcd", janet_cfun_gcd),
         JANET_CORE_REG("math/lcm", janet_cfun_lcm),
         JANET_CORE_REG("math/frexp", janet_cfun_frexp),
@@ -441,9 +435,9 @@ void janet_lib_math(JanetTable *env) {
     JANET_CORE_DEF(env, "math/int32-max", janet_wrap_number(INT32_MAX),
                    "The maximum contiguous integer representable by a 32 bit signed integer");
     JANET_CORE_DEF(env, "math/int-min", janet_wrap_number(JANET_INTMIN_DOUBLE),
-                   "The minimum contiguous integer representable by a double (-(2^53))");
+                   "The minimum contiguous integer representable by a double (2^53)");
     JANET_CORE_DEF(env, "math/int-max", janet_wrap_number(JANET_INTMAX_DOUBLE),
-                   "The maximum contiguous integer representable by a double (2^53)");
+                   "The maximum contiguous integer representable by a double (-(2^53))");
 #ifdef NAN
     JANET_CORE_DEF(env, "math/nan", janet_wrap_number(NAN), "Not a number (IEEE-754 NaN)");
 #else

src/core/net.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose and contributors.
+* Copyright (c) 2025 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
@@ -572,15 +572,7 @@ JANET_CORE_FN(cfun_net_connect,
     }
 #endif
 
-    if (status == 0) {
-        /* Connect completed synchronously (common for unix domain sockets).
-         * Return the stream directly without scheduling an async wait,
-         * as edge-triggered kqueue may not signal EVFILT_WRITE if the socket
-         * is already connected when registered. */
-        return janet_wrap_abstract(stream);
-    }
-
-    if (status == -1) {
+    if (status) {
 #ifdef JANET_WINDOWS
         if (err != WSAEWOULDBLOCK) {
 #else
@@ -1029,6 +1021,7 @@ struct sockopt_type {
 /* List of supported socket options; The type JANET_POINTER is used
  * for options that require special handling depending on the type. */
 static const struct sockopt_type sockopt_type_list[] = {
+    { "tcp-nodelay",  IPPROTO_TCP, TCP_NODELAY, JANET_BOOLEAN },
     { "so-broadcast", SOL_SOCKET, SO_BROADCAST, JANET_BOOLEAN },
     { "so-reuseaddr", SOL_SOCKET, SO_REUSEADDR, JANET_BOOLEAN },
     { "so-keepalive", SOL_SOCKET, SO_KEEPALIVE, JANET_BOOLEAN },
@@ -1050,6 +1043,7 @@ JANET_CORE_FN(cfun_net_setsockopt,
               "- :so-broadcast boolean\n"
               "- :so-reuseaddr boolean\n"
               "- :so-keepalive boolean\n"
+              "- :tcp-nodelay boolean\n"
               "- :ip-multicast-ttl number\n"
               "- :ip-add-membership string\n"
               "- :ip-drop-membership string\n"

src/core/os.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose and contributors.
+* Copyright (c) 2025 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
@@ -57,9 +57,7 @@
 #include <process.h>
 #define JANET_SPAWN_CHDIR
 #else
-#ifndef JANET_PLAN9
 #include <spawn.h>
-#endif
 #include <utime.h>
 #include <unistd.h>
 #include <dirent.h>
@@ -70,7 +68,7 @@
 #define environ (*_NSGetEnviron())
 #include <AvailabilityMacros.h>
 int chroot(const char *dirname);
-#elif !defined(JANET_PLAN9)
+#else
 extern char **environ;
 #endif
 #ifdef JANET_THREADS
@@ -246,7 +244,6 @@ JANET_CORE_FN(os_compiler,
               "* :gcc\n\n"
               "* :clang\n\n"
               "* :msvc\n\n"
-              "* :kencc\n\n"
               "* :unknown\n\n") {
     janet_fixarity(argc, 0);
     (void) argv;
@@ -256,8 +253,6 @@ JANET_CORE_FN(os_compiler,
     return janet_ckeywordv("clang");
 #elif defined(__GNUC__)
     return janet_ckeywordv("gcc");
-#elif defined(JANET_PLAN9)
-    return janet_ckeywordv("kencc");
 #else
     return janet_ckeywordv("unknown");
 #endif
@@ -296,43 +291,46 @@ JANET_CORE_FN(os_cpu_count,
               "Get an approximate number of CPUs available on for this process to use. If "
               "unable to get an approximation, will return a default value dflt.") {
     janet_arity(argc, 0, 1);
-    (void) argv; /* Prevent unused argument warning */
+    Janet dflt = argc > 0 ? argv[0] : janet_wrap_nil();
 #ifdef JANET_WINDOWS
+    (void) dflt;
     SYSTEM_INFO info;
     GetSystemInfo(&info);
     return janet_wrap_integer(info.dwNumberOfProcessors);
 #elif defined(JANET_LINUX)
+    (void) dflt;
     cpu_set_t cs;
     CPU_ZERO(&cs);
     sched_getaffinity(0, sizeof(cs), &cs);
     int count = CPU_COUNT(&cs);
     return janet_wrap_integer(count);
 #elif defined(JANET_BSD) && defined(HW_NCPUONLINE)
+    (void) dflt;
     const int name[2] = {CTL_HW, HW_NCPUONLINE};
     int result = 0;
     size_t len = sizeof(int);
     if (-1 == sysctl(name, 2, &result, &len, NULL, 0)) {
-        return argc > 0 ? argv[0] : janet_wrap_nil();
+        return dflt;
     }
     return janet_wrap_integer(result);
 #elif defined(JANET_BSD) && defined(HW_NCPU)
+    (void) dflt;
     const int name[2] = {CTL_HW, HW_NCPU};
     int result = 0;
     size_t len = sizeof(int);
     if (-1 == sysctl(name, 2, &result, &len, NULL, 0)) {
-        return argc > 0 ? argv[0] : janet_wrap_nil();
+        return dflt;
     }
     return janet_wrap_integer(result);
 #elif defined(JANET_ILLUMOS)
+    (void) dflt;
     long result = sysconf(_SC_NPROCESSORS_CONF);
     if (result < 0) {
-        return argc > 0 ? argv[0] : janet_wrap_nil();
+        return dflt;
     }
     return janet_wrap_integer(result);
-#elif defined(JANET_PLAN9)
-    return janet_wrap_integer(atoi(getenv("NPROC")));
 #else
-    return argc > 0 ? argv[0] : janet_wrap_nil();
+    return dflt;
 #endif
 }
 
@@ -362,8 +360,6 @@ static EnvBlock os_execute_env(int32_t argc, const Janet *argv) {
         janet_buffer_push_bytes(temp, vals, janet_string_length(vals));
         janet_buffer_push_u8(temp, '\0');
     }
-    /* Windows environment blocks must be double-NULL terminated */
-    if (temp->count == 0) janet_buffer_push_u8(temp, '\0');
     janet_buffer_push_u8(temp, '\0');
     char *ret = janet_smalloc(temp->count);
     memcpy(ret, temp->data, temp->count);
@@ -1343,9 +1339,6 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
     /* exec mode */
     if (mode == JANET_EXECUTE_EXEC) {
         int status;
-#ifdef JANET_PLAN9
-        status = exec(cargv[0], cargv);
-#else
         if (!use_environ) {
             environ = envp;
         }
@@ -1356,11 +1349,9 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
                 status = execv(cargv[0], cargv);
             }
         } while (status == -1 && errno == EINTR);
-#endif
         janet_panicf("%p: %s", cargv[0], janet_strerror(errno ? errno : ENOENT));
     }
 
-#ifndef JANET_NO_SPAWN
     /* Use posix_spawn to spawn new process */
 
     /* Posix spawn setup */
@@ -1429,8 +1420,6 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
     }
 
 #endif
-#endif
-#ifndef JANET_NO_SPAWN
     JanetProc *proc = janet_abstract(&ProcAT, sizeof(JanetProc));
     proc->return_code = -1;
 #ifdef JANET_WINDOWS
@@ -1468,7 +1457,6 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
         return os_proc_wait_impl(proc);
 #endif
     }
-#endif
 }
 
 JANET_CORE_FN(os_execute,
@@ -1529,7 +1517,7 @@ JANET_CORE_FN(os_posix_exec,
 JANET_CORE_FN(os_posix_fork,
               "(os/posix-fork)",
               "Make a `fork` system call and create a new process. Return nil if in the new process, otherwise a core/process object (as returned by os/spawn). "
-              "Not supported on all systems (POSIX and Plan 9 only).") {
+              "Not supported on all systems (POSIX only).") {
     janet_sandbox_assert(JANET_SANDBOX_SUBPROCESS);
     janet_fixarity(argc, 0);
     (void) argv;
@@ -1537,13 +1525,9 @@ JANET_CORE_FN(os_posix_fork,
     janet_panic("not supported on Windows");
 #else
     pid_t result;
-#ifdef JANET_PLAN9
-    result = fork();
-#else
     do {
         result = fork();
     } while (result == -1 && errno == EINTR);
-#endif
     if (result == -1) {
         janet_panic(janet_strerror(errno));
     }
@@ -1564,9 +1548,8 @@ JANET_CORE_FN(os_posix_chroot,
               "Not supported on all systems (POSIX only).") {
     janet_sandbox_assert(JANET_SANDBOX_CHROOT);
     janet_fixarity(argc, 1);
-#if defined(JANET_WINDOWS) || defined(JANET_PLAN9)
-    (void) argv;
-    janet_panic("not supported on Windows or Plan 9");
+#ifdef JANET_WINDOWS
+    janet_panic("not supported on Windows");
 #else
     const char *root = janet_getcstring(argv, 0);
     int result;
@@ -1615,7 +1598,6 @@ JANET_CORE_FN(os_shell,
 
 #endif /* JANET_NO_PROCESSES */
 
-#ifndef JANET_PLAN9
 JANET_CORE_FN(os_environ,
               "(os/environ)",
               "Get a copy of the OS environment table.") {
@@ -1647,7 +1629,6 @@ JANET_CORE_FN(os_environ,
     janet_unlock_environ();
     return janet_wrap_table(t);
 }
-#endif
 
 JANET_CORE_FN(os_getenv,
               "(os/getenv variable &opt dflt)",
@@ -1672,9 +1653,6 @@ JANET_CORE_FN(os_setenv,
 #ifdef JANET_WINDOWS
 #define SETENV(K,V) _putenv_s(K, V)
 #define UNSETENV(K) _putenv_s(K, "")
-#elif defined(JANET_PLAN9)
-#define SETENV(K,V) putenv(K, V)
-#define UNSETENV(K) unsetenv(K)
 #else
 #define SETENV(K,V) setenv(K, V, 1)
 #define UNSETENV(K) unsetenv(K)
@@ -1847,8 +1825,6 @@ static struct tm *time_to_tm(const Janet *argv, int32_t argc, int32_t n, struct
         _tzset();
         localtime_s(t_infos, &t);
         t_info = t_infos;
-#elif defined(JANET_PLAN9)
-        t_info = localtime(&t);
 #else
         tzset();
         t_info = localtime_r(&t, t_infos);
@@ -1858,8 +1834,6 @@ static struct tm *time_to_tm(const Janet *argv, int32_t argc, int32_t n, struct
 #ifdef JANET_WINDOWS
         gmtime_s(t_infos, &t);
         t_info = t_infos;
-#elif defined(JANET_PLAN9)
-        t_info = gmtime(&t);
 #else
         t_info = gmtime_r(&t, t_infos);
 #endif
@@ -2034,7 +2008,6 @@ JANET_CORE_FN(os_mktime,
 #define j_symlink symlink
 #endif
 
-#ifndef JANET_NO_LOCALES
 JANET_CORE_FN(os_setlocale,
               "(os/setlocale &opt locale category)",
               "Set the system locale, which affects how dates and numbers are formatted. "
@@ -2071,20 +2044,19 @@ JANET_CORE_FN(os_setlocale,
     if (old == NULL) return janet_wrap_nil();
     return janet_cstringv(old);
 }
-#endif
 
 JANET_CORE_FN(os_link,
               "(os/link oldpath newpath &opt symlink)",
               "Create a link at newpath that points to oldpath and returns nil. "
               "Iff symlink is truthy, creates a symlink. "
               "Iff symlink is falsey or not provided, "
-              "creates a hard link. Does not work on Windows or Plan 9.") {
+              "creates a hard link. Does not work on Windows.") {
     janet_sandbox_assert(JANET_SANDBOX_FS_WRITE);
     janet_arity(argc, 2, 3);
-#if defined(JANET_WINDOWS) || defined(JANET_PLAN9)
+#ifdef JANET_WINDOWS
     (void) argc;
     (void) argv;
-    janet_panic("not supported on Windows or Plan 9");
+    janet_panic("not supported on Windows");
 #else
     const char *oldpath = janet_getcstring(argv, 0);
     const char *newpath = janet_getcstring(argv, 1);
@@ -2099,10 +2071,10 @@ JANET_CORE_FN(os_symlink,
               "Create a symlink from oldpath to newpath, returning nil. Same as `(os/link oldpath newpath true)`.") {
     janet_sandbox_assert(JANET_SANDBOX_FS_WRITE);
     janet_fixarity(argc, 2);
-#if defined(JANET_WINDOWS) || defined(JANET_PLAN9)
+#ifdef JANET_WINDOWS
     (void) argc;
     (void) argv;
-    janet_panic("not supported on Windows or Plan 9");
+    janet_panic("not supported on Windows");
 #else
     const char *oldpath = janet_getcstring(argv, 0);
     const char *newpath = janet_getcstring(argv, 1);
@@ -2140,8 +2112,6 @@ JANET_CORE_FN(os_rmdir,
     const char *path = janet_getcstring(argv, 0);
 #ifdef JANET_WINDOWS
     int res = _rmdir(path);
-#elif defined(JANET_PLAN9)
-    int res = remove(path);
 #else
     int res = rmdir(path);
 #endif
@@ -2268,13 +2238,11 @@ static const uint8_t *janet_decode_mode(mode_t m) {
     const char *str = "other";
     if (S_ISREG(m)) str = "file";
     else if (S_ISDIR(m)) str = "directory";
-#ifndef JANET_PLAN9
     else if (S_ISFIFO(m)) str = "fifo";
     else if (S_ISBLK(m)) str = "block";
     else if (S_ISSOCK(m)) str = "socket";
     else if (S_ISLNK(m)) str = "link";
     else if (S_ISCHR(m)) str = "character";
-#endif
     return janet_ckeyword(str);
 }
 
@@ -2439,9 +2407,6 @@ static Janet os_stat_or_lstat(int do_lstat, int32_t argc, Janet *argv) {
 #ifdef JANET_WINDOWS
     (void) do_lstat;
     int res = _stat(path, &st);
-#elif defined(JANET_PLAN9)
-    (void)do_lstat;
-    int res = stat(path, &st);
 #else
     int res;
     if (do_lstat) {
@@ -2502,13 +2467,9 @@ JANET_CORE_FN(os_chmod,
               "Change file permissions, where `mode` is a permission string as returned by "
               "`os/perm-string`, or an integer as returned by `os/perm-int`. "
               "When `mode` is an integer, it is interpreted as a Unix permission value, best specified in octal, like "
-              "8r666 or 8r400. Windows will not differentiate between user, group, and other permissions, and thus will combine all of these permissions. Returns nil."
-              "Unsupported on plan9.") {
+              "8r666 or 8r400. Windows will not differentiate between user, group, and other permissions, and thus will combine all of these permissions. Returns nil.") {
     janet_sandbox_assert(JANET_SANDBOX_FS_WRITE);
     janet_fixarity(argc, 2);
-#ifdef JANET_PLAN9
-    janet_panic("not supported on Plan 9");
-#else
     const char *path = janet_getcstring(argv, 0);
 #ifdef JANET_WINDOWS
     int res = _chmod(path, os_getmode(argv, 1));
@@ -2517,7 +2478,6 @@ JANET_CORE_FN(os_chmod,
 #endif
     if (-1 == res) janet_panicf("%s: %s", janet_strerror(errno), path);
     return janet_wrap_nil();
-#endif
 }
 
 #ifndef JANET_NO_UMASK
@@ -2616,15 +2576,7 @@ JANET_CORE_FN(os_realpath,
 #endif
     if (NULL == dest) janet_panicf("%s: %s", janet_strerror(errno), src);
     Janet ret = janet_cstringv(dest);
-#ifdef JANET_WINDOWS
-    DWORD attrib = GetFileAttributes(dest);
-    free(dest); /* if janet_malloc is redefined, still use free to correspond with _fullpath */
-    if (attrib == INVALID_FILE_ATTRIBUTES) {
-        janet_panicf("path does not exist: %v", ret);
-    }
-#else
     janet_free(dest);
-#endif
     return ret;
 #endif
 }
@@ -2904,14 +2856,10 @@ void janet_lib_os(JanetTable *env) {
         JANET_CORE_REG("os/strftime", os_strftime),
         JANET_CORE_REG("os/sleep", os_sleep),
         JANET_CORE_REG("os/isatty", os_isatty),
-#ifndef JANET_NO_LOCALES
         JANET_CORE_REG("os/setlocale", os_setlocale),
-#endif
 
         /* env functions */
-#ifndef JANET_PLAN9
         JANET_CORE_REG("os/environ", os_environ),
-#endif
         JANET_CORE_REG("os/getenv", os_getenv),
         JANET_CORE_REG("os/setenv", os_setenv),
 
@@ -2923,6 +2871,7 @@ void janet_lib_os(JanetTable *env) {
         JANET_CORE_REG("os/touch", os_touch),
         JANET_CORE_REG("os/realpath", os_realpath),
         JANET_CORE_REG("os/cd", os_cd),
+        JANET_CORE_REG("os/posix-chroot", os_posix_chroot),
 #ifndef JANET_NO_UMASK
         JANET_CORE_REG("os/umask", os_umask),
 #endif
@@ -2947,7 +2896,6 @@ void janet_lib_os(JanetTable *env) {
         JANET_CORE_REG("os/shell", os_shell),
         JANET_CORE_REG("os/posix-fork", os_posix_fork),
         JANET_CORE_REG("os/posix-exec", os_posix_exec),
-        JANET_CORE_REG("os/posix-chroot", os_posix_chroot),
         /* no need to sandbox process management if you can't create processes
          * (allows for limited functionality if use exposes C-functions to create specific processes) */
         JANET_CORE_REG("os/proc-wait", os_proc_wait),

src/core/parse.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -105,6 +105,15 @@ static int to_hex(uint8_t c) {
     }
 }
 
+typedef int (*Consumer)(JanetParser *p, JanetParseState *state, uint8_t c);
+struct JanetParseState {
+    int32_t counter;
+    int32_t argn;
+    int flags;
+    size_t line;
+    size_t column;
+    Consumer consumer;
+};
 
 /* Define a stack on the main parser struct */
 #define DEF_PARSER_STACK(NAME, T, STACK, STACKCOUNT, STACKCAP) \

src/core/peg.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -622,7 +622,6 @@ tail:
         }
 
         case RULE_REPLACE:
-        case RULE_MATCHSPLICE:
         case RULE_MATCHTIME: {
             uint32_t tag = rule[3];
             int oldmode = s->mode;
@@ -663,17 +662,8 @@ tail:
                     break;
             }
             cap_load_keept(s, cs);
-            if (rule[0] != RULE_REPLACE && !janet_truthy(cap)) return NULL; /* matchtime or matchtime flatten */
-            const Janet *elements = NULL;
-            int32_t len = 0;
-            if ((rule[0] == RULE_MATCHSPLICE) && janet_indexed_view(cap, &elements, &len)) {
-                /* unpack and flatten capture */
-                for (int32_t i = 0; i < len; i++) {
-                    pushcap(s, elements[i], tag);
-                }
-            } else {
-                pushcap(s, cap, tag);
-            }
+            if (rule[0] == RULE_MATCHTIME && !janet_truthy(cap)) return NULL;
+            pushcap(s, cap, tag);
             return result;
         }
 
@@ -1254,7 +1244,7 @@ static void spec_replace(Builder *b, int32_t argc, const Janet *argv) {
     emit_3(r, RULE_REPLACE, subrule, constant, tag);
 }
 
-static void spec_matchtime_impl(Builder *b, int32_t argc, const Janet *argv, uint32_t op) {
+static void spec_matchtime(Builder *b, int32_t argc, const Janet *argv) {
     peg_arity(b, argc, 2, 3);
     Reserve r = reserve(b, 4);
     uint32_t subrule = peg_compile1(b, argv[0]);
@@ -1265,15 +1255,7 @@ static void spec_matchtime_impl(Builder *b, int32_t argc, const Janet *argv, uin
     }
     uint32_t tag = (argc == 3) ? emit_tag(b, argv[2]) : 0;
     uint32_t cindex = emit_constant(b, fun);
-    emit_3(r, op, subrule, cindex, tag);
-}
-
-static void spec_matchtime(Builder *b, int32_t argc, const Janet *argv) {
-    spec_matchtime_impl(b, argc, argv, RULE_MATCHTIME);
-}
-
-static void spec_matchtime_splice(Builder *b, int32_t argc, const Janet *argv) {
-    spec_matchtime_impl(b, argc, argv, RULE_MATCHSPLICE);
+    emit_3(r, RULE_MATCHTIME, subrule, cindex, tag);
 }
 
 static void spec_sub(Builder *b, int32_t argc, const Janet *argv) {
@@ -1359,7 +1341,6 @@ static const SpecialPair peg_specials[] = {
     {"between", spec_between},
     {"capture", spec_capture},
     {"choice", spec_choice},
-    {"cms", spec_matchtime_splice},
     {"cmt", spec_matchtime},
     {"column", spec_column},
     {"constant", spec_constant},
@@ -1616,7 +1597,7 @@ static void *peg_unmarshal(JanetMarshalContext *ctx) {
     /* After here, no panics except for the bad: label. */
 
     /* Keep track at each index if an instruction was
-     * referenced (0x01) or is in a main bytecode position
+     * reference (0x01) or is in a main bytecode position
      * (0x02). This lets us do a linear scan and not
      * need to a depth first traversal. It is stricter
      * than a dfs by not allowing certain kinds of unused
@@ -1722,7 +1703,6 @@ static void *peg_unmarshal(JanetMarshalContext *ctx) {
                 break;
             case RULE_REPLACE:
             case RULE_MATCHTIME:
-            case RULE_MATCHSPLICE:
                 /* [rule, constant, tag] */
                 if (rule[1] >= blen) goto bad;
                 if (rule[2] >= clen) goto bad;

src/core/pp.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -1023,20 +1023,10 @@ void janet_buffer_format(
             char form[MAX_FORMAT], item[MAX_ITEM];
             char width[3], precision[3];
             int nb = 0; /* number of bytes in added item */
-#ifdef JANET_PLAN9
-            if (*strfrmt == 'r') {
-                rerrstr(item, MAX_ITEM);
-                nb = strlen(item);
-            } else
-#endif
-                if (++arg >= argc)
-                    janet_panic("not enough values for format");
+            if (++arg >= argc)
+                janet_panic("not enough values for format");
             strfrmt = scanformat(strfrmt, form, width, precision);
             switch (*strfrmt++) {
-#ifdef JANET_PLAN9
-                case 'r':
-                    break;
-#endif
                 case 'c': {
                     nb = snprintf(item, MAX_ITEM, form, (int)
                                   janet_getinteger(argv, arg));

src/core/regalloc.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/regalloc.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/run.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -60,6 +60,7 @@ int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char
                     done = 1;
                 }
             } else {
+                ret = janet_wrap_string(cres.error);
                 int32_t line = (int32_t) parser->line;
                 int32_t col = (int32_t) parser->column;
                 if ((cres.error_mapping.line > 0) &&
@@ -67,17 +68,13 @@ int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char
                     line = cres.error_mapping.line;
                     col = cres.error_mapping.column;
                 }
-                JanetString ctx = janet_formatc("%s:%d:%d: compile error",
-                                                sourcePath, line, col);
-                JanetString errstr = janet_formatc("%s: %s",
-                                                   (const char *)ctx,
-                                                   (const char *)cres.error);
-                ret = janet_wrap_string(errstr);
                 if (cres.macrofiber) {
-                    janet_eprintf("%s", (const char *)ctx);
+                    janet_eprintf("%s:%d:%d: compile error", sourcePath,
+                                  line, col);
                     janet_stacktrace_ext(cres.macrofiber, ret, "");
                 } else {
-                    janet_eprintf("%s\n", (const char *)errstr);
+                    janet_eprintf("%s:%d:%d: compile error: %s\n", sourcePath,
+                                  line, col, (const char *)cres.error);
                 }
                 errflags |= JANET_DO_ERROR_COMPILE;
                 done = 1;
@@ -92,14 +89,12 @@ int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char
                 done = 1;
                 break;
             case JANET_PARSE_ERROR: {
+                const char *e = janet_parser_error(parser);
                 errflags |= JANET_DO_ERROR_PARSE;
+                ret = janet_cstringv(e);
                 int32_t line = (int32_t) parser->line;
                 int32_t col = (int32_t) parser->column;
-                JanetString errstr = janet_formatc("%s:%d:%d: parse error: %s",
-                                                   sourcePath, line, col,
-                                                   janet_parser_error(parser));
-                ret = janet_wrap_string(errstr);
-                janet_eprintf("%s\n", (const char *)errstr);
+                janet_eprintf("%s:%d:%d: parse error: %s\n", sourcePath, line, col, e);
                 done = 1;
                 break;
             }
@@ -127,8 +122,7 @@ int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char
         janet_loop();
         if (fiber) {
             janet_gcunroot(janet_wrap_fiber(fiber));
-            if (!errflags)
-                ret = fiber->last_value;
+            ret = fiber->last_value;
         }
     }
 #endif

src/core/specials.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -362,23 +362,6 @@ SlotHeadPair *dohead_destructure(JanetCompiler *c, SlotHeadPair *into, JanetFopt
         janet_indexed_view(lhs, &view_lhs.items, &view_lhs.len);
         janet_indexed_view(rhs, &view_rhs.items, &view_rhs.len);
         int found_amp = 0;
-        int found_splice = 0;
-        /* Check for (def [x y z] [(splice [1 2 3]) 4 5 6]), bail out of optimization */
-        for (int32_t i = 0; i < view_rhs.len; i++) {
-            if (!janet_checktype(view_rhs.items[i], JANET_TUPLE)) {
-                continue;
-            }
-            JanetTuple tup = janet_unwrap_tuple(view_rhs.items[i]);
-            if (janet_tuple_length(tup) == 0) {
-                continue;
-            }
-            if (janet_symeq(tup[0], "splice")) {
-                found_splice = 1;
-                /* Good error will be generated later. */
-                break;
-            }
-        }
-        /* Check for (def [x & more] [1 2 3]), bail out of optimization */
         for (int32_t i = 0; i < view_lhs.len; i++) {
             if (janet_symeq(view_lhs.items[i], "&")) {
                 found_amp = 1;
@@ -386,7 +369,7 @@ SlotHeadPair *dohead_destructure(JanetCompiler *c, SlotHeadPair *into, JanetFopt
                 break;
             }
         }
-        if (!found_amp && !found_splice) {
+        if (!found_amp) {
             for (int32_t i = 0; i < view_lhs.len; i++) {
                 Janet sub_rhs = view_rhs.len <= i ? janet_wrap_nil() : view_rhs.items[i];
                 into = dohead_destructure(c, into, subopts, view_lhs.items[i], sub_rhs);
@@ -464,24 +447,12 @@ static int varleaf(
     }
 }
 
-static void check_metadata_lint(JanetCompiler *c, JanetTable *attr_table) {
-    if (!(c->scope->flags & JANET_SCOPE_TOP) && attr_table && attr_table->count) {
-        /* A macro is a normal lint, other metadata is a strict lint */
-        if (janet_truthy(janet_table_get(attr_table, janet_ckeywordv("macro")))) {
-            janetc_lintf(c, JANET_C_LINT_NORMAL, "macro tag is ignored in inner scopes");
-        } else {
-            janetc_lintf(c, JANET_C_LINT_STRICT, "unused metadata %j in inner scope", janet_wrap_table(attr_table));
-        }
-    }
-}
-
 static JanetSlot janetc_var(JanetFopts opts, int32_t argn, const Janet *argv) {
     JanetCompiler *c = opts.compiler;
     JanetTable *attr_table = handleattr(c, "var", argn, argv);
     if (c->result.status == JANET_COMPILE_ERROR) {
         return janetc_cslot(janet_wrap_nil());
     }
-    check_metadata_lint(c, attr_table);
     SlotHeadPair *into = NULL;
     into = dohead_destructure(c, into, opts, argv[0], argv[argn - 1]);
     if (c->result.status == JANET_COMPILE_ERROR) {
@@ -542,7 +513,6 @@ static JanetSlot janetc_def(JanetFopts opts, int32_t argn, const Janet *argv) {
     if (c->result.status == JANET_COMPILE_ERROR) {
         return janetc_cslot(janet_wrap_nil());
     }
-    check_metadata_lint(c, attr_table);
     opts.flags &= ~JANET_FOPTS_HINT;
     SlotHeadPair *into = NULL;
     into = dohead_destructure(c, into, opts, argv[0], argv[argn - 1]);

src/core/state.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/state.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/string.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/strtod.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/struct.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/symcache.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/symcache.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/sysir.h

@@ -0,0 +1,337 @@
+/*
+* Copyright (c) 2024 Calvin Rose
+*
+* 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.
+*/
+
+/****
+ * The System Dialect Intermediate Representation (sysir) is a compiler intermediate representation
+ * that for "System Janet" a dialect for "System Programming". Sysir can then be retargeted to C or direct to machine
+ * code for JIT or AOT compilation.
+ */
+
+/* TODO
+ * [x] encode constants directly in 3 address codes - makes codegen easier
+ * [x] typed constants
+ * [x] named registers and types
+ * [x] better type errors (perhaps mostly for compiler debugging - full type system goes on top)
+ * [-] x86/x64 machine code target - in progress
+ *   [ ] handle floating point types
+ *   [ ] handle array types
+ *   [ ] emit machine code directly
+ * [ ] target specific extensions - custom instructions and custom primitives
+ * [ ] better casting semantics
+ * [x] separate pointer arithmetic from generalized arithmetic (easier to instrument code for safety)?
+ * [x] fixed-size array types
+ * [x] recursive pointer types
+ * [ ] global and thread local state
+ * [x] union types?
+ * [x] incremental compilation - save type definitions for later
+ * [ ] Extension to C target for interfacing with Janet
+ * [x] pointer math, pointer types
+ * [x] composite types - support for load, store, move, and function args.
+ * [x] Have some mechanism for field access (dest = src.offset)
+ * [x] Related, move type creation as opcodes like in SPIRV - have separate virtual "type slots" and value slots for this.
+ * [x] support for stack allocation of arrays
+ * [ ] more math intrinsics
+ * [x] source mapping (using built in Janet source mapping metadata on tuples)
+ * [x] unit type or void type
+ * [ ] (typed) function pointer types and remove calling untyped pointers
+ * [x] APL array semantics for binary operands (maybe?)
+ * [ ] a few built-in array combinators (maybe?)
+ * [ ] multiple error messages in one pass
+ * [ ] better verification of constants
+ * [x] don't allow redefining types
+ * [ ] generate elf/mach-o/pe directly
+ *   [ ] elf
+ *   [ ] mach-o
+ *   [ ] pe
+ * [ ] generate dwarf info
+ */
+
+#ifndef JANET_SYSIR_H
+#define JANET_SYSIR_H
+
+#ifndef JANET_AMALG
+#include "features.h"
+#include <janet.h>
+#include "state.h"
+#endif
+
+typedef enum {
+    JANET_PRIM_U8,
+    JANET_PRIM_S8,
+    JANET_PRIM_U16,
+    JANET_PRIM_S16,
+    JANET_PRIM_U32,
+    JANET_PRIM_S32,
+    JANET_PRIM_U64,
+    JANET_PRIM_S64,
+    JANET_PRIM_F32,
+    JANET_PRIM_F64,
+    JANET_PRIM_POINTER,
+    JANET_PRIM_BOOLEAN,
+    JANET_PRIM_STRUCT,
+    JANET_PRIM_UNION,
+    JANET_PRIM_ARRAY,
+    JANET_PRIM_VOID,
+    JANET_PRIM_UNKNOWN
+} JanetPrim;
+
+typedef struct {
+    const char *name;
+    JanetPrim prim;
+} JanetPrimName;
+
+typedef enum {
+    JANET_SYSOP_LINK_NAME,
+    JANET_SYSOP_PARAMETER_COUNT,
+    JANET_SYSOP_CALLING_CONVENTION,
+    JANET_SYSOP_MOVE,
+    JANET_SYSOP_CAST,
+    JANET_SYSOP_ADD,
+    JANET_SYSOP_SUBTRACT,
+    JANET_SYSOP_MULTIPLY,
+    JANET_SYSOP_DIVIDE,
+    JANET_SYSOP_BAND,
+    JANET_SYSOP_BOR,
+    JANET_SYSOP_BXOR,
+    JANET_SYSOP_BNOT,
+    JANET_SYSOP_SHL,
+    JANET_SYSOP_SHR,
+    JANET_SYSOP_LOAD,
+    JANET_SYSOP_STORE,
+    JANET_SYSOP_GT,
+    JANET_SYSOP_LT,
+    JANET_SYSOP_EQ,
+    JANET_SYSOP_NEQ,
+    JANET_SYSOP_GTE,
+    JANET_SYSOP_LTE,
+    JANET_SYSOP_CALL,
+    JANET_SYSOP_SYSCALL,
+    JANET_SYSOP_RETURN,
+    JANET_SYSOP_JUMP,
+    JANET_SYSOP_BRANCH,
+    JANET_SYSOP_BRANCH_NOT,
+    JANET_SYSOP_ADDRESS,
+    JANET_SYSOP_TYPE_PRIMITIVE,
+    JANET_SYSOP_TYPE_STRUCT,
+    JANET_SYSOP_TYPE_BIND,
+    JANET_SYSOP_ARG,
+    JANET_SYSOP_FIELD_GETP,
+    JANET_SYSOP_ARRAY_GETP,
+    JANET_SYSOP_ARRAY_PGETP,
+    JANET_SYSOP_TYPE_POINTER,
+    JANET_SYSOP_TYPE_ARRAY,
+    JANET_SYSOP_TYPE_UNION,
+    JANET_SYSOP_POINTER_ADD,
+    JANET_SYSOP_POINTER_SUBTRACT,
+    JANET_SYSOP_LABEL
+} JanetSysOp;
+
+typedef struct {
+    JanetPrim prim;
+    union {
+        struct {
+            uint32_t field_count;
+            uint32_t field_start;
+        } st;
+        struct {
+            uint32_t type;
+        } pointer;
+        struct {
+            uint32_t type;
+            uint64_t fixed_count;
+        } array;
+    };
+} JanetSysTypeInfo;
+
+typedef struct {
+    uint32_t type;
+} JanetSysTypeField;
+
+#define JANET_SYS_CALLFLAG_HAS_DEST 1
+#define JANET_SYS_CALLFLAG_VARARGS 2
+
+/* Allow read arguments to be constants to allow
+ * encoding immediates. This makes codegen easier. */
+#define JANET_SYS_MAX_OPERAND      0x7FFFFFFFU
+#define JANET_SYS_CONSTANT_PREFIX  0x80000000U
+
+typedef enum {
+    JANET_SYS_CC_DEFAULT, /* Reasonable default - maps to a specific cc based on target */
+    JANET_SYS_CC_SYSCALL, /* Reasonable default for platform syscalls - maps to a specific cc based on target */
+    JANET_SYS_CC_X86_CDECL,
+    JANET_SYS_CC_X86_STDCALL,
+    JANET_SYS_CC_X86_FASTCALL,
+    JANET_SYS_CC_X64_SYSV,
+    JANET_SYS_CC_X64_SYSV_SYSCALL,
+    JANET_SYS_CC_X64_WINDOWS,
+} JanetSysCallingConvention;
+
+typedef enum {
+    JANET_SYS_TARGET_X64_WINDOWS, /* 64 bit, modern windows */
+    JANET_SYS_TARGET_X64_LINUX, /* x64 linux with recent kernel */
+} JanetSysTarget;
+
+typedef struct {
+    JanetSysOp opcode;
+    union {
+        struct {
+            uint32_t dest;
+            uint32_t lhs;
+            uint32_t rhs;
+        } three;
+        struct {
+            uint32_t dest;
+            uint32_t callee;
+            uint32_t arg_count;
+            uint8_t flags;
+            JanetSysCallingConvention calling_convention;
+        } call;
+        struct {
+            uint32_t dest;
+            uint32_t src;
+        } two;
+        struct {
+            uint32_t src;
+        } one;
+        struct {
+            uint32_t to;
+        } jump;
+        struct {
+            uint32_t cond;
+            uint32_t to;
+        } branch;
+        struct {
+            uint32_t dest_type;
+            uint32_t prim;
+        } type_prim;
+        struct {
+            uint32_t dest_type;
+            uint32_t arg_count;
+        } type_types;
+        struct {
+            uint32_t dest;
+            uint32_t type;
+        } type_bind;
+        struct {
+            uint32_t args[3];
+        } arg;
+        struct {
+            uint32_t r;
+            uint32_t st;
+            uint32_t field;
+        } field;
+        struct {
+            uint32_t dest_type;
+            uint32_t type;
+            // Include address space?
+        } pointer;
+        struct {
+            uint32_t dest_type;
+            uint32_t type;
+            uint64_t fixed_count;
+        } array;
+        struct {
+            uint32_t id;
+        } label;
+        struct {
+            uint32_t value;
+            uint32_t has_value;
+        } ret;
+    };
+    int32_t line;
+    int32_t column;
+} JanetSysInstruction;
+
+/* Shared data between multiple
+ * IR Function bodies. Used to link
+ * multiple functions together in a
+ * single executable or shared object with
+ * multiple entry points. Contains shared
+ * type declarations, as well as a table of linked
+ * functions. */
+typedef struct {
+    uint32_t old_type_def_count;
+    uint32_t type_def_count;
+    uint32_t field_def_count;
+    JanetSysTypeInfo *type_defs;
+    JanetString *type_names;
+    JanetSysTypeField *field_defs;
+    JanetTable *irs;
+    JanetArray *ir_ordered;
+    JanetTable *type_name_lookup;
+} JanetSysIRLinkage;
+
+/* Keep source code information as well as
+ * typing information along with constants */
+typedef struct {
+    uint32_t type;
+    Janet value;
+    // TODO - source and line
+} JanetSysConstant;
+
+/* IR representation for a single function.
+ * Allow for incremental compilation and linking. */
+typedef struct {
+    JanetSysIRLinkage *linkage;
+    JanetString link_name;
+    uint32_t instruction_count;
+    uint32_t register_count;
+    uint32_t constant_count;
+    uint32_t return_type;
+    uint32_t has_return_type;
+    uint32_t parameter_count;
+    uint32_t label_count;
+    uint32_t *types;
+    JanetSysInstruction *instructions;
+    JanetString *register_names;
+    JanetSysConstant *constants;
+    JanetTable *register_name_lookup;
+    JanetTable *labels;
+    JanetSysCallingConvention calling_convention;
+    Janet error_ctx; /* Temporary for holding error messages */
+} JanetSysIR;
+
+/* Delay alignment info for the most part to the lowering phase */
+typedef struct {
+    uint32_t size;
+    uint32_t alignment;
+} JanetSysTypeLayout;
+
+/* Keep track of names for each instruction */
+extern const char *janet_sysop_names[];
+extern const char *prim_to_prim_name[];
+
+/* Utilities */
+
+uint32_t janet_sys_optype(JanetSysIR *ir, uint32_t op);
+
+/* Get list of uint32_t instruction arguments from a call or other variable length instruction.
+   Needs to be free with janet_sfree (or you can leak it and the garbage collector will eventually clean
+ * it up). */
+uint32_t *janet_sys_callargs(JanetSysInstruction *instr, uint32_t *count);
+
+/* Lowering */
+void janet_sys_ir_lower_to_ir(JanetSysIRLinkage *linkage, JanetArray *into);
+void janet_sys_ir_lower_to_c(JanetSysIRLinkage *linkage, JanetBuffer *buffer);
+void janet_sys_ir_lower_to_x64(JanetSysIRLinkage *linkage, JanetSysTarget target, JanetBuffer *buffer);
+
+#endif

src/core/sysir_c.c

@@ -0,0 +1,376 @@
+/*
+* Copyright (c) 2024 Calvin Rose
+*
+* 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.
+*/
+
+#ifndef JANET_AMALG
+#include "features.h"
+#include <janet.h>
+#include "sysir.h"
+#include "vector.h"
+#include "util.h"
+#endif
+
+/* Lowering to C */
+
+static const char *c_prim_names[] = {
+    "uint8_t",
+    "int8_t",
+    "uint16_t",
+    "int16_t",
+    "uint32_t",
+    "int32_t",
+    "uint64_t",
+    "int64_t",
+    "float",
+    "double",
+    "void *",
+    "bool",
+    "!!!struct",
+    "!!!union",
+    "!!!array",
+    "void",
+    "!!!unknown"
+};
+
+/* Print a C constant */
+static void print_const_c(JanetSysIR *ir, JanetBuffer *buf, Janet c, uint32_t tid) {
+    /* JanetSysTypeInfo *tinfo = &ir->linkage->type_defs[tid]; */
+    if (janet_checktype(c, JANET_TUPLE)) {
+        const Janet *elements = janet_unwrap_tuple(c);
+        janet_formatb(buf, "((_t%d){", tid);
+        for (int32_t i = 0; i < janet_tuple_length(elements); i++) {
+            if (i > 0) janet_formatb(buf, ", ");
+            /* TODO - limit recursion? */
+            uint32_t sub_type = ir->linkage->type_defs[tid].array.type;
+            print_const_c(ir, buf, elements[i], sub_type);
+        }
+        janet_formatb(buf, "})");
+    } else if (janet_checktype(c, JANET_ABSTRACT)) {
+        /* Allow printing int types */
+        janet_formatb(buf, "%V", c);
+    } else {
+        janet_formatb(buf, "%v", c);
+    }
+}
+
+static void c_op_or_const(JanetSysIR *ir, JanetBuffer *buf, uint32_t reg) {
+    if (reg < JANET_SYS_MAX_OPERAND) {
+        janet_formatb(buf, "_r%u", reg);
+    } else {
+        uint32_t constant_id = reg - JANET_SYS_CONSTANT_PREFIX;
+        uint32_t tid = ir->constants[constant_id].type;
+        Janet c = ir->constants[constant_id].value;
+        print_const_c(ir, buf, c, tid);
+    }
+}
+
+static void c_emit_binop(JanetSysIR *ir, JanetBuffer *buffer, JanetBuffer *tempbuf, JanetSysInstruction instruction, const char *op, int pointer_sugar) {
+    uint32_t operand_type = ir->types[instruction.three.dest];
+    tempbuf->count = 0;
+    uint32_t index_index = 0;
+    int is_pointer = 0;
+    JanetSysIRLinkage *linkage = ir->linkage;
+
+    /* Top-level pointer semantics */
+    if (pointer_sugar && janet_sys_optype(ir, instruction.three.dest) == JANET_PRIM_POINTER) {
+        operand_type = linkage->type_defs[operand_type].pointer.type;
+        is_pointer = 1;
+    }
+
+    /* Add nested for loops for any dimensionality of array */
+    while (linkage->type_defs[operand_type].prim == JANET_PRIM_ARRAY) {
+        janet_formatb(buffer, "  for (size_t _j%u = 0; _j%u < %u; _j%u++) ",
+                      index_index, index_index,
+                      linkage->type_defs[operand_type].array.fixed_count,
+                      index_index);
+        if (is_pointer) {
+            janet_formatb(tempbuf, "->els[_j%u]", index_index);
+            is_pointer = 0;
+        } else {
+            janet_formatb(tempbuf, ".els[_j%u]", index_index);
+        }
+        operand_type = linkage->type_defs[operand_type].array.type;
+        index_index++;
+    }
+
+    if (is_pointer) {
+        janet_formatb(buffer, "  *_r%u = *_r%u %s *_r%u;\n",
+                      instruction.three.dest,
+                      instruction.three.lhs,
+                      op,
+                      instruction.three.rhs);
+        janet_formatb(buffer, "  *_r%u = *", instruction.three.dest);
+        c_op_or_const(ir, buffer, instruction.three.lhs);
+        janet_formatb(buffer, " %s ", op);
+        c_op_or_const(ir, buffer, instruction.three.rhs);
+        janet_formatb(buffer, ";\n");
+    } else {
+        Janet index_part = janet_wrap_buffer(tempbuf);
+        janet_formatb(buffer, "  _r%u%V = ", instruction.three.dest, index_part);
+        c_op_or_const(ir, buffer, instruction.three.lhs);
+        janet_formatb(buffer, "%V %s ", index_part, op);
+        c_op_or_const(ir, buffer, instruction.three.rhs);
+        janet_formatb(buffer, "%V;\n", index_part);
+    }
+}
+
+void janet_sys_ir_lower_to_c(JanetSysIRLinkage *linkage, JanetBuffer *buffer) {
+
+    JanetBuffer *tempbuf = janet_buffer(0);
+
+#define EMITBINOP(OP) c_emit_binop(ir, buffer, tempbuf, instruction, OP, 1)
+#define EMITBINOP_NOSUGAR(OP) c_emit_binop(ir, buffer, tempbuf, instruction, OP, 0)
+
+    /* Prelude */
+    janet_formatb(buffer, "#include <stddef.h>\n#include <unistd.h>\n#include <stdlib.h>\n#include <stdint.h>\n#include <stdbool.h>\n#include <stdio.h>\n#include <sys/syscall.h>\n#define _t0 void\n\n");
+
+    /* Emit type defs */
+    for (uint32_t j = 0; j < (uint32_t) linkage->ir_ordered->count; j++) {
+        JanetSysIR *ir = janet_unwrap_abstract(linkage->ir_ordered->data[j]);
+        for (uint32_t i = 0; i < ir->instruction_count; i++) {
+            JanetSysInstruction instruction = ir->instructions[i];
+            switch (instruction.opcode) {
+                default:
+                    continue;
+                case JANET_SYSOP_TYPE_PRIMITIVE:
+                case JANET_SYSOP_TYPE_STRUCT:
+                case JANET_SYSOP_TYPE_UNION:
+                case JANET_SYSOP_TYPE_POINTER:
+                case JANET_SYSOP_TYPE_ARRAY:
+                    break;
+            }
+            if (instruction.line > 0) {
+                janet_formatb(buffer, "#line %d\n", instruction.line);
+            }
+            switch (instruction.opcode) {
+                default:
+                    break;
+                case JANET_SYSOP_TYPE_PRIMITIVE:
+                    janet_formatb(buffer, "typedef %s _t%u;\n", c_prim_names[instruction.type_prim.prim], instruction.type_prim.dest_type);
+                    break;
+                case JANET_SYSOP_TYPE_STRUCT:
+                case JANET_SYSOP_TYPE_UNION:
+                    janet_formatb(buffer, (instruction.opcode == JANET_SYSOP_TYPE_STRUCT) ? "typedef struct {\n" : "typedef union {\n");
+                    for (uint32_t j = 0; j < instruction.type_types.arg_count; j++) {
+                        uint32_t offset = j / 3 + 1;
+                        uint32_t index = j % 3;
+                        JanetSysInstruction arg_instruction = ir->instructions[i + offset];
+                        janet_formatb(buffer, "    _t%u _f%u;\n", arg_instruction.arg.args[index], j);
+                    }
+                    janet_formatb(buffer, "} _t%u;\n", instruction.type_types.dest_type);
+                    break;
+                case JANET_SYSOP_TYPE_POINTER:
+                    janet_formatb(buffer, "typedef _t%u *_t%u;\n", instruction.pointer.type, instruction.pointer.dest_type);
+                    break;
+                case JANET_SYSOP_TYPE_ARRAY:
+                    janet_formatb(buffer, "typedef struct { _t%u els[%u]; } _t%u;\n", instruction.array.type, instruction.array.fixed_count, instruction.array.dest_type);
+                    break;
+            }
+        }
+    }
+
+    /* Emit function header */
+    for (uint32_t j = 0; j < (uint32_t) linkage->ir_ordered->count; j++) {
+        JanetSysIR *ir = janet_unwrap_abstract(linkage->ir_ordered->data[j]);
+        if (ir->link_name == NULL) {
+            continue;
+        }
+        janet_formatb(buffer, "\n\n_t%u %s(", ir->return_type, (ir->link_name != NULL) ? ir->link_name : janet_cstring("_thunk"));
+        for (uint32_t i = 0; i < ir->parameter_count; i++) {
+            if (i) janet_buffer_push_cstring(buffer, ", ");
+            janet_formatb(buffer, "_t%u _r%u", ir->types[i], i);
+        }
+        janet_buffer_push_cstring(buffer, ")\n{\n");
+        for (uint32_t i = ir->parameter_count; i < ir->register_count; i++) {
+            janet_formatb(buffer, "    _t%u _r%u;\n", ir->types[i], i);
+        }
+        janet_buffer_push_cstring(buffer, "\n");
+
+        /* Emit body */
+        for (uint32_t i = 0; i < ir->instruction_count; i++) {
+            JanetSysInstruction instruction = ir->instructions[i];
+            if (instruction.line > 0) {
+                janet_formatb(buffer, "#line %d\n", instruction.line);
+            }
+            switch (instruction.opcode) {
+                case JANET_SYSOP_TYPE_PRIMITIVE:
+                case JANET_SYSOP_TYPE_BIND:
+                case JANET_SYSOP_TYPE_STRUCT:
+                case JANET_SYSOP_TYPE_UNION:
+                case JANET_SYSOP_TYPE_POINTER:
+                case JANET_SYSOP_TYPE_ARRAY:
+                case JANET_SYSOP_ARG:
+                case JANET_SYSOP_LINK_NAME:
+                case JANET_SYSOP_PARAMETER_COUNT:
+                case JANET_SYSOP_CALLING_CONVENTION:
+                    break;
+                case JANET_SYSOP_LABEL: {
+                    janet_formatb(buffer, "\n_label_%u:\n", instruction.label.id);
+                    break;
+                }
+                case JANET_SYSOP_ADDRESS:
+                    janet_formatb(buffer, "  _r%u = (void *) &", instruction.two.dest);
+                    c_op_or_const(ir, buffer, instruction.two.src);
+                    janet_formatb(buffer, ";\n");
+                    break;
+                case JANET_SYSOP_JUMP:
+                    janet_formatb(buffer, "  goto _label_%u;\n", instruction.jump.to);
+                    break;
+                case JANET_SYSOP_BRANCH:
+                case JANET_SYSOP_BRANCH_NOT:
+                    janet_formatb(buffer, instruction.opcode == JANET_SYSOP_BRANCH ? "  if (" : "  if (!");
+                    c_op_or_const(ir, buffer, instruction.branch.cond);
+                    janet_formatb(buffer, ") goto _label_%u;\n", instruction.branch.to);
+                    break;
+                case JANET_SYSOP_RETURN:
+                    if (instruction.ret.has_value) {
+                        janet_buffer_push_cstring(buffer, "  return ");
+                        c_op_or_const(ir, buffer, instruction.ret.value);
+                        janet_buffer_push_cstring(buffer, ";\n");
+                    } else {
+                        janet_buffer_push_cstring(buffer, "  return;\n");
+                    }
+                    break;
+                case JANET_SYSOP_ADD:
+                    EMITBINOP("+");
+                    break;
+                case JANET_SYSOP_POINTER_ADD:
+                    EMITBINOP_NOSUGAR("+");
+                    break;
+                case JANET_SYSOP_SUBTRACT:
+                    EMITBINOP("-");
+                    break;
+                case JANET_SYSOP_POINTER_SUBTRACT:
+                    EMITBINOP_NOSUGAR("-");
+                    break;
+                case JANET_SYSOP_MULTIPLY:
+                    EMITBINOP("*");
+                    break;
+                case JANET_SYSOP_DIVIDE:
+                    EMITBINOP("/");
+                    break;
+                case JANET_SYSOP_GT:
+                    EMITBINOP(">");
+                    break;
+                case JANET_SYSOP_GTE:
+                    EMITBINOP(">");
+                    break;
+                case JANET_SYSOP_LT:
+                    EMITBINOP("<");
+                    break;
+                case JANET_SYSOP_LTE:
+                    EMITBINOP("<=");
+                    break;
+                case JANET_SYSOP_EQ:
+                    EMITBINOP("==");
+                    break;
+                case JANET_SYSOP_NEQ:
+                    EMITBINOP("!=");
+                    break;
+                case JANET_SYSOP_BAND:
+                    EMITBINOP("&");
+                    break;
+                case JANET_SYSOP_BOR:
+                    EMITBINOP("|");
+                    break;
+                case JANET_SYSOP_BXOR:
+                    EMITBINOP("^");
+                    break;
+                case JANET_SYSOP_SHL:
+                    EMITBINOP("<<");
+                    break;
+                case JANET_SYSOP_SHR:
+                    EMITBINOP(">>");
+                    break;
+                case JANET_SYSOP_SYSCALL:
+                case JANET_SYSOP_CALL: {
+                    if (instruction.call.flags & JANET_SYS_CALLFLAG_HAS_DEST) {
+                        janet_formatb(buffer, "  _r%u = ", instruction.call.dest);
+                    } else {
+                        janet_formatb(buffer, "  ");
+                    }
+                    if (instruction.opcode == JANET_SYSOP_SYSCALL) {
+                        janet_formatb(buffer, "syscall(");
+                        c_op_or_const(ir, buffer, instruction.call.callee);
+                    } else {
+                        c_op_or_const(ir, buffer, instruction.call.callee);
+                        janet_formatb(buffer, "(");
+                    }
+                    uint32_t count;
+                    uint32_t *args = janet_sys_callargs(ir->instructions + i, &count);
+                    for (uint32_t j = 0; j < count; j++) {
+                        if (j || instruction.opcode == JANET_SYSOP_SYSCALL) janet_formatb(buffer, ", ");
+                        c_op_or_const(ir, buffer, args[j]);
+                    }
+                    janet_formatb(buffer, ");\n");
+                    break;
+                }
+                case JANET_SYSOP_CAST: {
+                    uint32_t to = ir->types[instruction.two.dest];
+                    janet_formatb(buffer, "  _r%u = (_t%u) ", instruction.two.dest, to);
+                    c_op_or_const(ir, buffer, instruction.two.src);
+                    janet_formatb(buffer, ";\n");
+                    break;
+                }
+                case JANET_SYSOP_MOVE:
+                    janet_formatb(buffer, "  _r%u = ", instruction.two.dest);
+                    c_op_or_const(ir, buffer, instruction.two.src);
+                    janet_formatb(buffer, ";\n");
+                    break;
+                case JANET_SYSOP_BNOT:
+                    janet_formatb(buffer, "  _r%u = ~", instruction.two.dest);
+                    c_op_or_const(ir, buffer, instruction.two.src);
+                    janet_formatb(buffer, ";\n");
+                    break;
+                case JANET_SYSOP_LOAD:
+                    janet_formatb(buffer, "  _r%u = *(", instruction.two.dest);
+                    c_op_or_const(ir, buffer, instruction.two.src);
+                    janet_formatb(buffer, ");\n");
+                    break;
+                case JANET_SYSOP_STORE:
+                    janet_formatb(buffer, "  *(_r%u) = ", instruction.two.dest);
+                    c_op_or_const(ir, buffer, instruction.two.src);
+                    janet_formatb(buffer, ";\n");
+                    break;
+                case JANET_SYSOP_FIELD_GETP:
+                    janet_formatb(buffer, "  _r%u = &(_r%u._f%u);\n", instruction.field.r, instruction.field.st, instruction.field.field);
+                    janet_formatb(buffer, "  _r%u = &(", instruction.field.r);
+                    janet_formatb(buffer, "._f%u);\n", instruction.field.field);
+                    break;
+                case JANET_SYSOP_ARRAY_GETP:
+                    janet_formatb(buffer, "  _r%u = &(_r%u.els[", instruction.three.dest, instruction.three.lhs);
+                    c_op_or_const(ir, buffer, instruction.three.rhs);
+                    janet_buffer_push_cstring(buffer, "]);\n");
+                    break;
+                case JANET_SYSOP_ARRAY_PGETP:
+                    janet_formatb(buffer, "  _r%u = &(_r%u->els[", instruction.three.dest, instruction.three.lhs);
+                    c_op_or_const(ir, buffer, instruction.three.rhs);
+                    janet_buffer_push_cstring(buffer, "]);\n");
+                    break;
+            }
+        }
+
+        janet_buffer_push_cstring(buffer, "}\n");
+#undef EMITBINOP
+#undef EMITBINOP_NOSUGAR
+    }
+
+}

src/core/table.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/tuple.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/util.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -848,15 +848,11 @@ int janet_checksize(Janet x) {
         return 0;
     double dval = janet_unwrap_number(x);
     if (dval != (double)((size_t) dval)) return 0;
-#ifdef JANET_PLAN9
-    return dval <= SIZE_MAX;
-#else
     if (SIZE_MAX > JANET_INTMAX_INT64) {
         return dval <= JANET_INTMAX_INT64;
     } else {
         return dval <= SIZE_MAX;
     }
-#endif
 }
 
 JanetTable *janet_get_core_table(const char *name) {

src/core/util.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -167,11 +167,7 @@ typedef void *Clib;
 #endif
 char *get_processed_name(const char *name);
 
-#ifdef JANET_PLAN9
-#define RETRY_EINTR(RC, CALL) (RC) = CALL;
-#else
 #define RETRY_EINTR(RC, CALL) do { (RC) = CALL; } while((RC) < 0 && errno == EINTR)
-#endif
 
 /* Initialize builtin libraries */
 void janet_lib_io(JanetTable *env);

src/core/value.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -322,8 +322,7 @@ int32_t janet_hash(Janet x) {
             break;
         case JANET_TUPLE:
             hash = janet_tuple_hash(janet_unwrap_tuple(x));
-            uint32_t inc = (janet_tuple_flag(janet_unwrap_tuple(x)) & JANET_TUPLE_FLAG_BRACKETCTOR) ? 1 : 0;
-            hash = (int32_t)((uint32_t)hash + inc); /* avoid overflow undefined behavior */
+            hash += (janet_tuple_flag(janet_unwrap_tuple(x)) & JANET_TUPLE_FLAG_BRACKETCTOR) ? 1 : 0;
             break;
         case JANET_STRUCT:
             hash = janet_struct_hash(janet_unwrap_struct(x));

src/core/vector.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/vector.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/vm.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/core/wrap.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

src/include/janet.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -121,7 +121,6 @@ extern "C" {
     || (defined(__sparc__) && defined(__arch64__) || defined (__sparcv9)) /* BE */ \
     || defined(__s390x__) /* S390 64-bit (BE) */ \
     || (defined(__ppc64__) || defined(__PPC64__)) \
-    || defined(PLAN9_arm64) || defined(PLAN9_amd64) \
     || defined(__aarch64__) /* ARM 64-bit */ \
     || (defined(__riscv) && (__riscv_xlen == 64)) /* RISC-V 64-bit */ \
     || defined(__loongarch64) /* LoongArch64 64-bit */
@@ -148,7 +147,6 @@ extern "C" {
     || defined(__s390x__) /* S390 64-bit */ \
     || defined(__s390__)  /* S390 32-bit */ \
     || defined(__ARMEB__) /* ARM big endian */ \
-    || defined(__AARCH64EB__) /* ARM64 big endian */ \
     || ((defined(__CC_ARM) || defined(__ARMCC__)) /* ARM RealView compiler */ \
         && defined(__BIG_ENDIAN))
 #define JANET_BIG_ENDIAN 1
@@ -668,8 +666,6 @@ JANET_API void janet_stream_level_triggered(JanetStream *stream);
  * signals. Define them here */
 #ifdef JANET_WINDOWS
 typedef long JanetAtomicInt;
-#elif defined(JANET_PLAN9)
-typedef long JanetAtomicInt;
 #else
 typedef int32_t JanetAtomicInt;
 #endif
@@ -1141,17 +1137,6 @@ struct JanetFunction {
 typedef struct JanetParseState JanetParseState;
 typedef struct JanetParser JanetParser;
 
-typedef int (*Consumer)(JanetParser *p, JanetParseState *state, uint8_t c);
-
-struct JanetParseState {
-    int32_t counter;
-    int32_t argn;
-    int flags;
-    size_t line;
-    size_t column;
-    Consumer consumer;
-};
-
 enum JanetParserStatus {
     JANET_PARSE_ROOT,
     JANET_PARSE_ERROR,
@@ -2117,8 +2102,6 @@ JANET_API int32_t janet_optinteger(const Janet *argv, int32_t argc, int32_t n, i
 JANET_API int64_t janet_optinteger64(const Janet *argv, int32_t argc, int32_t n, int64_t dflt);
 JANET_API size_t janet_optsize(const Janet *argv, int32_t argc, int32_t n, size_t dflt);
 JANET_API JanetAbstract janet_optabstract(const Janet *argv, int32_t argc, int32_t n, const JanetAbstractType *at, JanetAbstract dflt);
-JANET_API uint32_t janet_optuinteger(const Janet *argv, int32_t argc, int32_t n, uint32_t dflt);
-JANET_API uint64_t janet_optuinteger64(const Janet *argv, int32_t argc, int32_t n, uint64_t dflt);
 
 /* Mutable optional types specify a size default, and construct a new value if none is provided */
 JANET_API JanetBuffer *janet_optbuffer(const Janet *argv, int32_t argc, int32_t n, int32_t dflt_len);
@@ -2219,8 +2202,7 @@ typedef enum {
     RULE_SPLIT,        /* [rule, rule] */
     RULE_NTH,          /* [nth, rule, tag] */
     RULE_ONLY_TAGS,    /* [rule] */
-    RULE_MATCHSPLICE,  /* [rule, constant, tag] */
-} JanetPegOpcode;
+} JanetPegOpcod;
 
 typedef struct {
     uint32_t *bytecode;

src/mainclient/shell.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -79,11 +79,9 @@ static void simpleline(JanetBuffer *buffer) {
     int c;
     for (;;) {
         c = fgetc(in);
-#ifndef JANET_PLAN9
         if (c < 0 && !feof(in) && errno == EINTR) {
             continue;
         }
-#endif
         if (feof(in) || c < 0) {
             break;
         }
@@ -309,9 +307,7 @@ static int curpos(void) {
     char buf[32];
     int cols, rows;
     unsigned int i = 0;
-#ifndef JANET_PLAN9
     if (write_console("\x1b[6n", 4) != 4) return -1;
-#endif
     while (i < sizeof(buf) - 1) {
         if (read_console(buf + i, 1) != 1) break;
         if (buf[i] == 'R') break;
@@ -383,12 +379,10 @@ static void refresh(void) {
     janet_buffer_push_cstring(&b, gbl_prompt);
     janet_buffer_push_bytes(&b, (uint8_t *) _buf, _len);
     /* Erase to right */
-    janet_buffer_push_cstring(&b, "\x1b[0K\r");
+    janet_buffer_push_cstring(&b, "\x1b[0K");
     /* Move cursor to original position. */
-    if (_pos + gbl_plen) {
-        snprintf(seq, 64, "\x1b[%dC", (int)(_pos + gbl_plen));
-        janet_buffer_push_cstring(&b, seq);
-    }
+    snprintf(seq, 64, "\r\x1b[%dC", (int)(_pos + gbl_plen));
+    janet_buffer_push_cstring(&b, seq);
     if (write_console((char *) b.data, b.count) == -1) {
         exit(1);
     }
@@ -1135,10 +1129,6 @@ int main(int argc, char **argv) {
     JanetArray *args;
     JanetTable *env;
 
-#ifdef JANET_PLAN9
-    setfcr(0);
-#endif
-
 #ifdef _WIN32
     setup_console_output();
 #endif

test/amalg/main.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2026 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to

test/helper.janet

@@ -27,7 +27,7 @@
   (if x
     (when is-verbose (eprintf "\e[32m✔\e[0m %s: %s: %v" line-info (describe e) x))
     (do
-      (eprintf "\e[31m✘\e[0m %s: %s: %v" line-info (describe e) x) (eflush)))
+      (eprintf "\e[31m✘\e[0m %s: %s: %v" line-info (string e) x) (eflush)))
   x)
 
 (defn skip-asserts
@@ -50,11 +50,6 @@
   (def errsym (keyword (gensym)))
   ~(assert (= ,errsym (try (do ,;forms) ([_] ,errsym))) ,msg))
 
-(defmacro assert-error-value
-  [msg errval & forms]
-  (def e (gensym))
-  ~(assert (= ,errval (try (do ,;forms) ([,e] ,e))) ,msg))
-
 (defn check-compile-error
   [form]
   (def result (compile form))

test/suite-array.janet

@@ -1,4 +1,4 @@
-# Copyright (c) 2026 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to

test/suite-asm.janet

@@ -1,4 +1,4 @@
-# Copyright (c) 2026 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to

test/suite-boot.janet

@@ -1,4 +1,4 @@
-# Copyright (c) 2026 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -990,6 +990,17 @@
 (assert (= () '() (macex '())) "macex ()")
 (assert (= '[] (macex '[])) "macex []")
 
+# Knuth man or boy test
+(var a nil)
+(defn man-or-boy [x] (a x |1 |-1 |-1 |1 |0))
+(varfn a [k x1 x2 x3 x4 x5]
+  (var k k)
+  (defn b [] (-- k) (a k b x1 x2 x3 x4))
+  (if (<= k 0)
+    (+ (x4) (x5))
+    (b)))
+(assert (= -2 (man-or-boy 2)))
+(assert (= -67 (man-or-boy 10)))
 (assert (= :a (with-env @{:b :a} (dyn :b))) "with-env dyn")
 (assert-error "unknown symbol +" (with-env @{} (eval '(+ 1 2))))
 
@@ -1023,11 +1034,4 @@
 (assert (deep-not= @{:key1 "value1" [@"key2"] @"value2"}
                    @{:key1 "value1" [@"key2"] @"value2"}) "deep= mutable keys")
 
-# different try overloads
-(assert (= (try (error :error) ([] :caught)) :caught))
-(assert (= (try (error :error) ([e] e)) :error))
-(assert (= (try (error :error) ([e fib] [e (fiber? fib)])) [:error true]))
-# regression test for #1659
-(assert (= (try (error :error) ([_ _] :caught)) :caught))
-
 (end-suite)

test/suite-buffer.janet

@@ -1,4 +1,4 @@
-# Copyright (c) 2026 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to

test/suite-bundle.janet

@@ -1,4 +1,4 @@
-# Copyright (c) 2026 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -117,17 +117,8 @@
 (assert (= 0 (length (bundle/list))) "bundles are listed correctly 7")
 (assert (= 0 (length (bundle/topolist))) "bundles are listed correctly 8")
 
-# Try installing a bundle that is missing bundle script
-(assert-error-value "bundle missing bundle script"
-                    "bundle must contain bundle.janet or bundle/init.janet"
-                    (bundle/install "./examples/sample-bad-bundle1"))
-(assert (= 0 (length (bundle/list))) "check failure 0")
-(assert (= 0 (length (bundle/topolist))) "check failure 1")
-
 # Try installing a bundle that fails check
-(assert-error-value "bundle check hook fails"
-                    "Check failed!"
-                    (bundle/install "./examples/sample-bad-bundle2" :check true))
+(assert-error "bad test" (bundle/install "./examples/sample-bad-bundle" :check true))
 (assert (= 0 (length (bundle/list))) "check failure 0")
 (assert (= 0 (length (bundle/topolist))) "check failure 1")
 

test/suite-capi.janet

@@ -1,4 +1,4 @@
-# Copyright (c) 2026 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to

test/suite-cfuns.janet

@@ -1,4 +1,4 @@
-# Copyright (c) 2026 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to

test/suite-compile.janet

@@ -1,4 +1,4 @@
-# Copyright (c) 2026 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to