Test replacing CRITICAL_SECTION with SRWLOCK.

We use rw locks anyway, and it should be faster and smaller.

.builds/freebsd.yml

@@ -10,9 +10,3 @@ tasks:
     gmake test
     sudo gmake install
     sudo gmake uninstall
-- build-sanitizers: |
-    cd janet
-    CFLAGS="-g -O2 -fsanitize=address,undefined" gmake
-    gmake test
-    sudo gmake install
-    sudo gmake uninstall

.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/cosmo/setup

@@ -1,19 +1,19 @@
 #!/bin/sh
 set -e
 
-sudo apt-get update
+sudo apt update
 sudo apt-get install -y ca-certificates libssl-dev\
-    qemu-utils qemu-user-static\
+    qemu qemu-utils qemu-user-static\
     texinfo groff\
     cmake ninja-build bison zip\
     pkg-config build-essential autoconf re2c
 
 # download cosmocc
 cd /sc
-wget https://github.com/jart/cosmopolitan/releases/download/4.0.2/cosmocc-4.0.2.zip
+wget https://github.com/jart/cosmopolitan/releases/download/3.3.3/cosmocc-3.3.3.zip
 mkdir -p cosmocc
 cd cosmocc
-unzip ../cosmocc-4.0.2.zip
+unzip ../cosmocc-3.3.3.zip
 
 # register
 cd /sc/cosmocc

.github/workflows/release.yml

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

.github/workflows/test.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ ubuntu-latest, ubuntu-24.04-arm, macos-latest, macos-14, macos-15-intel ]
+        os: [ ubuntu-latest, macos-latest, macos-13 ]
     steps:
       - name: Checkout the repository
         uses: actions/checkout@master
@@ -21,20 +21,6 @@ jobs:
       - name: Test the project
         run: make test
 
-  test-posix-sanitizers:
-    name: Build and test on POSIX systems with sanitizers turned on
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ ubuntu-latest ]
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@master
-      - name: Compile the project
-        run: make clean && CFLAGS="-g -O2 -fsanitize=address,undefined" make
-      - name: Test the project
-        run: make test
-
   test-windows:
     name: Build and test on Windows
     strategy:
@@ -56,27 +42,6 @@ jobs:
         shell: cmd
         run: build_win dist
 
-  test-windows-sanitizers:
-    name: Build and test on Windows with sanitizers
-    strategy:
-      matrix:
-        os: [ windows-latest ]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@master
-      - name: Setup MSVC
-        uses: ilammy/msvc-dev-cmd@v1
-      - name: Build the project
-        shell: cmd
-        run: set SANITIZE=1 & build_win
-      - name: Test the project
-        shell: cmd
-        run: set VERBOSE=1 & build_win test
-      - name: Test installer build
-        shell: cmd
-        run: build_win dist
-
   test-windows-min:
     name: Build and test on Windows Minimal build
     strategy:
@@ -171,22 +136,3 @@ jobs:
       run: docker run --privileged --rm tonistiigi/binfmt --install s390x
     - name: Build and run on emulated architecture
       run: docker run --rm -v .:/janet --platform linux/s390x alpine sh -c "apk update && apk add --no-interactive git build-base && cd /janet && make -j3 && make test"
-
-  test-cosmo:
-    name: Test build for Cosmo
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@master
-      - name: create build folder
-        run: |
-          sudo mkdir -p /sc
-          sudo chmod -R 0777 /sc
-      - name: setup Cosmopolitan Libc
-        run: bash ./.github/cosmo/setup
-      - name: Set the version
-        run: echo "version=${GITHUB_REF/refs\/tags\//}" >> $GITHUB_ENV
-      - name: Set the platform
-        run: echo "platform=cosmo" >> $GITHUB_ENV
-      - name: build Janet APE binary
-        run: bash ./.github/cosmo/build

.gitignore

@@ -12,7 +12,6 @@ janet
 /src/include/generated/*.h
 janet-*.tar.gz
 dist
-/tmp
 
 # jpm lockfile
 lockfile.janet

CHANGELOG.md

@@ -2,54 +2,6 @@
 All notable changes to this project will be documented in this file.
 
 ## Unreleased - ???
-- Improve pretty printing layout for %M and %m modifiers to be more code-like.
-- Add filewatch support to BSD and macos.
-- Add linting support for shadowed bindings.
-- Add nanboxing support for Linux on ARM64 and turn on nanboxing by default on macos on ARM64 (aarch64).
-- Documentation fixes
-- ev/thread-chan deadlock bug fixed
-- Re-add removed support for non-blocking net/connect on windows with bug fixes.
-
-## 1.41.2 - 2026-02-18
-- Fix regressions in `put` for arrays and buffers.
-- Add `module/add-file-extension`
-- Add `module/add-syspath`
-- Fix issue with possible stack corrpution with abstract types that modify the current fiber.
-- Allow use of the interpreter and garbage collection inside module entry for native modules.
-
-## 1.41.1 - 2026-02-15
-- Revert to blocking behaior of `net/connect` on windows to fix spurious errors.
-- Allow overriding the loader when doing imports with the `:loader` argument.
-- Allow importing modules with a path extension to do what one would expect.
-- Add `find-all` argument to `module/find`
-- Add :threads, :unmarshal, :compiler, and :asm sandbox flags.
-- Add support for persistent REPL history with the environment variable `JANET_HISTFILE`
-- Fix a number of fuzzer-found compiler bugs
-- Fix windows processes launching bug with empty environment table that caused process-launch failures.
-- Add `:I`, `:V`, and `:N` flags to `os/open` for more control when creating streams.
-- Add `ev/go-gather` for a dynamic `ev/gather`.
-- Use color in script output if color is being used in REPL output.
-- Fix `varfn` macros handling of extra metadata.
-- Disallow certain degenerate uses of fibers with the ev/ module.
-- Add linting for unused bindings.
-- Add linting for extra or wrong parameters to &named functions.
-- 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`.
-- Add `*flychecking*` dynamic binding to check if inside flycheck evalutation
 - Add `gcperthread` callback for abstract types. This lets threaded abstracts have a finalizer that is called per thread, as well as a global finalizer.
 - Add `JANET_DO_ERROR_*` flags to describe the return value of `janet_dobytes` and `janet_dostring`.
 

CONTRIBUTING.md

@@ -37,12 +37,6 @@ may require changes before being merged.
   do this indentation, or approximate as close as possible. There is a janet formatter
   in [spork](https://github.com/janet-lang/spork.git) that can be used to format code as well.
 
-Bot pull requests will not be accepted, and anonymous submissions, including
-new accounts, unknown emails, and first time contributors will be subjected
-to greater scrutiny and code reivew. Automatically generated and filed bug
-reports MAY be ok, if they are of consistent and good quality, such as
-OSSFuzz or well constructed CI pipelines.
-
 ## C style
 
 For changes to the VM and Core code, you will probably need to know C. Janet is programmed with
@@ -67,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
@@ -96,18 +90,3 @@ timely manner. In short, if you want extra functionality now, then build it.
 
 * Include a good description of the problem that is being solved
 * Include descriptions of potential solutions if you have some in mind.
-
-## LLMs, Tool Usage, and Transparency
-
-All usage of Large Language Models (LLMs), Neural Networks, "AI" tools, and
-other tools such as software fuzzers or static analyzers must be disclosed.
-This applies to pull requests, email patches, bug reports, and any other
-meaningful contribution to Janet's source code. Please also refrain from using
-generative AI for code that will be embedded in the Janet runtime, which include
-all C source files as well as boot.janet. All code should be well
-and completely understood by the human author, including test cases. Large and
-obviously AI-driven changes will be rejected. Be mindful and transparent on the
-copyright implications of any submitted code. We will use discretion when
-accepting generated test cases for bug reproductions, one-line bug
-fixes, or typo fixes. Often, these can be trivially rewritten by a human to
-avoid the problem.

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
@@ -58,6 +58,7 @@ LDFLAGS?=-rdynamic
 LIBJANET_LDFLAGS?=$(LDFLAGS)
 RUN:=$(RUN)
 
+
 COMMON_CFLAGS:=-std=c99 -Wall -Wextra -Isrc/include -Isrc/conf -fvisibility=hidden -fPIC
 BOOT_CFLAGS:=-DJANET_BOOTSTRAP -DJANET_BUILD=$(JANET_BUILD) -O0 $(COMMON_CFLAGS) -g
 BUILD_CFLAGS:=$(CFLAGS) $(COMMON_CFLAGS)
@@ -219,9 +220,9 @@ build/%.bin.o: src/%.c $(JANET_HEADERS) $(JANET_LOCAL_HEADERS) Makefile
 ########################
 
 ifeq ($(UNAME), Darwin)
-SONAME=libjanet.1.41.dylib
+SONAME=libjanet.1.40.dylib
 else
-SONAME=libjanet.so.1.41
+SONAME=libjanet.so.1.40
 endif
 
 ifeq ($(MINGW_COMPILER), clang)
@@ -260,7 +261,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)
@@ -268,26 +268,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 #####
@@ -346,7 +341,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'
@@ -356,13 +350,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)'
@@ -419,6 +413,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'
@@ -430,8 +427,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'
@@ -441,9 +437,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

README.md

@@ -148,40 +148,8 @@ You can get the source on [GitHub](https://github.com/janet-lang/janet) or
 [SourceHut](https://git.sr.ht/~bakpakin/janet). While the GitHub repo is the official repo,
 the SourceHut mirror is actively maintained.
 
-## Spork and JPM
-
-Spork and JPM are two companion projects to Janet. They are optional, especially in an embedding use case.
-
-Spork is a collection of common utility modules, and several packaged scripts
-like `janet-format` for code formatting, `janet-netrepl` for a socket-based
-REPL, and `janet-pm` for a comprehensive Janet project manager tool. The
-modules in `spork` are less stable than the interfaces in core Janet, although
-we try to prevent breaking changes to existing modules, with a preference to
-add new modules and functions. Spork requires a C compiler to build and install
-various extenstion components such as miniz and JSON utilities. Many spork
-sub-modules, for example spork/path, are independent and can be manually
-vendored in programmer projects without fully installing spork.
-
-When install Spork, scripts will be installed to $JANET_PATH/bin/ on POSIX systems by default.
-This likely needs to be added to the path to use these scripts.
-
-JPM is the older, more opinionated, project manager tool, which has it's pros
-and cons. It does not require a C compiler to build and install, but is less
-flexible and is not receiving many changes and improvements going forward. It
-may also be harder to configure correctly on new systems. In that sense, it may
-be more stable.
-
-JPM will install to /usr/local/bin/ on posix systems by default, which may or
-may not be on your PATH.
-
 ## Building
 
-When building from source, for stability, please use the latest tagged release. For
-example, run `git checkout $(git describe --tags --abbrev=0)` after cloning but
-before building. For the latest development, build directly on the master
-branch. The master branch is not-necessarily stable as most Janet development
-happens directly on the master branch.
-
 ### macOS and Unix-like
 
 The Makefile is non-portable and requires GNU-flavored make.
@@ -192,18 +160,15 @@ make
 make test
 make repl
 make install
-make install-spork-git # optional
-make install-jpm-git # optional
+make install-jpm-git
 ```
 
 Find out more about the available make targets by running `make help`.
 
 ### Alpine Linux
 
-To build a statically-linked build of Janet, Alpine Linux + MUSL is a good
-combination. Janet can also be built inside a docker container or similar in
-this manner. This is a great way to try Janet without committing to a full
-install or needing to customize the default install.
+To build a statically-linked build of Janet, Alpine Linux + MUSL is a good combination. Janet can also
+be built inside a docker container or similar in this manner.
 
 ```sh
 docker run -it --rm alpine /bin/ash
@@ -213,13 +178,8 @@ $ cd janet
 $ make -j10
 $ make test
 $ make install
-$ make install-spork-git # optional
-$ make install-jpm-git # optional
 ```
 
-Note that for a true statically-linked binary with MUSL, one needs to add `-static` to the Makefile flags. This
-will also disable runtime loading of native modules (plugins) as well as the FFI.
-
 ### 32-bit Haiku
 
 32-bit Haiku build instructions are the same as the UNIX-like build instructions,
@@ -231,8 +191,7 @@ make CC=gcc-x86
 make test
 make repl
 make install
-make install-spork-git # optional
-make install-jpm-git # optional
+make install-jpm-git
 ```
 
 ### FreeBSD
@@ -246,8 +205,7 @@ gmake
 gmake test
 gmake repl
 gmake install
-gmake install-spork-git # optional
-gmake install-jpm-git # optional
+gmake install-jpm-git
 ```
 
 ### NetBSD
@@ -362,8 +320,8 @@ If installed, you can also run `man janet` to get usage information.
 ## Embedding
 
 Janet can be embedded in a host program very easily. The normal build
-will create a file `build/c/janet.c`, a C source code file that
-that contains the amalgamated source to Janet. This file, along with
+will create a file `build/janet.c`, which is a single C file
+that contains all the source to Janet. This file, along with
 `src/include/janet.h` and `src/conf/janetconf.h`, can be dragged into any C
 project and compiled into it. Janet should be compiled with `-std=c99`
 on most compilers, and will need to be linked to the math library, `-lm`, and

build_win.bat

@@ -23,17 +23,7 @@
 @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
 
-if DEFINED CLANG (
-    @set COMPILER=clang-cl.exe
-) else (
-    @set COMPILER=cl.exe
-)
-if DEFINED SANITIZE (
-    @set "SANITIZERS=/fsanitize=address"
-) else (
-    @set "SANITIZERS="
-)
-@set JANET_COMPILE=%COMPILER% /nologo /Isrc\include /Isrc\conf /c /O2 /W3 /D_CRT_SECURE_NO_WARNINGS /MD %SANITIZERS%
+@set JANET_COMPILE=cl /nologo /Isrc\include /Isrc\conf /c /O2 /W3 /D_CRT_SECURE_NO_WARNINGS /MD
 @set JANET_LINK=link /nologo
 
 @set JANET_LINK_STATIC=lib /nologo
@@ -59,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/chatserver.janet

@@ -26,7 +26,7 @@
           (broadcast name (string msg)))
         (print name " disconnected")))))
 
-(defn main [&]
+(defn main [& args]
   (printf "STARTING SERVER...")
   (flush)
   (def my-server (net/listen "127.0.0.1" "8000"))

examples/debugger.janet

@@ -132,7 +132,7 @@
   "Go to the next breakpoint."
   [&opt n]
   (var res nil)
-  (repeat (or n 1)
+  (for i 0 (or n 1)
     (set res (resume (.fiber))))
   res)
 
@@ -146,6 +146,6 @@
   "Execute the next n instructions."
   [&opt n]
   (var res nil)
-  (repeat (or n 1)
+  (for i 0 (or n 1)
     (set res (debug/step (.fiber))))
   res)

examples/error.janet

@@ -3,10 +3,10 @@
 
 (defn bork [x]
 
-  (defn bark [y]
+  (defn bark [x]
     (print "Woof!")
-    (print y)
-    (error y)
+    (print x)
+    (error x)
     (print "Woof!"))
 
   (bark (* 2 x))

examples/filewatch.janet

@@ -1,14 +0,0 @@
-###
-### example/filewatch.janet ...files
-###
-### Watch for all changes in a list of files and directories. Behavior
-### depends on the filewatch module, and different operating systems will
-### report different events.
-
-(def chan (ev/chan 1000))
-(def fw (filewatch/new chan))
-(each arg (drop 1 (dyn *args* []))
-    (filewatch/add fw arg :all))
-(filewatch/listen fw)
-
-(forever (let [event (ev/take chan)] (pp event)))

examples/iterate-fiber.janet

@@ -7,13 +7,13 @@
 (print "simple yielding")
 (each item f (print "got: " item ", now " (fiber/status f)))
 
-(def f2
+(def f
   (coro
     (for i 0 10
       (yield (string "yield " i))
       (ev/sleep 0))))
 
 (print "complex yielding")
-(each item f2 (print "got: " item ", now " (fiber/status f2)))
+(each item f (print "got: " item ", now " (fiber/status f)))
 
-(print (fiber/status f2))
+(print (fiber/status f))

examples/lazyseqs.janet

@@ -4,7 +4,7 @@
 # that must be called (realizing it), and the memoized.
 # Use with (import "./path/to/this/file" :prefix "seq.")
 
-(defmacro dolazy
+(defmacro delay
   "Lazily evaluate a series of expressions. Returns a function that
   returns the result of the last expression. Will only evaluate the
   body once, and then memoizes the result."
@@ -35,7 +35,7 @@
   (def x (tuple h t))
   (fn [] x))
 
-(defn lazy-empty?
+(defn empty?
   "Check if a sequence is empty."
   [s]
   (not (s)))
@@ -55,14 +55,14 @@
   [start end &]
   (if end
     (if (< start end)
-      (dolazy (tuple start (lazy-range (+ 1 start) end)))
+      (delay (tuple start (lazy-range (+ 1 start) end)))
       empty-seq)
     (lazy-range 0 start)))
 
 (defn lazy-map
   "Return a sequence that is the result of applying f to each value in s."
   [f s]
-  (dolazy
+  (delay
     (def x (s))
     (if x (tuple (f (get x HEAD)) (map f (get x TAIL))))))
 
@@ -76,31 +76,31 @@
   [f s]
   (when (s) (f (head s)) (realize-map f (tail s))))
 
-(defn lazy-drop
+(defn drop
   "Ignores the first n values of the sequence and returns the rest."
   [n s]
-  (dolazy
+  (delay
     (def x (s))
-    (if (and x (pos? n)) ((lazy-drop (- n 1) (get x TAIL))))))
+    (if (and x (pos? n)) ((drop (- n 1) (get x TAIL))))))
 
-(defn lazy-take
+(defn take
   "Returns at most the first n values of s."
   [n s]
-  (dolazy
+  (delay
     (def x (s))
     (if (and x (pos? n))
-      (tuple (get x HEAD) (lazy-take (- n 1) (get x TAIL))))))
+      (tuple (get x HEAD) (take (- n 1) (get x TAIL))))))
 
 (defn randseq
   "Return a sequence of random numbers."
   []
-  (dolazy (tuple (math/random) (randseq))))
+  (delay (tuple (math/random) (randseq))))
 
-(defn lazy-take-while
+(defn take-while
   "Returns a sequence of values until the predicate is false."
   [pred s]
-  (dolazy
+  (delay
     (def x (s))
     (when x
       (def thehead (get HEAD x))
-      (if thehead (tuple thehead (lazy-take-while pred (get TAIL x)))))))
+      (if thehead (tuple thehead (take-while pred (get TAIL x)))))))

examples/life.janet

@@ -16,8 +16,8 @@
   (def cell-set (frequencies state))
   (def neighbor-set (frequencies (mapcat neighbors state)))
   (seq [coord :keys neighbor-set
-         :let [ncount (get neighbor-set coord)]
-         :when (or (= ncount 3) (and (get cell-set coord) (= ncount 2)))]
+         :let [count (get neighbor-set coord)]
+         :when (or (= count 3) (and (get cell-set coord) (= count 2)))]
       coord))
 
 (defn draw

examples/rtest.janet

@@ -2,7 +2,7 @@
 
 (def counts (seq [_ :range [0 100]] 0))
 
-(repeat 1000000
+(for i 0 1000000
   (let [x (math/random)
         intrange (math/floor (* 100 x))
         oldcount (counts intrange)]

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/threaded-channels.janet

@@ -7,7 +7,7 @@
   (ev/give chan (math/random))
   (ev/give chan (math/random))
   (ev/sleep 0.5)
-  (repeat 10
+  (for i 0 10
     (print "giving to channel...")
     (ev/give chan (math/random))
     (ev/sleep 1))

janet.1

@@ -156,7 +156,7 @@ Shows the version text and exits immediately.
 
 .TP
 .BR \-s
-Read raw input from stdin and forgo fancy input, which includes prompt history and other readline-like features.
+Read raw input from stdin and forgo prompt history and other readline-like features.
 
 .TP
 .BR \-e\ code
@@ -272,12 +272,6 @@ This variable does nothing in the default configuration of Janet, as PRF is disa
 cannot be defined for this variable to have an effect.
 .RE
 
-.B JANET_HISTFILE
-.RS
-A file location to use for the default shell's REPL history when using fancy input. This relative path is where commands are persisted between sessions.
-If unset, no repl history well be used. Does not work with the -s flag where fancy input is disabled.
-.RE
-
 .B NO_COLOR
 .RS
 Turn off color by default in the repl and in the error handler of scripts. This can be changed at runtime

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.41.3')
+  version : '1.40.0')
 
 # Global settings
 janet_path = join_paths(get_option('prefix'), get_option('libdir'), 'janet')
@@ -72,9 +72,6 @@ conf.set_quoted('JANET_VERSION', meson.project_version())
 # Use options
 conf.set_quoted('JANET_BUILD', get_option('git_hash'))
 conf.set('JANET_NO_NANBOX', not get_option('nanbox'))
-if get_option('nanbox_pointer_shift') != -1 # -1 is auto-detect
-  conf.set('JANET_NANBOX_64_POINTER_SHIFT', get_option('nanbox_pointer_shift'))
-endif
 conf.set('JANET_SINGLE_THREADED', get_option('single_threaded'))
 conf.set('JANET_NO_DYNAMIC_MODULES', not get_option('dynamic_modules'))
 conf.set('JANET_NO_DOCSTRINGS', not get_option('docstrings'))
@@ -291,7 +288,6 @@ test_files = [
   'test/suite-io.janet',
   'test/suite-marsh.janet',
   'test/suite-math.janet',
-  'test/suite-net.janet',
   'test/suite-os.janet',
   'test/suite-parse.janet',
   'test/suite-peg.janet',

meson_options.txt

@@ -2,7 +2,6 @@ option('git_hash', type : 'string', value : 'meson')
 
 option('single_threaded', type : 'boolean', value : false)
 option('nanbox', type : 'boolean', value : true)
-option('nanbox_pointer_shift', type : 'integer', min : -1, max : 4, value : -1)
 option('dynamic_modules', type : 'boolean', value : true)
 option('docstrings', type : 'boolean', value : true)
 option('sourcemaps', type : 'boolean', value : true)

plan9.mk

@@ -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/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
@@ -37,7 +37,7 @@ int system_test() {
 
     /* Check the version defines are self consistent */
     char version_combined[256];
-    snprintf(version_combined, sizeof(version_combined), "%d.%d.%d%s", JANET_VERSION_MAJOR, JANET_VERSION_MINOR, JANET_VERSION_PATCH, JANET_VERSION_EXTRA);
+    sprintf(version_combined, "%d.%d.%d%s", JANET_VERSION_MAJOR, JANET_VERSION_MINOR, JANET_VERSION_PATCH, JANET_VERSION_EXTRA);
     assert(!strcmp(JANET_VERSION, version_combined));
 
     /* Reflexive testing and nanbox testing */
@@ -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

@@ -4,10 +4,10 @@
 #define JANETCONF_H
 
 #define JANET_VERSION_MAJOR 1
-#define JANET_VERSION_MINOR 41
-#define JANET_VERSION_PATCH 3
-#define JANET_VERSION_EXTRA "-dev"
-#define JANET_VERSION "1.41.3-dev"
+#define JANET_VERSION_MINOR 40
+#define JANET_VERSION_PATCH 0
+#define JANET_VERSION_EXTRA ""
+#define JANET_VERSION "1.40.0"
 
 /* #define JANET_BUILD "local" */
 
@@ -16,7 +16,6 @@
 /* #define JANET_THREAD_LOCAL _Thread_local */
 /* #define JANET_NO_DYNAMIC_MODULES */
 /* #define JANET_NO_NANBOX */
