Turtles v0.7.0

The shared parsers now use len, charAt, and nextCharPos. The JavaScript prototype keeps its ordinary string operations; ARM uses UTF-8 byte offsets and retains strlen for code-point counts. SOM string lengths and indexing, and $indexOf, use the same native offset convention.

Frequently written ARM VM globals now occupy a separate 4 KiB page, avoiding QEMU code-page write checks during ordinary calls and compilation.

Validated with JavaScript-host checks and native QEMU: T0/JS/SOM factorial, UTF-8 and malformed-input handling, reader switching, and reset.

Try the browser REPL and find direct QEMU commands at https://adamvy.github.io/TURTLES/ . The attached ELF and raw images target QEMU virt-8.2, Cortex-A53, 512 MiB RAM.

Turtles v0.6.0

ARM now uses an untagged 64-bit word stack. Integers are immediate values; strings, arrays and closures are raw pointers. Numeric boxing, floating-point arithmetic, runtime type predicates and generic object properties are removed. Operations assume the correct representation.

SOM returns to Kevin's closure-based objects, captured fields and parent delegation, with direct T0 code generation. The added tagged object model and central message dispatcher are gone. T0, JS-like and SOM readers still share one persistent session.

This changes ARM semantics: arithmetic is signed integer arithmetic, print displays a word, print$ displays a string, and strings use explicit operations such as +$ and =$. Parser combinators require explicit lit construction. UTF-8 storage remains. There is no garbage collector; exhausting the arena or heap halts the machine.

Validated with native QEMU and browser QEMU, including JS functions and mutable closures, SOM classes and inheritance, reader switching, UTF-8 strings, integer boundaries and direct terminal input. Semantics and usage are described in the repository README.

Open the REPL. Download turtles.elf below and run:

qemu-system-aarch64 -machine virt-8.2 -cpu cortex-a53 -accel tcg -m 512M -smp 1 -nographic -device loader,file=turtles.elf,cpu-num=0

Enter :js, :som or :t0 to switch readers. Exit QEMU with Ctrl-a, then x. The JavaScript host retains its Number arithmetic; the ARM readers use integer arithmetic. Physical hardware boot and rebuilding a native image from inside the guest remain future work.

Turtles v0.5.0

ARM strings now use UTF-8 storage and Unicode code-point operations. len counts code points; byteLen reports storage bytes; charAt, string @ and indexOf use code-point positions. charCode constructs a full Unicode scalar, replacing invalid scalar values with U+FFFD. The JavaScript host retains its existing UTF-16 code-unit behavior.

Parser streams use byte cursors on ARM, decoding the next code point directly. This keeps sequential parsing efficient without storing a second length in every string. The 64 KiB input buffer is allocated at boot instead of embedded in the image.

The raw image is 58,935 bytes, down from 159,270 bytes. Runtime code grew slightly; the reduction comes from string data and the removed static buffer.

Validated in native QEMU with upstream T0 assertions, parser/SOM fixtures, Unicode and malformed-byte cases, numeric parsing/formatting checks, and input overflow/reset checks. The shared readers were also checked on the unchanged JavaScript T0 host.

One image includes T0, JS-like and SOM readers. Run instructions and browser REPL: https://adamvy.github.io/TURTLES/

Turtles v0.4.2

One AArch64 Turtles image with T0, JS-like and SOM readers for QEMU virt-8.2 / Cortex-A53. Boot commands and browser REPL: https://adamvy.github.io/TURTLES/

Turtles v0.4.1

One AArch64 Turtles image with T0, JS-like and SOM readers for QEMU virt-8.2 / Cortex-A53. Boot commands and browser REPL: https://adamvy.github.io/TURTLES/

Turtles v0.4.0

One AArch64 Turtles image with T0, JS-like and SOM readers for QEMU virt-8.2 / Cortex-A53. Boot commands and browser REPL: https://adamvy.github.io/TURTLES/

Turtles v0.3.0

Raw T0 and JS-like AArch64 images for QEMU virt-8.2 / Cortex-A53. Boot commands and browser REPL: https://adamvy.github.io/TURTLES/

Turtles ARM/browser v0.2.1

Kevin Greer's Turtles boots from an AArch64 machine-code image, with no guest OS or C runtime. The browser demo runs the same image in QEMU WebAssembly.

Version 0.2.1 fixes first-visit browser setup: the page waits for the isolation
worker to control navigation before reloading and enabling Boot. The ARM image
bytes are unchanged from 0.2.0. Four startup-order regression tests cover the fix.

Try the live browser machine. Choose raw T0 or the JS-like language, then Boot. The emulator downloads only on demand; programs are compiled and evaluated inside the ARM guest.

The T0-written JS-like compiler now supports named and anonymous functions, lexical closures, recursion, argument lists, returns and arrow functions. It remains an experimental dialect, not full ECMAScript. See the repository's language and compatibility documentation.

Downloads:

• turtles-t0.elf and .bin: raw T0 REPL with original prelude.
• turtles-js.elf and .bin: T0 plus its self-hosted parser and JS-like compiler.
• Per-image JSON manifests, latest.json and SHA256SUMS: architecture, build inputs, image hashes and site manifest.

Native boot: qemu-system-aarch64 -machine virt-8.2 -cpu cortex-a53 -accel tcg -m 512M -smp 1 -nographic -device loader,file=turtles-js.elf,cpu-num=0. Exit with Ctrl-a, then x. A raw .bin additionally needs addr=0x40200000,force-raw=on on the loader device.

The 512 MiB guest has bounded, monotonic storage and no garbage collector. Exhaustion halts the machine; reboot starts a new session. Desktop Chrome is the browser target. QEMU Wasm is fetched directly from its author's pinned, checksum-verified artifacts and is not included in these downloads.

Publication requires the native differential, function, numeric, image-boot and exact QEMU Wasm suites to pass. This demonstrates bare-metal execution in an emulated ARM machine, not a physical hardware boot. The native assembly core and Node image builder are documented parts of the bootstrap.

Turtles ARM/browser v0.2.0

Kevin Greer's Turtles boots from an AArch64 machine-code image, with no guest OS or C runtime. The browser demo runs the same image in QEMU WebAssembly.

Try the live browser machine. Choose raw T0 or the JS-like language, then Boot. The emulator downloads only on demand; programs are compiled and evaluated inside the ARM guest.

The T0-written JS-like compiler now supports named and anonymous functions, lexical closures, recursion, argument lists, returns and arrow functions. It remains an experimental dialect, not full ECMAScript. See the repository's language and compatibility documentation.

Downloads:

• turtles-t0.elf and .bin: raw T0 REPL with original prelude.
• turtles-js.elf and .bin: T0 plus its self-hosted parser and JS-like compiler.
• Per-image JSON manifests, latest.json and SHA256SUMS: architecture, build inputs, image hashes and site manifest.

Native boot: qemu-system-aarch64 -machine virt-8.2 -cpu cortex-a53 -accel tcg -m 512M -smp 1 -nographic -device loader,file=turtles-js.elf,cpu-num=0. Exit with Ctrl-a, then x. A raw .bin additionally needs addr=0x40200000,force-raw=on on the loader device.

The 512 MiB guest has bounded, monotonic storage and no garbage collector. Exhaustion halts the machine; reboot starts a new session. Desktop Chrome is the browser target. QEMU Wasm is fetched directly from its author's pinned, checksum-verified artifacts and is not included in these downloads.

Publication requires the native differential, function, numeric, image-boot and exact QEMU Wasm suites to pass. This demonstrates bare-metal execution in an emulated ARM machine, not a physical hardware boot. The native assembly core and Node image builder are documented parts of the bootstrap.