-/* #define JANET_NANBOX_64_POINTER_SHIFT 0 */
 /* #define JANET_API __attribute__((visibility ("default"))) */
 
 /* These settings should be specified before amalgamation is

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
@@ -88,7 +88,7 @@ void *janet_abstract_threaded(const JanetAbstractType *atype, size_t size) {
 #ifdef JANET_WINDOWS
 
 size_t janet_os_mutex_size(void) {
-    return sizeof(CRITICAL_SECTION);
+    return sizeof(SRWLOCK);
 }
 
 size_t janet_os_rwlock_size(void) {
@@ -96,20 +96,20 @@ size_t janet_os_rwlock_size(void) {
 }
 
 void janet_os_mutex_init(JanetOSMutex *mutex) {
-    InitializeCriticalSection((CRITICAL_SECTION *) mutex);
+    InitializeSRWLock((PSRWLOCK) mutex);
 }
 
 void janet_os_mutex_deinit(JanetOSMutex *mutex) {
-    DeleteCriticalSection((CRITICAL_SECTION *) mutex);
+    /* no op? */
+    (void) mutex;
 }
 
 void janet_os_mutex_lock(JanetOSMutex *mutex) {
-    EnterCriticalSection((CRITICAL_SECTION *) mutex);
+    AcquireSRWLockExclusive((PSRWLOCK) mutex);
 }
 
 void janet_os_mutex_unlock(JanetOSMutex *mutex) {
-    /* error handling? May want to keep counter */
-    LeaveCriticalSection((CRITICAL_SECTION *) mutex);
+    ReleaseSRWLockExclusive((PSRWLOCK) mutex);
 }
 
 void janet_os_rwlock_init(JanetOSRWLock *rwlock) {
@@ -201,17 +201,4 @@ int32_t janet_abstract_decref(void *abst) {
     return janet_atomic_dec(&janet_abstract_head(abst)->gc.data.refcount);
 }
 
-int32_t janet_abstract_decref_maybe_free(void *abst) {
-    int32_t result = janet_abstract_decref(abst);
-    if (0 == result) {
-        JanetAbstractHead *head = janet_abstract_head(abst);
-        if (head->type->gc) {
-            janet_assert(!head->type->gc(head->data, head->size), "finalizer failed");
-        }
-        /* Free memory */
-        janet_free(head);
-    }
-    return result;
-}
-
 #endif

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
@@ -567,13 +567,6 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
     x = janet_get1(s, janet_ckeywordv("structarg"));
     if (janet_truthy(x)) def->flags |= JANET_FUNCDEF_FLAG_STRUCTARG;
 
-    /* Check namedarg */
-    x = janet_get1(s, janet_ckeywordv("namedargs"));
-    if (janet_checkint(x)) {
-        def->flags |= JANET_FUNCDEF_FLAG_NAMEDARGS;
-        def->named_args_count = janet_unwrap_integer(x);
-    }
-
     /* Check source */
     x = janet_get1(s, janet_ckeywordv("source"));
     if (janet_checktype(x, JANET_STRING)) def->source = janet_unwrap_string(x);
@@ -989,14 +982,6 @@ static Janet janet_disasm_structarg(JanetFuncDef *def) {
     return janet_wrap_boolean(def->flags & JANET_FUNCDEF_FLAG_STRUCTARG);
 }
 
-static Janet janet_disasm_namedargs(JanetFuncDef *def) {
-    if (def->flags & JANET_FUNCDEF_FLAG_NAMEDARGS) {
-        return janet_wrap_integer(def->named_args_count);
-    } else {
-        return janet_wrap_nil();
-    }
-}
-
 static Janet janet_disasm_constants(JanetFuncDef *def) {
     JanetArray *constants = janet_array(def->constants_length);
     for (int32_t i = 0; i < def->constants_length; i++) {
@@ -1047,7 +1032,6 @@ Janet janet_disasm(JanetFuncDef *def) {
     janet_table_put(ret, janet_ckeywordv("source"), janet_disasm_source(def));
     janet_table_put(ret, janet_ckeywordv("vararg"), janet_disasm_vararg(def));
     janet_table_put(ret, janet_ckeywordv("structarg"), janet_disasm_structarg(def));
-    janet_table_put(ret, janet_ckeywordv("namedargs"), janet_disasm_namedargs(def));
     janet_table_put(ret, janet_ckeywordv("name"), janet_disasm_name(def));
     janet_table_put(ret, janet_ckeywordv("slotcount"), janet_disasm_slotcount(def));
     janet_table_put(ret, janet_ckeywordv("symbolmap"), janet_disasm_symbolslots(def));
@@ -1064,7 +1048,6 @@ JANET_CORE_FN(cfun_asm,
               "The syntax for the assembly can be found on the Janet website, and should correspond\n"
               "to the return value of disasm. Will throw an\n"
               "error on invalid assembly.") {
-    janet_sandbox_assert(JANET_SANDBOX_ASM);
     janet_fixarity(argc, 1);
     JanetAssembleResult res;
     res = janet_asm(argv[0], 0);
@@ -1084,8 +1067,6 @@ JANET_CORE_FN(cfun_disasm,
               "* :min-arity - minimum number of arguments function can be called with.\n"
               "* :max-arity - maximum number of arguments function can be called with.\n"
               "* :vararg - true if function can take a variable number of arguments.\n"
-              "* :structarg - true if function can take a variable number of arguments using the &keys option.\n"
-              "* :namedargs - if function can take a variable number of arguments using the &named option, this will be the number of named arguments.\n"
               "* :bytecode - array of parsed bytecode instructions. Each instruction is a tuple.\n"
               "* :source - name of source file that this function was compiled from.\n"
               "* :name - name of function.\n"
@@ -1095,7 +1076,6 @@ JANET_CORE_FN(cfun_disasm,
               "* :sourcemap - a mapping of each bytecode instruction to a line and column in the source file.\n"
               "* :environments - an internal mapping of which enclosing functions are referenced for bindings.\n"
               "* :defs - other function definitions that this function may instantiate.\n") {
-    janet_sandbox_assert(JANET_SANDBOX_ASM);
     janet_arity(argc, 1, 2);
     JanetFunction *f = janet_getfunction(argv, 0);
     if (argc == 2) {
@@ -1108,9 +1088,7 @@ JANET_CORE_FN(cfun_disasm,
         if (!janet_cstrcmp(kw, "name")) return janet_disasm_name(f->def);
         if (!janet_cstrcmp(kw, "vararg")) return janet_disasm_vararg(f->def);
         if (!janet_cstrcmp(kw, "structarg")) return janet_disasm_structarg(f->def);
-        if (!janet_cstrcmp(kw, "namedargs")) return janet_disasm_namedargs(f->def);
         if (!janet_cstrcmp(kw, "slotcount")) return janet_disasm_slotcount(f->def);
-        if (!janet_cstrcmp(kw, "symbolmap")) return janet_disasm_symbolslots(f->def);
         if (!janet_cstrcmp(kw, "constants")) return janet_disasm_constants(f->def);
         if (!janet_cstrcmp(kw, "sourcemap")) return janet_disasm_sourcemap(f->def);
         if (!janet_cstrcmp(kw, "environments")) return janet_disasm_environments(f->def);

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
@@ -74,7 +74,6 @@ JanetBuffer *janet_pointer_buffer_unsafe(void *memory, int32_t capacity, int32_t
 void janet_buffer_deinit(JanetBuffer *buffer) {
     if (!(buffer->gc.flags & JANET_BUFFER_FLAG_NO_REALLOC)) {
         janet_free(buffer->data);
-        buffer->data = NULL;
     }
 }
 

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
@@ -29,7 +29,7 @@
 #endif
 
 /* Look up table for instructions */
-const enum JanetInstructionType janet_instructions[JOP_INSTRUCTION_COUNT] = {
+enum JanetInstructionType janet_instructions[JOP_INSTRUCTION_COUNT] = {
     JINT_0, /* JOP_NOOP, */
     JINT_S, /* JOP_ERROR, */
     JINT_ST, /* JOP_TYPECHECK, */
@@ -522,7 +522,6 @@ JanetFuncDef *janet_funcdef_alloc(void) {
     def->bytecode_length = 0;
     def->environments_length = 0;
     def->symbolmap_length = 0;
-    def->named_args_count = 0;
     return def;
 }
 

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
@@ -460,7 +460,7 @@ Janet janet_dyn(const char *name) {
         return janet_table_get(janet_vm.top_dyns, janet_ckeywordv(name));
     }
     if (janet_vm.fiber->env) {
-        return janet_table_get_keyword(janet_vm.fiber->env, name);
+        return janet_table_get(janet_vm.fiber->env, janet_ckeywordv(name));
     } else {
         return janet_wrap_nil();
     }
@@ -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
@@ -201,29 +201,14 @@ static JanetSlot do_cmp(JanetFopts opts, JanetSlot *args) {
     return opreduce(opts, args, JOP_COMPARE, 0, janet_wrap_nil(), janet_wrap_nil());
 }
 static JanetSlot do_put(JanetFopts opts, JanetSlot *args) {
-    int8_t inline_index = 0;
-    if (can_slot_be_imm(args[1], &inline_index)) {
-        /* Use JOP_PUT_INDEX */
-        if (opts.flags & JANET_FOPTS_DROP) {
-            janetc_emit_ssi(opts.compiler, JOP_PUT_INDEX, args[0], args[2], inline_index, 0);
-            return janetc_cslot(janet_wrap_nil());
-        } else {
-            JanetSlot t = janetc_gettarget(opts);
-            janetc_copy(opts.compiler, t, args[0]);
-            janetc_emit_ssi(opts.compiler, JOP_PUT_INDEX, t, args[2], inline_index, 0);
-            return t;
-        }
+    if (opts.flags & JANET_FOPTS_DROP) {
+        janetc_emit_sss(opts.compiler, JOP_PUT, args[0], args[1], args[2], 0);
+        return janetc_cslot(janet_wrap_nil());
     } else {
-        /* Use JOP_PUT */
-        if (opts.flags & JANET_FOPTS_DROP) {
-            janetc_emit_sss(opts.compiler, JOP_PUT, args[0], args[1], args[2], 0);
-            return janetc_cslot(janet_wrap_nil());
-        } else {
-            JanetSlot t = janetc_gettarget(opts);
-            janetc_copy(opts.compiler, t, args[0]);
-            janetc_emit_sss(opts.compiler, JOP_PUT, t, args[1], args[2], 0);
-            return t;
-        }
+        JanetSlot t = janetc_gettarget(opts);
+        janetc_copy(opts.compiler, t, args[0]);
+        janetc_emit_sss(opts.compiler, JOP_PUT, t, args[1], args[2], 0);
+        return t;
     }
 }
 static JanetSlot do_length(JanetFopts opts, JanetSlot *args) {

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
@@ -91,38 +91,13 @@ void janetc_freeslot(JanetCompiler *c, JanetSlot s) {
 }
 
 /* Add a slot to a scope with a symbol associated with it (def or var). */
-void janetc_nameslot(JanetCompiler *c, const uint8_t *sym, JanetSlot s, uint32_t flags) {
-    if (!(flags & JANET_DEFFLAG_NO_SHADOWCHECK)) {
-        if (sym[0] != '_') {
-            switch (janetc_shadowcheck(c, sym)) {
-                default:
-                    break;
-                case JANETC_SHADOW_MACRO:
-                    janetc_lintf(c, JANET_C_LINT_NORMAL, "binding %q is shadowing a macro", janet_wrap_symbol(sym));
-                    break;
-                case JANETC_SHADOW_LOCAL_HIDES_LOCAL:
-                    janetc_lintf(c, JANET_C_LINT_STRICT, "binding %q is shadowing a binding", janet_wrap_symbol(sym));
-                    break;
-                case JANETC_SHADOW_LOCAL_HIDES_GLOBAL:
-                    janetc_lintf(c, JANET_C_LINT_STRICT, "binding %q is shadowing a top-level binding", janet_wrap_symbol(sym));
-                    break;
-                case JANETC_SHADOW_GLOBAL_HIDES_GLOBAL:
-                    janetc_lintf(c, JANET_C_LINT_STRICT, "top-level binding %q is shadowing another top-level binding", janet_wrap_symbol(sym));
-                    break;
-            }
-        }
-    }
+void janetc_nameslot(JanetCompiler *c, const uint8_t *sym, JanetSlot s) {
     SymPair sp;
     int32_t cnt = janet_v_count(c->buffer);
     sp.sym = sym;
     sp.sym2 = sym;
     sp.slot = s;
     sp.keep = 0;
-    if (flags & JANET_DEFFLAG_NO_UNUSED) {
-        sp.referenced = 1;
-    } else {
-        sp.referenced = sym[0] == '_'; /* Fake ref if symbol starts with _ to avoid lints */
-    }
     sp.slot.flags |= JANET_SLOT_NAMED;
     sp.birth_pc = cnt ? cnt - 1 : 0;
     sp.death_pc = UINT32_MAX;
@@ -195,10 +170,6 @@ void janetc_popscope(JanetCompiler *c) {
         /* Keep upvalue slots and symbols for debugging. */
         for (int32_t i = 0; i < janet_v_count(oldscope->syms); i++) {
             SymPair pair = oldscope->syms[i];
-            /* Check for unused symbols */
-            if (pair.referenced == 0 && pair.sym) {
-                janetc_lintf(c, JANET_C_LINT_STRICT, "binding %q is unused", janet_wrap_symbol(pair.sym));
-            }
             /* The variable should not be lexically accessible */
             pair.sym = NULL;
             if (pair.death_pc == UINT32_MAX) {
@@ -269,38 +240,6 @@ static int lookup_missing(
     return 1;
 }
 
-/* Check if a binding is defined in an upper scope. This lets us check for
- * variable shadowing. */
-Shadowing janetc_shadowcheck(JanetCompiler *c, const uint8_t *sym) {
-    /* Check locals */
-    JanetScope *scope = c->scope;
-    int is_global = (scope->flags & JANET_SCOPE_TOP);
-    while (scope) {
-        int32_t len = janet_v_count(scope->syms);
-        for (int32_t i = len - 1; i >= 0; i--) {
-            SymPair *pair = scope->syms + i;
-            if (pair->sym == sym) {
-                janet_assert(!is_global, "shadowing analysis is incorrect. compiler bug");
-                return JANETC_SHADOW_LOCAL_HIDES_LOCAL;
-            }
-        }
-        scope = scope->parent;
-    }
-    /* Check globals */
-    JanetBinding binding = janet_resolve_ext(c->env, sym);
-    if (binding.type == JANET_BINDING_MACRO || binding.type == JANET_BINDING_DYNAMIC_MACRO) {
-        return JANETC_SHADOW_MACRO;
-    } else if (binding.type == JANET_BINDING_NONE) {
-        return JANETC_SHADOW_NONE;
-    } else {
-        if (is_global) {
-            return JANETC_SHADOW_GLOBAL_HIDES_GLOBAL;
-        } else {
-            return JANETC_SHADOW_LOCAL_HIDES_GLOBAL;
-        }
-    }
-}
-
 /* Allow searching for symbols. Return information about the symbol */
 JanetSlot janetc_resolve(
     JanetCompiler *c,
@@ -323,7 +262,6 @@ JanetSlot janetc_resolve(
             pair = scope->syms + i;
             if (pair->sym == sym) {
                 ret = pair->slot;
-                pair->referenced = 1;
                 goto found;
             }
         }
@@ -336,7 +274,7 @@ JanetSlot janetc_resolve(
     {
         JanetBinding binding = janet_resolve_ext(c->env, sym);
         if (binding.type == JANET_BINDING_NONE) {
-            Janet handler = janet_table_get_keyword(c->env, "missing-symbol");
+            Janet handler = janet_table_get(c->env, janet_ckeywordv("missing-symbol"));
             switch (janet_type(handler)) {
                 case JANET_NIL:
                     break;
@@ -408,7 +346,6 @@ found:
     /* non-local scope needs to expose its environment */
     JanetScope *original_scope = scope;
     pair->keep = 1;
-    pair->referenced = 1;
     while (scope && !(scope->flags & JANET_SCOPE_FUNCTION))
         scope = scope->parent;
     janet_assert(scope, "invalid scopes");
@@ -500,22 +437,11 @@ JanetSlot *janetc_toslotskv(JanetCompiler *c, Janet ds) {
     const JanetKV *kvs = NULL;
     int32_t cap = 0, len = 0;
     janet_dictionary_view(ds, &kvs, &len, &cap);
-    /* Sort keys for stability of order? */
-    int32_t *index_buf;
-    int32_t index_buf_stack[32];
-    int32_t *index_buf_heap = NULL;
-    if (len < 32) {
-        index_buf = index_buf_stack;
-    } else {
-        index_buf_heap = janet_smalloc(sizeof(int32_t) * len);
-        index_buf = index_buf_heap;
+    for (int32_t i = 0; i < cap; i++) {
+        if (janet_checktype(kvs[i].key, JANET_NIL)) continue;
+        janet_v_push(ret, janetc_value(subopts, kvs[i].key));
+        janet_v_push(ret, janetc_value(subopts, kvs[i].value));
     }
-    if (len) janet_sorted_keys(kvs, cap, index_buf);
-    for (int32_t i = 0; i < len; i++) {
-        janet_v_push(ret, janetc_value(subopts, kvs[index_buf[i]].key));
-        janet_v_push(ret, janetc_value(subopts, kvs[index_buf[i]].value));
-    }
-    if (index_buf_heap) janet_sfree(index_buf_heap);
     return ret;
 }
 
@@ -588,9 +514,9 @@ void janetc_throwaway(JanetFopts opts, Janet x) {
     JanetScope unusedScope;
     int32_t bufstart = janet_v_count(c->buffer);
     int32_t mapbufstart = janet_v_count(c->mapbuffer);
-    janetc_scope(&unusedScope, c, JANET_SCOPE_UNUSED, "unused");
+    janetc_scope(&unusedScope, c, JANET_SCOPE_UNUSED, "unusued");
     janetc_value(opts, x);
-    janetc_lintf(c, JANET_C_LINT_STRICT, "dead code, consider removing %.4q", x);
+    janetc_lintf(c, JANET_C_LINT_STRICT, "dead code, consider removing %.2q", x);
     janetc_popscope(c);
     if (c->buffer) {
         janet_v__cnt(c->buffer) = bufstart;
@@ -600,7 +526,7 @@ void janetc_throwaway(JanetFopts opts, Janet x) {
 }
 
 /* Compile a call or tailcall instruction */
-static JanetSlot janetc_call(JanetFopts opts, JanetSlot *slots, JanetSlot fun, const Janet *form) {
+static JanetSlot janetc_call(JanetFopts opts, JanetSlot *slots, JanetSlot fun) {
     JanetSlot retslot;
     JanetCompiler *c = opts.compiler;
     int specialized = 0;
@@ -626,8 +552,6 @@ static JanetSlot janetc_call(JanetFopts opts, JanetSlot *slots, JanetSlot fun, c
                     JanetFunction *f = janet_unwrap_function(fun.constant);
                     int32_t min = f->def->min_arity;
                     int32_t max = f->def->max_arity;
-                    int structarg = f->def->flags & JANET_FUNCDEF_FLAG_STRUCTARG;
-                    int namedarg = f->def->flags & JANET_FUNCDEF_FLAG_NAMEDARGS;
                     if (min_arity < 0) {
                         /* Call has splices */
                         min_arity = -1 - min_arity;
@@ -651,47 +575,6 @@ static JanetSlot janetc_call(JanetFopts opts, JanetSlot *slots, JanetSlot fun, c
                                                     fun.constant, min, min == 1 ? "" : "s", min_arity);
                             janetc_error(c, es);
                         }
-                        if (structarg && (min_arity > f->def->arity) && ((min_arity - f->def->arity) & 1)) {
-                            /* If we have an odd number of variadic arguments to a `&keys` function, that is almost certainly wrong. */
-                            if (namedarg) {
-                                janetc_lintf(c, JANET_C_LINT_NORMAL,
-                                             "odd number of named arguments to `&named` function %v", fun.constant);
-                            } else {
-                                janetc_lintf(c, JANET_C_LINT_NORMAL,
-                                             "odd number of named arguments to `&keys` function %v", fun.constant);
-                            }
-                        }
-                        if (namedarg && f->def->named_args_count > 0) {
-                            /* For each argument passed in, check if it is one of the used named arguments
-                             * by checking the list defined in the function def. If not, raise a normal compiler
-                             * lint. We can also do a strict lint for _missing_ named arguments, although in many
-                             * cases those are assumed to have some kind of default, or we have dynamic keys. */
-                            int32_t first_arg_key_index = f->def->arity + 1;
-                            for (int32_t i = first_arg_key_index; i < janet_tuple_length(form); i += 2) {
-                                Janet argkey = form[i];
-                                /* Assumption: The first N constants of a function are its named argument keys. This
-                                 * may change if the compiler changes, but is true for all Janet generated functions. */
-                                int found = 0;
-                                if (janet_checktype(argkey, JANET_KEYWORD)) {
-                                    for (int32_t j = 0; j < f->def->named_args_count && j < f->def->constants_length; j++) {
-                                        if (janet_equals(argkey, f->def->constants[j])) {
-                                            found = 1;
-                                            break;
-                                        }
-                                    }
-                                } else if (janet_checktype(argkey, JANET_TUPLE)) {
-                                    /* Possible lint : too dynamic, be dumber
-                                     * (defn f [&named x] [x])
-                                     * (f (if (coin-flip) :x :w) 10)
-                                     * A tuple could be a function call the evaluates to a valid key */
-                                    found = 1;
-                                }
-                                if (!found) {
-                                    janetc_lintf(c, JANET_C_LINT_NORMAL,
-                                                 "unused named argument %v to function %v", argkey, fun.constant);
-                                }
-                            }
-                        }
                     }
                 }
                 break;
@@ -926,16 +809,14 @@ JanetSlot janetc_value(JanetFopts opts, Janet x) {
                 } else if (janet_tuple_flag(tup) & JANET_TUPLE_FLAG_BRACKETCTOR) { /* [] tuples are not function call */
                     ret = janetc_tuple(opts, x);
                 } else {
-                    /* Function calls */
                     JanetSlot head = janetc_value(subopts, tup[0]);
                     subopts.flags = JANET_FUNCTION | JANET_CFUNCTION;
-                    ret = janetc_call(opts, janetc_toslots(c, tup + 1, janet_tuple_length(tup) - 1), head, tup);
+                    ret = janetc_call(opts, janetc_toslots(c, tup + 1, janet_tuple_length(tup) - 1), head);
                     janetc_freeslot(c, head);
                 }
                 ret.flags &= ~JANET_SLOT_SPLICED;
             }
             break;
-            /* Data Constructors */
             case JANET_SYMBOL:
                 ret = janetc_resolve(c, janet_unwrap_symbol(x));
                 break;
@@ -975,21 +856,19 @@ void janet_def_addflags(JanetFuncDef *def) {
     int32_t set_flags = 0;
     int32_t unset_flags = 0;
     /* pos checks */
-    if (def->name)              set_flags |= JANET_FUNCDEF_FLAG_HASNAME;
-    if (def->source)            set_flags |= JANET_FUNCDEF_FLAG_HASSOURCE;
-    if (def->defs)              set_flags |= JANET_FUNCDEF_FLAG_HASDEFS;
-    if (def->environments)      set_flags |= JANET_FUNCDEF_FLAG_HASENVS;
-    if (def->sourcemap)         set_flags |= JANET_FUNCDEF_FLAG_HASSOURCEMAP;
-    if (def->closure_bitset)    set_flags |= JANET_FUNCDEF_FLAG_HASCLOBITSET;
-    if (def->named_args_count)  set_flags |= JANET_FUNCDEF_FLAG_NAMEDARGS;
+    if (def->name)            set_flags |= JANET_FUNCDEF_FLAG_HASNAME;
+    if (def->source)          set_flags |= JANET_FUNCDEF_FLAG_HASSOURCE;
+    if (def->defs)            set_flags |= JANET_FUNCDEF_FLAG_HASDEFS;
+    if (def->environments)    set_flags |= JANET_FUNCDEF_FLAG_HASENVS;
+    if (def->sourcemap)       set_flags |= JANET_FUNCDEF_FLAG_HASSOURCEMAP;
+    if (def->closure_bitset)  set_flags |= JANET_FUNCDEF_FLAG_HASCLOBITSET;
     /* negative checks */
-    if (!def->name)             unset_flags |= JANET_FUNCDEF_FLAG_HASNAME;
-    if (!def->source)           unset_flags |= JANET_FUNCDEF_FLAG_HASSOURCE;
-    if (!def->defs)             unset_flags |= JANET_FUNCDEF_FLAG_HASDEFS;
-    if (!def->environments)     unset_flags |= JANET_FUNCDEF_FLAG_HASENVS;
-    if (!def->sourcemap)        unset_flags |= JANET_FUNCDEF_FLAG_HASSOURCEMAP;
-    if (!def->closure_bitset)   unset_flags |= JANET_FUNCDEF_FLAG_HASCLOBITSET;
-    if (!def->named_args_count) unset_flags |= JANET_FUNCDEF_FLAG_NAMEDARGS;
+    if (!def->name)           unset_flags |= JANET_FUNCDEF_FLAG_HASNAME;
+    if (!def->source)         unset_flags |= JANET_FUNCDEF_FLAG_HASSOURCE;
+    if (!def->defs)           unset_flags |= JANET_FUNCDEF_FLAG_HASDEFS;
+    if (!def->environments)   unset_flags |= JANET_FUNCDEF_FLAG_HASENVS;
+    if (!def->sourcemap)      unset_flags |= JANET_FUNCDEF_FLAG_HASSOURCEMAP;
+    if (!def->closure_bitset) unset_flags |= JANET_FUNCDEF_FLAG_HASCLOBITSET;
     /* Update flags */
     def->flags |= set_flags;
     def->flags &= ~unset_flags;
@@ -1060,9 +939,8 @@ JanetFuncDef *janetc_pop_funcdef(JanetCompiler *c) {
             JANET_OUT_OF_MEMORY;
         }
         memcpy(chunks, scope->ua.chunks, sizeof(uint32_t) * numchunks);
-        /* fprintf(stderr, "slot chunks: %d, scope->ua.count: %d, numchunks: %d\n", slotchunks, scope->ua.count, numchunks); */
         /* Register allocator preallocates some registers [240-255, high 16 bits of chunk index 7], we can ignore those. */
-        if (scope->ua.count > 7 && slotchunks > 7) chunks[7] &= 0xFFFFU;
+        if (scope->ua.count > 7) chunks[7] &= 0xFFFFU;
         def->closure_bitset = chunks;
     }
 
@@ -1096,10 +974,6 @@ JanetFuncDef *janetc_pop_funcdef(JanetCompiler *c) {
         SymPair pair = scope->syms[i];
         if (pair.sym2) {
             JanetSymbolMap jsm;
-            /* Check for unused symbols */
-            if (pair.referenced == 0 && pair.sym) {
-                janetc_lintf(c, JANET_C_LINT_STRICT, "binding %q is unused", janet_wrap_symbol(pair.sym));
-            }
             if (pair.death_pc == UINT32_MAX) {
                 jsm.death_pc = def->bytecode_length;
             } else {
@@ -1144,7 +1018,6 @@ static void janetc_init(JanetCompiler *c, JanetTable *env, const uint8_t *where,
     c->current_mapping.line = -1;
     c->current_mapping.column = -1;
     c->lints = lints;
-    c->is_redef = janet_truthy(janet_table_get_keyword(c->env, "redef"));
     /* Init result */
     c->result.error = NULL;
     c->result.status = JANET_COMPILE_OK;
@@ -1209,7 +1082,6 @@ JANET_CORE_FN(cfun_compile,
               "struct with keys :line, :column, and :error if compilation fails. "
               "If a `lints` array is given, linting messages will be appended to the array. "
               "Each message will be a tuple of the form `(level line col message)`.") {
-    janet_sandbox_assert(JANET_SANDBOX_COMPILE);
     janet_arity(argc, 1, 4);
     JanetTable *env = (argc > 1 && !janet_checktype(argv[1], JANET_NIL))
                       ? janet_gettable(argv, 1) : janet_vm.fiber->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
@@ -36,15 +36,6 @@ typedef enum {
     JANET_C_LINT_STRICT
 } JanetCompileLintLevel;
 
-/* Kinds of variable shadowing for linting */
-typedef enum {
-    JANETC_SHADOW_NONE,
-    JANETC_SHADOW_MACRO,
-    JANETC_SHADOW_GLOBAL_HIDES_GLOBAL,
-    JANETC_SHADOW_LOCAL_HIDES_GLOBAL,
-    JANETC_SHADOW_LOCAL_HIDES_LOCAL
-} Shadowing;
-
 /* Tags for some functions for the prepared inliner */
 #define JANET_FUN_DEBUG 1
 #define JANET_FUN_ERROR 2
@@ -123,7 +114,6 @@ typedef struct SymPair {
     const uint8_t *sym;
     const uint8_t *sym2;
     int keep;
-    int referenced; /* Has this value been used */
     uint32_t birth_pc;
     uint32_t death_pc;
 } SymPair;
@@ -193,9 +183,6 @@ struct JanetCompiler {
 
     /* Collect linting results */
     JanetArray *lints;
-
-    /* Cached version of (dyn *redef*) */
-    int is_redef;
 };
 
 #define JANET_FOPTS_TAIL 0x10000
@@ -233,11 +220,8 @@ const JanetFunOptimizer *janetc_funopt(uint32_t flags);
 /* Get a special. Return NULL if none exists */
 const JanetSpecial *janetc_special(const uint8_t *name);
 
-#define JANET_DEFFLAG_NO_SHADOWCHECK 1
-#define JANET_DEFFLAG_NO_UNUSED 2
-
 void janetc_freeslot(JanetCompiler *c, JanetSlot s);
-void janetc_nameslot(JanetCompiler *c, const uint8_t *sym, JanetSlot s, uint32_t flags);
+void janetc_nameslot(JanetCompiler *c, const uint8_t *sym, JanetSlot s);
 JanetSlot janetc_farslot(JanetCompiler *c);
 
 /* Throw away some code after checking that it is well formed. */
@@ -281,12 +265,9 @@ JanetFuncDef *janetc_pop_funcdef(JanetCompiler *c);
 /* Create a destroy slot */
 JanetSlot janetc_cslot(Janet x);
 
-/* Search for a symbol, and mark any found symbols as "used" for dead code elimination and linting */
+/* Search for a symbol */
 JanetSlot janetc_resolve(JanetCompiler *c, const uint8_t *sym);
 
-/* Check if a symbol is already in scope for shadowing lints */
-Shadowing janetc_shadowcheck(JanetCompiler *c, const uint8_t *sym);
-
 /* 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
@@ -27,7 +27,6 @@
 #include "compile.h"
 #include "state.h"
 #include "util.h"
-#include "fiber.h"
 #endif
 
 /* Generated bytes */
@@ -70,7 +69,7 @@ JanetModule janet_native(const char *name, const uint8_t **error) {
             host.minor != modconf.minor ||
             host.bits != modconf.bits) {
         char errbuf[128];
-        snprintf(errbuf, sizeof(errbuf), "config mismatch - host %d.%.d.%d(%.4x) vs. module %d.%d.%d(%.4x) - native needs to be recompiled!",
+        snprintf(errbuf, sizeof(errbuf), "config mismatch - host %d.%.d.%d(%.4x) vs. module %d.%d.%d(%.4x)",
                  host.major,
                  host.minor,
                  host.patch,
@@ -295,7 +294,6 @@ JANET_CORE_FN(janet_core_native,
               "from the native module.") {
     JanetModule init;
     janet_arity(argc, 1, 2);
-    Janet argv0 = argv[0];
     const uint8_t *path = janet_getstring(argv, 0);
     const uint8_t *error = NULL;
     JanetTable *env;
@@ -308,10 +306,8 @@ JANET_CORE_FN(janet_core_native,
     if (!init) {
         janet_panicf("could not load native %S: %S", path, error);
     }
-    /* GC root incase garbage collection called inside module entry */
-    janet_fiber_push(janet_vm.fiber, janet_wrap_table(env));
     init(env);
-    janet_table_put(env, janet_ckeywordv("native"), argv0);
+    janet_table_put(env, janet_ckeywordv("native"), argv[0]);
     return janet_wrap_table(env);
 }
 
@@ -750,9 +746,6 @@ typedef struct SandboxOption {
 
 static const SandboxOption sandbox_options[] = {
     {"all", JANET_SANDBOX_ALL},
-    {"asm", JANET_SANDBOX_ASM},
-    {"chroot", JANET_SANDBOX_CHROOT},
-    {"compile", JANET_SANDBOX_COMPILE},
     {"env", JANET_SANDBOX_ENV},
     {"ffi", JANET_SANDBOX_FFI},
     {"ffi-define", JANET_SANDBOX_FFI_DEFINE},
@@ -770,8 +763,6 @@ static const SandboxOption sandbox_options[] = {
     {"sandbox", JANET_SANDBOX_SANDBOX},
     {"signal", JANET_SANDBOX_SIGNAL},
     {"subprocess", JANET_SANDBOX_SUBPROCESS},
-    {"threads", JANET_SANDBOX_THREADS},
-    {"unmarshal", JANET_SANDBOX_UNMARSHAL},
     {NULL, 0}
 };
 
@@ -780,9 +771,6 @@ JANET_CORE_FN(janet_core_sandbox,
               "Disable feature sets to prevent the interpreter from using certain system resources. "
               "Once a feature is disabled, there is no way to re-enable it. Capabilities can be:\n\n"
               "* :all - disallow all (except IO to stdout, stderr, and stdin)\n"
-              "* :asm - disallow calling `asm` and `disasm` functions.\n"
-              "* :chroot - disallow calling `os/posix-chroot`\n"
-              "* :compile - disallow calling `compile`. This will disable a lot of functionality, such as `eval`.\n"
               "* :env - disallow reading and write env variables\n"
               "* :ffi - disallow FFI (recommended if disabling anything else)\n"
               "* :ffi-define - disallow loading new FFI modules and binding new functions\n"
@@ -799,9 +787,7 @@ JANET_CORE_FN(janet_core_sandbox,
               "* :net-listen - disallow accepting inbound network connections\n"
               "* :sandbox - disallow calling this function\n"
               "* :signal - disallow adding or removing signal handlers\n"
-              "* :subprocess - disallow running subprocesses\n"
-              "* :threads - disallow spawning threads with `ev/thread`. Certain helper threads may still be spawned.\n"
-              "* :unmarshal - disallow calling the unmarshal function.\n") {
+              "* :subprocess - disallow running subprocesses") {
     uint32_t flags = 0;
     for (int32_t i = 0; i < argc; i++) {
         JanetKeyword kw = janet_getkeyword(argv, i);
@@ -1009,11 +995,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[] = {
@@ -1166,82 +1152,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."));
@@ -1250,74 +1236,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),
@@ -1326,7 +1312,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),
@@ -1366,16 +1352,12 @@ JanetTable *janet_core_env(JanetTable *replacements) {
     lidv = midv = janet_wrap_nil();
     janet_resolve(env, janet_csymbol("load-image-dict"), &lidv);
     janet_resolve(env, janet_csymbol("make-image-dict"), &midv);
-
-    /* Check that we actually got tables - if we are using a smaller corelib, may not exist */
-    if (janet_checktype(lidv, JANET_TABLE) && janet_checktype(midv, JANET_TABLE)) {
-        JanetTable *lid = janet_unwrap_table(lidv);
-        JanetTable *mid = janet_unwrap_table(midv);
-        for (int32_t i = 0; i < lid->capacity; i++) {
-            const JanetKV *kv = lid->data + i;
-            if (!janet_checktype(kv->key, JANET_NIL)) {
-                janet_table_put(mid, kv->value, kv->key);
-            }
+    JanetTable *lid = janet_unwrap_table(lidv);
+    JanetTable *mid = janet_unwrap_table(midv);
+    for (int32_t i = 0; i < lid->capacity; i++) {
+        const JanetKV *kv = lid->data + i;
+        if (!janet_checktype(kv->key, JANET_NIL)) {
+            janet_table_put(mid, kv->value, kv->key);
         }
     }
 

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
@@ -83,7 +83,7 @@ struct JanetChannel {
     int closed;
     int is_threaded;
 #ifdef JANET_WINDOWS
-    CRITICAL_SECTION lock;
+    SRWLOCK lock;
 #else
     pthread_mutex_t lock;
 #endif
@@ -117,9 +117,6 @@ typedef struct {
     double sec;
     JanetVM *vm;
     JanetFiber *fiber;
-#ifdef JANET_WINDOWS
-    HANDLE cancel_event;
-#endif
 } JanetThreadedTimeout;
 
 #define JANET_MAX_Q_CAPACITY 0x7FFFFFF
@@ -524,9 +521,9 @@ static void janet_schedule_general(JanetFiber *fiber, Janet value, JanetSignal s
     fiber->gc.flags |= JANET_FIBER_FLAG_ROOT;
     if (sig == JANET_SIGNAL_ERROR) fiber->gc.flags |= JANET_FIBER_EV_FLAG_CANCELED;
     if (soon) {
-        janet_assert(!janet_q_push_head(&janet_vm.spawn, &t, sizeof(t)), "schedule queue overflow");
+        janet_q_push_head(&janet_vm.spawn, &t, sizeof(t));
     } else {
-        janet_assert(!janet_q_push(&janet_vm.spawn, &t, sizeof(t)), "schedule queue overflow");
+        janet_q_push(&janet_vm.spawn, &t, sizeof(t));
     }
 }
 
@@ -539,9 +536,6 @@ void janet_schedule_soon(JanetFiber *fiber, Janet value, JanetSignal sig) {
 }
 
 void janet_cancel(JanetFiber *fiber, Janet value) {
-    if (!(fiber->gc.flags & JANET_FIBER_FLAG_ROOT)) {
-        janet_panic("cannot cancel non-task fiber");
-    }
     janet_schedule_signal(fiber, value, JANET_SIGNAL_ERROR);
 }
 
@@ -610,7 +604,12 @@ void janet_ev_init_common(void) {
 #endif
 }
 
-#if JANET_ANDROID
+#ifdef JANET_WINDOWS
+static VOID CALLBACK janet_timeout_stop(ULONG_PTR ptr) {
+    UNREFERENCED_PARAMETER(ptr);
+    ExitThread(0);
+}
+#elif JANET_ANDROID
 static void janet_timeout_stop(int sig_num) {
     if (sig_num == SIGUSR1) {
         pthread_exit(0);
@@ -621,14 +620,10 @@ static void janet_timeout_stop(int sig_num) {
 static void handle_timeout_worker(JanetTimeout to, int cancel) {
     if (!to.has_worker) return;
 #ifdef JANET_WINDOWS
-    if (cancel && to.worker_event) {
-        SetEvent(to.worker_event);
-    }
+    (void) cancel;
+    QueueUserAPC(janet_timeout_stop, to.worker, 0);
     WaitForSingleObject(to.worker, INFINITE);
     CloseHandle(to.worker);
-    if (to.worker_event) {
-        CloseHandle(to.worker_event);
-    }
 #else
 #ifdef JANET_ANDROID
     if (cancel) janet_assert(!pthread_kill(to.worker, SIGUSR1), "pthread_kill");
@@ -698,20 +693,10 @@ static void janet_timeout_cb(JanetEVGenericMessage msg) {
 static DWORD WINAPI janet_timeout_body(LPVOID ptr) {
     JanetThreadedTimeout tto = *(JanetThreadedTimeout *)ptr;
     janet_free(ptr);
-    JanetTimestamp wait_begin = ts_now();
-    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++) {
-        res = WaitForSingleObject(tto.cancel_event, (duration + i));
-        wait_end = ts_now();
-    }
-    /* only send interrupt message if result is WAIT_TIMEOUT */
-    if (res == WAIT_TIMEOUT) {
-        janet_interpreter_interrupt(tto.vm);
-        JanetEVGenericMessage msg = {0};
-        janet_ev_post_event(tto.vm, janet_timeout_cb, msg);
-    }
+    SleepEx((DWORD)(tto.sec * 1000), TRUE);
+    janet_interpreter_interrupt(tto.vm);
+    JanetEVGenericMessage msg = {0};
+    janet_ev_post_event(tto.vm, janet_timeout_cb, msg);
     return 0;
 }
 #else
@@ -959,12 +944,11 @@ static void janet_thread_chan_cb(JanetEVGenericMessage msg) {
             janet_schedule(fiber, janet_wrap_nil());
         }
     } else if (mode != JANET_CP_MODE_CLOSE) {
-        /* Fiber has already been canceled or resumed. */
+        /* Fiber has already been cancelled or resumed. */
         /* Resend event to another waiting thread, depending on mode */
         int is_read = (mode == JANET_CP_MODE_CHOICE_READ) || (mode == JANET_CP_MODE_READ);
         if (is_read) {
             JanetChannelPending reader;
-            int sent = 0;
             while (!janet_q_pop(&channel->read_pending, &reader, sizeof(reader))) {
                 JanetVM *vm = reader.thread;
                 if (!vm) continue;
@@ -975,12 +959,8 @@ static void janet_thread_chan_cb(JanetEVGenericMessage msg) {
                 msg.argp = channel;
                 msg.argj = x;
                 janet_ev_post_event(vm, janet_thread_chan_cb, msg);
-                sent = 1;
                 break;
             }
-            if (!sent) {
-                janet_chan_unpack(channel, &x, 1);
-            }
         } else {
             JanetChannelPending writer;
             while (!janet_q_pop(&channel->write_pending, &writer, sizeof(writer))) {
@@ -1006,14 +986,14 @@ static void janet_thread_chan_cb(JanetEVGenericMessage msg) {
 static int janet_channel_push_with_lock(JanetChannel *channel, Janet x, int mode) {
     JanetChannelPending reader;
     int is_empty;
-    if (channel->closed) {
-        janet_chan_unlock(channel);
-        janet_panic("cannot write to closed channel");
-    }
     if (janet_chan_pack(channel, &x)) {
         janet_chan_unlock(channel);
         janet_panicf("failed to pack value for channel: %v", x);
     }
+    if (channel->closed) {
+        janet_chan_unlock(channel);
+        janet_panic("cannot write to closed channel");
+    }
     int is_threaded = janet_chan_is_threaded(channel);
     if (is_threaded) {
         /* don't dereference fiber from another thread */
@@ -1026,7 +1006,6 @@ static int janet_channel_push_with_lock(JanetChannel *channel, Janet x, int mode
     if (is_empty) {
         /* No pending reader */
         if (janet_q_push(&channel->items, &x, sizeof(Janet))) {
-            janet_chan_unpack(channel, &x, 1);
             janet_chan_unlock(channel);
             janet_panicf("channel overflow: %v", x);
         } else if (janet_q_count(&channel->items) > channel->limit) {
@@ -1060,9 +1039,6 @@ static int janet_channel_push_with_lock(JanetChannel *channel, Janet x, int mode
             msg.argj = x;
             if (vm) {
                 janet_ev_post_event(vm, janet_thread_chan_cb, msg);
-            } else {
-                /* If no vm to send to, we must clean up (unpack) the packed payload to avoid leak */
-                janet_chan_unpack(channel, &x, 1);
             }
         } else {
             if (reader.mode == JANET_CP_MODE_CHOICE_READ) {
@@ -1094,7 +1070,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,
@@ -1172,7 +1148,7 @@ JanetChannel *janet_channel_make(uint32_t limit) {
 JanetChannel *janet_channel_make_threaded(uint32_t limit) {
     janet_assert(limit <= INT32_MAX, "bad limit");
     JanetChannel *channel = janet_abstract_threaded(&janet_channel_type, sizeof(JanetChannel));
-    janet_chan_init(channel, (int32_t) limit, 1);
+    janet_chan_init(channel, (int32_t) limit, 0);
     return channel;
 }
 
@@ -1208,6 +1184,20 @@ JANET_CORE_FN(cfun_channel_pop,
     janet_await();
 }
 
+static void chan_unlock_args(const Janet *argv, int32_t n) {
+    for (int32_t i = 0; i < n; i++) {
+        int32_t len;
+        const Janet *data;
+        JanetChannel *chan;
+        if (janet_indexed_view(argv[i], &data, &len) && len == 2) {
+            chan = janet_getchannel(data, 0);
+        } else {
+            chan = janet_getchannel(argv, i);
+        }
+        janet_chan_unlock(chan);
+    }
+}
+
 JANET_CORE_FN(cfun_channel_choice,
               "(ev/select & clauses)",
               "Block until the first of several channel operations occur. Returns a "
@@ -1236,27 +1226,29 @@ JANET_CORE_FN(cfun_channel_choice,
             janet_chan_lock(chan);
             if (chan->closed) {
                 janet_chan_unlock(chan);
+                chan_unlock_args(argv, i);
                 return make_close_result(chan);
             }
             if (janet_q_count(&chan->items) < chan->limit) {
                 janet_channel_push_with_lock(chan, data[1], 1);
+                chan_unlock_args(argv, i);
                 return make_write_result(chan);
             }
-            janet_chan_unlock(chan);
         } else {
             /* Read */
             JanetChannel *chan = janet_getchannel(argv, i);
             janet_chan_lock(chan);
             if (chan->closed) {
                 janet_chan_unlock(chan);
+                chan_unlock_args(argv, i);
                 return make_close_result(chan);
             }
             if (chan->items.head != chan->items.tail) {
                 Janet item;
                 janet_channel_pop_with_lock(chan, &item, 1);
+                chan_unlock_args(argv, i);
                 return make_read_result(chan, item);
             }
-            janet_chan_unlock(chan);
         }
     }
 
@@ -1265,13 +1257,11 @@ JANET_CORE_FN(cfun_channel_choice,
         if (janet_indexed_view(argv[i], &data, &len) && len == 2) {
             /* Write */
             JanetChannel *chan = janet_getchannel(data, 0);
-            janet_chan_lock(chan);
             janet_channel_push_with_lock(chan, data[1], 1);
         } else {
             /* Read */
             Janet item;
             JanetChannel *chan = janet_getchannel(argv, i);
-            janet_chan_lock(chan);
             janet_channel_pop_with_lock(chan, &item, 1);
         }
     }
@@ -1374,7 +1364,7 @@ JANET_CORE_FN(cfun_channel_close,
                     janet_ev_post_event(vm, janet_thread_chan_cb, msg);
                 }
             } else {
-                if (janet_fiber_can_resume(writer.fiber) && writer.sched_id == writer.fiber->sched_id) {
+                if (janet_fiber_can_resume(writer.fiber)) {
                     if (writer.mode == JANET_CP_MODE_CHOICE_WRITE) {
                         janet_schedule(writer.fiber, make_close_result(channel));
                     } else {
@@ -1397,7 +1387,7 @@ JANET_CORE_FN(cfun_channel_close,
                     janet_ev_post_event(vm, janet_thread_chan_cb, msg);
                 }
             } else {
-                if (janet_fiber_can_resume(reader.fiber) && reader.sched_id == reader.fiber->sched_id) {
+                if (janet_fiber_can_resume(reader.fiber)) {
                     if (reader.mode == JANET_CP_MODE_CHOICE_READ) {
                         janet_schedule(reader.fiber, make_close_result(channel));
                     } else {
@@ -1467,12 +1457,11 @@ static void *janet_chanat_unmarshal(JanetMarshalContext *ctx) {
     int32_t limit = janet_unmarshal_int(ctx);
     int32_t count = janet_unmarshal_int(ctx);
     if (count < 0) janet_panic("invalid negative channel count");
-    if (count > limit) janet_panic("invalid channel count");
     janet_chan_init(abst, limit, 0);
     abst->closed = !!is_closed;
     for (int32_t i = 0; i < count; i++) {
         Janet item = janet_unmarshal_janet(ctx);
-        janet_assert(!janet_q_push(&abst->items, &item, sizeof(item)), "bad unmarshal channel");
+        janet_q_push(&abst->items, &item, sizeof(item));
     }
     return abst;
 }
@@ -1712,20 +1701,20 @@ void janet_loop1_impl(int has_timeout, JanetTimestamp to) {
             janet_free(response);
         } else {
             /* Normal event */
-            JanetOverlapped *jo = (JanetOverlapped *) overlapped;
             JanetStream *stream = (JanetStream *) completionKey;
             JanetFiber *fiber = NULL;
-            if (stream->read_fiber && stream->read_fiber->ev_state == jo) {
+            if (stream->read_fiber && stream->read_fiber->ev_state == overlapped) {
                 fiber = stream->read_fiber;
-            } else if (stream->write_fiber && stream->write_fiber->ev_state == jo) {
+            } else if (stream->write_fiber && stream->write_fiber->ev_state == overlapped) {
                 fiber = stream->write_fiber;
             }
             if (fiber != NULL) {
                 fiber->flags &= ~JANET_FIBER_EV_FLAG_IN_FLIGHT;
-                jo->bytes_transfered = (ULONG_PTR) num_bytes_transferred;
+                /* System is done with this, we can reused this data */
+                overlapped->InternalHigh = (ULONG_PTR) num_bytes_transferred;
                 fiber->ev_callback(fiber, result ? JANET_ASYNC_EVENT_COMPLETE : JANET_ASYNC_EVENT_FAILED);
             } else {
-                janet_free((void *) jo);
+                janet_free((void *) overlapped);
                 janet_ev_dec_refcount();
             }
             janet_stream_checktoclose(stream);
@@ -1962,7 +1951,7 @@ void janet_stream_level_triggered(JanetStream *stream) {
     janet_register_stream_impl(stream, 0);
 }
 
-#define JANET_KQUEUE_MAX_EVENTS 512
+#define JANET_KQUEUE_MAX_EVENTS 64
 
 void janet_loop1_impl(int has_timeout, JanetTimestamp timeout) {
     /* Poll for events */
@@ -2026,7 +2015,6 @@ void janet_loop1_impl(int has_timeout, JanetTimestamp timeout) {
 
 void janet_ev_init(void) {
     janet_ev_init_common();
-    /* TODO - replace selfpipe with EVFILT_USER (or other events) */
     janet_ev_setup_selfpipe();
     janet_vm.kq = kqueue();
     janet_vm.timer_enabled = 0;
@@ -2411,7 +2399,7 @@ Janet janet_ev_lasterr(void) {
                   msgbuf,
                   sizeof(msgbuf),
                   NULL);
-    if (!*msgbuf) snprintf(msgbuf, sizeof(msgbuf), "%d", code);
+    if (!*msgbuf) sprintf(msgbuf, "%d", code);
     char *c = msgbuf;
     while (*c) {
         if (*c == '\n' || *c == '\r') {
@@ -2438,7 +2426,7 @@ typedef enum {
 
 typedef struct {
 #ifdef JANET_WINDOWS
-    JanetOverlapped overlapped;
+    OVERLAPPED overlapped;
     DWORD flags;
 #ifdef JANET_NET
     WSABUF wbuf;
@@ -2473,7 +2461,7 @@ void ev_callback_read(JanetFiber *fiber, JanetAsyncEvent event) {
         case JANET_ASYNC_EVENT_FAILED:
         case JANET_ASYNC_EVENT_COMPLETE: {
             /* Called when read finished */
-            uint32_t ev_bytes = (uint32_t) state->overlapped.bytes_transfered;
+            uint32_t ev_bytes = (uint32_t) state->overlapped.InternalHigh;
             state->bytes_read += ev_bytes;
             if (state->bytes_read == 0 && (state->mode != JANET_ASYNC_READMODE_RECVFROM)) {
                 janet_schedule(fiber, janet_wrap_nil());
@@ -2505,7 +2493,7 @@ void ev_callback_read(JanetFiber *fiber, JanetAsyncEvent event) {
         /* fallthrough */
         case JANET_ASYNC_EVENT_INIT: {
             int32_t chunk_size = state->bytes_left > JANET_EV_CHUNKSIZE ? JANET_EV_CHUNKSIZE : state->bytes_left;
-            memset(&(state->overlapped), 0, sizeof(JanetOverlapped));
+            memset(&(state->overlapped), 0, sizeof(OVERLAPPED));
             int status;
 #ifdef JANET_NET
             if (state->mode == JANET_ASYNC_READMODE_RECVFROM) {
@@ -2513,7 +2501,7 @@ void ev_callback_read(JanetFiber *fiber, JanetAsyncEvent event) {
                 state->wbuf.buf = (char *) state->chunk_buf;
                 state->fromlen = sizeof(state->from);
                 status = WSARecvFrom((SOCKET) stream->handle, &state->wbuf, 1,
-                                     NULL, &state->flags, &state->from, &state->fromlen, &state->overlapped.as.wsaoverlapped, NULL);
+                                     NULL, &state->flags, &state->from, &state->fromlen, &state->overlapped, NULL);
                 if (status && (WSA_IO_PENDING != WSAGetLastError())) {
                     janet_cancel(fiber, janet_ev_lasterr());
                     janet_async_end(fiber);
@@ -2524,9 +2512,9 @@ void ev_callback_read(JanetFiber *fiber, JanetAsyncEvent event) {
             {
                 /* Some handles (not all) read from the offset in lpOverlapped
                  * if its not set before calling `ReadFile` these streams will always read from offset 0 */
-                state->overlapped.as.overlapped.Offset = (DWORD) state->bytes_read;
+                state->overlapped.Offset = (DWORD) state->bytes_read;
 
-                status = ReadFile(stream->handle, state->chunk_buf, chunk_size, NULL, &state->overlapped.as.overlapped);
+                status = ReadFile(stream->handle, state->chunk_buf, chunk_size, NULL, &state->overlapped);
                 if (!status && (ERROR_IO_PENDING != GetLastError())) {
                     if (GetLastError() == ERROR_BROKEN_PIPE) {
                         if (state->bytes_read) {
@@ -2682,7 +2670,7 @@ typedef enum {
 
 typedef struct {
 #ifdef JANET_WINDOWS
-    JanetOverlapped overlapped;
+    OVERLAPPED overlapped;
     DWORD flags;
 #ifdef JANET_NET
     WSABUF wbuf;
@@ -2723,7 +2711,7 @@ void ev_callback_write(JanetFiber *fiber, JanetAsyncEvent event) {
         case JANET_ASYNC_EVENT_FAILED:
         case JANET_ASYNC_EVENT_COMPLETE: {
             /* Called when write finished */
-            uint32_t ev_bytes = (uint32_t) state->overlapped.bytes_transfered;
+            uint32_t ev_bytes = (uint32_t) state->overlapped.InternalHigh;
             if (ev_bytes == 0 && (state->mode != JANET_ASYNC_WRITEMODE_SENDTO)) {
                 janet_cancel(fiber, janet_cstringv("disconnect"));
                 janet_async_end(fiber);
@@ -2752,7 +2740,7 @@ void ev_callback_write(JanetFiber *fiber, JanetAsyncEvent event) {
                 bytes = state->src.str;
                 len = janet_string_length(bytes);
             }
-            memset(&(state->overlapped), 0, sizeof(JanetOverlapped));
+            memset(&(state->overlapped), 0, sizeof(WSAOVERLAPPED));
 
             int status;
 #ifdef JANET_NET
@@ -2762,7 +2750,7 @@ void ev_callback_write(JanetFiber *fiber, JanetAsyncEvent event) {
                 state->wbuf.len = len;
                 const struct sockaddr *to = state->dest_abst;
                 int tolen = (int) janet_abstract_size((void *) to);
-                status = WSASendTo(sock, &state->wbuf, 1, NULL, state->flags, to, tolen, &state->overlapped.as.wsaoverlapped, NULL);
+                status = WSASendTo(sock, &state->wbuf, 1, NULL, state->flags, to, tolen, &state->overlapped, NULL);
                 if (status) {
                     if (WSA_IO_PENDING == WSAGetLastError()) {
                         janet_async_in_flight(fiber);
@@ -2785,9 +2773,9 @@ void ev_callback_write(JanetFiber *fiber, JanetAsyncEvent event) {
                  * for more details see the lpOverlapped parameter in
                  * https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-writefile
                  */
-                state->overlapped.as.overlapped.Offset = (DWORD) 0xFFFFFFFF;
-                state->overlapped.as.overlapped.OffsetHigh = (DWORD) 0xFFFFFFFF;
-                status = WriteFile(stream->handle, bytes, len, NULL, &state->overlapped.as.overlapped);
+                state->overlapped.Offset = (DWORD) 0xFFFFFFFF;
+                state->overlapped.OffsetHigh = (DWORD) 0xFFFFFFFF;
+                status = WriteFile(stream->handle, bytes, len, NULL, &state->overlapped);
                 if (!status) {
                     if (ERROR_IO_PENDING == GetLastError()) {
                         janet_async_in_flight(fiber);
@@ -2943,11 +2931,10 @@ int janet_make_pipe(JanetHandle handles[2], int mode) {
         if (!CreatePipe(handles, handles + 1, &saAttr, 0)) return -1;
         return 0;
     }
-    snprintf(PipeNameBuffer,
-             sizeof(PipeNameBuffer),
-             "\\\\.\\Pipe\\JanetPipeFile.%08x.%08x",
-             (unsigned int) GetCurrentProcessId(),
-             (unsigned int) InterlockedIncrement(&PipeSerialNumber));
+    sprintf(PipeNameBuffer,
+            "\\\\.\\Pipe\\JanetPipeFile.%08x.%08x",
+            (unsigned int) GetCurrentProcessId(),
+            (unsigned int) InterlockedIncrement(&PipeSerialNumber));
 
     /* server handle goes to subprocess */
     shandle = CreateNamedPipeA(
@@ -3003,14 +2990,12 @@ error:
 
 JANET_CORE_FN(cfun_ev_go,
               "(ev/go fiber-or-fun &opt value supervisor)",
-              "Put a fiber on the event loop to be resumed later. If a "
-              "function is used, it is wrapped with `fiber/new` first. "
-              "Returns a task fiber. Optionally pass a value to resume "
-              "with, otherwise resumes with nil. An optional `core/channel` "
-              "can be provided as a supervisor. When various events occur "
-              "in the newly scheduled fiber, an event will be pushed to the "
-              "supervisor. If not provided, the new fiber will inherit the "
-              "current supervisor.") {
+              "Put a fiber on the event loop to be resumed later. If a function is used, it is wrapped "
+              "with `fiber/new` first. "
+              "Optionally pass a value to resume with, otherwise resumes with nil. Returns the fiber. "
+              "An optional `core/channel` can be provided as a supervisor. When various "
+              "events occur in the newly scheduled fiber, an event will be pushed to the supervisor. "
+              "If not provided, the new fiber will inherit the current supervisor.") {
     janet_arity(argc, 1, 3);
     Janet value = argc >= 2 ? argv[1] : janet_wrap_nil();
     void *supervisor = janet_optabstract(argv, argc, 2, &janet_channel_type, janet_vm.root_fiber->supervisor_channel);
@@ -3036,9 +3021,6 @@ JANET_CORE_FN(cfun_ev_go,
         fiber->env->proto = janet_vm.fiber->env;
     } else {
         fiber = janet_getfiber(argv, 0);
-        if (janet_fiber_status(fiber) != JANET_STATUS_NEW) {
-            janet_panic("can only schedule new fibers where (= (fiber/status f) :new)");
-        }
     }
     fiber->supervisor_channel = supervisor;
     janet_schedule(fiber, value);
@@ -3174,7 +3156,6 @@ JANET_CORE_FN(cfun_ev_thread,
               "* `:t` - set the task-id of the new thread to value. The task-id is passed in messages to the supervisor channel.\n"
               "* `:a` - don't copy abstract registry to new thread (performance optimization)\n"
               "* `:c` - don't copy cfunction registry to new thread (performance optimization)") {
-    janet_sandbox_assert(JANET_SANDBOX_THREADS);
     janet_arity(argc, 1, 4);
     Janet value = argc >= 2 ? argv[1] : janet_wrap_nil();
     if (!janet_checktype(argv[0], JANET_FUNCTION)) janet_getfiber(argv, 0);
@@ -3289,13 +3270,7 @@ JANET_CORE_FN(cfun_ev_deadline,
         tto->vm = &janet_vm;
         tto->fiber = tocheck;
 #ifdef JANET_WINDOWS
-        HANDLE cancel_event = CreateEvent(NULL, TRUE, FALSE, NULL);
-        if (NULL == cancel_event) {
-            janet_free(tto);
-            janet_panic("failed to create cancel event");
-        }
-        tto->cancel_event = cancel_event;
-        HANDLE worker = CreateThread(NULL, 0, janet_timeout_body, tto, CREATE_SUSPENDED, NULL);
+        HANDLE worker = CreateThread(NULL, 0, janet_timeout_body, tto, 0, NULL);
         if (NULL == worker) {
             janet_free(tto);
             janet_panic("failed to create thread");
@@ -3310,10 +3285,6 @@ JANET_CORE_FN(cfun_ev_deadline,
 #endif
         to.has_worker = 1;
         to.worker = worker;
-#ifdef JANET_WINDOWS
-        to.worker_event = cancel_event;
-        ResumeThread(worker);
-#endif
     } else {
         to.has_worker = 0;
     }
@@ -3323,8 +3294,7 @@ JANET_CORE_FN(cfun_ev_deadline,
 
 JANET_CORE_FN(cfun_ev_cancel,
               "(ev/cancel fiber err)",
-              "Cancel a suspended task fiber in the event loop. Differs from "
-              "`cancel` in that it returns the canceled fiber immediately.") {
+              "Cancel a suspended fiber in the event loop. Differs from cancel in that it returns the canceled fiber immediately.") {
     janet_fixarity(argc, 2);
     JanetFiber *fiber = janet_getfiber(argv, 0);
     Janet err = argv[1];
@@ -3557,7 +3527,7 @@ JANET_CORE_FN(janet_cfun_to_file,
 
 JANET_CORE_FN(janet_cfun_ev_all_tasks,
               "(ev/all-tasks)",
-              "Get an array of all active task fibers that are being used by the scheduler.") {
+              "Get an array of all active fibers that are being used by the scheduler.") {
     janet_fixarity(argc, 0);
     (void) argv;
     JanetArray *array = janet_array(janet_vm.active_tasks.count);

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
@@ -592,8 +592,8 @@ JANET_CORE_FN(cfun_fiber_status,
               "* :user(0-7) - the fiber is suspended by a user signal\n"
               "* :interrupted - the fiber was interrupted\n"
               "* :suspended - the fiber is waiting to be resumed by the scheduler\n"
-              "* :new - the fiber has just been created and not yet run\n"
-              "* :alive - the fiber is currently running and cannot be resumed") {
+              "* :alive - the fiber is currently running and cannot be resumed\n"
+              "* :new - the fiber has just been created and not yet run") {
     janet_fixarity(argc, 1);
     JanetFiber *fiber = janet_getfiber(argv, 0);
     uint32_t s = janet_fiber_status(fiber);
@@ -610,9 +610,8 @@ JANET_CORE_FN(cfun_fiber_current,
 
 JANET_CORE_FN(cfun_fiber_root,
               "(fiber/root)",
-              "Returns the current root fiber. The root fiber is the oldest "
-              "ancestor that does not have a parent. Note that a root fiber "
-              "is also a task fiber.") {
+              "Returns the current root fiber. The root fiber is the oldest ancestor "
+              "that does not have a parent.") {
     (void) argv;
     janet_fixarity(argc, 0);
     return janet_wrap_fiber(janet_vm.root_fiber);

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
@@ -38,13 +38,6 @@
 #include <windows.h>
 #endif
 
-#if defined(JANET_APPLE) || defined(JANET_BSD)
-#include <sys/event.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <fcntl.h>
-#endif
-
 typedef struct {
     const char *name;
     uint32_t flag;
@@ -96,7 +89,7 @@ static uint32_t decode_watch_flags(const Janet *options, int32_t n) {
                                            sizeof(JanetWatchFlagName),
                                            keyw);
         if (!result) {
-            janet_panicf("unknown linux flag %v", options[i]);
+            janet_panicf("unknown inotify flag %v", options[i]);
         }
         flags |= result->flag;
     }
@@ -135,11 +128,8 @@ static void janet_watcher_add(JanetWatcher *watcher, const char *path, uint32_t
 
 static void janet_watcher_remove(JanetWatcher *watcher, const char *path) {
     if (watcher->stream == NULL) janet_panic("watcher closed");
-    Janet pathv = janet_cstringv(path);
-    Janet check = janet_table_get(watcher->watch_descriptors, pathv);
-    if (!janet_checktype(check, JANET_NUMBER)) {
-        janet_panic("bad watch descriptor");
-    }
+    Janet check = janet_table_get(watcher->watch_descriptors, janet_cstringv(path));
+    janet_assert(janet_checktype(check, JANET_NUMBER), "bad watch descriptor");
     int watch_handle = janet_unwrap_integer(check);
     int result;
     do {
@@ -148,10 +138,6 @@ static void janet_watcher_remove(JanetWatcher *watcher, const char *path) {
     if (result == -1) {
         janet_panicv(janet_ev_lasterr());
     }
-    /*
-    janet_table_put(watcher->watch_descriptors, pathv, janet_wrap_nil());
-    janet_table_put(watcher->watch_descriptors, janet_wrap_integer(watch_handle), janet_wrap_nil());
-    */
 }
 
 static void watcher_callback_read(JanetFiber *fiber, JanetAsyncEvent event) {
@@ -340,7 +326,7 @@ static void janet_watcher_init(JanetWatcher *watcher, JanetChannel *channel, uin
 #define FILE_INFO_PADDING (4096 * 4)
 
 typedef struct {
-    JanetOverlapped overlapped;
+    OVERLAPPED overlapped;
     JanetStream *stream;
     JanetWatcher *watcher;
     JanetFiber *fiber;
@@ -470,7 +456,7 @@ static void janet_watcher_add(JanetWatcher *watcher, const char *path, uint32_t
     Janet pathv = janet_wrap_string(ow->dir_path);
     ow->flags = flags | watcher->default_flags;
     ow->watcher = watcher;
-    ow->overlapped.as.overlapped.hEvent = CreateEvent(NULL, FALSE, 0, NULL); /* Do we need this */
+    ow->overlapped.hEvent = CreateEvent(NULL, FALSE, 0, NULL); /* Do we need this */
     Janet streamv = janet_wrap_pointer(ow);
     janet_table_put(watcher->watch_descriptors, pathv, streamv);
     if (watcher->is_watching) {
@@ -514,254 +500,6 @@ static void janet_watcher_unlisten(JanetWatcher *watcher) {
     janet_gcunroot(janet_wrap_abstract(watcher));
 }
 
-#elif defined(JANET_APPLE) || defined(JANET_BSD)
-
-/* kqueue implementation */
-
-/* Cribbed from ev.c */
-#define EV_SETx(ev, a, b, c, d, e, f) EV_SET((ev), (a), (b), (c), (d), (e), ((__typeof__((ev)->udata))(f)))
-
-/* Different BSDs define different NOTE_* constants for different kinds of events. Use ifdef to
-   determine when they are available (assuming they are defines and not enums */
-static const JanetWatchFlagName watcher_flags_kqueue[] = {
-    {
-        "all", NOTE_ATTRIB | NOTE_DELETE | NOTE_EXTEND | NOTE_RENAME | NOTE_REVOKE | NOTE_WRITE | NOTE_LINK
-#ifdef NOTE_CLOSE
-        | NOTE_CLOSE
-#endif
-#ifdef NOTE_CLOSE_WRITE
-        | NOTE_CLOSE_WRITE
-#endif
-#ifdef NOTE_OPEN
-        | NOTE_OPEN
-#endif
-#ifdef NOTE_READ
-        | NOTE_READ
-#endif
-#ifdef NOTE_FUNLOCK
-        | NOTE_FUNLOCK
-#endif
-#ifdef NOTE_TRUNCATE
-        | NOTE_TRUNCATE
-#endif
-    },
-    {"attrib", NOTE_ATTRIB},
-#ifdef NOTE_CLOSE
-    {"close", NOTE_CLOSE},
-#endif
-#ifdef NOTE_CLOSE_WRITE
-    {"close-write", NOTE_CLOSE_WRITE},
-#endif
-    {"delete", NOTE_DELETE},
-    {"extend", NOTE_EXTEND},
-#ifdef NOTE_FUNLOCK
-    {"funlock", NOTE_FUNLOCK},
-#endif
-    {"link", NOTE_LINK},
-#ifdef NOTE_OPEN
-    {"open", NOTE_OPEN},
-#endif
-#ifdef NOTE_READ
-    {"read", NOTE_READ},
-#endif
-    {"rename", NOTE_RENAME},
-    {"revoke", NOTE_REVOKE},
-#ifdef NOTE_TRUNCATE
-    {"truncate", NOTE_TRUNCATE},
-#endif
-    {"write", NOTE_WRITE},
-};
-
-static uint32_t decode_watch_flags(const Janet *options, int32_t n) {
-    uint32_t flags = 0;
-    for (int32_t i = 0; i < n; i++) {
-        if (!(janet_checktype(options[i], JANET_KEYWORD))) {
-            janet_panicf("expected keyword, got %v", options[i]);
-        }
-        JanetKeyword keyw = janet_unwrap_keyword(options[i]);
-        const JanetWatchFlagName *result = janet_strbinsearch(watcher_flags_kqueue,
-                                           sizeof(watcher_flags_kqueue) / sizeof(JanetWatchFlagName),
-                                           sizeof(JanetWatchFlagName),
-                                           keyw);
-        if (!result) {
-            janet_panicf("unknown bsd flag %v", options[i]);
-        }
-        flags |= result->flag;
-    }
-    return flags;
-}
-
-static void janet_watcher_init(JanetWatcher *watcher, JanetChannel *channel, uint32_t default_flags) {
-    int kq = kqueue();
-    watcher->watch_descriptors = janet_table(0);
-    watcher->channel = channel;
-    watcher->default_flags = default_flags;
-    watcher->is_watching = 0;
-    watcher->stream = janet_stream(kq, JANET_STREAM_READABLE, NULL);
-    janet_stream_level_triggered(watcher->stream);
-}
-
-static void janet_watcher_add(JanetWatcher *watcher, const char *path, uint32_t flags) {
-    if (watcher->stream == NULL) janet_panic("watcher closed");
-    int kq = watcher->stream->handle;
-    struct kevent kev = {0};
-    /* Get file descriptor for path */
-    int file_fd;
-    do {
-        file_fd = open(path, O_RDONLY);
-    } while (file_fd == -1 && errno == EINTR);
-    if (file_fd == -1) {
-        janet_panicf("failed to open: %v", janet_ev_lasterr());
-    }
-    /* Watch for EVFILT_VNODE on the file descriptor */
-    EV_SETx(&kev, file_fd, EVFILT_VNODE, EV_ADD | EV_ENABLE | EV_CLEAR, flags, 0, NULL);
-    int status;
-    do {
-        status = kevent(kq, &kev, 1, NULL, 0, NULL);
-    } while (status == -1 && errno == EINTR);
-    if (status == -1) {
-        close(file_fd);
-        janet_panicf("failed to listen: %v", janet_ev_lasterr());
-    }
-    /* Bookkeeping */
-    Janet name = janet_cstringv(path);
-    Janet wd = janet_wrap_integer(file_fd);
-    janet_table_put(watcher->watch_descriptors, name, wd);
-    janet_table_put(watcher->watch_descriptors, wd, name);
-}
-
-static void janet_watcher_remove(JanetWatcher *watcher, const char *path) {
-    if (watcher->stream == NULL) janet_panic("watcher closed");
-    Janet pathv = janet_cstringv(path);
-    Janet check = janet_table_get(watcher->watch_descriptors, pathv);
-    if (!janet_checktype(check, JANET_NUMBER)) {
-        janet_panic("bad watch descriptor");
-    }
-    /* Closing the file descriptor will also remove it from the kqueue */
-    int wd = janet_unwrap_integer(check);
-    int result;
-    do {
-        result = close(wd);
-    } while (result != -1 && errno == EINTR);
-    if (result == -1) {
-        janet_panicv(janet_ev_lasterr());
-    }
-    janet_table_put(watcher->watch_descriptors, pathv, janet_wrap_nil());
-    janet_table_put(watcher->watch_descriptors, janet_wrap_integer(wd), janet_wrap_nil());
-}
-
-typedef struct {
-    JanetWatcher *watcher;
-    uint32_t cookie;
-} KqueueWatcherState;
-
-static void watcher_callback_read(JanetFiber *fiber, JanetAsyncEvent event) {
-    JanetStream *stream = fiber->ev_stream;
-    KqueueWatcherState *state = fiber->ev_state;
-    JanetWatcher *watcher = state->watcher;
-    switch (event) {
-        case JANET_ASYNC_EVENT_MARK:
-            janet_mark(janet_wrap_abstract(watcher));
-            break;
-        case JANET_ASYNC_EVENT_CLOSE:
-            janet_schedule(fiber, janet_wrap_nil());
-            janet_async_end(fiber);
-            break;
-        case JANET_ASYNC_EVENT_ERR: {
-            janet_schedule(fiber, janet_wrap_nil());
-            janet_async_end(fiber);
-            break;
-        }
-        case JANET_ASYNC_EVENT_HUP:
-        case JANET_ASYNC_EVENT_INIT:
-            break;
-        case JANET_ASYNC_EVENT_READ: {
-            /* Pump events from the sub kqueue */
-            const int num_events = 512; /* Extra will be pumped after another event loop rotation. */
-            struct kevent events[num_events];
-            int kq = stream->handle;
-            int status;
-            do {
-                status = kevent(kq, NULL, 0, events, num_events, NULL);
-            } while (status == -1 && errno == EINTR);
-            if (status == -1) {
-                janet_schedule(fiber, janet_wrap_nil());
-                janet_async_end(fiber);
-                break;
-            }
-            for (int i = 0; i < status; i++) {
-                state->cookie += 6700417;
-                struct kevent kev = events[i];
-                /* TODO - avoid stat call here, maybe just when adding listener? */
-                struct stat stat_buf = {0};
-                int status;
-                do {
-                    status = fstat(kev.ident, &stat_buf);
-                } while (status == -1 && errno == EINTR);
-                if (status == -1) continue;
-                int is_dir = S_ISDIR(stat_buf.st_mode);
-                Janet ident = janet_wrap_integer(kev.ident);
-                Janet path = janet_table_get(watcher->watch_descriptors, ident);
-                for (unsigned int j = 1; j < (sizeof(watcher_flags_kqueue) / sizeof(watcher_flags_kqueue[0])); j++) {
-                    uint32_t flagcheck = watcher_flags_kqueue[j].flag;
-                    if (kev.fflags & flagcheck) {
-                        JanetKV *event = janet_struct_begin(6);
-                        janet_struct_put(event, janet_ckeywordv("wd"), ident);
-                        janet_struct_put(event, janet_ckeywordv("wd-path"), path);
-                        janet_struct_put(event, janet_ckeywordv("cookie"), janet_wrap_number((double) state->cookie));
-                        janet_struct_put(event, janet_ckeywordv("type"), janet_ckeywordv(watcher_flags_kqueue[j].name));
-                        if (is_dir) {
-                            /* Pass in directly */
-                            janet_struct_put(event, janet_ckeywordv("file-name"), janet_cstringv(""));
-                            janet_struct_put(event, janet_ckeywordv("dir-name"), path);
-                        } else {
-                            /* Split path */
-                            JanetString spath = janet_unwrap_string(path);
-                            const uint8_t *cursor = spath + janet_string_length(spath);
-                            const uint8_t *cursor_end = cursor;
-                            while (cursor > spath && cursor[0] != '/') {
-                                cursor--;
-                            }
-                            if (cursor == spath) {
-                                /* No path separators */
-                                janet_struct_put(event, janet_ckeywordv("dir-name"), janet_cstringv("."));
-                                janet_struct_put(event, janet_ckeywordv("file-name"), janet_wrap_string(spath));
-                            } else {
-                                /* Found path separator */
-                                janet_struct_put(event, janet_ckeywordv("dir-name"), janet_wrap_string(janet_string(spath, (cursor - spath))));
-                                janet_struct_put(event, janet_ckeywordv("file-name"), janet_wrap_string(janet_string(cursor + 1, (cursor_end - cursor - 1))));
-                            }
-                        }
-                        Janet eventv = janet_wrap_struct(janet_struct_end(event));
-                        janet_channel_give(watcher->channel, eventv);
-                    }
-                }
-            }
-            break;
-        }
-        default:
-            break;
-    }
-}
-
-static void janet_watcher_listen(JanetWatcher *watcher) {
-    if (watcher->is_watching) janet_panic("already watching");
-    watcher->is_watching = 1;
-    JanetFunction *thunk = janet_thunk_delay(janet_wrap_nil());
-    JanetFiber *fiber = janet_fiber(thunk, 64, 0, NULL);
-    KqueueWatcherState *state = janet_malloc(sizeof(KqueueWatcherState));
-    state->watcher = watcher;
-    janet_async_start_fiber(fiber, watcher->stream, JANET_ASYNC_LISTEN_READ, watcher_callback_read, state);
-    janet_gcroot(janet_wrap_abstract(watcher));
-}
-
-static void janet_watcher_unlisten(JanetWatcher *watcher) {
-    if (!watcher->is_watching) return;
-    watcher->is_watching = 0;
-    janet_stream_close(watcher->stream);
-    janet_gcunroot(janet_wrap_abstract(watcher));
-}
-
 #else
 
 /* Default implementation */
@@ -783,23 +521,23 @@ static void janet_watcher_add(JanetWatcher *watcher, const char *path, uint32_t
     (void) watcher;
     (void) flags;
     (void) path;
-    janet_panic("filewatch not supported on this platform");
+    janet_panic("nyi");
 }
 
 static void janet_watcher_remove(JanetWatcher *watcher, const char *path) {
     (void) watcher;
     (void) path;
-    janet_panic("filewatch not supported on this platform");
+    janet_panic("nyi");
 }
 
 static void janet_watcher_listen(JanetWatcher *watcher) {
     (void) watcher;
-    janet_panic("filewatch not supported on this platform");
+    janet_panic("nyi");
 }
 
 static void janet_watcher_unlisten(JanetWatcher *watcher) {
     (void) watcher;
-    janet_panic("filewatch not supported on this platform");
+    janet_panic("nyi");
 }
 
 #endif
@@ -835,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"
@@ -844,10 +582,10 @@ JANET_CORE_FN(cfun_filewatch_make,
               "* `:dir-name` -- the directory name of the file that triggered the event.\n\n"
               "Events also will contain keys specific to the host OS.\n\n"
               "Windows has no extra properties on events.\n\n"
-              "Linux and the BSDs have the following extra properties on events:\n\n"
-              "* `:wd` -- the integer key returned by `filewatch/add` for the path that triggered this. This is a file descriptor integer on BSD and macos.\n\n"
+              "Linux has the following extra properties on events:\n\n"
+              "* `:wd` -- the integer key returned by `filewatch/add` for the path that triggered this.\n\n"
               "* `:wd-path` -- the string path for watched directory of file. For files, will be the same as `:file-name`, and for directories, will be the same as `:dir-name`.\n\n"
-              "* `:cookie` -- a semi-randomized integer used to associate related events, such as :moved-from and :moved-to events.\n\n"
+              "* `:cookie` -- a randomized integer used to associate related events, such as :moved-from and :moved-to events.\n\n"
               "") {
     janet_sandbox_assert(JANET_SANDBOX_FS_READ);
     janet_arity(argc, 1, -1);
@@ -859,10 +597,9 @@ 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"
-              "FLAGS\n\n"
               "* `:all` - trigger an event for all of the below triggers.\n\n"
               "* `:attributes` - `FILE_NOTIFY_CHANGE_ATTRIBUTES`\n\n"
               "* `:creation` - `FILE_NOTIFY_CHANGE_CREATION`\n\n"
@@ -889,22 +626,6 @@ JANET_CORE_FN(cfun_filewatch_add,
               "* `:open` - `IN_OPEN`\n\n"
               "* `:q-overflow` - `IN_Q_OVERFLOW`\n\n"
               "* `:unmount` - `IN_UNMOUNT`\n\n\n"
-              "BSDs and macos (flags correspond to `NOTE_*` flags from <sys/event.h>). Not all flags are available on all systems:\n\n"
-              "* `:all` - `All available NOTE_* flags on the current platform`\n\n"
-              "* `:attrib` - `NOTE_ATTRIB`\n\n"
-              "* `:close-write` - `NOTE_CLOSE_WRITE`\n\n"
-              "* `:close` - `NOTE_CLOSE`\n\n"
-              "* `:delete` - `NOTE_DELETE`\n\n"
-              "* `:extend` - `NOTE_EXTEND`\n\n"
-              "* `:funlock` - `NOTE_FUNLOCK`\n\n"
-              "* `:link` - `NOTE_LINK`\n\n"
-              "* `:open` - `NOTE_OPEN`\n\n"
-              "* `:read` - `NOTE_READ`\n\n"
-              "* `:rename` - `NOTE_RENAME`\n\n"
-              "* `:revoke` - `NOTE_REVOKE`\n\n"
-              "* `:truncate` - `NOTE_TRUNCATE`\n\n"
-              "* `:write` - `NOTE_WRITE`\n\n\n"
-              "EVENT TYPES\n\n"
               "On Windows, events will have the following possible types:\n\n"
               "* `:unknown`\n\n"
               "* `:added`\n\n"
@@ -912,7 +633,7 @@ JANET_CORE_FN(cfun_filewatch_add,
               "* `:modified`\n\n"
               "* `:renamed-old`\n\n"
               "* `:renamed-new`\n\n"
-              "On Linux and BSDs, events will have a `:type` corresponding to the possible flags, excluding `:all`.\n"
+              "On Linux, events will have a `:type` corresponding to the possible flags, excluding `:all`.\n"
               "") {
     janet_arity(argc, 2, -1);
     JanetWatcher *watcher = janet_getabstract(argv, 0, &janet_filewatch_at);
@@ -927,7 +648,6 @@ JANET_CORE_FN(cfun_filewatch_remove,
               "Remove a path from the watcher.") {
     janet_fixarity(argc, 2);
     JanetWatcher *watcher = janet_getabstract(argv, 0, &janet_filewatch_at);
-    /* TODO - pass string in directly to avoid extra allocation */
     const char *path = janet_getcstring(argv, 1);
     janet_watcher_remove(watcher, path);
     return argv[0];

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
@@ -504,7 +504,14 @@ void janet_sweep() {
                 if (head->type->gcperthread) {
                     janet_assert(!head->type->gcperthread(head->data, head->size), "per-thread finalizer failed");
                 }
-                janet_abstract_decref_maybe_free(abst);
+                if (0 == janet_abstract_decref(abst)) {
+                    /* Run finalizer */
+                    if (head->type->gc) {
+                        janet_assert(!head->type->gc(head->data, head->size), "finalizer failed");
+                    }
+                    /* Free memory */
+                    janet_free(janet_abstract_head(abst));
+                }
 
                 /* Mark as tombstone in place */
                 items[i].key = janet_wrap_nil();
@@ -675,7 +682,12 @@ void janet_clear_memory(void) {
             if (head->type->gcperthread) {
                 janet_assert(!head->type->gcperthread(head->data, head->size), "per-thread finalizer failed");
             }
-            janet_abstract_decref_maybe_free(abst);
+            if (0 == janet_abstract_decref(abst)) {
+                if (head->type->gc) {
+                    janet_assert(!head->type->gc(head->data, head->size), "finalizer failed");
+                }
+                janet_free(janet_abstract_head(abst));
+            }
         }
     }
 #endif

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
@@ -333,7 +333,7 @@ static int compare_uint64_double(uint64_t x, double y) {
     }
 }
 
-static JANET_CFUNCTION_ALIGN Janet cfun_it_s64_compare(int32_t argc, Janet *argv) {
+static Janet cfun_it_s64_compare(int32_t argc, Janet *argv) {
     janet_fixarity(argc, 2);
     if (janet_is_int(argv[0]) != JANET_INT_S64) {
         janet_panic("compare method requires int/s64 as first argument");
@@ -368,7 +368,7 @@ static JANET_CFUNCTION_ALIGN Janet cfun_it_s64_compare(int32_t argc, Janet *argv
     return janet_wrap_nil();
 }
 
-static JANET_CFUNCTION_ALIGN Janet cfun_it_u64_compare(int32_t argc, Janet *argv) {
+static Janet cfun_it_u64_compare(int32_t argc, Janet *argv) {
     janet_fixarity(argc, 2);
     if (janet_is_int(argv[0]) != JANET_INT_U64) {
         janet_panic("compare method requires int/u64 as first argument");
@@ -416,7 +416,7 @@ static JANET_CFUNCTION_ALIGN Janet cfun_it_u64_compare(int32_t argc, Janet *argv
  * This will not affect the end result (property of twos complement).
  */
 #define OPMETHOD(T, type, name, oper) \
-static JANET_CFUNCTION_ALIGN Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
+static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
     janet_arity(argc, 2, -1); \
     T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
     *box = janet_unwrap_##type(argv[0]); \
@@ -427,7 +427,7 @@ static JANET_CFUNCTION_ALIGN Janet cfun_it_##type##_##name(int32_t argc, Janet *
 } \
 
 #define OPMETHODINVERT(T, type, name, oper) \
-static JANET_CFUNCTION_ALIGN Janet cfun_it_##type##_##name##i(int32_t argc, Janet *argv) { \
+static Janet cfun_it_##type##_##name##i(int32_t argc, Janet *argv) { \
     janet_fixarity(argc, 2); \
     T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
     *box = janet_unwrap_##type(argv[1]); \
@@ -437,7 +437,7 @@ static JANET_CFUNCTION_ALIGN Janet cfun_it_##type##_##name##i(int32_t argc, Jane
 } \
 
 #define UNARYMETHOD(T, type, name, oper) \
-static JANET_CFUNCTION_ALIGN Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
+static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
     janet_fixarity(argc, 1); \
     T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
     *box = oper(janet_unwrap_##type(argv[0])); \
@@ -450,7 +450,7 @@ static JANET_CFUNCTION_ALIGN Janet cfun_it_##type##_##name(int32_t argc, Janet *
 #define DIVZERO_mod return janet_wrap_abstract(box)
 
 #define DIVMETHOD(T, type, name, oper) \
-static JANET_CFUNCTION_ALIGN Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
+static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
     janet_arity(argc, 2, -1);                       \
     T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
     *box = janet_unwrap_##type(argv[0]); \
@@ -463,7 +463,7 @@ static JANET_CFUNCTION_ALIGN Janet cfun_it_##type##_##name(int32_t argc, Janet *
 } \
 
 #define DIVMETHODINVERT(T, type, name, oper) \
-static JANET_CFUNCTION_ALIGN Janet cfun_it_##type##_##name##i(int32_t argc, Janet *argv) { \
+static Janet cfun_it_##type##_##name##i(int32_t argc, Janet *argv) { \
     janet_fixarity(argc, 2);                       \
     T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
     *box = janet_unwrap_##type(argv[1]); \
@@ -474,7 +474,7 @@ static JANET_CFUNCTION_ALIGN Janet cfun_it_##type##_##name##i(int32_t argc, Jane
 } \
 
 #define DIVMETHOD_SIGNED(T, type, name, oper) \
-static JANET_CFUNCTION_ALIGN Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
+static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
     janet_arity(argc, 2, -1);                       \
     T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
     *box = janet_unwrap_##type(argv[0]); \
@@ -488,7 +488,7 @@ static JANET_CFUNCTION_ALIGN Janet cfun_it_##type##_##name(int32_t argc, Janet *
 } \
 
 #define DIVMETHODINVERT_SIGNED(T, type, name, oper) \
-static JANET_CFUNCTION_ALIGN Janet cfun_it_##type##_##name##i(int32_t argc, Janet *argv) { \
+static Janet cfun_it_##type##_##name##i(int32_t argc, Janet *argv) { \
     janet_fixarity(argc, 2);                       \
     T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
     *box = janet_unwrap_##type(argv[1]); \
@@ -499,7 +499,7 @@ static JANET_CFUNCTION_ALIGN Janet cfun_it_##type##_##name##i(int32_t argc, Jane
     return janet_wrap_abstract(box); \
 } \
 
-static JANET_CFUNCTION_ALIGN Janet cfun_it_s64_divf(int32_t argc, Janet *argv) {
+static Janet cfun_it_s64_divf(int32_t argc, Janet *argv) {
     janet_fixarity(argc, 2);
     int64_t *box = janet_abstract(&janet_s64_type, sizeof(int64_t));
     int64_t op1 = janet_unwrap_s64(argv[0]);
@@ -510,7 +510,7 @@ static JANET_CFUNCTION_ALIGN Janet cfun_it_s64_divf(int32_t argc, Janet *argv) {
     return janet_wrap_abstract(box);
 }
 
-static JANET_CFUNCTION_ALIGN Janet cfun_it_s64_divfi(int32_t argc, Janet *argv) {
+static Janet cfun_it_s64_divfi(int32_t argc, Janet *argv) {
     janet_fixarity(argc, 2);
     int64_t *box = janet_abstract(&janet_s64_type, sizeof(int64_t));
     int64_t op2 = janet_unwrap_s64(argv[0]);
@@ -521,7 +521,7 @@ static JANET_CFUNCTION_ALIGN Janet cfun_it_s64_divfi(int32_t argc, Janet *argv)
     return janet_wrap_abstract(box);
 }
 
-static JANET_CFUNCTION_ALIGN Janet cfun_it_s64_mod(int32_t argc, Janet *argv) {
+static Janet cfun_it_s64_mod(int32_t argc, Janet *argv) {
     janet_fixarity(argc, 2);
     int64_t *box = janet_abstract(&janet_s64_type, sizeof(int64_t));
     int64_t op1 = janet_unwrap_s64(argv[0]);
@@ -535,7 +535,7 @@ static JANET_CFUNCTION_ALIGN Janet cfun_it_s64_mod(int32_t argc, Janet *argv) {
     return janet_wrap_abstract(box);
 }
 
-static JANET_CFUNCTION_ALIGN Janet cfun_it_s64_modi(int32_t argc, Janet *argv) {
+static Janet cfun_it_s64_modi(int32_t argc, Janet *argv) {
     janet_fixarity(argc, 2);
     int64_t *box = janet_abstract(&janet_s64_type, sizeof(int64_t));
     int64_t op2 = janet_unwrap_s64(argv[0]);

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
@@ -43,7 +43,6 @@ static void *io_file_unmarshal(JanetMarshalContext *ctx);
 static Janet io_file_next(void *p, Janet key);
 
 #ifdef JANET_WINDOWS
-#include <io.h>
 #define ftell _ftelli64
 #define fseek _fseeki64
 #endif
@@ -110,12 +109,11 @@ static int32_t checkflags(const uint8_t *str) {
     return flags;
 }
 
-static void *makef(FILE *f, int32_t flags, size_t bufsize) {
+static void *makef(FILE *f, int32_t flags) {
     JanetFile *iof = (JanetFile *) janet_abstract(&janet_file_type, sizeof(JanetFile));
     iof->file = f;
     iof->flags = flags;
-    iof->vbufsize = bufsize;
-#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))
@@ -166,9 +164,8 @@ JANET_CORE_FN(cfun_io_fopen,
         flags = JANET_FILE_READ;
     }
     FILE *f = fopen((const char *)fname, (const char *)fmode);
-    size_t bufsize = BUFSIZ;
     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)) {
@@ -176,7 +173,7 @@ JANET_CORE_FN(cfun_io_fopen,
             janet_panicf("cannot open directory: %s", fname);
         }
 #endif
-        bufsize = janet_optsize(argv, argc, 2, BUFSIZ);
+        size_t bufsize = janet_optsize(argv, argc, 2, BUFSIZ);
         if (bufsize != BUFSIZ) {
             int result = setvbuf(f, NULL, bufsize ? _IOFBF : _IONBF, bufsize);
             if (result) {
@@ -184,7 +181,7 @@ JANET_CORE_FN(cfun_io_fopen,
             }
         }
     }
-    return f ? janet_wrap_abstract(makef(f, flags, bufsize))
+    return f ? janet_makefile(f, flags)
            : (flags & JANET_FILE_NONIL) ? (janet_panicf("failed to open file %s: %s", fname, janet_strerror(errno)), janet_wrap_nil())
            : janet_wrap_nil();
 }
@@ -252,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)
@@ -413,23 +410,12 @@ static void io_file_marshal(void *p, JanetMarshalContext *ctx) {
     JanetFile *iof = (JanetFile *)p;
     if (ctx->flags & JANET_MARSHAL_UNSAFE) {
         janet_marshal_abstract(ctx, p);
-        int fno = -1;
 #ifdef JANET_WINDOWS
-        if (iof->flags & JANET_FILE_NOT_CLOSEABLE) {
-            fno = _fileno(iof->file);
-        } else {
-            fno = _dup(_fileno(iof->file));
-        }
+        janet_marshal_int(ctx, _fileno(iof->file));
 #else
-        if (iof->flags & JANET_FILE_NOT_CLOSEABLE) {
-            fno = fileno(iof->file);
-        } else {
-            fno = dup(fileno(iof->file));
-        }
+        janet_marshal_int(ctx, fileno(iof->file));
 #endif
-        janet_marshal_int(ctx, fno);
         janet_marshal_int(ctx, iof->flags);
-        janet_marshal_size(ctx, iof->vbufsize);
     } else {
         janet_panic("cannot marshal file in safe mode");
     }
@@ -458,11 +444,6 @@ static void *io_file_unmarshal(JanetMarshalContext *ctx) {
         } else {
             iof->flags = flags;
         }
-        iof->vbufsize = janet_unmarshal_size(ctx);
-        if (iof->vbufsize != BUFSIZ) {
-            int result = setvbuf(iof->file, NULL, iof->vbufsize ? _IOFBF : _IONBF, iof->vbufsize);
-            janet_assert(!result, "unmarshal setvbuf");
-        }
         return iof;
     } else {
         janet_panic("cannot unmarshal file in safe mode");
@@ -740,15 +721,8 @@ JANET_CORE_FN(cfun_io_eflush,
 void janet_dynprintf(const char *name, FILE *dflt_file, const char *format, ...) {
     va_list args;
     va_start(args, format);
-    JanetType xtype;
-    Janet x;
-    if (!name || name[0] == '\0') { /* Allow NULL or empty string to just use dflt_file directly */
-        x = janet_wrap_nil();
-        xtype = JANET_NIL;
-    } else {
-        x = janet_dyn(name);
-        xtype = janet_type(x);
-    }
+    Janet x = janet_dyn(name);
+    JanetType xtype = janet_type(x);
     switch (xtype) {
         default:
             /* Other values simply do nothing */
@@ -804,11 +778,11 @@ FILE *janet_getfile(const Janet *argv, int32_t n, int32_t *flags) {
 }
 
 JanetFile *janet_makejfile(FILE *f, int32_t flags) {
-    return makef(f, flags, BUFSIZ);
+    return makef(f, flags);
 }
 
 Janet janet_makefile(FILE *f, int32_t flags) {
-    return janet_wrap_abstract(makef(f, flags, BUFSIZ));
+    return janet_wrap_abstract(makef(f, flags));
 }
 
 JanetAbstract janet_checkfile(Janet j) {

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
@@ -276,8 +276,6 @@ static void marshal_one_def(MarshalState *st, JanetFuncDef *def, int flags) {
     pushint(st, def->max_arity);
     pushint(st, def->constants_length);
     pushint(st, def->bytecode_length);
-    if (def->flags & JANET_FUNCDEF_FLAG_NAMEDARGS)
-        pushint(st, def->named_args_count);
     if (def->flags & JANET_FUNCDEF_FLAG_HASENVS)
         pushint(st, def->environments_length);
     if (def->flags & JANET_FUNCDEF_FLAG_HASDEFS)
@@ -916,7 +914,6 @@ static const uint8_t *unmarshal_one_def(
         def->sourcemap = NULL;
         def->symbolmap = NULL;
         def->symbolmap_length = 0;
-        def->named_args_count = 0;
         janet_v_push(st->lookup_defs, def);
 
         /* Set default lengths to zero */
@@ -936,8 +933,6 @@ static const uint8_t *unmarshal_one_def(
         /* Read some lengths */
         constants_length = readnat(st, &data);
         bytecode_length = readnat(st, &data);
-        if (def->flags & JANET_FUNCDEF_FLAG_NAMEDARGS)
-            def->named_args_count = readnat(st, &data);
         if (def->flags & JANET_FUNCDEF_FLAG_HASENVS)
             environments_length = readnat(st, &data);
         if (def->flags & JANET_FUNCDEF_FLAG_HASDEFS)
@@ -1698,7 +1693,6 @@ JANET_CORE_FN(cfun_unmarshal,
               "Unmarshal a value from a buffer. An optional lookup table "
               "can be provided to allow for aliases to be resolved. Returns the value "
               "unmarshalled from the buffer.") {
-    janet_sandbox_assert(JANET_SANDBOX_UNMARSHAL);
     janet_arity(argc, 1, 2);
     JanetByteView view = janet_getbytes(argv, 0);
     JanetTable *reg = NULL;

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
@@ -120,55 +120,7 @@ static void janet_net_socknoblock(JSock s) {
 #endif
 }
 
-/* Allow specifying IPV6 vs. IPV4 (or unix domain socket) */
-static int net_get_address_family(Janet x) {
-    if (janet_checktype(x, JANET_NIL)) {
-        return AF_UNSPEC;
-    }
-    if (janet_keyeq(x, "ipv4")) {
-        return AF_INET;
-    }
-    if (janet_keyeq(x, "ipv6")) {
-        return AF_INET6;
-    }
-#ifndef JANET_WINDOWS
-    if (janet_keyeq(x, "unix")) {
-        return AF_UNIX;
-    }
-#endif
-    return AF_UNSPEC;
-}
-
 /* State machine for async connect */
-#ifdef JANET_WINDOWS
-
-typedef struct NetStateConnect {
-    /* Only used for ConnectEx */
-    JanetOverlapped overlapped;
-} NetStateConnect;
-
-static LPFN_CONNECTEX lazy_get_connectex(JSock sock) {
-    /* Get ConnectEx */
-    if (janet_vm.connect_ex_loaded) {
-        return janet_vm.connect_ex;
-    }
-    GUID guid = WSAID_CONNECTEX;
-    LPFN_CONNECTEX connect_ex_ptr = NULL;
-    DWORD byte_len = 0;
-    int success = WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER,
-                           (void*)&guid, sizeof(guid),
-                           (void*)&connect_ex_ptr, sizeof(connect_ex_ptr),
-                           &byte_len, NULL, NULL);
-    if (success) {
-        janet_vm.connect_ex = connect_ex_ptr;
-    } else {
-        janet_vm.connect_ex = NULL;
-    }
-    janet_vm.connect_ex_loaded = 1;
-    return janet_vm.connect_ex;
-}
-
-#endif
 
 void net_callback_connect(JanetFiber *fiber, JanetAsyncEvent event) {
     JanetStream *stream = fiber->ev_stream;
@@ -188,21 +140,15 @@ void net_callback_connect(JanetFiber *fiber, JanetAsyncEvent event) {
             return;
     }
 #ifdef JANET_WINDOWS
-    /* We should be using ConnectEx here */
     int res = 0;
     int size = sizeof(res);
-    int r = getsockopt((SOCKET)stream->handle, SOL_SOCKET, SO_CONNECT_TIME, (char *)&res, &size);
-    if (r == NO_ERROR && res == 0xFFFFFFFF) {
-        return; /* This apparently indicates we haven't yet gotten a connection */
-    }
-    const int no_error = NO_ERROR;
+    int r = getsockopt((SOCKET)stream->handle, SOL_SOCKET, SO_ERROR, (char *)&res, &size);
 #else
     int res = 0;
-    socklen_t size = sizeof(res);
+    socklen_t size = sizeof res;
     int r = getsockopt(stream->handle, SOL_SOCKET, SO_ERROR, &res, &size);
-    const int no_error = 0;
 #endif
-    if (r == no_error) {
+    if (r == 0) {
         if (res == 0) {
             janet_schedule(fiber, janet_wrap_abstract(stream));
         } else {
@@ -216,8 +162,8 @@ void net_callback_connect(JanetFiber *fiber, JanetAsyncEvent event) {
     janet_async_end(fiber);
 }
 
-static JANET_NO_RETURN void net_sched_connect(JanetStream *stream, void *state) {
-    janet_async_start(stream, JANET_ASYNC_LISTEN_WRITE, net_callback_connect, state);
+static JANET_NO_RETURN void net_sched_connect(JanetStream *stream) {
+    janet_async_start(stream, JANET_ASYNC_LISTEN_WRITE, net_callback_connect, NULL);
 }
 
 /* State machine for accepting connections. */
@@ -225,7 +171,7 @@ static JANET_NO_RETURN void net_sched_connect(JanetStream *stream, void *state)
 #ifdef JANET_WINDOWS
 
 typedef struct {
-    JanetOverlapped overlapped;
+    WSAOVERLAPPED overlapped;
     JanetFunction *function;
     JanetStream *lstream;
     JanetStream *astream;
@@ -288,7 +234,7 @@ void net_callback_accept(JanetFiber *fiber, JanetAsyncEvent event) {
 JANET_NO_RETURN static void janet_sched_accept(JanetStream *stream, JanetFunction *fun) {
     Janet err;
     NetStateAccept *state = janet_malloc(sizeof(NetStateAccept));
-    memset(&state->overlapped, 0, sizeof(JanetOverlapped));
+    memset(&state->overlapped, 0, sizeof(WSAOVERLAPPED));
     memset(&state->buf, 0, 1024);
     state->function = fun;
     state->lstream = stream;
@@ -309,7 +255,7 @@ static int net_sched_accept_impl(NetStateAccept *state, JanetFiber *fiber, Janet
     JanetStream *astream = make_stream(asock, JANET_STREAM_READABLE | JANET_STREAM_WRITABLE);
     state->astream = astream;
     int socksize = sizeof(SOCKADDR_STORAGE) + 16;
-    if (FALSE == AcceptEx(lsock, asock, state->buf, 0, socksize, socksize, NULL, &state->overlapped.as.wsaoverlapped)) {
+    if (FALSE == AcceptEx(lsock, asock, state->buf, 0, socksize, socksize, NULL, &state->overlapped)) {
         int code = WSAGetLastError();
         if (code == WSA_IO_PENDING) {
             /* indicates io is happening async */
@@ -605,44 +551,15 @@ JANET_CORE_FN(cfun_net_connect,
     if (socktype == SOCK_DGRAM) udp_flag = JANET_STREAM_UDPSERVER;
     JanetStream *stream = make_stream(sock, JANET_STREAM_READABLE | JANET_STREAM_WRITABLE | udp_flag);
 
-    /* Connect to socket */
-#ifdef JANET_WINDOWS
-    int status = 0;
-    int err = 0;
-    LPFN_CONNECTEX connect_ex = NULL;
-    if (socktype == SOCK_STREAM && ((connect_ex = lazy_get_connectex(sock)))) {
-        /* Prefer ConnecEx as it works well with overlapped IO. */
-        janet_net_socknoblock(sock);
-        NetStateConnect *state = janet_malloc(sizeof(NetStateConnect));
-        memset(state, 0, sizeof(NetStateConnect));
-        BOOL success = connect_ex(sock, addr, addrlen, NULL, 0, NULL, &state->overlapped.as.overlapped);
-        freeaddrinfo(ai);
-        if (success) {
-            /* Did not fail */
-        } else {
-            int err = WSAGetLastError();
-            if (err == ERROR_IO_PENDING) {
-                /* Did not actually fail yet */
-            } else {
-                janet_free(state);
-                Janet lasterr = janet_ev_lasterr();
-                janet_panicf("could not connect socket (ConnectEx): %V", lasterr);
-            }
-        }
-
-        net_sched_connect(stream, state);
-    } else {
-        /* Default to blocking connect if ConnectEx not available */
-        status = WSAConnect(sock, addr, addrlen, NULL, NULL, NULL, NULL);
-        err = WSAGetLastError();
-        freeaddrinfo(ai);
-        /* Set up the socket for non-blocking IO after connecting on windows by default */
-        janet_net_socknoblock(sock);
-    }
-
-#else
     /* Set up the socket for non-blocking IO before connecting */
     janet_net_socknoblock(sock);
+
+    /* Connect to socket */
+#ifdef JANET_WINDOWS
+    int status = WSAConnect(sock, addr, addrlen, NULL, NULL, NULL, NULL);
+    int err = WSAGetLastError();
+    freeaddrinfo(ai);
+#else
     int status;
     do {
         status = connect(sock, addr, addrlen);
@@ -655,19 +572,10 @@ 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) {
 #ifdef JANET_WINDOWS
-    if (status == SOCKET_ERROR) {
         if (err != WSAEWOULDBLOCK) {
 #else
-    if (status == -1) {
         if (err != EINPROGRESS) {
 #endif
             JSOCKCLOSE(sock);
@@ -676,15 +584,14 @@ JANET_CORE_FN(cfun_net_connect,
         }
     }
 
-    net_sched_connect(stream, NULL);
+    net_sched_connect(stream);
 }
 
 JANET_CORE_FN(cfun_net_socket,
-              "(net/socket &opt type address-family)",
+              "(net/socket &opt type)",
               "Creates a new unbound socket. Type is an optional keyword, "
-              "either a :stream (usually tcp), or :datagram (usually udp). The default is :stream. "
-              "`address-family` should be one of :ipv4 or :ipv6.") {
-    janet_arity(argc, 0, 2);
+              "either a :stream (usually tcp), or :datagram (usually udp). The default is :stream.") {
+    janet_arity(argc, 0, 1);
 
     int socktype = janet_get_sockettype(argv, argc, 0);
 
@@ -695,14 +602,7 @@ JANET_CORE_FN(cfun_net_socket,
     memset(&hints, 0, sizeof(hints));
     hints.ai_family = AF_UNSPEC;
     hints.ai_socktype = socktype;
-#ifdef AI_NUMERICSERV
-    hints.ai_flags = AI_NUMERICSERV; /* Explicitly prevent name resolution */
-#else
     hints.ai_flags = 0;
-#endif
-    if (argc >= 2) {
-        hints.ai_family = net_get_address_family(argv[1]);
-    }
     int status = getaddrinfo(NULL, "0", &hints, &ai);
     if (status) {
         janet_panicf("could not get address info: %s", gai_strerror(status));
@@ -1130,8 +1030,6 @@ static const struct sockopt_type sockopt_type_list[] = {
 #ifndef JANET_NO_IPV6
     { "ipv6-join-group", IPPROTO_IPV6, IPV6_JOIN_GROUP, JANET_POINTER },
     { "ipv6-leave-group", IPPROTO_IPV6, IPV6_LEAVE_GROUP, JANET_POINTER },
-    { "ipv6-multicast-hops", IPPROTO_IPV6, IPV6_MULTICAST_HOPS, JANET_NUMBER },
-    { "ipv6-unicast-hops", IPPROTO_IPV6, IPV6_UNICAST_HOPS, JANET_NUMBER },
 #endif
     { NULL, 0, 0, JANET_POINTER }
 };
@@ -1148,10 +1046,7 @@ JANET_CORE_FN(cfun_net_setsockopt,
               "- :ip-add-membership string\n"
               "- :ip-drop-membership string\n"
               "- :ipv6-join-group string\n"
-              "- :ipv6-leave-group string\n"
-              "- :ipv6-multicast-hops number\n"
-              "- :ipv6-unicast-hops number\n"
-             ) {
+              "- :ipv6-leave-group string\n") {
     janet_arity(argc, 3, 3);
     JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type);
     janet_stream_flags(stream, JANET_STREAM_SOCKET);
@@ -1170,7 +1065,6 @@ JANET_CORE_FN(cfun_net_setsockopt,
     }
 
     union {
-        unsigned char v_uchar;
         int v_int;
         struct ip_mreq v_mreq;
 #ifndef JANET_NO_IPV6
@@ -1185,19 +1079,8 @@ JANET_CORE_FN(cfun_net_setsockopt,
         val.v_int = janet_getboolean(argv, 2);
         optlen = sizeof(val.v_int);
     } else if (st->type == JANET_NUMBER) {
-#if defined(JANET_BSD) || defined(JANET_ILLUMOS)
-        int v_int = janet_getinteger(argv, 2);
-        if (st->optname == IP_MULTICAST_TTL) {
-            val.v_uchar = v_int;
-            optlen = sizeof(val.v_uchar);
-        } else {
-            val.v_int = v_int;
-            optlen = sizeof(val.v_int);
-        }
-#else
         val.v_int = janet_getinteger(argv, 2);
         optlen = sizeof(val.v_int);
-#endif
     } else if (st->optname == IP_ADD_MEMBERSHIP || st->optname == IP_DROP_MEMBERSHIP) {
         const char *addr = janet_getcstring(argv, 2);
         memset(&val.v_mreq, 0, sizeof val.v_mreq);
@@ -1276,8 +1159,6 @@ void janet_net_init(void) {
 #ifdef JANET_WINDOWS
     WSADATA wsaData;
     janet_assert(!WSAStartup(MAKEWORD(2, 2), &wsaData), "could not start winsock");
-    janet_vm.connect_ex_loaded = 0;
-    janet_vm.connect_ex = NULL;
 #endif
 }
 

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
@@ -40,7 +40,6 @@
 #include <sys/stat.h>
 #include <signal.h>
 #include <locale.h>
-#include <inttypes.h>
 
 #ifdef JANET_BSD
 #include <sys/sysctl.h>
@@ -58,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,8 +67,7 @@
 #include <crt_externs.h>
 #define environ (*_NSGetEnviron())
 #include <AvailabilityMacros.h>
-int chroot(const char *dirname);
-#elif !defined(JANET_PLAN9)
+#else
 extern char **environ;
 #endif
 #ifdef JANET_THREADS
@@ -143,8 +139,8 @@ static void janet_unlock_environ(void) {
 #define janet_stringify(x) janet_stringify1(x)
 
 JANET_CORE_FN(os_which,
-              "(os/which &opt test)",
-              "Check the current operating system. If `test` is nil or unset, Returns one of:\n\n"
+              "(os/which)",
+              "Check the current operating system. Returns one of:\n\n"
               "* :windows\n\n"
               "* :mingw\n\n"
               "* :cygwin\n\n"
@@ -157,12 +153,9 @@ JANET_CORE_FN(os_which,
               "* :dragonfly\n\n"
               "* :bsd\n\n"
               "* :posix - A POSIX compatible system (default)\n\n"
-              "May also return a custom keyword specified at build time. Is `test` is truthy, will check if the current operating system equals `test` and return true if they are the same, false otherwise.") {
-    janet_arity(argc, 0, 1);
-    if (argc == 1 && janet_truthy(argv[0])) {
-        janet_getkeyword(argv, 0); /* Constrain to keywords */
-        return janet_wrap_boolean(janet_equals(argv[0], os_which(0, NULL)));
-    }
+              "May also return a custom keyword specified at build time.") {
+    janet_fixarity(argc, 0);
+    (void) argv;
 #if defined(JANET_OS_NAME)
     return janet_ckeywordv(janet_stringify(JANET_OS_NAME));
 #elif defined(JANET_MINGW)
@@ -250,7 +243,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;
@@ -260,8 +252,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
@@ -300,43 +290,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
 }
 
@@ -366,8 +359,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);
@@ -1215,7 +1206,7 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
         if (is_spawn && janet_keyeq(maybe_stderr, "pipe")) {
             new_err = make_pipes(&pipe_err, 0, &pipe_errflag);
             pipe_owner_flags |= JANET_PROC_OWNS_STDERR;
-        } else if (janet_keyeq(maybe_stderr, "out")) {
+        } else if (is_spawn && janet_keyeq(maybe_stderr, "out")) {
             stderr_is_stdout = 1;
         } else if (!janet_checktype(maybe_stderr, JANET_NIL)) {
             new_err = janet_getjstream(&maybe_stderr, 0, &orig_err);
@@ -1301,7 +1292,6 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
     }
 
     int cp_failed = 0;
-    DWORD cp_error_code = 0;
     if (!CreateProcess(janet_flag_at(flags, 1) ? NULL : path,
                        (char *) buf->data, /* Single CLI argument */
                        &saAttr, /* no proc inheritance */
@@ -1313,7 +1303,6 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
                        &startupInfo,
                        &processInfo)) {
         cp_failed = 1;
-        cp_error_code = GetLastError();
     }
 
     if (pipe_in != JANET_HANDLE_NONE) CloseHandle(pipe_in);
@@ -1323,25 +1312,7 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
     os_execute_cleanup(envp, NULL);
 
     if (cp_failed)  {
-        char msgbuf[256];
-        msgbuf[0] = '\0';
-        FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-                      NULL,
-                      cp_error_code,
-                      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-                      msgbuf,
-                      sizeof(msgbuf),
-                      NULL);
-        if (!*msgbuf) snprintf(msgbuf, sizeof(msgbuf), "%" PRIu32, (uint32_t) cp_error_code);
-        char *c = msgbuf;
-        while (*c) {
-            if (*c == '\n' || *c == '\r') {
-                *c = '\0';
-                break;
-            }
-            c++;
-        }
-        janet_panicf("failed to create process: %s", janet_cstringv(msgbuf));
+        janet_panic("failed to create process");
     }
 
     pHandle = processInfo.hProcess;
@@ -1367,9 +1338,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;
         }
@@ -1380,11 +1348,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 */
@@ -1453,8 +1419,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
@@ -1492,7 +1456,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,
@@ -1553,7 +1516,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;
@@ -1561,13 +1524,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));
     }
@@ -1582,28 +1541,6 @@ JANET_CORE_FN(os_posix_fork,
 #endif
 }
 
-JANET_CORE_FN(os_posix_chroot,
-              "(os/posix-chroot dirname)",
-              "Call `chroot` to change the root directory to `dirname`. "
-              "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");
-#else
-    const char *root = janet_getcstring(argv, 0);
-    int result;
-    do {
-        result = chroot(root);
-    } while (result == -1 && errno == EINTR);
-    if (result == -1) {
-        janet_panic(janet_strerror(errno));
-    }
-    return janet_wrap_nil();
-#endif
-}
-
 #ifdef JANET_EV
 /* Runs in a separate thread */
 static JanetEVGenericMessage os_shell_subr(JanetEVGenericMessage args) {
@@ -1639,7 +1576,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.") {
@@ -1671,7 +1607,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)",
@@ -1696,9 +1631,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)
@@ -1871,8 +1803,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);
@@ -1882,8 +1812,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
@@ -1894,8 +1822,9 @@ static struct tm *time_to_tm(const Janet *argv, int32_t argc, int32_t n, struct
 JANET_CORE_FN(os_date,
               "(os/date &opt time local)",
               "Returns the given time as a date struct, or the current time if `time` is not given. "
+              "Returns a struct with following key values. Note that all numbers are 0-indexed. "
               "Date is given in UTC unless `local` is truthy, in which case the date is formatted for "
-              "the local timezone. Returns a struct with following key values. Note that all numbers are 0-indexed.\n\n"
+              "the local timezone.\n\n"
               "* :seconds - number of seconds [0-61]\n\n"
               "* :minutes - number of minutes [0-59]\n\n"
               "* :hours - number of hours [0-23]\n\n"
@@ -1904,9 +1833,7 @@ JANET_CORE_FN(os_date,
               "* :year - years since year 0 (e.g. 2019)\n\n"
               "* :week-day - day of the week [0-6]\n\n"
               "* :year-day - day of the year [0-365]\n\n"
-              "* :dst - if Day Light Savings is in effect\n\n"
-              "You can set local timezone by setting TZ environment variable. "
-              "See tzset(<time.h>) or _tzset(<time.h>) for further details.") {
+              "* :dst - if Day Light Savings is in effect") {
     janet_arity(argc, 0, 2);
     (void) argv;
     struct tm t_infos;
@@ -1924,15 +1851,14 @@ JANET_CORE_FN(os_date,
     return janet_wrap_struct(janet_struct_end(st));
 }
 
-#define SIZETIMEFMT 250
+#define SIZETIMEFMT     250
 
 JANET_CORE_FN(os_strftime,
               "(os/strftime fmt &opt time local)",
               "Format the given time as a string, or the current time if `time` is not given. "
               "The time is formatted according to the same rules as the ISO C89 function strftime(). "
               "The time is formatted in UTC unless `local` is truthy, in which case the date is formatted for "
-              "the local timezone. You can set local timezone by setting TZ environment variable. "
-              "See tzset(<time.h>) or _tzset(<time.h>) for further details.") {
+              "the local timezone.") {
     janet_arity(argc, 1, 3);
     const char *fmt = janet_getcstring(argv, 0);
     /* ANSI X3.159-1989, section 4.12.3.5 "The strftime function" */
@@ -1940,9 +1866,6 @@ JANET_CORE_FN(os_strftime,
     const char *p = fmt;
     while (*p) {
         if (*p++ == '%') {
-            if (!*p) {
-                janet_panic("invalid conversion specifier");
-            }
             if (!strchr(valid, *p)) {
                 janet_panicf("invalid conversion specifier '%%%c'", *p);
             }
@@ -1952,7 +1875,7 @@ JANET_CORE_FN(os_strftime,
     struct tm t_infos;
     struct tm *t_info = time_to_tm(argv, argc, 1, &t_infos);
     char buf[SIZETIMEFMT];
-    (void)strftime(buf, sizeof(buf), fmt, t_info);
+    (void)strftime(buf, SIZETIMEFMT, fmt, t_info);
     return janet_cstringv(buf);
 }
 
@@ -1960,7 +1883,7 @@ static int entry_getdst(Janet env_entry) {
     Janet v;
     if (janet_checktype(env_entry, JANET_TABLE)) {
         JanetTable *entry = janet_unwrap_table(env_entry);
-        v = janet_table_get_keyword(entry, "dst");
+        v = janet_table_get(entry, janet_ckeywordv("dst"));
     } else if (janet_checktype(env_entry, JANET_STRUCT)) {
         const JanetKV *entry = janet_unwrap_struct(env_entry);
         v = janet_struct_get(entry, janet_ckeywordv("dst"));
@@ -1984,7 +1907,7 @@ static timeint_t entry_getint(Janet env_entry, char *field) {
     Janet i;
     if (janet_checktype(env_entry, JANET_TABLE)) {
         JanetTable *entry = janet_unwrap_table(env_entry);
-        i = janet_table_get_keyword(entry, field);
+        i = janet_table_get(entry, janet_ckeywordv(field));
     } else if (janet_checktype(env_entry, JANET_STRUCT)) {
         const JanetKV *entry = janet_unwrap_struct(env_entry);
         i = janet_struct_get(entry, janet_ckeywordv(field));
@@ -2063,7 +1986,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. "
@@ -2100,20 +2022,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);
@@ -2128,10 +2049,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);
@@ -2169,8 +2090,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
@@ -2297,13 +2216,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);
 }
 
@@ -2468,9 +2385,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) {
@@ -2531,13 +2445,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));
@@ -2546,7 +2456,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
@@ -2579,7 +2488,7 @@ JANET_CORE_FN(os_dir,
     char pattern[MAX_PATH + 1];
     if (strlen(dir) > (sizeof(pattern) - 3))
         janet_panicf("path too long: %s", dir);
-    snprintf(pattern, sizeof(pattern), "%s/*", dir);
+    sprintf(pattern, "%s/*", dir);
     intptr_t res = _findfirst(pattern, &afile);
     if (-1 == res) janet_panicv(janet_cstringv(janet_strerror(errno)));
     do {
@@ -2645,15 +2554,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
 }
@@ -2697,11 +2598,10 @@ JANET_CORE_FN(os_open,
               "  * :c - create a new file (O\\_CREATE)\n"
               "  * :e - fail if the file exists (O\\_EXCL)\n"
               "  * :t - shorten an existing file to length 0 (O\\_TRUNC)\n\n"
-              "  * :a - append to a file (O\\_APPEND on posix, FILE_APPEND_DATA on windows)\n"
               "Posix-only flags:\n\n"
+              "  * :a - append to a file (O\\_APPEND)\n"
               "  * :x - O\\_SYNC\n"
               "  * :C - O\\_NOCTTY\n\n"
-              "  * :N - Turn off O\\_NONBLOCK and disable ev reading/writing\n\n"
               "Windows-only flags:\n\n"
               "  * :R - share reads (FILE\\_SHARE\\_READ)\n"
               "  * :W - share writes (FILE\\_SHARE\\_WRITE)\n"
@@ -2711,24 +2611,19 @@ JANET_CORE_FN(os_open,
               "  * :F - FILE\\_ATTRIBUTE\\_OFFLINE\n"
               "  * :T - FILE\\_ATTRIBUTE\\_TEMPORARY\n"
               "  * :d - FILE\\_FLAG\\_DELETE\\_ON\\_CLOSE\n"
-              "  * :V - Turn off FILE\\_FLAG\\_OVERLAPPED and disable ev reading/writing\n"
-              "  * :I - set bInheritHandle on the created file so it can be passed to other processes.\n"
               "  * :b - FILE\\_FLAG\\_NO\\_BUFFERING\n") {
     janet_arity(argc, 1, 3);
     const char *path = janet_getcstring(argv, 0);
     const uint8_t *opt_flags = janet_optkeyword(argv, argc, 1, (const uint8_t *) "r");
     jmode_t mode = os_optmode(argc, argv, 2, 0666);
     uint32_t stream_flags = 0;
-    int disable_stream_mode = 0;
     JanetHandle fd;
 #ifdef JANET_WINDOWS
     (void) mode;
-    int inherited_handle = 0;
     DWORD desiredAccess = 0;
     DWORD shareMode = 0;
     DWORD creationDisp = 0;
-    DWORD fileFlags = FILE_FLAG_OVERLAPPED;
-    DWORD fileAttributes = 0;
+    DWORD flagsAndAttributes = FILE_FLAG_OVERLAPPED;
     /* We map unix-like open flags to the creationDisp parameter */
     int creatUnix = 0;
 #define OCREAT 1
@@ -2748,11 +2643,6 @@ JANET_CORE_FN(os_open,
                 stream_flags |= JANET_STREAM_WRITABLE;
                 janet_sandbox_assert(JANET_SANDBOX_FS_WRITE);
                 break;
-            case 'a':
-                desiredAccess |= FILE_APPEND_DATA;
-                stream_flags |= JANET_STREAM_WRITABLE;
-                janet_sandbox_assert(JANET_SANDBOX_FS_WRITE);
-                break;
             case 'c':
                 creatUnix |= OCREAT;
                 janet_sandbox_assert(JANET_SANDBOX_FS_WRITE);
@@ -2775,29 +2665,22 @@ JANET_CORE_FN(os_open,
                 shareMode |= FILE_SHARE_WRITE;
                 break;
             case 'H':
-                fileAttributes |= FILE_ATTRIBUTE_HIDDEN;
+                flagsAndAttributes |= FILE_ATTRIBUTE_HIDDEN;
                 break;
             case 'O':
-                fileAttributes |= FILE_ATTRIBUTE_READONLY;
+                flagsAndAttributes |= FILE_ATTRIBUTE_READONLY;
                 break;
             case 'F':
-                fileAttributes |= FILE_ATTRIBUTE_OFFLINE;
+                flagsAndAttributes |= FILE_ATTRIBUTE_OFFLINE;
                 break;
             case 'T':
-                fileAttributes |= FILE_ATTRIBUTE_TEMPORARY;
+                flagsAndAttributes |= FILE_ATTRIBUTE_TEMPORARY;
                 break;
             case 'd':
-                fileFlags |= FILE_FLAG_DELETE_ON_CLOSE;
+                flagsAndAttributes |= FILE_FLAG_DELETE_ON_CLOSE;
                 break;
             case 'b':
-                fileFlags |= FILE_FLAG_NO_BUFFERING;
-                break;
-            case 'I':
-                inherited_handle = 1;
-                break;
-            case 'V':
-                fileFlags &= ~FILE_FLAG_OVERLAPPED;
-                disable_stream_mode = 1;
+                flagsAndAttributes |= FILE_FLAG_NO_BUFFERING;
                 break;
                 /* we could potentially add more here -
                  * https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea
@@ -2823,16 +2706,7 @@ JANET_CORE_FN(os_open,
             creationDisp = TRUNCATE_EXISTING;
             break;
     }
-    if (fileAttributes == 0) {
-        fileAttributes = FILE_ATTRIBUTE_NORMAL;
-    }
-    SECURITY_ATTRIBUTES saAttr;
-    memset(&saAttr, 0, sizeof(saAttr));
-    saAttr.nLength = sizeof(saAttr);
-    if (inherited_handle) {
-        saAttr.bInheritHandle = TRUE; /* Needed to do interesting things with file */
-    }
-    fd = CreateFileA(path, desiredAccess, shareMode, &saAttr, creationDisp, fileFlags | fileAttributes, NULL);
+    fd = CreateFileA(path, desiredAccess, shareMode, NULL, creationDisp, flagsAndAttributes, NULL);
     if (fd == INVALID_HANDLE_VALUE) janet_panicv(janet_ev_lasterr());
 #else
     int open_flags = O_NONBLOCK;
@@ -2876,10 +2750,6 @@ JANET_CORE_FN(os_open,
             case 'a':
                 open_flags |= O_APPEND;
                 break;
-            case 'N':
-                open_flags &= ~O_NONBLOCK;
-                disable_stream_mode = 1;
-                break;
         }
     }
     /* If both read and write, fix up to O_RDWR */
@@ -2896,7 +2766,7 @@ JANET_CORE_FN(os_open,
     } while (fd == -1 && errno == EINTR);
     if (fd == -1) janet_panicv(janet_ev_lasterr());
 #endif
-    return janet_wrap_abstract(janet_stream(fd, disable_stream_mode ? 0 : stream_flags, NULL));
+    return janet_wrap_abstract(janet_stream(fd, stream_flags, NULL));
 }
 
 JANET_CORE_FN(os_pipe,
@@ -2964,14 +2834,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),
 
@@ -3007,7 +2873,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
@@ -194,41 +194,6 @@ tail:
             return memcmp(text, rule + 2, len) ? NULL : text + len;
         }
 
-        case RULE_DEBUG: {
-            char buffer[32] = {0};
-            size_t len = (size_t)(s->outer_text_end - text);
-            memcpy(buffer, text, (len > 31 ? 31 : len));
-            janet_eprintf("?? at [%s] (index %d)\n", buffer, (int32_t)(text - s->text_start));
-            int has_color = janet_truthy(janet_dyn("err-color"));
-            /* Accumulate buffer */
-            if (s->scratch->count) {
-                janet_eprintf("accumulate buffer: %v\n", janet_wrap_buffer(s->scratch));
-            }
-            /* Normal captures */
-            if (s->captures->count) {
-                janet_eprintf("stack [%d]:\n", s->captures->count);
-                for (int32_t i = 0; i < s->captures->count; i++) {
-                    if (has_color) {
-                        janet_eprintf("  [%d]: %M\n", i, s->captures->data[i]);
-                    } else {
-                        janet_eprintf("  [%d]: %m\n", i, s->captures->data[i]);
-                    }
-                }
-            }
-            /* Tagged captures */
-            if (s->tagged_captures->count) {
-                janet_eprintf("tag stack [%d]:\n", s->tagged_captures->count);
-                for (int32_t i = 0; i < s->tagged_captures->count; i++) {
-                    if (has_color) {
-                        janet_eprintf("  [%d] tag=%d: %M\n", i, (int32_t) s->tags->data[i], s->tagged_captures->data[i]);
-                    } else {
-                        janet_eprintf("  [%d] tag=%d: %m\n", i, (int32_t) s->tags->data[i], s->tagged_captures->data[i]);
-                    }
-                }
-            }
-            return text;
-        }
-
         case RULE_NCHAR: {
             uint32_t n = rule[1];
             return (text + n > s->text_end) ? NULL : text + n;
@@ -657,7 +622,6 @@ tail:
         }
 
         case RULE_REPLACE:
-        case RULE_MATCHSPLICE:
         case RULE_MATCHTIME: {
             uint32_t tag = rule[3];
             int oldmode = s->mode;
@@ -698,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;
         }
 
@@ -1280,14 +1235,6 @@ static void spec_constant(Builder *b, int32_t argc, const Janet *argv) {
     emit_2(r, RULE_CONSTANT, emit_constant(b, argv[0]), tag);
 }
 
-static void spec_debug(Builder *b, int32_t argc, const Janet *argv) {
-    peg_arity(b, argc, 0, 0);
-    Reserve r = reserve(b, 1);
-    uint32_t empty = 0;
-    (void) argv;
-    emit_rule(r, RULE_DEBUG, 0, &empty);
-}
-
 static void spec_replace(Builder *b, int32_t argc, const Janet *argv) {
     peg_arity(b, argc, 2, 3);
     Reserve r = reserve(b, 4);
@@ -1297,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]);
@@ -1308,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) {
@@ -1392,7 +1331,6 @@ static const SpecialPair peg_specials[] = {
     {"<-", spec_capture},
     {">", spec_look},
     {"?", spec_opt},
-    {"??", spec_debug},
     {"accumulate", spec_accumulate},
     {"any", spec_any},
     {"argument", spec_argument},
@@ -1403,11 +1341,9 @@ 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},
-    {"debug", spec_debug},
     {"drop", spec_drop},
     {"error", spec_error},
     {"group", spec_group},
@@ -1661,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
@@ -1684,10 +1620,6 @@ static void *peg_unmarshal(JanetMarshalContext *ctx) {
             case RULE_LITERAL:
                 i += 2 + ((rule[1] + 3) >> 2);
                 break;
-            case RULE_DEBUG:
-                /* [0 words] */
-                i += 1;
-                break;
             case RULE_NCHAR:
             case RULE_NOTNCHAR:
             case RULE_RANGE:
@@ -1771,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;
@@ -1903,8 +1834,8 @@ static JanetPeg *compile_peg(Janet x) {
 JANET_CORE_FN(cfun_peg_compile,
               "(peg/compile peg)",
               "Compiles a peg source data structure into a <core/peg>. This will speed up matching "
-              "if the same peg will be used multiple times. `(dyn :peg-grammar)` replaces "
-              "`default-peg-grammar` for the grammar of the peg.") {
+              "if the same peg will be used multiple times. Will also use `(dyn :peg-grammar)` to supplement "
+              "the grammar of the peg for otherwise undefined peg keywords.") {
     janet_fixarity(argc, 1);
     JanetPeg *peg = compile_peg(argv[0]);
     return janet_wrap_abstract(peg);

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
@@ -72,7 +72,7 @@ static int count_dig10(int32_t x) {
     }
 }
 
-static int32_t integer_to_string_b(JanetBuffer *buffer, int32_t x) {
+static void integer_to_string_b(JanetBuffer *buffer, int32_t x) {
     janet_buffer_extra(buffer, BUFSIZE);
     uint8_t *buf = buffer->data + buffer->count;
     int32_t neg = 0;
@@ -80,7 +80,7 @@ static int32_t integer_to_string_b(JanetBuffer *buffer, int32_t x) {
     if (x == 0) {
         buf[0] = '0';
         buffer->count++;
-        return 1;
+        return;
     }
     if (x > 0) {
         x = -x;
@@ -96,7 +96,6 @@ static int32_t integer_to_string_b(JanetBuffer *buffer, int32_t x) {
         x /= 10;
     }
     buffer->count += len + neg;
-    return len + neg;
 }
 
 #define HEX(i) (((uint8_t *) janet_base64)[(i)])
@@ -135,55 +134,43 @@ static void string_description_b(JanetBuffer *buffer, const char *title, void *p
 #undef POINTSIZE
 }
 
-static int janet_escape_string_impl(JanetBuffer *buffer, const uint8_t *str, int32_t len) {
+static void janet_escape_string_impl(JanetBuffer *buffer, const uint8_t *str, int32_t len) {
     janet_buffer_push_u8(buffer, '"');
-    int align = 1;
     for (int32_t i = 0; i < len; ++i) {
         uint8_t c = str[i];
         switch (c) {
             case '"':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\\"", 2);
-                align += 2;
                 break;
             case '\n':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\n", 2);
-                align += 2;
                 break;
             case '\r':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\r", 2);
-                align += 2;
                 break;
             case '\0':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\0", 2);
-                align += 2;
                 break;
             case '\f':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\f", 2);
-                align += 2;
                 break;
             case '\v':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\v", 2);
-                align += 2;
                 break;
             case '\a':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\a", 2);
-                align += 2;
                 break;
             case '\b':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\b", 2);
-                align += 2;
                 break;
             case 27:
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\e", 2);
-                align += 2;
                 break;
             case '\\':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\\\", 2);
-                align += 2;
                 break;
             case '\t':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\t", 2);
-                align += 2;
                 break;
             default:
                 if (c < 32 || c > 126) {
@@ -193,16 +180,13 @@ static int janet_escape_string_impl(JanetBuffer *buffer, const uint8_t *str, int
                     buf[2] = janet_base64[(c >> 4) & 0xF];
                     buf[3] = janet_base64[c & 0xF];
                     janet_buffer_push_bytes(buffer, buf, 4);
-                    align += 4;
                 } else {
                     janet_buffer_push_u8(buffer, c);
-                    align++;
                 }
                 break;
         }
     }
     janet_buffer_push_u8(buffer, '"');
-    return align + 1;
 }
 
 static void janet_escape_string_b(JanetBuffer *buffer, const uint8_t *str) {
@@ -374,12 +358,9 @@ const uint8_t *janet_to_string(Janet x) {
 struct pretty {
     JanetBuffer *buffer;
     int depth;
-    int width;
-    int align;
-    int leaf_align;
+    int indent;
     int flags;
     int32_t bufstartlen;
-    int32_t lookback_barrier;
     int32_t *keysort_buffer;
     int32_t keysort_capacity;
     int32_t keysort_start;
@@ -469,76 +450,14 @@ static int print_jdn_one(struct pretty *S, Janet x, int depth) {
     return 0;
 }
 
-static void backtrack_newlines(const struct pretty *S) {
-    if (S->flags & JANET_PRETTY_ONELINE || S->buffer->count <= 0)
-        return;
-    switch (S->buffer->data[S->buffer->count - 1]) {
-        case ')':
-        case '}':
-        case ']':
-            break;
-        default:
-            return;
-    }
-    int32_t removed = 0;
-    int32_t old_count = S->buffer->count;
-    int32_t offset = old_count;
-    int32_t b0 = S->lookback_barrier;
-    int32_t columns = S->width;
-    int32_t align = 0;
-    while (--offset >= b0) {
-        const char *s = (const char *)S->buffer->data + offset;
-        if (*s == '\n') {
-            if (align < S->leaf_align) {
-                break;
-            }
-            columns += align;
-            removed += align;
-            align = 0;
-        } else if (*s == ' ') {
-            align++;
-        } else {
-            align = 0;
-            /* Don't count color sequences: \x1B(0|3\d)m */
-            if (S->flags & JANET_PRETTY_COLOR && *s == 'm') {
-                if (offset >= (3 + b0) && strncmp("\x1B[0m", s - 3, 4) == 0) {
-                    offset -= 3;
-                    columns++;
-                } else if (offset >= (4 + b0) && strncmp("\x1B[3", s - 4, 3) == 0) {
-                    offset -= 4;
-                    columns++;
-                }
-            }
-        }
-        if (--columns <= 0) {
-            return;
-        }
-    }
-    offset++; /* Don't mess with the last newline we found */
-    janet_assert(offset >= b0, "bad buffer index");
-    S->buffer->count -= removed;
-    for (int32_t i = offset; i < S->buffer->count; i++) {
-        if (S->buffer->data[offset] == '\n') {
-            S->buffer->data[i] = ' ';
-            while (S->buffer->data[++offset] == ' ') {
-                janet_assert(offset < old_count, "bad replacement of newline");
-            }
-        } else {
-            S->buffer->data[i] = S->buffer->data[offset++];
-        }
-    }
-}
-
-static void print_newline(struct pretty *S, int align) {
+static void print_newline(struct pretty *S, int just_a_space) {
     int i;
-    if (S->flags & JANET_PRETTY_ONELINE) {
+    if (just_a_space || (S->flags & JANET_PRETTY_ONELINE)) {
         janet_buffer_push_u8(S->buffer, ' ');
         return;
     }
-    backtrack_newlines(S);
     janet_buffer_push_u8(S->buffer, '\n');
-    S->leaf_align = S->align = align;
-    for (i = 0; i < S->align; i++) {
+    for (i = 0; i < S->indent; i++) {
         janet_buffer_push_u8(S->buffer, ' ');
     }
 }
@@ -565,12 +484,13 @@ static const char *janet_pretty_colors[] = {
     "\x1B[36m"
 };
 
+#define JANET_PRETTY_DICT_ONELINE 4
+#define JANET_PRETTY_IND_ONELINE 10
 #define JANET_PRETTY_DICT_LIMIT 30
-#define JANET_PRETTY_DICT_KEYSORT_LIMIT 2000
 #define JANET_PRETTY_ARRAY_LIMIT 160
 
 /* Helper for pretty printing */
-static void janet_pretty_one(struct pretty *S, Janet x) {
+static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
     /* Add to seen */
     switch (janet_type(x)) {
         case JANET_NIL:
@@ -585,7 +505,7 @@ static void janet_pretty_one(struct pretty *S, Janet x) {
                     janet_buffer_push_cstring(S->buffer, janet_cycle_color);
                 }
                 janet_buffer_push_cstring(S->buffer, "<cycle ");
-                S->align += 8 + integer_to_string_b(S->buffer, janet_unwrap_integer(seenid));
+                integer_to_string_b(S->buffer, janet_unwrap_integer(seenid));
                 janet_buffer_push_u8(S->buffer, '>');
                 if (S->flags & JANET_PRETTY_COLOR) {
                     janet_buffer_push_cstring(S->buffer, "\x1B[0m");
@@ -607,12 +527,9 @@ static void janet_pretty_one(struct pretty *S, Janet x) {
             if (janet_checktype(x, JANET_BUFFER) && janet_unwrap_buffer(x) == S->buffer) {
                 janet_buffer_ensure(S->buffer, S->buffer->count + S->bufstartlen * 4 + 3, 1);
                 janet_buffer_push_u8(S->buffer, '@');
-                /* Use start len to print to self better */
-                S->align += 1 + janet_escape_string_impl(S->buffer, S->buffer->data, S->bufstartlen);
+                janet_escape_string_impl(S->buffer, S->buffer->data, S->bufstartlen);
             } else {
-                S->align -= S->buffer->count;
                 janet_description_b(S->buffer, x);
-                S->align += S->buffer->count;
             }
             if (color && (S->flags & JANET_PRETTY_COLOR)) {
                 janet_buffer_push_cstring(S->buffer, "\x1B[0m");
@@ -629,35 +546,35 @@ static void janet_pretty_one(struct pretty *S, Janet x) {
             const char *startstr = isarray ? "@[" : hasbrackets ? "[" : "(";
             const char endchar = isarray ? ']' : hasbrackets ? ']' : ')';
             janet_buffer_push_cstring(S->buffer, startstr);
-            S->align += strlen(startstr);
-            const int align = S->leaf_align = S->align;
             S->depth--;
+            S->indent += 2;
             if (S->depth == 0) {
                 janet_buffer_push_cstring(S->buffer, "...");
-                S->align += 3;
             } else {
+                if (!isarray && !(S->flags & JANET_PRETTY_ONELINE) && len >= JANET_PRETTY_IND_ONELINE)
+                    janet_buffer_push_u8(S->buffer, ' ');
+                if (is_dict_value && len >= JANET_PRETTY_IND_ONELINE) print_newline(S, 0);
                 if (len > JANET_PRETTY_ARRAY_LIMIT && !(S->flags & JANET_PRETTY_NOTRUNC)) {
                     for (i = 0; i < 3; i++) {
-                        if (i) print_newline(S, align);
-                        janet_pretty_one(S, arr[i]);
+                        if (i) print_newline(S, 0);
+                        janet_pretty_one(S, arr[i], 0);
                     }
-                    print_newline(S, align);
+                    print_newline(S, 0);
                     janet_buffer_push_cstring(S->buffer, "...");
-                    S->align += 3;
-                    for (i = len - 3; i < len; i++) {
-                        print_newline(S, align);
-                        janet_pretty_one(S, arr[i]);
+                    for (i = 0; i < 3; i++) {
+                        print_newline(S, 0);
+                        janet_pretty_one(S, arr[len - 3 + i], 0);
                     }
                 } else {
                     for (i = 0; i < len; i++) {
-                        if (i) print_newline(S, align);
-                        janet_pretty_one(S, arr[i]);
+                        if (i) print_newline(S, len < JANET_PRETTY_IND_ONELINE);
+                        janet_pretty_one(S, arr[i], 0);
                     }
                 }
             }
+            S->indent -= 2;
             S->depth++;
             janet_buffer_push_u8(S->buffer, endchar);
-            S->align++;
             break;
         }
         case JANET_STRUCT:
@@ -668,7 +585,6 @@ static void janet_pretty_one(struct pretty *S, Janet x) {
             if (istable) {
                 JanetTable *t = janet_unwrap_table(x);
                 JanetTable *proto = t->proto;
-                S->align++;
                 janet_buffer_push_cstring(S->buffer, "@");
                 if (NULL != proto) {
                     Janet name = janet_table_get(proto, janet_ckeywordv("_name"));
@@ -679,7 +595,6 @@ static void janet_pretty_one(struct pretty *S, Janet x) {
                             janet_buffer_push_cstring(S->buffer, janet_class_color);
                         }
                         janet_buffer_push_bytes(S->buffer, n, len);
-                        S->align += len;
                         if (S->flags & JANET_PRETTY_COLOR) {
                             janet_buffer_push_cstring(S->buffer, "\x1B[0m");
                         }
@@ -697,99 +612,73 @@ static void janet_pretty_one(struct pretty *S, Janet x) {
                             janet_buffer_push_cstring(S->buffer, janet_class_color);
                         }
                         janet_buffer_push_bytes(S->buffer, n, len);
-                        S->align += len;
                         if (S->flags & JANET_PRETTY_COLOR) {
                             janet_buffer_push_cstring(S->buffer, "\x1B[0m");
                         }
                     }
                 }
             }
-            janet_buffer_push_u8(S->buffer, '{');
-            const int align = S->leaf_align = ++S->align;
+            janet_buffer_push_cstring(S->buffer, "{");
 
             S->depth--;
+            S->indent += 2;
             if (S->depth == 0) {
                 janet_buffer_push_cstring(S->buffer, "...");
-                S->align += 3;
             } else {
-                int32_t len = 0, cap = 0;
+                int32_t i = 0, len = 0, cap = 0;
                 const JanetKV *kvs = NULL;
                 janet_dictionary_view(x, &kvs, &len, &cap);
+                if (!istable && !(S->flags & JANET_PRETTY_ONELINE) && len >= JANET_PRETTY_DICT_ONELINE)
+                    janet_buffer_push_u8(S->buffer, ' ');
+                if (is_dict_value && len >= JANET_PRETTY_DICT_ONELINE) print_newline(S, 0);
                 int32_t ks_start = S->keysort_start;
+
+                /* Ensure buffer is large enough to sort keys. */
                 int truncated = 0;
-
-                /* Shortcut for huge dictionaries, don't bother sorting keys */
-                if (len > JANET_PRETTY_DICT_KEYSORT_LIMIT) {
-                    if (!(S->flags & JANET_PRETTY_NOTRUNC) && (len > JANET_PRETTY_DICT_LIMIT)) {
-                        len = JANET_PRETTY_DICT_LIMIT;
-                        truncated = 1;
-                    }
-                    int32_t j = 0;
-                    for (int32_t i = 0; i < len; i++) {
-                        while (janet_checktype(kvs[j].key, JANET_NIL)) j++;
-                        if (i) print_newline(S, align);
-                        janet_pretty_one(S, kvs[j].key);
-                        janet_buffer_push_u8(S->buffer, ' ');
-                        S->align++;
-                        janet_pretty_one(S, kvs[j].value);
-                        j++;
-                    }
-                    if (truncated) {
-                        print_newline(S, align);
-                        janet_buffer_push_cstring(S->buffer, "...");
-                        S->align += 3;
-                    }
-                } else {
-                    /* Sorted keys dictionaries */
-
-                    /* Ensure buffer is large enough to sort keys. */
-                    int64_t mincap = (int64_t) len + (int64_t) ks_start;
-                    if (mincap > INT32_MAX) {
-                        truncated = 1;
-                        len = 0;
-                        mincap = ks_start;
-                    }
-
-                    if (S->keysort_capacity < mincap) {
-                        if (mincap >= INT32_MAX / 2) {
-                            S->keysort_capacity = INT32_MAX;
-                        } else {
-                            S->keysort_capacity = (int32_t)(mincap * 2);
-                        }
-                        S->keysort_buffer = janet_srealloc(S->keysort_buffer, sizeof(int32_t) * S->keysort_capacity);
-                        if (NULL == S->keysort_buffer) {
-                            JANET_OUT_OF_MEMORY;
-                        }
-                    }
-
-                    janet_sorted_keys(kvs, cap, S->keysort_buffer == NULL ? NULL : S->keysort_buffer + ks_start);
-                    S->keysort_start += len;
-                    if (!(S->flags & JANET_PRETTY_NOTRUNC) && (len > JANET_PRETTY_DICT_LIMIT)) {
-                        len = JANET_PRETTY_DICT_LIMIT;
-                        truncated = 1;
-                    }
-
-                    for (int32_t i = 0; i < len; i++) {
-                        if (i) print_newline(S, align);
-                        int32_t j = S->keysort_buffer[i + ks_start];
-                        janet_pretty_one(S, kvs[j].key);
-                        janet_buffer_push_u8(S->buffer, ' ');
-                        S->align++;
-                        janet_pretty_one(S, kvs[j].value);
-                    }
-
-                    if (truncated) {
-                        print_newline(S, align);
-                        janet_buffer_push_cstring(S->buffer, "...");
-                        S->align += 3;
-                    }
-
+                int64_t mincap = (int64_t) len + (int64_t) ks_start;
+                if (mincap > INT32_MAX) {
+                    truncated = 1;
+                    len = 0;
+                    mincap = ks_start;
                 }
+
+                if (S->keysort_capacity < mincap) {
+                    if (mincap >= INT32_MAX / 2) {
+                        S->keysort_capacity = INT32_MAX;
+                    } else {
+                        S->keysort_capacity = (int32_t)(mincap * 2);
+                    }
+                    S->keysort_buffer = janet_srealloc(S->keysort_buffer, sizeof(int32_t) * S->keysort_capacity);
+                    if (NULL == S->keysort_buffer) {
+                        JANET_OUT_OF_MEMORY;
+                    }
+                }
+
+                janet_sorted_keys(kvs, cap, S->keysort_buffer == NULL ? NULL : S->keysort_buffer + ks_start);
+                S->keysort_start += len;
+                if (!(S->flags & JANET_PRETTY_NOTRUNC) && (len > JANET_PRETTY_DICT_LIMIT)) {
+                    len = JANET_PRETTY_DICT_LIMIT;
+                    truncated = 1;
+                }
+
+                for (i = 0; i < len; i++) {
+                    if (i) print_newline(S, len < JANET_PRETTY_DICT_ONELINE);
+                    int32_t j = S->keysort_buffer[i + ks_start];
+                    janet_pretty_one(S, kvs[j].key, 0);
+                    janet_buffer_push_u8(S->buffer, ' ');
+                    janet_pretty_one(S, kvs[j].value, 1);
+                }
+
+                if (truncated) {
+                    print_newline(S, 0);
+                    janet_buffer_push_cstring(S->buffer, "...");
+                }
+
                 S->keysort_start = ks_start;
             }
+            S->indent -= 2;
             S->depth++;
             janet_buffer_push_u8(S->buffer, '}');
-            S->align++;
             break;
         }
     }
@@ -798,27 +687,21 @@ static void janet_pretty_one(struct pretty *S, Janet x) {
     return;
 }
 
-#define JANET_COLUMNS 80
-
-static JanetBuffer *janet_pretty_(JanetBuffer *buffer, int depth, int width,
-                                  int flags, Janet x, int32_t startlen, int32_t lookback_barrier) {
+static JanetBuffer *janet_pretty_(JanetBuffer *buffer, int depth, int flags, Janet x, int32_t startlen) {
     struct pretty S;
     if (NULL == buffer) {
         buffer = janet_buffer(0);
     }
     S.buffer = buffer;
     S.depth = depth;
-    S.width = width;
-    S.align = 0;
+    S.indent = 0;
     S.flags = flags;
     S.bufstartlen = startlen;
-    S.lookback_barrier = lookback_barrier;
     S.keysort_capacity = 0;
     S.keysort_buffer = NULL;
     S.keysort_start = 0;
     janet_table_init(&S.seen, 10);
-    janet_pretty_one(&S, x);
-    backtrack_newlines(&S);
+    janet_pretty_one(&S, x, 0);
     janet_table_deinit(&S.seen);
     return S.buffer;
 }
@@ -826,21 +709,19 @@ static JanetBuffer *janet_pretty_(JanetBuffer *buffer, int depth, int width,
 /* Helper for printing a janet value in a pretty form. Not meant to be used
  * for serialization or anything like that. */
 JanetBuffer *janet_pretty(JanetBuffer *buffer, int depth, int flags, Janet x) {
-    return janet_pretty_(buffer, depth, JANET_COLUMNS, flags,
-                         x, buffer ? buffer->count : 0, buffer ? buffer->count : 0);
+    return janet_pretty_(buffer, depth, flags, x, buffer ? buffer->count : 0);
 }
 
-static JanetBuffer *janet_jdn_(JanetBuffer *buffer, int depth, Janet x, int32_t startlen, int32_t lookback_barrier) {
+static JanetBuffer *janet_jdn_(JanetBuffer *buffer, int depth, Janet x, int32_t startlen) {
     struct pretty S;
     if (NULL == buffer) {
         buffer = janet_buffer(0);
     }
     S.buffer = buffer;
     S.depth = depth;
-    S.align = 0;
+    S.indent = 0;
     S.flags = 0;
     S.bufstartlen = startlen;
-    S.lookback_barrier = lookback_barrier;
     S.keysort_capacity = 0;
     S.keysort_buffer = NULL;
     S.keysort_start = 0;
@@ -854,7 +735,7 @@ static JanetBuffer *janet_jdn_(JanetBuffer *buffer, int depth, Janet x, int32_t
 }
 
 JanetBuffer *janet_jdn(JanetBuffer *buffer, int depth, Janet x) {
-    return janet_jdn_(buffer, depth, x, buffer ? buffer->count : 0, buffer ? buffer->count : 0);
+    return janet_jdn_(buffer, depth, x, buffer ? buffer->count : 0);
 }
 
 static const char *typestr(Janet x) {
@@ -1016,7 +897,7 @@ void janet_formatbv(JanetBuffer *b, const char *format, va_list args) {
                 case 's':
                 case 'S': {
                     const char *str = va_arg(args, const char *);
-                    int32_t len = (c[-1] == 's')
+                    int32_t len = c[-1] == 's'
                                   ? (int32_t) strlen(str)
                                   : janet_string_length((JanetString) str);
                     if (form[2] == '\0')
@@ -1060,26 +941,18 @@ void janet_formatbv(JanetBuffer *b, const char *format, va_list args) {
                     int has_color = (d == 'P') || (d == 'Q') || (d == 'M') || (d == 'N');
                     int has_oneline = (d == 'Q') || (d == 'q') || (d == 'N') || (d == 'n');
                     int has_notrunc = (d == 'M') || (d == 'm') || (d == 'N') || (d == 'n');
-                    int columns = atoi(width);
-                    if (columns == 0) {
-                        columns = JANET_COLUMNS;
-                    } else if (columns < 0) {
-                        has_oneline = 1;
-                    }
                     int flags = 0;
                     flags |= has_color ? JANET_PRETTY_COLOR : 0;
                     flags |= has_oneline ? JANET_PRETTY_ONELINE : 0;
                     flags |= has_notrunc ? JANET_PRETTY_NOTRUNC : 0;
-                    janet_pretty_(b, depth, columns, flags,
-                                  va_arg(args, Janet), startlen, b->count);
+                    janet_pretty_(b, depth, flags, va_arg(args, Janet), startlen);
                     break;
                 }
                 case 'j': {
                     int depth = atoi(precision);
-                    if (depth < 1) {
+                    if (depth < 1)
                         depth = JANET_RECURSION_GUARD;
-                    }
-                    janet_jdn_(b, depth, va_arg(args, Janet), startlen, b->count);
+                    janet_jdn_(b, depth, va_arg(args, Janet), startlen);
                     break;
                 }
                 default: {
@@ -1150,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));
@@ -1230,24 +1093,18 @@ void janet_buffer_format(
                     int has_color = (d == 'P') || (d == 'Q') || (d == 'M') || (d == 'N');
                     int has_oneline = (d == 'Q') || (d == 'q') || (d == 'N') || (d == 'n');
                     int has_notrunc = (d == 'M') || (d == 'm') || (d == 'N') || (d == 'n');
-                    int columns = atoi(width);
-                    if (columns == 0)
-                        columns = JANET_COLUMNS;
-                    else if (columns < 0)
-                        has_oneline = 1;
                     int flags = 0;
                     flags |= has_color ? JANET_PRETTY_COLOR : 0;
                     flags |= has_oneline ? JANET_PRETTY_ONELINE : 0;
                     flags |= has_notrunc ? JANET_PRETTY_NOTRUNC : 0;
-                    janet_pretty_(b, depth, columns, flags,
-                                  argv[arg], startlen, b->count);
+                    janet_pretty_(b, depth, flags, argv[arg], startlen);
                     break;
                 }
                 case 'j': {
                     int depth = atoi(precision);
                     if (depth < 1)
                         depth = JANET_RECURSION_GUARD;
-                    janet_jdn_(b, depth, argv[arg], startlen, b->count);
+                    janet_jdn_(b, depth, argv[arg], startlen);
                     break;
                 }
                 default: {

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
@@ -307,14 +307,14 @@ static JanetSlot janetc_varset(JanetFopts opts, int32_t argn, const Janet *argv)
 /* Add attributes to a global def or var table */
 static JanetTable *handleattr(JanetCompiler *c, const char *kind, int32_t argn, const Janet *argv) {
     int32_t i;
-    if (argn < 2) {
-        janetc_error(c, janet_formatc("expected at least 2 arguments to %s", kind));
-        return NULL;
-    }
     JanetTable *tab = janet_table(2);
     const char *binding_name = janet_type(argv[0]) == JANET_SYMBOL
                                ? ((const char *)janet_unwrap_symbol(argv[0]))
                                : "<multiple bindings>";
+    if (argn < 2) {
+        janetc_error(c, janet_formatc("expected at least 2 arguments to %s", kind));
+        return NULL;
+    }
     for (i = 1; i < argn - 1; i++) {
         Janet attr = argv[i];
         switch (janet_type(attr)) {
@@ -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);
@@ -404,7 +387,7 @@ SlotHeadPair *dohead_destructure(JanetCompiler *c, SlotHeadPair *into, JanetFopt
 }
 
 /* Def or var a symbol in a local scope */
-static int namelocal(JanetCompiler *c, const uint8_t *head, int32_t flags, JanetSlot ret, uint32_t def_flags) {
+static int namelocal(JanetCompiler *c, const uint8_t *head, int32_t flags, JanetSlot ret) {
     int isUnnamedRegister = !(ret.flags & JANET_SLOT_NAMED) &&
                             ret.index > 0 &&
                             ret.envindex >= 0;
@@ -425,10 +408,7 @@ static int namelocal(JanetCompiler *c, const uint8_t *head, int32_t flags, Janet
         ret = localslot;
     }
     ret.flags |= flags;
-    if (c->scope->flags & JANET_SCOPE_TOP) {
-        def_flags |= JANET_DEFFLAG_NO_UNUSED;
-    }
-    janetc_nameslot(c, head, ret, def_flags);
+    janetc_nameslot(c, head, ret);
     return !isUnnamedRegister;
 }
 
@@ -442,7 +422,8 @@ static int varleaf(
         JanetSlot refslot;
         JanetTable *entry = janet_table_clone(reftab);
 
-        int is_redef = c->is_redef;
+        Janet redef_kw = janet_ckeywordv("redef");
+        int is_redef = janet_truthy(janet_table_get(c->env, redef_kw));
 
         JanetArray *ref;
         JanetBinding old_binding;
@@ -462,21 +443,7 @@ static int varleaf(
         janetc_emit_ssu(c, JOP_PUT_INDEX, refslot, s, 0, 0);
         return 1;
     } else {
-        int no_unused = reftab && reftab->count && janet_truthy(janet_table_get_keyword(reftab, "unused"));
-        int no_shadow = reftab && reftab->count && janet_truthy(janet_table_get_keyword(reftab, "shadow"));
-        uint32_t def_flags = 0;
-        if (no_unused) def_flags |= JANET_DEFFLAG_NO_UNUSED;
-        if (no_shadow) def_flags |= JANET_DEFFLAG_NO_SHADOWCHECK;
-        return namelocal(c, sym, JANET_SLOT_MUTABLE, s, def_flags);
-    }
-}
-
-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_keyword(attr_table, "macro"))) {
-            janetc_lintf(c, JANET_C_LINT_NORMAL, "macro tag is ignored in inner scopes");
-        }
+        return namelocal(c, sym, JANET_SLOT_MUTABLE, s);
     }
 }
 
@@ -486,7 +453,6 @@ static JanetSlot janetc_var(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);
     SlotHeadPair *into = NULL;
     into = dohead_destructure(c, into, opts, argv[0], argv[argn - 1]);
     if (c->result.status == JANET_COMPILE_ERROR) {
@@ -508,15 +474,14 @@ static int defleaf(
     const uint8_t *sym,
     JanetSlot s,
     JanetTable *tab) {
-    JanetTable *entry = NULL;
-    int is_redef = 0;
     if (c->scope->flags & JANET_SCOPE_TOP) {
-        entry = janet_table_clone(tab);
+        JanetTable *entry = janet_table_clone(tab);
         janet_table_put(entry, janet_ckeywordv("source-map"),
                         janet_wrap_tuple(janetc_make_sourcemap(c)));
 
-        is_redef = c->is_redef;
-        if (is_redef) janet_table_put(entry, janet_ckeywordv("redef"), janet_wrap_true());
+        Janet redef_kw = janet_ckeywordv("redef");
+        int is_redef = janet_truthy(janet_table_get(c->env, redef_kw));
+        if (is_redef) janet_table_put(entry, redef_kw, janet_wrap_true());
 
         if (is_redef) {
             JanetBinding binding = janet_resolve_ext(c->env, sym);
@@ -535,18 +500,11 @@ static int defleaf(
             JanetSlot tabslot = janetc_cslot(janet_wrap_table(entry));
             janetc_emit_sss(c, JOP_PUT, tabslot, valsym, s, 0);
         }
-    }
-    int no_unused = tab && tab->count && janet_truthy(janet_table_get_keyword(tab, "unused"));
-    int no_shadow = is_redef || (tab && tab->count && janet_truthy(janet_table_get_keyword(tab, "shadow")));
-    uint32_t def_flags = 0;
-    if (no_unused) def_flags |= JANET_DEFFLAG_NO_UNUSED;
-    if (no_shadow) def_flags |= JANET_DEFFLAG_NO_SHADOWCHECK;
-    int result = namelocal(c, sym, 0, s, def_flags);
-    if (entry) {
-        /* Add env entry to env AFTER namelocal to avoid the shadowcheck false positive */
+
+        /* Add env entry to env */
         janet_table_put(c->env, janet_wrap_symbol(sym), janet_wrap_table(entry));
     }
-    return result;
+    return namelocal(c, sym, 0, s);
 }
 
 static JanetSlot janetc_def(JanetFopts opts, int32_t argn, const Janet *argv) {
@@ -555,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]);
@@ -695,10 +652,8 @@ static JanetSlot janetc_if(JanetFopts opts, int32_t argn, const Janet *argv) {
 
     /* Write jumps - only add jump lengths if jump actually emitted */
     labeld = janet_v_count(c->buffer);
-    if (labeljr < labeld) {
-        c->buffer[labeljr] |= (labelr - labeljr) << 16;
-        if (!tail && labeljd < labeld) c->buffer[labeljd] |= (labeld - labeljd) << 8;
-    }
+    c->buffer[labeljr] |= (labelr - labeljr) << 16;
+    if (!tail) c->buffer[labeljd] |= (labeld - labeljd) << 8;
 
     if (tail) target.flags |= JANET_SLOT_RETURNED;
     return target;
@@ -920,7 +875,7 @@ static JanetSlot janetc_while(JanetFopts opts, int32_t argn, const Janet *argv)
         janetc_regalloc_freetemp(&c->scope->ra, tempself, JANETC_REGTEMP_0);
         /* Compile function */
         JanetFuncDef *def = janetc_pop_funcdef(c);
-        def->name = janet_cstring("while");
+        def->name = janet_cstring("_while");
         janet_def_addflags(def);
         int32_t defindex = janetc_addfuncdef(c, def);
         /* And then load the closure and call it. */
@@ -1077,24 +1032,16 @@ static JanetSlot janetc_fn(JanetFopts opts, int32_t argn, const Janet *argv) {
                     named_table = janet_table(10);
                     named_slot = janetc_farslot(c);
                 } else {
-                    janetc_nameslot(c, sym, janetc_farslot(c), 0);
+                    janetc_nameslot(c, sym, janetc_farslot(c));
                 }
             } else {
-                janetc_nameslot(c, sym, janetc_farslot(c), 0);
+                janetc_nameslot(c, sym, janetc_farslot(c));
             }
         } else {
             janet_v_push(destructed_params, janetc_farslot(c));
         }
     }
 
-    /* Compile named arguments */
-    if (namedargs) {
-        Janet param = janet_wrap_table(named_table);
-        destructure(c, param, named_slot, defleaf, NULL);
-        janetc_freeslot(c, named_slot);
-        janet_v_free(named_params);
-    }
-
     /* Compile destructed params */
     int32_t j = 0;
     for (i = 0; i < paramcount; i++) {
@@ -1108,6 +1055,14 @@ static JanetSlot janetc_fn(JanetFopts opts, int32_t argn, const Janet *argv) {
     }
     janet_v_free(destructed_params);
 
+    /* Compile named arguments */
+    if (namedargs) {
+        Janet param = janet_wrap_table(named_table);
+        destructure(c, param, named_slot, defleaf, NULL);
+        janetc_freeslot(c, named_slot);
+        janet_v_free(named_params);
+    }
+
     max_arity = (vararg || allow_extra) ? INT32_MAX : arity;
     if (!seenopt) min_arity = arity;
 
@@ -1129,9 +1084,7 @@ static JanetSlot janetc_fn(JanetFopts opts, int32_t argn, const Janet *argv) {
             JanetSlot slot = janetc_farslot(c);
             slot.flags = JANET_SLOT_NAMED | JANET_FUNCTION;
             janetc_emit_s(c, JOP_LOAD_SELF, slot, 1);
-            /* We should figure out a better way to avoid `(def x 1) (def x :shadow (fn x [...] ...))` triggering a
-             * shadow lint for the last x */
-            janetc_nameslot(c, sym, slot, JANET_DEFFLAG_NO_UNUSED | JANET_DEFFLAG_NO_SHADOWCHECK);
+            janetc_nameslot(c, sym, slot);
         }
     }
 
@@ -1152,12 +1105,8 @@ static JanetSlot janetc_fn(JanetFopts opts, int32_t argn, const Janet *argv) {
     def->arity = arity;
     def->min_arity = min_arity;
     def->max_arity = max_arity;
-    if (named_table != NULL) {
-        def->named_args_count = named_table->count;
-    }
     if (vararg) def->flags |= JANET_FUNCDEF_FLAG_VARARG;
     if (structarg) def->flags |= JANET_FUNCDEF_FLAG_STRUCTARG;
-    if (namedargs) def->flags |= JANET_FUNCDEF_FLAG_NAMEDARGS;
 
     if (hasname) def->name = janet_unwrap_symbol(head); /* Also correctly unwraps keyword */
     janet_def_addflags(def);

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
@@ -68,7 +68,6 @@ typedef struct {
     int has_worker;
 #ifdef JANET_WINDOWS
     HANDLE worker;
-    HANDLE worker_event;
 #else
     pthread_t worker;
 #endif
@@ -182,8 +181,6 @@ struct JanetVM {
     JanetTable signal_handlers;
 #ifdef JANET_WINDOWS
     void **iocp;
-    void *connect_ex; /* MSWsock extension if available */
-    int connect_ex_loaded;
 #elif defined(JANET_EV_EPOLL)
     pthread_attr_t new_thread_attr;
     JanetHandle selfpipe[2];

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
@@ -555,9 +555,7 @@ JANET_CORE_FN(cfun_string_format,
               "\n"
               "The following conversion specifiers are used for \"pretty-printing\", where the upper-case "
               "variants generate colored output. These specifiers can take a precision "
-              "argument to specify the maximum nesting depth to print. "
-              "The multiline specifiers can also take a width argument, "
-              "which defaults to 80 columns.\n"
+              "argument to specify the maximum nesting depth to print.\n"
               "- `p`, `P`: pretty format, truncating if necessary\n"
               "- `m`, `M`: pretty format without truncating.\n"
               "- `q`, `Q`: pretty format on one line, truncating if necessary.\n"

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
@@ -49,8 +49,6 @@
 #include <math.h>
 #include <string.h>
 
-#define JANET_NUMBER_LENGTH_RIDICULOUS 0xFFFF
-
 /* Lookup table for getting values of characters when parsing numbers. Handles
  * digits 0-9 and a-z (and A-Z). A-Z have values of 10 to 35. */
 static uint8_t digit_lookup[128] = {
@@ -268,7 +266,7 @@ int janet_scan_number_base(
      * the decimal point, exponent could wrap around and become positive. It's
      * easier to reject ridiculously large inputs than to check for overflows.
      * */
-    if (len > JANET_NUMBER_LENGTH_RIDICULOUS) goto error;
+    if (len > INT32_MAX / 40) goto error;
 
     /* Get sign */
     if (str >= end) goto error;
@@ -412,7 +410,10 @@ static int scan_uint64(
     *neg = 0;
     *out = 0;
     uint64_t accum = 0;
-    if (len > JANET_NUMBER_LENGTH_RIDICULOUS) return 0;
+    /* len max is INT64_MAX in base 2 with _ between each bits */
+    /* '2r' + 64 bits + 63 _  + sign = 130 => 150 for some leading  */
+    /* zeros */
+    if (len > 150) return 0;
     /* Get sign */
     if (str >= end) return 0;
     if (*str == '-') {

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/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
@@ -155,17 +155,6 @@ Janet janet_table_get(JanetTable *t, Janet key) {
     return janet_wrap_nil();
 }
 
-/* Used internally for compiler stuff */
-Janet janet_table_get_keyword(JanetTable *t, const char *keyword) {
-    int32_t keyword_len = (int32_t) strlen(keyword);
-    for (int i = JANET_MAX_PROTO_DEPTH; t && i; t = t->proto, --i) {
-        JanetKV *bucket = (JanetKV *) janet_dict_find_keyword(t->data, t->capacity, (const uint8_t *) keyword, keyword_len);
-        if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL))
-            return bucket->value;
-    }
-    return janet_wrap_nil();
-}
-
 /* Get a value out of the table, and record which prototype it was from. */
 Janet janet_table_get_ex(JanetTable *t, Janet key, JanetTable **which) {
     for (int i = JANET_MAX_PROTO_DEPTH; t && i; t = t->proto, --i) {

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
@@ -268,7 +268,7 @@ int32_t janet_kv_calchash(const JanetKV *kvs, int32_t len) {
     return (int32_t) hash;
 }
 
-/* Calculate next power of 2. May overflow. If n < 0,
+/* Calculate next power of 2. May overflow. If n is 0,
  * will return 0. */
 int32_t janet_tablen(int32_t n) {
     if (n < 0) return 0;
@@ -321,54 +321,6 @@ const JanetKV *janet_dict_find(const JanetKV *buckets, int32_t cap, Janet key) {
     return first_bucket;
 }
 
-/* Helper to find a keyword, symbol, or string in a Janet struct or table without allocating
- * memory or needing to find interned symbols */
-const JanetKV *janet_dict_find_keyword(
-    const JanetKV *buckets, int32_t cap,
-    const uint8_t *cstr, int32_t cstr_len) {
-    int32_t hash = janet_string_calchash(cstr, cstr_len);
-    int32_t index = janet_maphash(cap, hash);
-    int32_t i;
-    const JanetKV *first_bucket = NULL;
-    /* Higher half */
-    for (i = index; i < cap; i++) {
-        const JanetKV *kv = buckets + i;
-        if (janet_checktype(kv->key, JANET_NIL)) {
-            if (janet_checktype(kv->value, JANET_NIL)) {
-                return kv;
-            } else if (NULL == first_bucket) {
-                first_bucket = kv;
-            }
-        } else if (janet_checktype(kv->key, JANET_KEYWORD)) {
-            /* Works for symbol and keyword, too */
-            JanetString str = janet_unwrap_string(kv->key);
-            int32_t len = janet_string_length(str);
-            if (hash == janet_string_hash(str) && len == cstr_len && !memcmp(str, cstr, len)) {
-                return buckets + i;
-            }
-        }
-    }
-    /* Lower half */
-    for (i = 0; i < index; i++) {
-        const JanetKV *kv = buckets + i;
-        if (janet_checktype(kv->key, JANET_NIL)) {
-            if (janet_checktype(kv->value, JANET_NIL)) {
-                return kv;
-            } else if (NULL == first_bucket) {
-                first_bucket = kv;
-            }
-        } else if (janet_checktype(kv->key, JANET_KEYWORD)) {
-            /* Works for symbol and keyword, too */
-            JanetString str = janet_unwrap_string(kv->key);
-            int32_t len = janet_string_length(str);
-            if (hash == janet_string_hash(str) && len == cstr_len && !memcmp(str, cstr, len)) {
-                return buckets + i;
-            }
-        }
-    }
-    return first_bucket;
-}
-
 /* Get a value from a janet struct or table. */
 Janet janet_dictionary_get(const JanetKV *data, int32_t cap, Janet key) {
     const JanetKV *kv = janet_dict_find(data, cap, key);
@@ -573,24 +525,8 @@ static char *namebuf_name(NameBuf *namebuf, const char *suffix) {
     return (char *)(namebuf->buf);
 }
 
-/* Add a little bit of safety when using nanboxing on arm. Instead of inserting run-time checks everywhere, we are
- * only doing it during registration which has much less cost (1 shift and mask). */
-static void janet_check_pointer_align(void *p) {
-    (void) p;
-#if defined(JANET_NANBOX_64) && JANET_NANBOX_64_POINTER_SHIFT != 0
-    union {
-        void *p;
-        uintptr_t u;
-    } un;
-    un.p = p;
-    janet_assert(!(un.u & (uintptr_t) ((1 << JANET_NANBOX_64_POINTER_SHIFT) - 1)),
-                 "unaligned pointer wrap - cfunction pointers and abstract types must be aligned with this nanboxing configuration.");
-#endif
-}
-
 void janet_cfuns(JanetTable *env, const char *regprefix, const JanetReg *cfuns) {
     while (cfuns->name) {
-        janet_check_pointer_align(cfuns->cfun);
         Janet fun = janet_wrap_cfunction(cfuns->cfun);
         if (env) janet_def(env, cfuns->name, fun, cfuns->documentation);
         janet_registry_put(cfuns->cfun, cfuns->name, regprefix, NULL, 0);
@@ -600,7 +536,6 @@ void janet_cfuns(JanetTable *env, const char *regprefix, const JanetReg *cfuns)
 
 void janet_cfuns_ext(JanetTable *env, const char *regprefix, const JanetRegExt *cfuns) {
     while (cfuns->name) {
-        janet_check_pointer_align(cfuns->cfun);
         Janet fun = janet_wrap_cfunction(cfuns->cfun);
         if (env) janet_def_sm(env, cfuns->name, fun, cfuns->documentation, cfuns->source_file, cfuns->source_line);
         janet_registry_put(cfuns->cfun, cfuns->name, regprefix, cfuns->source_file, cfuns->source_line);
@@ -612,7 +547,6 @@ void janet_cfuns_prefix(JanetTable *env, const char *regprefix, const JanetReg *
     NameBuf nb;
     if (env) namebuf_init(&nb, regprefix);
     while (cfuns->name) {
-        janet_check_pointer_align(cfuns->cfun);
         Janet fun = janet_wrap_cfunction(cfuns->cfun);
         if (env) janet_def(env, namebuf_name(&nb, cfuns->name), fun, cfuns->documentation);
         janet_registry_put(cfuns->cfun, cfuns->name, regprefix, NULL, 0);
@@ -625,7 +559,6 @@ void janet_cfuns_ext_prefix(JanetTable *env, const char *regprefix, const JanetR
     NameBuf nb;
     if (env) namebuf_init(&nb, regprefix);
     while (cfuns->name) {
-        janet_check_pointer_align(cfuns->cfun);
         Janet fun = janet_wrap_cfunction(cfuns->cfun);
         if (env) janet_def_sm(env, namebuf_name(&nb, cfuns->name), fun, cfuns->documentation, cfuns->source_file, cfuns->source_line);
         janet_registry_put(cfuns->cfun, cfuns->name, regprefix, cfuns->source_file, cfuns->source_line);
@@ -642,7 +575,6 @@ void janet_register(const char *name, JanetCFunction cfun) {
 /* Abstract type introspection */
 
 void janet_register_abstract_type(const JanetAbstractType *at) {
-    janet_check_pointer_align((void *) at);
     Janet sym = janet_csymbolv(at->name);
     Janet check = janet_table_get(janet_vm.abstract_registry, sym);
     if (!janet_checktype(check, JANET_NIL) && at != janet_unwrap_pointer(check)) {
@@ -675,7 +607,6 @@ void janet_core_def_sm(JanetTable *env, const char *name, Janet x, const void *p
 void janet_core_cfuns_ext(JanetTable *env, const char *regprefix, const JanetRegExt *cfuns) {
     (void) regprefix;
     while (cfuns->name) {
-        janet_check_pointer_align(cfuns->cfun);
         Janet fun = janet_wrap_cfunction(cfuns->cfun);
         janet_table_put(env, janet_csymbolv(cfuns->name), fun);
         janet_registry_put(cfuns->cfun, cfuns->name, regprefix, cfuns->source_file, cfuns->source_line);
@@ -697,11 +628,8 @@ JanetBinding janet_binding_from_entry(Janet entry) {
         return binding;
     entry_table = janet_unwrap_table(entry);
 
-    Janet deprecate = janet_table_get_keyword(entry_table, "deprecated");
-    int macro = janet_truthy(janet_table_get_keyword(entry_table, "macro"));
-    Janet value = janet_table_get_keyword(entry_table, "value");
-    Janet ref = janet_table_get_keyword(entry_table, "ref");
-
+    /* deprecation check */
+    Janet deprecate = janet_table_get(entry_table, janet_ckeywordv("deprecated"));
     if (janet_checktype(deprecate, JANET_KEYWORD)) {
         JanetKeyword depkw = janet_unwrap_keyword(deprecate);
         if (!janet_cstrcmp(depkw, "relaxed")) {
@@ -715,8 +643,11 @@ JanetBinding janet_binding_from_entry(Janet entry) {
         binding.deprecation = JANET_BINDING_DEP_NORMAL;
     }
 
+    int macro = janet_truthy(janet_table_get(entry_table, janet_ckeywordv("macro")));
+    Janet value = janet_table_get(entry_table, janet_ckeywordv("value"));
+    Janet ref = janet_table_get(entry_table, janet_ckeywordv("ref"));
     int ref_is_valid = janet_checktype(ref, JANET_ARRAY);
-    int redef = ref_is_valid && janet_truthy(janet_table_get_keyword(entry_table, "redef"));
+    int redef = ref_is_valid && janet_truthy(janet_table_get(entry_table, janet_ckeywordv("redef")));
 
     if (macro) {
         binding.value = redef ? ref : value;
@@ -917,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
@@ -50,9 +50,9 @@
 #ifndef JANET_EXIT
 #include <stdio.h>
 #define JANET_EXIT(m) do { \
-    fprintf(stderr, "janet abort at %s:%d: %s\n",\
-        __FILE__,\
+    fprintf(stderr, "janet internal error at line %d in file %s: %s\n",\
         __LINE__,\
+        __FILE__,\
         (m));\
     abort();\
 } while (0)
@@ -66,72 +66,42 @@
 
 /* Utils */
 uint32_t janet_hash_mix(uint32_t input, uint32_t more);
-
 #define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1))
-
 int janet_valid_utf8(const uint8_t *str, int32_t len);
-
 int janet_is_symbol_char(uint8_t c);
-
 extern const char janet_base64[65];
-
 int32_t janet_array_calchash(const Janet *array, int32_t len);
-
 int32_t janet_kv_calchash(const JanetKV *kvs, int32_t len);
-
 int32_t janet_string_calchash(const uint8_t *str, int32_t len);
-
 int32_t janet_tablen(int32_t n);
-
 void safe_memcpy(void *dest, const void *src, size_t len);
-
 void janet_buffer_push_types(JanetBuffer *buffer, int types);
-
 const JanetKV *janet_dict_find(const JanetKV *buckets, int32_t cap, Janet key);
-
 void janet_memempty(JanetKV *mem, int32_t count);
-
 void *janet_memalloc_empty(int32_t count);
-
 JanetTable *janet_get_core_table(const char *name);
-
 void janet_def_addflags(JanetFuncDef *def);
-
 void janet_buffer_dtostr(JanetBuffer *buffer, double x);
-
 const char *janet_strerror(int e);
-
 const void *janet_strbinsearch(
     const void *tab,
     size_t tabcount,
     size_t itemsize,
     const uint8_t *key);
-
 void janet_buffer_format(
     JanetBuffer *b,
     const char *strfrmt,
     int32_t argstart,
     int32_t argc,
     Janet *argv);
-
 Janet janet_next_impl(Janet ds, Janet key, int is_interpreter);
-
 JanetBinding janet_binding_from_entry(Janet entry);
-
 JanetByteView janet_text_substitution(
     Janet *subst,
     const uint8_t *bytes,
     uint32_t len,
     JanetArray *extra_args);
 
-const JanetKV *janet_dict_find_keyword(
-    const JanetKV *buckets,
-    int32_t cap,
-    const uint8_t *cstr,
-    int32_t cstr_len);
-
-Janet janet_table_get_keyword(JanetTable *t, const char *keyword);
-
 /* Registry functions */
 void janet_registry_put(
     JanetCFunction key,
@@ -197,26 +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
-
-#ifdef JANET_EV
-#ifdef JANET_WINDOWS
-#include <winsock2.h>
-#include <windows.h>
-#include <io.h>
-typedef struct {
-    union {
-        OVERLAPPED overlapped;
-        WSAOVERLAPPED wsaoverlapped;
-    } as;
-    uint32_t bytes_transfered;
-} JanetOverlapped;
-#endif
-#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));
@@ -335,9 +334,10 @@ int32_t janet_hash(Janet x) {
             } as;
             as.d = janet_unwrap_number(x);
             as.d += 0.0; /* normalize negative 0 */
-            as.u = murmur64(as.u);
+            uint32_t lo = (uint32_t)(as.u & 0xFFFFFFFF);
             uint32_t hi = (uint32_t)(as.u >> 32);
-            hash = (int32_t)hi;
+            uint32_t hilo = (hi ^ lo) * 2654435769u;
+            hash = (int32_t)((hilo << 16) | (hilo >> 16));
             break;
         }
         case JANET_ABSTRACT: {
@@ -495,7 +495,7 @@ Janet janet_in(Janet ds, Janet key) {
                 if (!(type->get)(janet_unwrap_abstract(ds), key, &value))
                     janet_panicf("key %v not found in %v ", key, ds);
             } else {
-                janet_panicf("no getter for %v", ds);
+                janet_panicf("no getter for %v ", ds);
             }
             break;
         }
@@ -622,7 +622,7 @@ Janet janet_getindex(Janet ds, int32_t index) {
                 if (!(type->get)(janet_unwrap_abstract(ds), janet_wrap_integer(index), &value))
                     value = janet_wrap_nil();
             } else {
-                janet_panicf("no getter for %v", ds);
+                janet_panicf("no getter for %v ", ds);
             }
             break;
         }
@@ -724,9 +724,6 @@ void janet_putindex(Janet ds, int32_t index, Janet value) {
             JanetArray *array = janet_unwrap_array(ds);
             if (index >= array->count) {
                 janet_array_ensure(array, index + 1, 2);
-                for (int32_t i = array->count; i < index + 1; i++) {
-                    array->data[i] = janet_wrap_nil();
-                }
                 array->count = index + 1;
             }
             array->data[index] = value;
@@ -738,7 +735,6 @@ void janet_putindex(Janet ds, int32_t index, Janet value) {
                 janet_panicf("can only put integers in buffers, got %v", value);
             if (index >= buffer->count) {
                 janet_buffer_ensure(buffer, index + 1, 2);
-                memset(buffer->data + buffer->count, 0, index + 1 - buffer->count);
                 buffer->count = index + 1;
             }
             buffer->data[index] = (uint8_t)(janet_unwrap_integer(value) & 0xFF);
@@ -771,11 +767,7 @@ void janet_put(Janet ds, Janet key, Janet value) {
             JanetArray *array = janet_unwrap_array(ds);
             int32_t index = getter_checkint(type, key, INT32_MAX - 1);
             if (index >= array->count) {
-                janet_array_ensure(array, index + 1, 2);
-                for (int32_t i = array->count; i < index + 1; i++) {
-                    array->data[i] = janet_wrap_nil();
-                }
-                array->count = index + 1;
+                janet_array_setcount(array, index + 1);
             }
             array->data[index] = value;
             break;
@@ -786,9 +778,7 @@ void janet_put(Janet ds, Janet key, Janet value) {
             if (!janet_checkint(value))
                 janet_panicf("can only put integers in buffers, got %v", value);
             if (index >= buffer->count) {
-                janet_buffer_ensure(buffer, index + 1, 2);
-                memset(buffer->data + buffer->count, 0, index + 1 - buffer->count);
-                buffer->count = index + 1;
+                janet_buffer_setcount(buffer, index + 1);
             }
             buffer->data[index] = (uint8_t)(janet_unwrap_integer(value) & 0xFF);
             break;

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
@@ -129,9 +129,7 @@
         if (!janet_checktype(op1, JANET_NUMBER)) {\
             vm_commit();\
             Janet _argv[2] = { op1, janet_wrap_number(CS) };\
-            Janet a = janet_mcall(#op, 2, _argv);\
-            stack = fiber->data + fiber->frame;\
-            stack[A] = a;\
+            stack[A] = janet_mcall(#op, 2, _argv);\
             vm_checkgc_pcnext();\
         } else {\
             double x1 = janet_unwrap_number(op1);\
@@ -145,9 +143,7 @@
         if (!janet_checktype(op1, JANET_NUMBER)) {\
             vm_commit();\
             Janet _argv[2] = { op1, janet_wrap_number(CS) };\
-            Janet a = janet_mcall(#op, 2, _argv);\
-            stack = fiber->data + fiber->frame;\
-            stack[A] = a;\
+            stack[A] = janet_mcall(#op, 2, _argv);\
             vm_checkgc_pcnext();\
         } else {\
             double y1 = janet_unwrap_number(op1);\
@@ -170,9 +166,7 @@
             vm_pcnext();\
         } else {\
             vm_commit();\
-            Janet a = janet_binop_call(#op, "r" #op, op1, op2);\
-            stack = fiber->data + fiber->frame;\
-            stack[A] = a;\
+            stack[A] = janet_binop_call(#op, "r" #op, op1, op2);\
             vm_checkgc_pcnext();\
         }\
     }
@@ -192,9 +186,7 @@
             vm_pcnext();\
         } else {\
             vm_commit();\
-            Janet a = janet_binop_call(#op, "r" #op, op1, op2);\
-            stack = fiber->data + fiber->frame;\
-            stack[A] = a;\
+            stack[A] = janet_binop_call(#op, "r" #op, op1, op2);\
             vm_checkgc_pcnext();\
         }\
     }
@@ -211,9 +203,7 @@
             vm_pcnext();\
         } else {\
             vm_commit();\
-            Janet a = janet_wrap_boolean(janet_compare(op1, op2) op 0);\
-            stack = fiber->data + fiber->frame;\
-            stack[A] = a;\
+            stack[A] = janet_wrap_boolean(janet_compare(op1, op2) op 0);\
             vm_checkgc_pcnext();\
         }\
     }
@@ -227,9 +217,7 @@
             vm_pcnext();\
         } else {\
             vm_commit();\
-            Janet a = janet_wrap_boolean(janet_compare(op1, janet_wrap_integer(CS)) op 0);\
-            stack = fiber->data + fiber->frame;\
-            stack[A] = a;\
+            stack[A] = janet_wrap_boolean(janet_compare(op1, janet_wrap_integer(CS)) op 0);\
             vm_checkgc_pcnext();\
         }\
     }
@@ -722,9 +710,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
             vm_pcnext();
         } else {
             vm_commit();
-            Janet a = janet_binop_call("div", "rdiv", op1, op2);
-            stack = fiber->data + fiber->frame;
-            stack[A] = a;
+            stack[A] = janet_binop_call("div", "rdiv", op1, op2);
             vm_checkgc_pcnext();
         }
     }
@@ -744,9 +730,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
             vm_pcnext();
         } else {
             vm_commit();
-            Janet a = janet_binop_call("mod", "rmod", op1, op2);
-            stack = fiber->data + fiber->frame;
-            stack[A] = a;
+            stack[A] = janet_binop_call("mod", "rmod", op1, op2);
             vm_checkgc_pcnext();
         }
     }
@@ -761,9 +745,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
             vm_pcnext();
         } else {
             vm_commit();
-            Janet a = janet_binop_call("%", "r%", op1, op2);
-            stack = fiber->data + fiber->frame;
-            stack[A] = a;
+            stack[A] = janet_binop_call("%", "r%", op1, op2);
             vm_checkgc_pcnext();
         }
     }
@@ -784,9 +766,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
             vm_pcnext();
         } else {
             vm_commit();
-            Janet a = janet_unary_call("~", op);
-            stack = fiber->data + fiber->frame;
-            stack[A] = a;
+            stack[A] = janet_unary_call("~", op);
             vm_checkgc_pcnext();
         }
     }
@@ -892,11 +872,8 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
     stack[A] = janet_wrap_boolean(!janet_checktype(stack[B], JANET_NUMBER) || (janet_unwrap_number(stack[B]) != (double) CS));
     vm_pcnext();
 
-    VM_OP(JOP_COMPARE) {
-        Janet a = janet_wrap_integer(janet_compare(stack[B], stack[C]));
-        stack = fiber->data + fiber->frame;
-        stack[A] = a;
-    }
+    VM_OP(JOP_COMPARE)
+    stack[A] = janet_wrap_integer(janet_compare(stack[B], stack[C]));
     vm_pcnext();
 
     VM_OP(JOP_NEXT)
@@ -1127,11 +1104,11 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
         }
         fiber->child = child;
         JanetSignal sig = janet_continue_no_check(child, stack[C], &retreg);
-        stack = fiber->data + fiber->frame;
         if (sig != JANET_SIGNAL_OK && !(child->flags & (1 << sig))) {
             vm_return(sig, retreg);
         }
         fiber->child = NULL;
+        stack = fiber->data + fiber->frame;
         stack[A] = retreg;
         vm_checkgc_pcnext();
     }
@@ -1180,7 +1157,6 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
     vm_commit();
     fiber->flags |= JANET_FIBER_RESUME_NO_USEVAL;
     janet_put(stack[A], stack[B], stack[C]);
-    stack = fiber->data + fiber->frame;
     fiber->flags &= ~JANET_FIBER_RESUME_NO_USEVAL;
     vm_checkgc_pcnext();
 
@@ -1188,44 +1164,27 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
     vm_commit();
     fiber->flags |= JANET_FIBER_RESUME_NO_USEVAL;
     janet_putindex(stack[A], C, stack[B]);
-    stack = fiber->data + fiber->frame;
     fiber->flags &= ~JANET_FIBER_RESUME_NO_USEVAL;
     vm_checkgc_pcnext();
 
     VM_OP(JOP_IN)
     vm_commit();
-    {
-        Janet a = janet_in(stack[B], stack[C]);
-        stack = fiber->data + fiber->frame;
-        stack[A] = a;
-    }
+    stack[A] = janet_in(stack[B], stack[C]);
     vm_pcnext();
 
     VM_OP(JOP_GET)
     vm_commit();
-    {
-        Janet a = janet_get(stack[B], stack[C]);
-        stack = fiber->data + fiber->frame;
-        stack[A] = a;
-    }
+    stack[A] = janet_get(stack[B], stack[C]);
     vm_pcnext();
 
     VM_OP(JOP_GET_INDEX)
     vm_commit();
-    {
-        Janet a = janet_getindex(stack[B], C);
-        stack = fiber->data + fiber->frame;
-        stack[A] = a;
-    }
+    stack[A] = janet_getindex(stack[B], C);
     vm_pcnext();
 
     VM_OP(JOP_LENGTH)
     vm_commit();
-    {
-        Janet a = janet_lengthv(stack[E]);
-        stack = fiber->data + fiber->frame;
-        stack[A] = a;
-    }
+    stack[A] = janet_lengthv(stack[E]);
     vm_pcnext();
 
     VM_OP(JOP_MAKE_ARRAY) {
@@ -1559,15 +1518,6 @@ static JanetSignal janet_continue_no_check(JanetFiber *fiber, Janet in, Janet *o
         }
     }
 
-    /* If this is a nested continue (root_fiber already set), root the fiber
-     * so it survives GC. janet_collect only marks root_fiber, so without
-     * this a nested fiber (e.g., from janet_pcall in a C function) would be
-     * invisible to GC and could be collected while actively running. */
-    int fiber_rooted = (janet_vm.root_fiber != NULL);
-    if (fiber_rooted) {
-        janet_gcroot(janet_wrap_fiber(fiber));
-    }
-
     /* Save global state */
     JanetTryState tstate;
     JanetSignal sig = janet_try(&tstate);
@@ -1583,9 +1533,6 @@ static JanetSignal janet_continue_no_check(JanetFiber *fiber, Janet in, Janet *o
     if (janet_vm.root_fiber == fiber) janet_vm.root_fiber = NULL;
     janet_fiber_set_status(fiber, sig);
     janet_restore(&tstate);
-    if (fiber_rooted) {
-        janet_gcunroot(janet_wrap_fiber(fiber));
-    }
     fiber->last_value = tstate.payload;
     *out = tstate.payload;
 

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
@@ -194,18 +194,12 @@ Janet janet_wrap_number_safe(double d) {
 
 void *janet_nanbox_to_pointer(Janet x) {
     x.i64 &= JANET_NANBOX_PAYLOADBITS;
-    x.u64 <<= JANET_NANBOX_64_POINTER_SHIFT; /* Alignment, usually 0 */
     return x.pointer;
 }
 
 Janet janet_nanbox_from_pointer(void *p, uint64_t tagmask) {
     Janet ret;
     ret.pointer = p;
-    /* Should be noop when pointer shift is 0 */
-    /*
-    janet_assert(!(ret.u64 & (uint64_t) ((1 << JANET_NANBOX_64_POINTER_SHIFT) - 1)), "unaligned pointer wrap");
-    */
-    ret.u64 >>= JANET_NANBOX_64_POINTER_SHIFT; /* Alignment, usually 0 */
     ret.u64 |= tagmask;
     return ret;
 }
@@ -213,11 +207,6 @@ Janet janet_nanbox_from_pointer(void *p, uint64_t tagmask) {
 Janet janet_nanbox_from_cpointer(const void *p, uint64_t tagmask) {
     Janet ret;
     ret.pointer = (void *)p;
-    /* Should be noop when pointer shift is 0 */
-    /*
-    janet_assert(!(ret.u64 & (uint64_t) ((1 << JANET_NANBOX_64_POINTER_SHIFT) - 1)), "unaligned pointer wrap");
-    */
-    ret.u64 >>= JANET_NANBOX_64_POINTER_SHIFT; /* Alignment, usually 0 */
     ret.u64 |= tagmask;
     return ret;
 }

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
@@ -307,38 +305,25 @@ extern "C" {
  * architectures (Nanboxing only tested on x86 and x64), comment out
  * the JANET_NANBOX define.*/
 
+#if defined(_M_ARM64) || defined(_M_ARM) || defined(__aarch64__)
+#define JANET_NO_NANBOX
+#endif
+
 #ifndef JANET_NO_NANBOX
 #ifdef JANET_32
 #define JANET_NANBOX_32
-#elif defined(__x86_64__) || defined(_WIN64) || defined(__riscv) || defined(__aarch64__) || defined(_M_ARM64)
+#elif defined(__x86_64__) || defined(_WIN64) || defined(__riscv)
 /* We will only enable nanboxing by default on 64 bit systems
- * for x64, risc-v, and arm64. This is mainly because the approach is tied to the
+ * for x64 and risc-v. This is mainly because the approach is tied to the
  * implicit 47 bit address space. Many arches allow/require this, but not all,
- * and it requires cooperation from the OS. ARM should also work in many configurations by taking advantage
- * of pointer alignment to allow for 48 or 49 bits of address space. */
+ * and it requires cooperation from the OS. ARM should also work in many configurations. */
 #define JANET_NANBOX_64
-
-/* Allow 64-bit nanboxing to assume aligned pointers to get back some extra bits for representation.
- * This is needed to use nanboxing on systems with larger than 47-bit address spaces, such as many
- * aarch64 systems. */
-#ifndef JANET_NANBOX_64_POINTER_SHIFT
-#if (defined(_M_ARM64) || defined(__aarch64__)) && !defined(JANET_APPLE)
-/* All pointers, including function pointers, should be 4-byte aligned on aarch64 by default.
- * The exception is aarch64 macos, as it uses the same 47-bit userland address-space as on amd64. */
-#define JANET_NANBOX_64_POINTER_SHIFT 2
 #endif
 #endif
-#endif
-#endif
-
-/* Allow for custom pointer alignment as well */
-#if defined(JANET_NANBOX_64) && !defined(JANET_NANBOX_64_POINTER_SHIFT)
-#define JANET_NANBOX_64_POINTER_SHIFT 0
-#endif
 
 /* Runtime config constants */
 #ifdef JANET_NO_NANBOX
-#define JANET_NANBOX_BIT 0x0
+#define JANET_NANBOX_BIT 0
 #else
 #define JANET_NANBOX_BIT 0x1
 #endif
@@ -349,16 +334,9 @@ extern "C" {
 #define JANET_SINGLE_THREADED_BIT 0
 #endif
 
-#ifdef JANET_NANBOX_64_POINTER_SHIFT
-#define JANET_NANBOX_POINTER_SHIFT_BITS (JANET_NANBOX_64_POINTER_SHIFT ? (0x4 << JANET_NANBOX_64_POINTER_SHIFT) : 0)
-#else
-#define JANET_NANBOX_POINTER_SHIFT_BITS 0
-#endif
-
 #define JANET_CURRENT_CONFIG_BITS \
     (JANET_SINGLE_THREADED_BIT | \
-     JANET_NANBOX_BIT | \
-     JANET_NANBOX_POINTER_SHIFT_BITS)
+     JANET_NANBOX_BIT)
 
 /* Represents the settings used to compile Janet, as well as the version */
 typedef struct {
@@ -688,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
@@ -1094,7 +1070,6 @@ struct JanetAbstractHead {
 #define JANET_FUNCDEF_FLAG_HASSOURCEMAP 0x800000
 #define JANET_FUNCDEF_FLAG_STRUCTARG 0x1000000
 #define JANET_FUNCDEF_FLAG_HASCLOBITSET 0x2000000
-#define JANET_FUNCDEF_FLAG_NAMEDARGS 0x4000000
 #define JANET_FUNCDEF_FLAG_TAG 0xFFFF
 
 /* Source mapping structure for a bytecode instruction */
@@ -1136,7 +1111,6 @@ struct JanetFuncDef {
     int32_t environments_length;
     int32_t defs_length;
     int32_t symbolmap_length;
-    int32_t named_args_count;
 };
 
 /* A function environment */
@@ -1160,21 +1134,9 @@ struct JanetFunction {
     JanetFuncEnv *envs[];
 };
 
-/* Use to read Janet data structures into memory from source code */
 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,
@@ -1210,10 +1172,7 @@ typedef struct {
     const JanetAbstractType *at;
 } JanetMarshalContext;
 
-/* Defines an abstract type. Use a const pointer to one of these structures
- * when creating abstract types. The memory for this pointer should not be free
- * until after janet_deinit is called. Usually, this means declaring JanetAbstractType's
- * as const data at file scope, and creating instances with janet_abstract(&MyType, sizeof(MyTypeStruct)); */
+/* Defines an abstract type */
 struct JanetAbstractType {
     const char *name;
     int (*gc)(void *data, size_t len);
@@ -1301,7 +1260,6 @@ typedef struct JanetFile JanetFile;
 struct JanetFile {
     FILE *file;
     int32_t flags;
-    size_t vbufsize;
 };
 
 /* For janet_try and janet_restore */
@@ -1435,7 +1393,7 @@ enum JanetOpCode {
 };
 
 /* Info about all instructions */
-extern const enum JanetInstructionType janet_instructions[JOP_INSTRUCTION_COUNT];
+extern enum JanetInstructionType janet_instructions[JOP_INSTRUCTION_COUNT];
 
 /***** END SECTION OPCODES *****/
 
@@ -1466,7 +1424,6 @@ JANET_API void janet_loop(void);
  *     } else {
  *       janet_schedule(interrupted_fiber, janet_wrap_nil());
  *     }
- *     janet_interpreter_interrupt_handled(NULL);
  *   }
  * }
  *
@@ -1506,18 +1463,9 @@ JANET_API void janet_ev_dec_refcount(void);
 JANET_API void *janet_abstract_begin_threaded(const JanetAbstractType *atype, size_t size);
 JANET_API void *janet_abstract_end_threaded(void *x);
 JANET_API void *janet_abstract_threaded(const JanetAbstractType *atype, size_t size);
-
-/* Allow reference counting on threaded abstract types. This is useful when external code , either
- * in the current OS thread or in a different OS thread, takes a pointer to this abstract type. The programmer
- * should tncrement the reference count when taking the pointer, and then decrement and possibly cleanup and free
- * if the reference count is 0. */
 JANET_API int32_t janet_abstract_incref(void *abst);
 JANET_API int32_t janet_abstract_decref(void *abst);
 
-/* If this returns 0, *abst will be deinitialized and freed. Useful shorthand if there is no other cleanup for
- * this abstract type before calling `janet_free` on it's backing memory. */
-JANET_API int32_t janet_abstract_decref_maybe_free(void *abst);
-
 /* Expose channel utilities */
 JANET_API JanetChannel *janet_channel_make(uint32_t limit);
 JANET_API JanetChannel *janet_channel_make_threaded(uint32_t limit);
@@ -1526,7 +1474,7 @@ JANET_API JanetChannel *janet_optchannel(const Janet *argv, int32_t argc, int32_
 JANET_API int janet_channel_give(JanetChannel *channel, Janet x);
 JANET_API int janet_channel_take(JanetChannel *channel, Janet *out);
 
-/* Expose some OS sync primitives - mutexes and reader-writer locks */
+/* Expose some OS sync primitives */
 JANET_API size_t janet_os_mutex_size(void);
 JANET_API size_t janet_os_rwlock_size(void);
 JANET_API void janet_os_mutex_init(JanetOSMutex *mutex);
@@ -1594,8 +1542,7 @@ JANET_API void janet_ev_post_event(JanetVM *vm, JanetCallback cb, JanetEVGeneric
 /* Callback used by janet_ev_threaded_await */
 JANET_API void janet_ev_default_threaded_callback(JanetEVGenericMessage return_value);
 
-/* Read async from a stream. These function yield to the event-loop with janet_await(), and so do not return.
- * When the fiber is resumed, the fiber will simply continue to the next Janet abstract machine instruction. */
+/* Read async from a stream */
 JANET_NO_RETURN JANET_API void janet_ev_read(JanetStream *stream, JanetBuffer *buf, int32_t nbytes);
 JANET_NO_RETURN JANET_API void janet_ev_readchunk(JanetStream *stream, JanetBuffer *buf, int32_t nbytes);
 #ifdef JANET_NET
@@ -1604,8 +1551,7 @@ JANET_NO_RETURN JANET_API void janet_ev_recvchunk(JanetStream *stream, JanetBuff
 JANET_NO_RETURN JANET_API void janet_ev_recvfrom(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags);
 #endif
 
-/* Write async to a stream. These function yield to the event-loop with janet_await(), and so do not return.
- * When the fiber is resumed, the fiber will simply continue to the next Janet abstract machine instruction. */
+/* Write async to a stream */
 JANET_NO_RETURN JANET_API void janet_ev_write_buffer(JanetStream *stream, JanetBuffer *buf);
 JANET_NO_RETURN JANET_API void janet_ev_write_string(JanetStream *stream, JanetString str);
 #ifdef JANET_NET
@@ -1617,63 +1563,17 @@ JANET_NO_RETURN JANET_API void janet_ev_sendto_string(JanetStream *stream, Janet
 
 #endif
 
-/* Parsing.
- *
- * E.g.
- *
- * JanetParser parser;
- * janet_parser_init(&parser);
- * for (int i = 0; i < source_code_length + 1; i++) {
- *   if (i >= source_code_length) {
- *     janet_parser_eof(&parser);
- *   } else {
- *     janet_parser_consume(&parser, source_code[i]);
- *   }
- *   while (janet_parser_has_more(&parser)) {
- *      Janet x = janet_parser_produce(&parser);
- *      janet_printf("got value: %v\n", x);
- *   }
- *   switch (janet_parser_status(&parser)) {
- *      case JANET_PARSE_PENDING: break;
- *      case JANET_PARSE_ERROR: janet_eprintf("error: %s\n", janet_parser_error(&parser)); break;
- *      case JANET_PARSE_ROOT: break;
- *      case JANET_PARSE_DEAD: break;
- *   }
- * }
- * janet_parser_deinit(&parser);
- *
- * */
+/* Parsing */
 extern JANET_API const JanetAbstractType janet_parser_type;
-
-/* Construct/destruct a parser. Parsers can be allocated on the stack or the heap. */
 JANET_API void janet_parser_init(JanetParser *parser);
 JANET_API void janet_parser_deinit(JanetParser *parser);
-
-/* Feed bytes into the parser. Check the parser state after every byte to handle errors. */
 JANET_API void janet_parser_consume(JanetParser *parser, uint8_t c);
-
-/* Check the current status of the parser */
 JANET_API enum JanetParserStatus janet_parser_status(JanetParser *parser);
-
-/* Produce a value from the parser. Call this when janet_parser_has_more(&parser) is non-zero. */
 JANET_API Janet janet_parser_produce(JanetParser *parser);
-
-/* Produce a value from the parser, wrapped in a tuple. The tuple is used to carry the source mapping information of the
- * top level form, such as a line number or symbol. */
 JANET_API Janet janet_parser_produce_wrapped(JanetParser *parser);
-
-/* When there is an error while parsing (janet_parser_status(&parser) == JANET_PARSE_ERROR), get a nice error string.
- * Calling this will also flush the parser. */
 JANET_API const char *janet_parser_error(JanetParser *parser);
-
-/* If there is a parsing error, flush the parser to set the state back to empty.
- * This allows for better error recover and less confusing error messages on bad syntax deep inside nested data structures. */
 JANET_API void janet_parser_flush(JanetParser *parser);
-
-/* Indicate that there is no more source code */
 JANET_API void janet_parser_eof(JanetParser *parser);
-
-/* If non-zero, the parser has values ready to be produced. */
 JANET_API int janet_parser_has_more(JanetParser *parser);
 
 /* Assembly */
@@ -1717,10 +1617,7 @@ JANET_API JanetCompileResult janet_compile_lint(
 JANET_API JanetTable *janet_core_env(JanetTable *replacements);
 JANET_API JanetTable *janet_core_lookup_table(JanetTable *replacements);
 
-/* Execute strings.
- *
- * These functions wrap parsing, compilation, and evalutation into convenient functions.
- * */
+/* Execute strings */
 #define JANET_DO_ERROR_RUNTIME 0x01
 #define JANET_DO_ERROR_COMPILE 0x02
 #define JANET_DO_ERROR_PARSE 0x04
@@ -1914,41 +1811,21 @@ JANET_API JanetTable *janet_env_lookup(JanetTable *env);
 JANET_API void janet_env_lookup_into(JanetTable *renv, JanetTable *env, const char *prefix, int recurse);
 
 /* GC */
-
-/* The main interface to garbage collection. Call this to do a full mark and sweep cleanup. */
-JANET_API void janet_collect(void);
-
-/* Add "roots" to the garbage collector to prevent the runtime from freeing objects.
- * This is only needed if code outside of Janet keeps references to Janet values */
-JANET_API void janet_gcroot(Janet root);
-JANET_API int janet_gcunroot(Janet root);
-
-/* Allow disabling garbage collection temporarily or for certain sections of code.
- * this is a very cheap operation. */
-JANET_API int janet_gclock(void);
-JANET_API void janet_gcunlock(int handle);
-
-/* The mark and sweep components of the mark and sweep collector. Prefer using janet_collect directly. */
 JANET_API void janet_mark(Janet x);
 JANET_API void janet_sweep(void);
-
-/* Clear all gced memory and call all destructors. Used as part of the standard cleanup routune, most programmers will not need this. */
+JANET_API void janet_collect(void);
 JANET_API void janet_clear_memory(void);
-
-/* Remove all GC roots. Used as part of the standard cleanup routine, most programmers will not need this. */
+JANET_API void janet_gcroot(Janet root);
+JANET_API int janet_gcunroot(Janet root);
 JANET_API int janet_gcunrootall(Janet root);
-
-/* Hint to the collector that memory of size s was just allocated to help it better understand when to free memory. */
+JANET_API int janet_gclock(void);
+JANET_API void janet_gcunlock(int handle);
 JANET_API void janet_gcpressure(size_t s);
 
 /* Functions */
 JANET_API JanetFuncDef *janet_funcdef_alloc(void);
 JANET_API JanetFunction *janet_thunk(JanetFuncDef *def);
-
-/* Get a function that when called with no args, will return x. */
 JANET_API JanetFunction *janet_thunk_delay(Janet x);
-
-/* Do some simple verfification on constructed bytecode to disallow any trivial incorrect bytecode. */
 JANET_API int janet_verify(JanetFuncDef *def);
 
 /* Pretty printing */
@@ -1997,7 +1874,7 @@ JANET_API void janet_vm_free(JanetVM *vm);
 JANET_API void janet_vm_save(JanetVM *into);
 JANET_API void janet_vm_load(JanetVM *from);
 JANET_API void janet_interpreter_interrupt(JanetVM *vm);
-JANET_API void janet_interpreter_interrupt_handled(JanetVM *vm); /* Call this after running interrupt handler */
+JANET_API void janet_interpreter_interrupt_handled(JanetVM *vm);
 JANET_API JanetSignal janet_continue(JanetFiber *fiber, Janet in, Janet *out);
 JANET_API JanetSignal janet_continue_signal(JanetFiber *fiber, Janet in, Janet *out, JanetSignal sig);
 JANET_API JanetSignal janet_pcall(JanetFunction *fun, int32_t argn, const Janet *argv, Janet *out, JanetFiber **f);
@@ -2022,14 +1899,9 @@ JANET_API void janet_stacktrace_ext(JanetFiber *fiber, Janet err, const char *pr
 #define JANET_SANDBOX_FFI_USE 2048
 #define JANET_SANDBOX_FFI_JIT 4096
 #define JANET_SANDBOX_SIGNAL 8192
-#define JANET_SANDBOX_CHROOT 16384
 #define JANET_SANDBOX_FFI (JANET_SANDBOX_FFI_DEFINE | JANET_SANDBOX_FFI_USE | JANET_SANDBOX_FFI_JIT)
 #define JANET_SANDBOX_FS (JANET_SANDBOX_FS_WRITE | JANET_SANDBOX_FS_READ | JANET_SANDBOX_FS_TEMP)
 #define JANET_SANDBOX_NET (JANET_SANDBOX_NET_CONNECT | JANET_SANDBOX_NET_LISTEN)
-#define JANET_SANDBOX_COMPILE 32768
-#define JANET_SANDBOX_ASM 65536
-#define JANET_SANDBOX_THREADS 131072
-#define JANET_SANDBOX_UNMARSHAL 262144
 #define JANET_SANDBOX_ALL (UINT32_MAX)
 JANET_API void janet_sandbox(uint32_t flags);
 JANET_API void janet_sandbox_assert(uint32_t forbidden_flags);
@@ -2074,23 +1946,10 @@ JANET_API JanetBinding janet_resolve_ext(JanetTable *env, JanetSymbol sym);
 /* Get values from the core environment. */
 JANET_API Janet janet_resolve_core(const char *name);
 
-/* New C API
- *
- * The "New" C API is intended to make constructing good documentation and source maps
- * much more straightforward. This not only ensures doc strings for functions in native
- * modules, it also add source code mapping for C functions so that programmers can see which
- * file and line a native function that calls janet_panic came from.
- *
- * */
-
-#if defined(JANET_NANBOX_64) && (JANET_NANBOX_64_POINTER_SHIFT != 0) && !defined(JANET_MSVC)
-#define JANET_CFUNCTION_ALIGN __attribute__((aligned(1 << JANET_NANBOX_64_POINTER_SHIFT)))
-#else
-#define JANET_CFUNCTION_ALIGN
-#endif
+/* New C API */
 
 /* Shorthand for janet C function declarations */
-#define JANET_CFUN(name) JANET_CFUNCTION_ALIGN Janet name (int32_t argc, Janet *argv)
+#define JANET_CFUN(name) Janet name (int32_t argc, Janet *argv)
 
 /* Declare a C function with documentation and source mapping */
 #define JANET_REG_END {NULL, NULL, NULL, NULL, 0}
@@ -2106,7 +1965,7 @@ JANET_API Janet janet_resolve_core(const char *name);
 #define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_}
 #define JANET_FN_S(CNAME, USAGE, DOCSTRING) \
     static const int32_t CNAME##_sourceline_ = __LINE__; \
-    Janet JANET_CFUNCTION_ALIGN CNAME (int32_t argc, Janet *argv)
+    Janet CNAME (int32_t argc, Janet *argv)
 #define JANET_DEF_S(ENV, JNAME, VAL, DOC) \
     janet_def_sm(ENV, JNAME, VAL, NULL, __FILE__, __LINE__)
 
@@ -2114,7 +1973,7 @@ JANET_API Janet janet_resolve_core(const char *name);
 #define JANET_REG_D(JNAME, CNAME) {JNAME, CNAME, CNAME##_docstring_, NULL, 0}
 #define JANET_FN_D(CNAME, USAGE, DOCSTRING) \
     static const char CNAME##_docstring_[] = USAGE "\n\n" DOCSTRING; \
-    Janet JANET_CFUNCTION_ALIGN CNAME (int32_t argc, Janet *argv)
+    Janet CNAME (int32_t argc, Janet *argv)
 #define JANET_DEF_D(ENV, JNAME, VAL, DOC) \
     janet_def(ENV, JNAME, VAL, DOC)
 
@@ -2123,7 +1982,7 @@ JANET_API Janet janet_resolve_core(const char *name);
 #define JANET_FN_SD(CNAME, USAGE, DOCSTRING) \
     static const int32_t CNAME##_sourceline_ = __LINE__; \
     static const char CNAME##_docstring_[] = USAGE "\n\n" DOCSTRING; \
-    Janet JANET_CFUNCTION_ALIGN CNAME (int32_t argc, Janet *argv)
+    Janet CNAME (int32_t argc, Janet *argv)
 #define JANET_DEF_SD(ENV, JNAME, VAL, DOC) \
     janet_def_sm(ENV, JNAME, VAL, DOC, __FILE__, __LINE__)
 
@@ -2242,8 +2101,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);
@@ -2344,9 +2201,7 @@ typedef enum {
     RULE_SPLIT,        /* [rule, rule] */
     RULE_NTH,          /* [nth, rule, tag] */
     RULE_ONLY_TAGS,    /* [rule] */
-    RULE_MATCHSPLICE,  /* [rule, constant, tag] */
-    RULE_DEBUG,        /* [] */
-} 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
@@ -26,7 +26,6 @@
 
 #include <janet.h>
 #include <errno.h>
-#include <assert.h>
 
 #ifdef _WIN32
 #include <windows.h>
@@ -80,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;
         }
@@ -113,8 +110,6 @@ static JANET_THREAD_LOCAL int gbl_historyi = 0;
 static JANET_THREAD_LOCAL JanetByteView gbl_matches[JANET_MATCH_MAX];
 static JANET_THREAD_LOCAL int gbl_match_count = 0;
 static JANET_THREAD_LOCAL int gbl_lines_below = 0;
-static JANET_THREAD_LOCAL int gbl_history_loaded = 0;
-static JANET_THREAD_LOCAL char *gbl_history_file = NULL;
 #endif
 
 /* Fallback */
@@ -312,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;
@@ -363,52 +356,33 @@ static void clear(void) {
     }
 }
 
-static int getplen(void) {
-    int _plen = gbl_plen;
-    /* Ensure at least 16 characters of data entry; */
-    while (_plen && (_plen + 16 > gbl_cols)) {
-        _plen--;
-    }
-    return _plen;
-}
-
 static void refresh(void) {
     char seq[64];
     JanetBuffer b;
 
-    /* If prompt is too long, truncate */
-    int _plen = getplen();
-
     /* Keep cursor position on screen */
     char *_buf = gbl_buf;
     int _len = gbl_len;
     int _pos = gbl_pos;
-
-    while ((_plen + _pos) >= gbl_cols) {
+    while ((gbl_plen + _pos) >= gbl_cols) {
         _buf++;
         _len--;
         _pos--;
     }
-
-    while ((_plen + _len) > gbl_cols) {
+    while ((gbl_plen + _len) > gbl_cols) {
         _len--;
     }
 
-
     janet_buffer_init(&b, 0);
     /* Cursor to left edge, gbl_prompt and buffer */
     janet_buffer_push_u8(&b, '\r');
-    janet_buffer_push_bytes(&b, (const uint8_t *) gbl_prompt, _plen);
-    if (_len > 0) {
-        janet_buffer_push_bytes(&b, (uint8_t *) _buf, _len);
-    }
+    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 + _plen) {
-        snprintf(seq, 64, "\x1b[%dC", (int)(_pos + _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);
     }
@@ -432,8 +406,7 @@ static int insert(char c, int draw) {
             gbl_buf[gbl_pos++] = c;
             gbl_buf[++gbl_len] = '\0';
             if (draw) {
-                int _plen = getplen();
-                if (_plen + gbl_len < gbl_cols) {
+                if (gbl_plen + gbl_len < gbl_cols) {
                     /* Avoid a full update of the line in the
                      * trivial case. */
                     if (write_console(&c, 1) == -1) return -1;
@@ -451,63 +424,6 @@ static int insert(char c, int draw) {
     return 0;
 }
 
-static void calc_history_file(void) {
-    char *hist = getenv("JANET_HISTFILE");
-    if (hist != NULL) {
-        gbl_history_file = sdup(hist);
-    } else {
-        gbl_history_file = NULL;
-    }
-}
-
-static void loadhistory(void) {
-    if (gbl_history_loaded) return;
-    calc_history_file();
-    gbl_history_loaded = 1;
-    if (NULL == gbl_history_file) return;
-    FILE *history_file = fopen(gbl_history_file, "rb");
-    if (NULL == history_file) return;
-    JanetParser p;
-    janet_parser_init(&p);
-    int c = 0;
-    while ((c = fgetc(history_file))) {
-        if (c == EOF) {
-            janet_parser_eof(&p);
-        } else {
-            janet_parser_consume(&p, c);
-        }
-
-        while (janet_parser_has_more(&p) && gbl_history_count < JANET_HISTORY_MAX) {
-            if (janet_parser_status(&p) == JANET_PARSE_ERROR) {
-                janet_eprintf("bad history file: %s\n", janet_parser_error(&p));
-                goto parsing_done;
-            }
-            Janet x = janet_parser_produce(&p);
-            const char *cstr = (const char *) janet_to_string(x);
-            if (cstr[0]) { /* Drop empty strings */
-                gbl_history[gbl_history_count++] = sdup(cstr);
-            }
-        }
-
-        if (c == EOF) break;
-    }
-parsing_done:
-    janet_parser_deinit(&p);
-    gbl_historyi = 0;
-    fclose(history_file);
-}
-
-static void savehistory(void) {
-    if (gbl_history_count < 1 || (gbl_history_file == NULL)) return;
-    FILE *history_file = fopen(gbl_history_file, "wb");
-    for (int i = 0; i < gbl_history_count; i++) {
-        if (gbl_history[i][0]) { /* Drop empty strings */
-            janet_dynprintf(NULL, history_file, "%j\n", janet_cstringv(gbl_history[i]));
-        }
-    }
-    fclose(history_file);
-}
-
 static void historymove(int delta) {
     if (gbl_history_count > 1) {
         janet_free(gbl_history[gbl_historyi]);
@@ -519,13 +435,8 @@ static void historymove(int delta) {
         } else if (gbl_historyi >= gbl_history_count) {
             gbl_historyi = gbl_history_count - 1;
         }
-        gbl_len = (int) strlen(gbl_history[gbl_historyi]);
-        /* If history element is longer the JANET_LINE_MAX - 1, truncate */
-        if (gbl_len > JANET_LINE_MAX - 1) {
-            gbl_len = JANET_LINE_MAX - 1;
-        }
-        gbl_pos = gbl_len;
         strncpy(gbl_buf, gbl_history[gbl_historyi], JANET_LINE_MAX - 1);
+        gbl_pos = gbl_len = (int) strlen(gbl_buf);
         gbl_buf[gbl_len] = '\0';
 
         refresh();
@@ -949,12 +860,11 @@ static int line() {
     gbl_len = 0;
     gbl_pos = 0;
     while (gbl_prompt[gbl_plen]) gbl_plen++;
-    int _plen = getplen();
     gbl_buf[0] = '\0';
 
     addhistory();
 
-    if (write_console((char *) gbl_prompt, _plen) == -1) return -1;
+    if (write_console((char *) gbl_prompt, gbl_plen) == -1) return -1;
     for (;;) {
         char c;
         char seq[5];
@@ -980,7 +890,6 @@ static int line() {
             case 3:     /* ctrl-c */
                 clearlines();
                 norawmode();
-                savehistory();
 #ifdef _WIN32
                 ExitProcess(1);
 #else
@@ -1174,21 +1083,17 @@ void janet_line_init() {
 }
 
 void janet_line_deinit() {
+    int i;
     norawmode();
-    for (int i = 0; i < gbl_history_count; i++)
+    for (i = 0; i < gbl_history_count; i++)
         janet_free(gbl_history[i]);
     gbl_historyi = 0;
-    if (gbl_history_file) {
-        janet_free(gbl_history_file);
-        gbl_history_file = NULL;
-    }
 }
 
 void janet_line_get(const char *p, JanetBuffer *buffer) {
     gbl_prompt = p;
     buffer->count = 0;
     gbl_historyi = 0;
-    loadhistory();
     if (check_simpleline(buffer)) return;
     FILE *out = janet_dynfile("err", stderr);
     if (line()) {
@@ -1224,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
@@ -1237,7 +1138,7 @@ int main(int argc, char **argv) {
 #endif
 
 #if defined(JANET_PRF)
-    uint8_t hash_key[JANET_HASH_KEY_SIZE + 1] = {0};
+    uint8_t hash_key[JANET_HASH_KEY_SIZE + 1];
 #ifdef JANET_REDUCED_OS
     char *envvar = NULL;
 #else
@@ -1245,7 +1146,6 @@ int main(int argc, char **argv) {
 #endif
     if (NULL != envvar) {
         strncpy((char *) hash_key, envvar, sizeof(hash_key) - 1);
-        hash_key[JANET_HASH_KEY_SIZE] = '\0'; /* in case copy didn't get null byte */
     } else if (janet_cryptorand(hash_key, JANET_HASH_KEY_SIZE) != 0) {
         fputs("unable to initialize janet PRF hash function.\n", stderr);
         return 1;
@@ -1284,10 +1184,6 @@ int main(int argc, char **argv) {
     status = janet_loop_fiber(fiber);
 
     /* Deinitialize vm */
-
-#if !defined(JANET_SIMPLE_GETLINE)
-    savehistory();
-#endif
     janet_deinit();
     janet_line_deinit();
 

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/c/test-gc-pcall.c

@@ -1,143 +0,0 @@
-/*
- * Test that GC does not collect fibers during janet_pcall.
- *
- * Bug: janet_collect() marks janet_vm.root_fiber but not janet_vm.fiber.
- * When janet_pcall is called from a C function, the inner fiber becomes
- * janet_vm.fiber while root_fiber still points to the outer fiber. If GC
- * triggers inside the inner fiber's execution, the inner fiber is not in
- * any GC root set and can be collected — including its stack memory —
- * while it is actively running.
- *
- * Two tests:
- *   1. Single nesting: F1 -> C func -> janet_pcall -> F2
- *      F2 is not marked (it's janet_vm.fiber but not root_fiber)
- *   2. Deep nesting: F1 -> C func -> janet_pcall -> F2 -> C func -> janet_pcall -> F3
- *      F2 is not marked (saved only in a C stack local tstate.vm_fiber)
- *
- * Build (after building janet):
- *   cc -o build/test-gc-pcall test/test-gc-pcall.c \
- *      -Isrc/include -Isrc/conf build/libjanet.a -lm -lpthread -ldl
- *
- * Run:
- *   ./build/test-gc-pcall
- */
-
-#include "janet.h"
-#include <stdio.h>
-
-/* C function that calls a Janet callback via janet_pcall. */
-static Janet cfun_call_via_pcall(int32_t argc, Janet *argv) {
-    janet_fixarity(argc, 1);
-    JanetFunction *fn = janet_getfunction(argv, 0);
-
-    Janet result;
-    JanetFiber *fiber = NULL;
-    JanetSignal sig = janet_pcall(fn, 0, NULL, &result, &fiber);
-
-    if (sig != JANET_SIGNAL_OK) {
-        janet_panicv(result);
-    }
-
-    return result;
-}
-
-static int run_test(JanetTable *env, const char *name, const char *source) {
-    printf("  %s... ", name);
-    fflush(stdout);
-    Janet result;
-    int status = janet_dostring(env, source, name, &result);
-    if (status != 0) {
-        printf("FAIL (crashed or errored)\n");
-        return 1;
-    }
-    printf("PASS\n");
-    return 0;
-}
-
-/* Test 1: Single nesting.
- * F1 -> cfun_call_via_pcall -> janet_pcall -> F2
- * F2 is janet_vm.fiber but not root_fiber, so GC can collect it.
- *
- * All allocations are done in Janet code so GC checks trigger in the
- * VM loop (janet_gcalloc does NOT call janet_collect — only the VM's
- * vm_checkgc_next does). */
-static const char test_single[] =
-    "(gcsetinterval 1024)\n"
-    "(def cb\n"
-    "  (do\n"
-    "    (def captured @{:key \"value\" :nested @[1 2 3 4 5]})\n"
-    "    (fn []\n"
-    "      (var result nil)\n"
-    "      (for i 0 500\n"
-    "        (def t @{:i i :s (string \"iter-\" i) :arr @[i (+ i 1) (+ i 2)]})\n"
-    "        (set result (get captured :key)))\n"
-    "      result)))\n"
-    "(for round 0 200\n"
-    "  (def result (call-via-pcall cb))\n"
-    "  (assert (= result \"value\")\n"
-    "    (string \"round \" round \": expected 'value', got \" (describe result))))\n";
-
-/* Test 2: Deep nesting.
- * F1 -> cfun_call_via_pcall -> janet_pcall -> F2 -> cfun_call_via_pcall -> janet_pcall -> F3
- * F2 is saved only in C stack local tstate.vm_fiber, invisible to GC.
- * F2's stack data can be freed if F2 is collected during F3's execution.
- *
- * The inner callback allocates in Janet code (not C) to ensure the
- * VM loop triggers GC checks during F3's execution. */
-static const char test_deep[] =
-    "(gcsetinterval 1024)\n"
-    "(def inner-cb\n"
-    "  (do\n"
-    "    (def captured @{:key \"deep\" :nested @[10 20 30]})\n"
-    "    (fn []\n"
-    "      (var result nil)\n"
-    "      (for i 0 500\n"
-    "        (def t @{:i i :s (string \"iter-\" i) :arr @[i (+ i 1) (+ i 2)]})\n"
-    "        (set result (get captured :key)))\n"
-    "      result)))\n"
-    "\n"
-    "(def outer-cb\n"
-    "  (do\n"
-    "    (def state @{:count 0 :data @[\"a\" \"b\" \"c\" \"d\" \"e\"]})\n"
-    "    (fn []\n"
-    "      # This runs on F2. Calling call-via-pcall here creates F3.\n"
-    "      # F2 becomes unreachable: it's not root_fiber (that's F1)\n"
-    "      # and it's no longer janet_vm.fiber (that's now F3).\n"
-    "      (def inner-result (call-via-pcall inner-cb))\n"
-    "      # If F2 was collected during F3's execution, accessing\n"
-    "      # state here reads freed memory.\n"
-    "      (put state :count (+ (state :count) 1))\n"
-    "      (string inner-result \"-\" (state :count)))))\n"
-    "\n"
-    "(for round 0 200\n"
-    "  (def result (call-via-pcall outer-cb))\n"
-    "  (def expected (string \"deep-\" (+ round 1)))\n"
-    "  (assert (= result expected)\n"
-    "    (string \"round \" round \": expected '\" expected \"', got '\" (describe result) \"'\")))\n";
-
-int main(int argc, char **argv) {
-    (void)argc;
-    (void)argv;
-    int failures = 0;
-
-    janet_init();
-
-    JanetTable *env = janet_core_env(NULL);
-
-    janet_def(env, "call-via-pcall",
-              janet_wrap_cfunction(cfun_call_via_pcall),
-              "Call a function via janet_pcall from C.");
-
-    printf("Testing janet_pcall GC safety:\n");
-    failures += run_test(env, "single-nesting", test_single);
-    failures += run_test(env, "deep-nesting", test_deep);
-
-    janet_deinit();
-
-    if (failures > 0) {
-        printf("\n%d test(s) FAILED\n", failures);
-        return 1;
-    }
-    printf("\nAll tests passed.\n");
-    return 0;
-}

test/helper.janet

@@ -1,8 +1,5 @@
 # Helper code for running tests
 
-# Turn on strict linting by default in test suite.
-(put root-env *lint-warn* :strict)
-
 (var num-tests-passed 0)
 (var num-tests-run 0)
 (var suite-name 0)
@@ -10,7 +7,7 @@
 (var skip-count 0)
 (var skip-n 0)
 
-(var is-verbose (os/getenv "VERBOSE"))
+(def is-verbose (os/getenv "VERBOSE"))
 
 (defn- assert-no-tail
   "Override's the default assert with some nice error handling."
@@ -22,16 +19,15 @@
     (break x))
   (default e "assert error")
   (when x (++ num-tests-passed))
+  (def str (string e))
   (def stack (debug/stack (fiber/current)))
   (def frame (last stack))
   (def line-info (string/format "%s:%d"
                               (frame :source) (frame :source-line)))
   (if x
-    (when is-verbose
-      (eprintf "\e[32m✔\e[0m %s: %s: %v" line-info (describe e) x)
-      (eflush) (flush))
+    (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) (flush)))
+      (eprintf "\e[31m✘\e[0m %s: %s: %v" line-info (describe e) x) (eflush)))
   x)
 
 (defn skip-asserts
@@ -40,7 +36,7 @@
   (+= skip-n n)
   nil)
 
-(defmacro assert :shadow
+(defmacro assert
   [x &opt e]
   (def xx (gensym))
   (default e (string/format "%j" x))
@@ -52,12 +48,7 @@
 (defmacro assert-error
   [msg & forms]
   (def errsym (keyword (gensym)))
-  ~(as-macro ,assert (= ,errsym (try (do ,;forms) ([_] ,errsym))) ,msg))
-
-(defmacro assert-error-value
-  [msg errval & forms]
-  (def e (gensym))
-  ~(as-macro ,assert (= ,errval (try (do ,;forms) ([,e] ,e))) ,msg))
+  ~(assert (= ,errsym (try (do ,;forms) ([_] ,errsym))) ,msg))
 
 (defn check-compile-error
   [form]
@@ -69,8 +60,8 @@
   (def e (gensym))
   (def f (gensym))
   (if is-verbose
-  ~(try (do ,;forms (as-macro ,assert true ,msg)) ([,e ,f] (as-macro ,assert false ,msg) (,debug/stacktrace ,f ,e "\e[31m✘\e[0m ")))
-  ~(try (do ,;forms (as-macro ,assert true ,msg)) ([_] (as-macro ,assert false ,msg)))))
+  ~(try (do ,;forms (,assert true ,msg)) ([,e ,f] (,assert false ,msg) (,debug/stacktrace ,f ,e "\e[31m✘\e[0m ")))
+  ~(try (do ,;forms (,assert true ,msg)) ([_] (,assert false ,msg)))))
 
 (defn start-suite [&opt x]
   (default x (dyn :current-file))

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
@@ -70,9 +70,9 @@
 (assert (= (array/pop @[]) nil) "array/pop empty")
 
 # Code coverage
-(def a1 @[1])
-(array/pop a1)
-(array/trim a1)
+(def a @[1])
+(array/pop a)
+(array/trim a)
 (array/ensure @[1 1] 6 2)
 
 # array/join
@@ -86,10 +86,5 @@
 (assert-error "array/join error 4" (array/join @[] "abc123"))
 (assert-error "array/join error 5" (array/join @[] "abc123"))
 
-# Regression 1714
-(repeat 10
-  (assert (deep= (put @[] 100 10) (put (seq [_ :range [0 101]] nil) 100 10)) "regression 1714")
-  (assert (deep= (put @[] 200 10) (put (seq [_ :range [0 201]] nil) 200 10)) "regression 1714"))
-
 (end-suite)
 

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
@@ -21,8 +21,6 @@
 (import ./helper :prefix "" :exit true)
 (start-suite)
 
-(setdyn *lint-warn* :none)
-
 # Assembly test
 # Fibonacci sequence, implemented with naive recursion.
 # a679f60

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
@@ -21,8 +21,6 @@
 (import ./helper :prefix "" :exit true)
 (start-suite)
 
-(setdyn *lint-warn* :none)
-
 # Let
 # 807f981
 (assert (= (let [a 1 b 2] (+ a b)) 3) "simple let")
@@ -1025,11 +1023,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
@@ -48,8 +48,8 @@
 
 (assert (deep= (buffer/push @"AA" @"BB") @"AABB") "buffer/push buffer")
 (assert (deep= (buffer/push @"AA" 66 66) @"AABB") "buffer/push int")
-(def b1 @"AA")
-(assert (deep= (buffer/push b1 b1) @"AAAA") "buffer/push buffer self")
+(def b @"AA")
+(assert (deep= (buffer/push b b) @"AAAA") "buffer/push buffer self")
 
 # buffer/push-byte
 (assert (deep= (buffer/push-byte @"AA" 66) @"AAB") "buffer/push-byte")
@@ -145,8 +145,8 @@
 
 # Regression #301
 # a3d4ecddb
-(def b8 (buffer/new-filled 128 0x78))
-(assert (= 38 (length (buffer/blit @"" b8 -1 90))) "buffer/blit 1")
+(def b (buffer/new-filled 128 0x78))
+(assert (= 38 (length (buffer/blit @"" b -1 90))) "buffer/blit 1")
 
 (def a @"abcdefghijklm")
 (assert (deep= @"abcde" (buffer/blit @"" a -1 0 5)) "buffer/blit 2")
@@ -179,10 +179,5 @@
 (assert (= (string buf) "xxxxxx") "buffer/format-at negative index")
 (assert-error "expected index at to be in range [0, 0), got 1" (buffer/format-at @"" 1 "abc"))
 
-# Regression 1714
-(repeat 10
-  (assert (deep= (put @"" 100 10) (put (buffer (string/repeat "\0" 101)) 100 10)) "regression 1714")
-  (assert (deep= (put @"" 200 10) (put (buffer (string/repeat "\0" 201)) 200 10)) "regression 1714"))
-
 (end-suite)
 

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
@@ -30,7 +30,7 @@
 (defn myfun [x]
   (var a 10)
   (set a (do
-         (def _y x)
+         (def y x)
          (if x 8 9))))
 
 (assert (= (myfun true) 8) "check do form regression")
@@ -46,10 +46,8 @@
 # Edge case should cause old compilers to fail due to
 # if statement optimization
 # 17283241
-(setdyn *lint-warn* :relaxed)
 (var var-a 1)
 (var var-b (if false 2 (string "hello")))
-(setdyn *lint-warn* nil)
 
 (assert (= var-b "hello") "regression 1")
 
@@ -75,85 +73,5 @@
   (foo 0)
   10)
 
-# Issue #1699 - fuzz case with bad def
-(def result
-  (compile '(defn sum3
-              "Solve the 3SUM problem in O(n^2) time."
-              [s]
-              (def)tab @{})))
-(assert (get result :error) "bad sum3 fuzz issue valgrind")
-
-# Issue #1700
-(def result1
-  (compile
-    '(defn fuzz-case-1
-      [start end &]
-      (if end
-        (if e start (lazy-range (+ 1 start) end)))
-      1)))
-(assert (get result1 :error) "fuzz case issue #1700")
-
-# Issue #1702 - fuzz case with upvalues
-(def result2
-  (compile
-  '(each item [1 2 3]
-    # Generate a lot of upvalues (more than 224)
-    (def ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;out-buf @"")
-    (with-dyns [:out out-buf] 1))))
-(assert result2 "bad upvalues fuzz case")
-
-# Named argument linting
-# Enhancement for #1654
-
-(defn fnamed [&named x y z] [x y z])
-(defn fkeys [&keys ks] ks)
-(defn fnamed2 [_a _b _c &named x y z] [x y z])
-(defn fkeys2 [_a _b _c &keys ks] ks)
-(defn fnamed3 [{:x x} &named a b c] [x a b c])
-(defn fnamed4 [_y &opt _z &named a b c] [a b c])
-(defn fnamed5 [&opt _z &named a b c] [a b c])
-(defn g [x &opt y &named z] [x y z])
-
-(defn check-good-compile
-  [code msg]
-  (def lints @[])
-  (def result4 (compile code (curenv) "suite-compile.janet" lints))
-  (assert (and (function? result4) (empty? lints)) msg))
-
-(defn check-lint-compile
-  [code msg]
-  (def lints @[])
-  (def result4 (compile code (curenv) "suite-compile.janet" lints))
-  (assert (and (function? result4) (next lints)) msg))
-
-(check-good-compile '(fnamed) "named no args")
-(check-good-compile '(fnamed :x 1 :y 2 :z 3) "named full args")
-(check-lint-compile '(fnamed :x) "named odd args")
-(check-lint-compile '(fnamed :w 0) "named wrong key args")
-(check-good-compile '(fkeys :a 1) "keys even args")
-(check-lint-compile '(fkeys :a 1 :b) "keys odd args")
-(check-good-compile '(fnamed2 nil nil nil) "named 2 no args")
-(check-good-compile '(fnamed2 nil nil nil :x 1 :y 2 :z 3) "named 2 full args")
-(check-lint-compile '(fnamed2 nil nil nil :x) "named 2 odd args")
-(check-lint-compile '(fnamed2 nil nil nil :w 0) "named 2 wrong key args")
-(check-good-compile '(fkeys2 nil nil nil :a 1) "keys 2 even args")
-(check-lint-compile '(fkeys2 nil nil nil :a 1 :b) "keys 2 odd args")
-(check-good-compile '(fnamed3 {:x 1} :a 1 :b 2 :c 3) "named 3 good")
-(check-lint-compile '(fnamed3 {:x 1} :a 1 :b 2 :d 3) "named 3 lint")
-(check-good-compile '(fnamed4 10 20 :a 1 :b 2 :c 3) "named 4 good")
-(check-lint-compile '(fnamed4 10 20 :a 1 :b 2 :d 3) "named 4 lint")
-(check-good-compile '(fnamed5 10 :a 1 :b 2 :c 3) "named 5 good")
-(check-lint-compile '(fnamed5 10 :a 1 :b 2 :d 3) "named 5 lint")
-(check-good-compile '(g 1) "g good 1")
-(check-good-compile '(g 1 2) "g good 2")
-(check-good-compile '(g 1 2 :z 10) "g good 3")
-(check-lint-compile '(g 1 2 :z) "g lint 1")
-(check-lint-compile '(g 1 2 :z 4 5) "g lint 2")
-
-# Variable shadowing linting
-(def outer1 "a")
-(check-lint-compile '(def outer1 "b") "shadow global-to-global")
-(check-lint-compile '(let [outer1 "b"] outer1) "shadow local-to-global")
-(check-lint-compile '(do (def x "b") (def x "c")) "shadow local-to-local")
-
 (end-suite)
+