Repository navigation
Releases
Maylang v0.15.1 — Fern
Released 2026-11-14 UTC. A patch release that prepares the repository for
public access and removes Any from the library and the tools. The legacy
maypkg package manager is gone; projects use may workspaces. Strict typing
narrows Optional<T> after a nil check and lets a closure inside a generic
function name its type parameters, and the language gains hexadecimal, octal
and binary integer literals with digit separators. Generated code gets faster
again: a top-level main and Float loop bodies compile to native words, records
are built into fixed slots, enum payload reads and map probes skip runtime
calls, and a bounded collection threshold cuts the collector's pause and peak
footprint. Doc comments are now the single source of the API reference, and
the repository gains an MIT license and a security policy.
Repository
- Prepared the repository for public access. The unmaintained
frozen/tree
(other targets, NodeOS, the core runtime, maybrowser, mayos,stdlib/mland
archived examples) was removed frommain; its last version is the
frozen-archive
tag. Also removed: the dated repository audit,docs/history/, the stale
compliance snapshots, a duplicate.github/CONTRIBUTE.mdand a scratch
example.maycnow saystarget … is not supportedinstead ofis frozen,
and the language server no longer skips directories namedfrozen. - Removed the legacy
maypkgpackage manager and everymayproj.json.
Projects usemayworkspaces;may migratestill
converts an oldermayproj.json. The example projects that usedmaypkg
(starfall, kaindsim, rivet, sdl_test and the learning projects) now have
may.jsonmanifests, and kaindsim's and rivet's Makefiles compile with
maycdirectly. Release bundles and installers no longer shipmaypkg;
saved component lists and--componentsvalues that name it are ignored,
so older installations still upgrade. - Added a security policy with private vulnerability
reporting, an experimental-status note in the README, and a roadmap rebuilt
from the open issues.
Language
- Strict typing narrows
Optional<T>toTafter anilcheck: inside
if (x != nil), in the else-branch ofif (x == nil), on the right of
x != nil and ..., and for the rest of a block after an
if (x == nil) { return ...; }guard. Only names their module never
assigns narrow (strict guide). - Strict typing for generics: a closure inside a generic function can name
the enclosing function's type parameters (compose<A, B, C>can return
fun(x: A) -> C), and a type parameter no argument determines becomes
Neverat the call, solet xs: List<Int> = stack();is accepted.
reverseof aStris typedStr, as the runtime returns, instead of
List<Str>(strict guide). - The standard library uses concrete and generic types instead of
Any:
algo,iter,functional,collections,stats,random,csv,
format,string,path,math,test,io,net,validateand the
prelude.Anyremains only at dynamic boundaries, each commented: JSON,
validators that inspect runtime types, mixed-type[a, b]pairs, and the
Int-or-Float helperssquare,cube,averageandmedian. Breaking:
callers holdingAnyvalues must use the real types; stacks areList<T>,
queuesList<List<T>>and setsMap<T, Bool>;stats_*results that can
be undefined areOptional<Float>andstats_linear_regressionreturns a
Regressionstruct;random_newreturns aRandomstruct;validate_all
takesValidationRules and returns aValidation
(contracts). - The examples use concrete types:
Anydropped from 348 to 26 uses, all
commented dynamic boundaries (JSON documents, the ledger's untrusted input
stream,extern_ccallables). market, game, ledger, features, maytasks,
starfall and kaindsim model their data with structs; their output and
exported files are unchanged. maytasks now skips malformed saved tasks
instead of listing them asnil, and starfall starts a fresh flight from a
truncated save file instead of failing with a type fault.uniqueis typed
as returning its list element type. mayand the shared tool modules use concrete types:may.jsonis
validated as JSON as before, then decoded intoTargetSpec,Profile,
DependencyandConfigstructs, and builds returnArtifacts. Because a
target's cache identity includes its serialized spec, existing.may/
caches rebuild once.tools/shared/imports.maykeeps only the import
scannermayuses; its graph traversal and brace checker were dead code
after themaypkgremoval. An empty[]or{}now joins with a typed
collection (xs ?? []).maylspuses concrete types: indexed documents areDocstructs holding
Token,Scope,DefandImportvalues, ranges and positions are
Range/Position, and queued navigation and workspace requests and
diagnostic waiters are structs instead of string-keyed maps.
Lookups returnOptional<Def>/Optional<Doc>and rely onnilnarrowing.
Anyremains at the JSON-RPC boundary — parsed messages, replies and the
diagnostic caches, which a forked worker serializes and the parent stores as
a parsed snapshot. Behavior and protocol output are unchanged.- Hexadecimal
0xff, octal0o755and binary0b1010integer literals, and
_digit separators in every numeric literal (1_000_000,0xffff_ffff,
6.022_140e2_3). Prefixes are lowercase; each_must sit between two
digits; every radix has the signed 64-bit range, with the minimum reached
through unary minus. Invalid digits, misplaced separators, uppercase
prefixes and radix fractions are lexer errors.1_000was documented
before but did not compile. The formatter keeps a hexadecimalEfrom
reading as an exponent, the VS Code grammar highlights the new forms, and
the Rust bootstrap lexer accepts them too. String conversions (int,
float) still read decimal only. - Behavior contracts admit the numeric conversions and rounding primitives:
to_float,float,int,trunc,floor,ceil,round,sqrtand
abshave empty effect rows when the checker can establish that their single
argument is anIntorFloat. Other arguments, includingBool, fail
closed.int,truncandabscan still raise catchablearithmetic
faults, as/can (docs). - Behavior contracts admit the scalar mathematics:
sin,cos,tan,ln,
log2,log10,exp,powand**with aFloatoperand onIntor
Floatarguments,min/maxon two arguments of the same type, andbool
onInt,FloatorBool.Int ** Intand mixedmin/maxstay unknown
(docs).
Strict typing now typespowas returningFloatinstead ofAny.
Tooling
maychas a command surface instead of flags only:mayc run <source> [-- ARGS...]compiles to a private temporary executable in
$TMPDIR/mayc-run-<pid>/, forwards the arguments after--unchanged and
exits with the program's status (removing the temporary directory unless
-onames a path);mayc check <source>andmayc build <source>are
subcommand forms of--checkand the default. Diagnostics keep their source
excerpt and caret span but now carry a stableerror[E_STAGE]code and honor
--color auto|always|never/--no-color(autouses a terminal's stderr
unlessNO_COLORis set).-O0/-O1/-O2select the optional backend
passes and the inliner, and--deps FILEwrites a Make-style dependency file
naming the produced binary, every expanded import, the compiler and the
runtime sidecars that were read.--helpdocuments the commands and options
(compiler guide, toolchain
reference).maygained a scriptable command surface:may list [--json]describes
targets, defaults and prerequisites,may which [TARGET] [--build] [--json]
prints the artifact path a target would use without compiling (exit 1 until
it exists),may test --listandmay test --filter PATTERNnarrow the
discovered.test.mayfiles, andmay version/may doctorreport toolchain
identity and dependency-lock state as text or JSON. Global-C DIR,-qand
-vwork before or after the command (everything after--still belongs to
the program), and verbose builds print the exact compiler/recipe command and
per-target time (workspace runner).
Performance
- Language-server call hierarchy and navigation replies
(measurements):callHierarchy/incomingCallsnow
streams through the navigation worker's 32-file batches like references,
instead of loading the whole workspace into the worker, and the parent
forwards worker results without parsing and re-encoding them. On 3,000
files with 4 callers each, incoming calls drop from 11.71 s and 560 MiB peak
to 2.47 s and 188 MiB, and references from 3.06 s to 1.93 s.
benchmark_call_hierarchy.pyreproduces the measurements, and a new test
checks incoming calls across batch boundaries. - Native Float loop bodies and a native Float main (reports:
loops, main,
follow-up): a Float
function that contains a loop now compiles as native-word code. Declared
Float locals get pre-planned XMM8-15 homes that survive iterations and are
spilled/reloaded around calls, operations coalesce into...
Maylang v0.15.0 — Fern
Released 2026-11-01 UTC. Maylang narrows to one host and target, Linux
x86-64, and its values become fat: 16 bytes with a separate type word, so
Int is a full signed 64-bit integer and Floats are unboxed. Generated code
is much faster. Maps hash every key type, struct fields are cached per site,
hot locals and temporaries stay in registers (Floats in XMM registers), and
type proofs remove checks. Field caching alone makes n-body 11× faster,
and mayc compiles itself in under half the time it took in 0.14 (median
6.3 s instead of 15.4 s over five runs on the same machine). Bitwise
operators arrive, and the UI adapter and the VS Code extension get
sanitizer and extension-host tests.
Behavior changes
- Only
--target x86_64-linuxis supported. The other targets, the core
runtime, NodeOS, MayOS, the browser andstdlib/mlare frozen in
frozen/, and selecting them fails with an explanation. Theclang-llvm
target and--emit-llvmare removed. Intreaches ±2^63; overflow faults only beyond that.addrof a Float
is atypefault, aList<Any>uses 16 bytes per element, and--values
fails with an explanation.&,|,^,~,<<and>>work on 64-bit integers; a shift result
that does not fit raisesinteger overflowinstead of wrapping.- A function defined twice across the runtime and library sidecars is a
compile error. The prelude'srepeatandsubstringare removed;
native.mayprovides them, as before. - The VS Code extension restarts the language server when
maylang.serverPathormaylang.strictchanges.
Remaining limits
- The compiler host and the only target are Linux x86-64; release bundles are
Linux x86-64 only. - Long-running, allocation-heavy programs can still crash the full runtime's
collector (#2). - Dynamic code is still well behind compiled languages; records are maps
with per-site caches, and the remaining work is tracked in
#101. - The compiler frontend uses mutable global state and is not re-entrant
(#49).
Scope
- Breaking: freeze the platform experiments and the experimental ML
library while Maylang focuses on Linux x86-64
(plan,
#102).platform/maybrowser,
platform/mayos,stdlib/ml(import "ml/..."no longer resolves), its
reference pages,examples/ml_xor.mayand the artificial ecosystem
simulation, which usedstdlib/ml, move tofrozen/, where they are kept
but not built, tested or maintained.make test-browser, the doctor's
browserprofile and themaybrowser.ymlworkflow are removed. - Breaking: mayc targets only
x86_64-linux, with the full runtime and
--raw(--runtime none).--target x86_64-nodeos,arm64-linux,
riscv64-linux,arm64-macosandx86_64-windowsand--runtime core
fail withtarget ... is frozen/runtime core is frozen. The ARM64 and
RISC-V backends and their RAW lowering (raw.may,raw_fat.may,
raw_float.may), the Mach-O, PE and NXF formats, the NodeOS syscall gate
and personality (runtime/nodeos.may), the core runtime
(runtime/fat_core.may,runtime/fat_corelib.may, thecoreAPI page),
their harnesses (core_runtime.py,portable_values.py,
native_targets.py,nodeos.py) and target documentation move to
frozen/. The remaining harnesses test x86-64 Linux only. Release bundles
no longer containruntime/fat_core.may. The compiler is 2.67 MB instead
of 3.19 MB, and its x86-64 Linux output is byte-identical
(#102). - Stop running cross-target emulation (
core-emulation) and the Windows and
macOS real-loader workflow (native-targets.yml) in CI, and freeze the
WSL launcherdist/install.ps1; releases no longer publish it. Release
bundles describe themselves as Linux x86-64 only
(#102).
Compiler
- Reject a second definition of a function in the runtime and library
sidecars (runtime/fat.may,runtime/fat_linux.may,prelude.may,
native.may,runtime/math.may) with an error naming both locations.
The later definition used to replace the earlier one silently for every
caller. User code may still shadow library functions. The prelude's
repeatandsubstring, whichnative.mayhad always replaced, are
removed (#114). - Native-word functions call
externfunctions withInt,UInt,Ptr
andBoolsignatures directly again, passing machine words to C instead
of going through the extern's fat entry, asdocs/guide/STRICT.md
describes. UInt range faults keep the fat entry's messages
(#94). - Breaking: remove the experimental
clang-llvmtarget and
--emit-llvm. mayc is its own toolchain and writes every executable
itself; both now fail with an explanation.make test-llvm, the doctor's
llvmprofile, the harnesses'--llvmoptions and the runtimes' LLVM
accommodations (a libc-supplied environment pointer and 256-byte handler
slots) are gone, and the compiler's code is 290 KB smaller. - Breaking: compile every program with a runtime using fat values, 16
bytes with a separate type word, instead of 3-bit tagged words, on every
target (design: docs/design/FAT_VALUES.md).
Intis signed 64-bit: literals and arithmetic reach ±2^63 and
overflow faults only beyond that, values between 2^60 and 2^63 no longer
raiseinteger overflow, native-word results and C results cross into
dynamic code unchanged, Floats are unboxed (addrof a Float is now a
typefault) and aList<Any>uses 16 bytes per element. The compiler
itself runs on fat values and reaches the bootstrap fixpoint. The tagged
runtimes (runtime.may,runtime/core.may,runtime/corelib.may) and
their code generation are gone, the compiler is 3.19 MB, and--values
now fails with an explanation (MAYC_VALUESis ignored). A copied
compiler needsnative.may,prelude.mayandruntime/beside it
(#92). - Breaking: the core runtime (the default on arm64-linux, riscv64-linux,
arm64-macos and x86_64-windows, and--runtime core) shares the full
runtime'sruntime/fat.may,prelude.mayandnative.may, so core
programs print what full-runtime programs print: lists and maps compare
by identity rather than structurally, uncaught faults print
kind: message, and library functions such asslicefollow
native.may. ARM64 and RISC-V compile dynamic code with the new
backend/raw_fat.may, and their emitters accept frames beyond 4 KiB
(#92). - Fix the fat collector freeing a block whose only reference was a
Ptr
(fromcstroraddr) stored in a list, map or other heap value: Int
payloads in heap values are now checked conservatively, as stack words
are (#92). - Fix ELF symbols of fat functions, and of native-word functions called only
from native code, which all pointed at_start
(#92). - Run Int
/and%, closure calls and their type checks inline in fat
code, and share one slow-path stub per operator: Int loops run 3.7x and
closure calls 4.7x faster than before, closures now 2.2x faster than
tagged values, and the compiler's code shrinks to 3.65 MB
(#92). - Run fat Float
+ - * /and comparisons in shared SSE stubs instead of
the runtime: a Float loop runs 5.5x faster (405 ms against 2.2 s; tagged
values take 8.0 s) for 70 KB more compiler code
(#92). - Count
forloops over an Int-bounded rangea..bora..=binstead of
building the list first: a 20M-iteration loop no longer runs out of
memory with fat values (169 ms) and runs 9.7x faster with tagged values
(#92). - Make
index_of,contains,replace,to_lowerandto_upperlinear:
they scanned or rebuilt strings one code point at a time from the start,
so a 17 KB string took seconds.stress.mayruns 10x faster. - Use fat values with the full runtime on x86_64-nodeos as well;
execand
systemstart programs through the personality's spawn extension there.
Fat code is about 20% smaller andstress.mayruns 1.6x faster: short-lived
temporaries share frame slots reached with 8-bit displacements, and a value
consumed by the next instruction is no longer stored and reloaded
(#92). - Add integer bitwise operators
&,|,^,~,<<and>>with
Rust-style precedence and signed 61-bit behavior. Replace the NodeOS NXF
CRC-32 lookup tables with a portable bitwise implementation
(#91). - Preserve native 64-bit values, including bit 63, in raw-mode bitwise
operations as the first step toward the native-word ABI
(#92). - Compile functions whose parameters, result, locals and operations are all
Intwith untagged 64-bit machine words in the full and core runtimes on
every target. Arithmetic faults on 64-bit overflow, division by zero and
shift counts outside 0 through 63; results are retagged, with an overflow fault,
when they return to tagged code. Calls between such functions pass machine
words directly (#92). - Accept
PtrandBoolparameters, results and locals,true/false, and
load8..load64/store8..store64, in native-word fun...
Maylang v0.14.0 — Elm
Maylang 0.14.0 — Elm
Released 2026-10-20 UTC. Maylang targets NodeOS, a capability microkernel,
with every runtime, and the compiler runs there: it rebuilds itself on NodeOS
into a compiler byte-identical to the one cross-built on Linux. The full
runtime's heap can now outgrow 256 MiB, and Float rounding and conversion
are stricter.
Behavior changes
floor,ceilandroundreturn Floats, andint/truncfault on
values outside the Int range (details under Runtime).- The full runtime reserves 1 GiB of address space for its heap (committed on
demand). Collection still starts at 256 MiB; a program whose live data
exceeds that now keeps running instead of exiting without of memory.
Remaining limits
- On NodeOS there are no C externs (no dynamic loader), no sockets (no network
service) and no wall clock; children do not inherit the working directory
or environment, and created file names must fit 8.3. - Compiler hosts are Linux x86-64 and NodeOS; release bundles are Linux
x86-64 only.
Targets
- Add
--target x86_64-nodeosfor NodeOS,
with the full, core and raw runtimes. Images are NXF, written directly with
the CRC-32 NodeOS's loader checks. Eachsyscallsite calls a gate into
runtime/nodeos.may, an in-process personality that answers the Linux calls
Maylang uses with NodeOS syscalls and IPC: console and file I/O, directories,
memory, time,exec/system/waitthrough a spawn extension, and
/proc/selfarguments. C externs and sockets are unsupported there.
See NodeOS target. - The compiler runs on NodeOS. A
maycbuilt for NodeOS compiles programs
there and defaults tox86_64-nodeos; it rebuilds itself on NodeOS into a
compiler byte-identical to the one cross-built on Linux. Without-o, NodeOS
output is named<source>.nxf.compiler/mayc/tests/nodeos.pychecks the
images; NodeOS'smake test-maylangruns them.
Compiler
- Bound the compiler's source arena: a failed mapping or an exhausted arena is
reported as an error instead of writing past the mapping (a program importing
300 small modules crashed with a segmentation fault).MAYC_ARENA_BYTES
selects the arena size (#39). - Reserve only the bytes actually read for each source file instead of 1 MiB
per module, so programs with hundreds of imported modules compile in the
default arena. - Enforce the 4 MiB bound on the expanded import closure. Several modules that
were each under the 1 MiB file limit could overflow the expansion buffer; the
compiler now stops with the offending line and the chain of imports that
reached it (#38).
Runtime
- Let the full runtime's heap outgrow 256 MiB instead of failing with
out of memory: collection still starts at 256 MiB, and when a collection cannot
satisfy an allocation the threshold grows within a 1 GiB on-demand
reservation. The self-hosted compiler sat at the old limit while compiling
itself.execandsystemfall back to a spawn extension wherefork
returnsENOSYS. - Fault with a catchable
arithmeticerror ("Float outside Int range") when
intortruncwould produce an Int outside ±2^60 or is given NaN or an
infinity. These conversions previously returned 0 or a wrapped value
silently. Full, core and LLVM runtimes agree on every target
(#89). - Behavior change:
floor,ceilandroundreturn Floats, as their
strict types always declared (floor(2.5)prints2.0,floor(1.0e300)is
1e300, and NaN, infinities and-0.0pass through). Useint(floor(x))
where an Int is needed;random_int,stats_quantileand the ML train/test
split do so.roundno longer rounds0.49999999999999994or odd values
above 2^52 incorrectly, andformat_byteskeeps its decimal (1.5 KiB
instead of1 KiB) (#89).
Behavior contracts
- Accept
forloops over literalIntranges (a..b,a..=b) in functions
with behavior contracts. Range bounds are effect-checked, the loop variable is
an immutable body-scopedInt, andbreak/continuework as inwhile.
Loops over collections, strings or stored ranges remain unknown behavior.
Tools
mayfmt --helpandmayfmt -hprint usage and exit 0 without reading or
writing files, and unknown options are rejected before any file is
formatted (#64).scripts/doctor.pycompiles and links a test program with the selected
CCinstead of only finding it onPATH, so a broken compiler is reported
before the bootstrap fails (#66).mayskips directories and non-executable files while searchingPATHfor
native recipe and task commands, and reports explicit paths that are missing,
not regular files or not executable separately from PATH exhaustion
(#41).may devno longer hangs when replacing an application that ignores
SIGTERM: the process group gets a two-second grace period, then SIGKILL
(#42).maytargets accept anenvlist of environment variables whose values
join the cache identity, so a native recipe that readsCFLAGSrebuilds when
it changes. Values are hashed, never stored in artifact metadata
(#40).
Distribution
dist/install.shrejects archives containing symbolic or hard links,
special files, duplicate entries or more than one bundle root before
extracting, so a supplied archive can no longer make the installer change
permissions outside the bundle (#43).
Maylang 0.13.103 — Dahlia
Released 2026-10-19 UTC. The portable native runtime gains collections,
closures, recoverable faults, fibers and floating point on every direct target;
float display, parsing and trigonometry now agree bit for bit across runtimes;
and RAW x86-64 code is faster and placement-stable.
Behavior changes
- Reject comparisons between values of different types. Strict checking now
rejectsIntvsFloatcomparisons; on dynamic values==across types is
false,!=istrue(so1.0 != 1is nowtrue), and<,<=,>
and>=raise a catchabletypefault.matchpatterns of another type
still simply fail to match.Any-typed stdlib numeric code now normalizes
withto_float. - Display floats with the shortest digits that round-trip (
0.1 + 0.2prints
0.30000000000000004,-0.0keeps its sign, nested values no longer
truncate to six decimals) and parsefloat(text)and JSON numbers with
correct rounding, on every runtime. - Support
sin,cos,tan,ln,log2,log10,expand floating
pow/**in the portable runtime on every native target. The binary64-only
implementation is bit-identical across targets, within one ulp of the host
libm, and reduces trigonometric arguments of any magnitude exactly. Thepow
builtin now returns a Float in the core runtime, as documented, and negative
integer exponents of**produce a Float instead of a fault.
Floating point
- Share exact
sin,cosandtanbetween the full, LLVM and core runtimes;
the full runtime's x87 versions were inaccurate near multiples of pi and
returned arguments above 2^63 unchanged. The newruntime/math.maysidecar
holds this shared code, and core releases the temporaries of pure math,
parsing and formatting calls so long loops no longer exhaust its heap. - Convert float literals with exact big-integer arithmetic so they are
correctly rounded on every backend; decimal scaling misrounded most
17-digit literals by one or two ulps. - Follow C99
powspecial cases (zeros, infinities, NaN, negative bases with
integer exponents) and returninf/0.0fromexp(±inf)in the full
runtime. Accept Int arguments tosqrt,floor,ceil,sin,exp,pow
and related builtins on x86-64 instead of crashing. - Stop crashing when a Float is compared with
nilor another non-number
using!=or<, and when the full runtime displays the smallest
subnormals. - Support boxed Float/Float32 arithmetic, conversions, comparisons, square roots
and rounding on every native target. Format nonfinite scalar floats as
nan,infor-infin both runtimes. Cross-platform FFI remains
unsupported in the portable runtime.
Portable native targets
- Support cooperative fibers on every native target with isolated handlers and
traces; returnnilfromyield()consistently with its declared type. - Support recoverable faults and debug traces on every native target; preserve
callee-saved registers during unwinding and check the 64-handler limit. - Support closures, shared captures, callbacks, overloaded struct operators and
stack arguments in the portable runtime; fix recursive local closure binding. - Support maps, records, structs and enums in the core runtime on every native
target; preserve exclusive range endpoints on ARM64 and RISC-V. - Preserve each fiber's caught error and exception handlers across yields, and
accept the C binding typesUIntandVoidunder strict checking.
LLVM backend
- Support typed extern calls and cooperative fibers in the LLVM backend,
including C stack arguments, function values and isolated suspended handlers.
RAW code generation
- Lower signed power-of-two division and remainder up to 2^59 with shifts
instead ofidiv(#84). - Branch directly on RAW
and/orconditions instead of materializing a
Boolean, keeping short-circuit order, effects and faults (#85). - Keep parameters and loop-weighted locals in dedicated registers, including
bodies...
Maylang v0.13.103 — Dahlia
Maylang 0.13.103 — Dahlia
Released 2026-10-19 UTC. The portable native runtime gains collections,
closures, recoverable faults, fibers and floating point on every direct target;
float display, parsing and trigonometry now agree bit for bit across runtimes;
and RAW x86-64 code is faster and placement-stable.
Behavior changes
- Reject comparisons between values of different types. Strict checking now
rejectsIntvsFloatcomparisons; on dynamic values==across types is
false,!=istrue(so1.0 != 1is nowtrue), and<,<=,>
and>=raise a catchabletypefault.matchpatterns of another type
still simply fail to match.Any-typed stdlib numeric code now normalizes
withto_float. - Display floats with the shortest digits that round-trip (
0.1 + 0.2prints
0.30000000000000004,-0.0keeps its sign, nested values no longer
truncate to six decimals) and parsefloat(text)and JSON numbers with
correct rounding, on every runtime. - Support
sin,cos,tan,ln,log2,log10,expand floating
pow/**in the portable runtime on every native target. The binary64-only
implementation is bit-identical across targets, within one ulp of the host
libm, and reduces trigonometric arguments of any magnitude exactly. Thepow
builtin now returns a Float in the core runtime, as documented, and negative
integer exponents of**produce a Float instead of a fault.
Floating point
- Share exact
sin,cosandtanbetween the full, LLVM and core runtimes;
the full runtime's x87 versions were inaccurate near multiples of pi and
returned arguments above 2^63 unchanged. The newruntime/math.maysidecar
holds this shared code, and core releases the temporaries of pure math,
parsing and formatting calls so long loops no longer exhaust its heap. - Convert float literals with exact big-integer arithmetic so they are
correctly rounded on every backend; decimal scaling misrounded most
17-digit literals by one or two ulps. - Follow C99
powspecial cases (zeros, infinities, NaN, negative bases with
integer exponents) and returninf/0.0fromexp(±inf)in the full
runtime. Accept Int arguments tosqrt,floor,ceil,sin,exp,pow
and related builtins on x86-64 instead of crashing. - Stop crashing when a Float is compared with
nilor another non-number
using!=or<, and when the full runtime displays the smallest
subnormals. - Support boxed Float/Float32 arithmetic, conversions, comparisons, square roots
and rounding on every native target. Format nonfinite scalar floats as
nan,infor-infin both runtimes. Cross-platform FFI remains
unsupported in the portable runtime.
Portable native targets
- Support cooperative fibers on every native target with isolated handlers and
traces; returnnilfromyield()consistently with its declared type. - Support recoverable faults and debug traces on every native target; preserve
callee-saved registers during unwinding and check the 64-handler limit. - Support closures, shared captures, callbacks, overloaded struct operators and
stack arguments in the portable runtime; fix recursive local closure binding. - Support maps, records, structs and enums in the core runtime on every native
target; preserve exclusive range endpoints on ARM64 and RISC-V. - Preserve each fiber's caught error and exception handlers across yields, and
accept the C binding typesUIntandVoidunder strict checking.
LLVM backend
- Support typed extern calls and cooperative fibers in the LLVM backend,
including C stack arguments, function values and isolated suspended handlers.
RAW code generation
- Lower signed power-of-two division and remainder up to 2^59 with shifts
instead ofidiv(#84). - Branch directly on RAW
and/orconditions instead of materializing a
Boolean, keeping short-circuit order, effects and faults (#85). - Keep parameters and loop-weighted locals in dedicated registers, including
bodies with direct user calls and syscalls (#86), and hold values that no call
clobbers in volatile registers so fewer callee-saved registers are saved;
drop unreachable and fallthrough jumps (#87). The extended suite is 33%
faster than 0.13.102 and runs at 1.32× GCC's time
(report). - Align RAW x86-64 function bodies and loop heads to 16 bytes with NOP
padding, so unrelated code no longer moves hot loops (#83). Collatz's
spread across 16 code placements falls from 5.5% to 2.3% of cycles. Suite
medians are unchanged and code grows about 5%.--no-code-alignrestores
the previous layout. Addraw_layout.pyand a branch-predictability suite
(report). - Add an eleven-workload extended RAW benchmark suite
(report).
Remaining limits
- File, process and network libraries and typed FFI still need the full
x86-64 Linux runtime; the portable runtime keeps allocations until exit
(256 MiB cap). See the
backend parity handoff. - Full and LLVM builds keep x87/libm logarithms,
expandpow, which can
differ from the portable runtime in the last place;nan == nanistrue
on every backend.
Maylang 0.13.102 — Dahlia
Released 2026-10-17 UTC. Branch-free RAW scalar diamonds, fused memory
addressing with register-resident memory loops, and a repository layout
organized by role.
Compiler and RAW code generation
- Lower short scalar if/else diamonds over dedicated local registers with
conditional moves instead of branches. Both arms are speculated only when
they are pure, nontrapping and within a bounded cost; predicates over
induction locals (written only asv = literalorv = v ± literal) keep
their predictable branches
(report, #78). - Fuse
load8–load64/store8–store64pointer arithmetic built from
single-use additions, scales of 1, 2, 4 or 8, imm32 literals and local
snapshots into one[base + index*scale + displacement]operand. Memory
accesses keep their order, widths and faults
(report, #79). - Keep locals in dedicated registers in functions whose only non-scalar
operations are unshadowed RAW loads and stores, and allocate their
temporaries in volatile r8–r10.__sp,syscalland other calls still
exclude promotion.
Recorded performance
Committed 100-run interleaved measurements on an Intel i5-13500H, pinned
performance CPU 2, GCC 14.2, against the 0.13.101 compiler c3d3ea8. All six
checksums match in every sample; these are saved pre-release measurements.
| Measurement | 0.13.101 | 0.13.102 |
|---|---|---|
| Six-kernel end-to-end median | 21.693 ms | 15.991 ms |
GCC -O3 -march=native, same trial |
18.042 ms | 18.042 ms |
Median runtime falls 26.3%; RAW output now runs at 0.89× GCC's time
on this suite. Branch-free diamonds alone reach 16.742 ms; address fusion and
memory-loop registers cut the automaton kernel 38.6% and the histogram 19.9%.
Collatz loop timing still varies by up to 12% with code placement alone;
function and loop-head alignment is tracked in
#83. No machine-specific speed
threshold is added to CI.
Repository layout
- Reorganize the repository by role:
compiler/(mayc, Rust bootstrap),
tools/,platform/,dist/,tests/, a singleexamples/tree and
groupeddocs/with the generated reference underdocs/reference/.
Behavior change: thetoolchain/compatibility entry points are
removed, and release bundles ship sample apps underexamples/apps/. See
the path migration table.
Verification
- Decode 4,698 addressing encodings with objdump as an independent oracle,
check 120 generated memory loops against a byte-array model, and check 480
calls of 160 generated diamond functions against an exact 64-bit Python
oracle, includingINT64_MIN/INT64_MAXinputs and untaken traps that must
keep their branches. IR tests cover absorbed instructions, snapshots, CFG
boundaries and shadowed intrinsics. - The source passed 115 compiler verifier checks, compliance cases, Rust
workspace tests, source-bootstrap convergence, LLVM and native macOS/Windows
loader checks in CI. - Synchronize compiler, release metadata, README and editor extension
versions to 0.13.102.
Maylang remains experimental; platform support and runtime limits are
unchanged from 0.13.101.
Full Git changelog: v0.13.101...v0.13.102.
Maylang 0.13.101 — Dahlia
Released 2026-10-17 UTC. This release includes all changes since 0.13.0:
faster Linux x86-64 RAW code generation, native GPU UI rendering, the May NES
example application, and fixes for compiler-build heap fragmentation.
Compiler and RAW code generation
- Use allocated registers and spill homes directly for binary operands and
store values. Forward a single-use accumulator result into its adjacent
consumer, and borrow adjacent local reads as memory or register operands
when snapshots and evaluation order permit it. - Fuse exclusive signed branch comparisons and zero/nonzero power-of-two
remainder tests into direct conditional branches. Keep observable Boolean
and remainder results, short-circuit effects, extra readers and CFG barriers. - Select compact immediate moves with correct sign/zero extension and a
full-width fallback. Rematerialize integer literals and string addresses,
use checked compact ELF address relocations, and retain full-width paths for
high layouts, including Windows PE addresses. - Lower positive non-power-of-two literal division and remainder with verified
signed rec...
Maylang v0.13.102 — Dahlia
Maylang 0.13.102 — Dahlia
Released 2026-10-17 UTC. Branch-free RAW scalar diamonds, fused memory
addressing with register-resident memory loops, and a repository layout
organized by role.
Compiler and RAW code generation
- Lower short scalar if/else diamonds over dedicated local registers with
conditional moves instead of branches. Both arms are speculated only when
they are pure, nontrapping and within a bounded cost; predicates over
induction locals (written only asv = literalorv = v ± literal) keep
their predictable branches
(report, #78). - Fuse
load8–load64/store8–store64pointer arithmetic built from
single-use additions, scales of 1, 2, 4 or 8, imm32 literals and local
snapshots into one[base + index*scale + displacement]operand. Memory
accesses keep their order, widths and faults
(report, #79). - Keep locals in dedicated registers in functions whose only non-scalar
operations are unshadowed RAW loads and stores, and allocate their
temporaries in volatile r8–r10.__sp,syscalland other calls still
exclude promotion.
Recorded performance
Committed 100-run interleaved measurements on an Intel i5-13500H, pinned
performance CPU 2, GCC 14.2, against the 0.13.101 compiler c3d3ea8. All six
checksums match in every sample; these are saved pre-release measurements.
| Measurement | 0.13.101 | 0.13.102 |
|---|---|---|
| Six-kernel end-to-end median | 21.693 ms | 15.991 ms |
GCC -O3 -march=native, same trial |
18.042 ms | 18.042 ms |
Median runtime falls 26.3%; RAW output now runs at 0.89× GCC's time
on this suite. Branch-free diamonds alone reach 16.742 ms; address fusion and
memory-loop registers cut the automaton kernel 38.6% and the histogram 19.9%.
Collatz loop timing still varies by up to 12% with code placement alone;
function and loop-head alignment is tracked in
#83. No machine-specific speed
threshold is added to CI.
Repository layout
- Reorganize the repository by role:
compiler/(mayc, Rust bootstrap),
tools/,platform/,dist/,tests/, a singleexamples/tree and
groupeddocs/with the generated reference underdocs/reference/.
Behavior change: thetoolchain/compatibility entry points are
removed, and release bundles ship sample apps underexamples/apps/. See
the path migration table.
Verification
- Decode 4,698 addressing encodings with objdump as an independent oracle,
check 120 generated memory loops against a byte-array model, and check 480
calls of 160 generated diamond functions against an exact 64-bit Python
oracle, includingINT64_MIN/INT64_MAXinputs and untaken traps that must
keep their branches. IR tests cover absorbed instructions, snapshots, CFG
boundaries and shadowed intrinsics. - The source passed 115 compiler verifier checks, compliance cases, Rust
workspace tests, source-bootstrap convergence, LLVM and native macOS/Windows
loader checks in CI. - Synchronize compiler, release metadata, README and editor extension
versions to 0.13.102.
Maylang remains experimental; platform support and runtime limits are
unchanged from 0.13.101.
Full Git changelog: v0.13.101...v0.13.102.
Maylang 0.13.101 — Dahlia
Released 2026-10-17 UTC. This release includes all changes since 0.13.0:
faster Linux x86-64 RAW code generation, native GPU UI rendering, the May NES
example application, and fixes for compiler-build heap fragmentation.
Compiler and RAW code generation
- Use allocated registers and spill homes directly for binary operands and
store values. Forward a single-use accumulator result into its adjacent
consumer, and borrow adjacent local reads as memory or register operands
when snapshots and evaluation order permit it. - Fuse exclusive signed branch comparisons and zero/nonzero power-of-two
remainder tests into direct conditional branches. Keep observable Boolean
and remainder results, short-circuit effects, extra readers and CFG barriers. - Select compact immediate moves with correct sign/zero extension and a
full-width fallback. Rematerialize integer literals and string addresses,
use checked compact ELF address relocations, and retain full-width paths for
high layouts, including Windows PE addresses. - Lower positive non-power-of-two literal division and remainder with verified
signed reciprocal arithmetic. Preserve negative-dividend corrections,
negative-divisor fallbacks, division by zero andINT64_MIN / -1traps.
Proven nonnegative snapshots and bounded scalar recurrences permit shorter
signed arithmetic; multiplication uses shifts or LEA where appropriate. - Pass resolved user-call and syscall arguments directly in their ABI
locations when safe, preserving order, stack arguments, alignment and
clobbers. Keep an additional call-heavy benchmark alongside the six kernels. - Remove unread nontrapping expression trees, address allocations and branch
result copies, including copies with multiple definitions. Preserve calls,
memory operations, faults, observable joins and private spill homes. - Keep frequently used locals in up to five dedicated callee-saved registers
in eligible freestanding scalar functions. Direct counter, affine-update,
signed power-of-two arithmetic and comparison instructions operate on these
homes across joins, nested loops, break and continue. Calls, memory accesses,
captures, boxed values and unknown bindings exclude promotion; virtual
temporary liveness and GC-root rules retain their existing guarantees. - Store relocation kind/offset/target triples in bounded chunks of 1,024
records instead of a doubling list of maps. This fixes compiler-build OOMs
where a 512 KiB contiguous allocation could not fit despite about 162 MiB
of fragmented free heap. x86-64, ARM64 and RISC-V patchers retain relocation
ordering. Production heap sizing and collector policy are unchanged.
Recorded performance
The committed 100-run interleaved experiment on an Intel i5-13500H, performance
CPU 2, GCC 14.2, compares the pre-optimization compiler f551c97 with the
optimized RAW backend. These are saved pre-release measurements, not a new
release-build timing trial. All six checksums match in every sample.
| Measurement | Original RAW | Optimized RAW |
|---|---|---|
| End-to-end median | 44.499 ms | 21.700 ms |
| Standard deviation | 0.772 ms | 0.322 ms |
| Dynamic instructions, five-run median | 778,075,220 | 181,598,885 |
| Cycles, five-run median | 202,904,018 | 96,883,675 |
Median runtime falls 51.2%, a 2.05× speedup; instructions fall 76.7%
and cycles 52.3%. The same trial records GCC at 18.057 ms with
-O3 -march=native, or 17.593 ms with tree vectorization disabled.
The host was pinned, not isolated. Samples, dispersion, source/compiler hashes,
checksums, disassembly notes and PMU coverage are retained in the
design report and
complete measurement data.
No machine-specific speed threshold is added to CI.
Merged PR #77 completes
issue #76. Remaining branch
if-conversion and memory-address/loop-state opportunities are tracked in
#78 and
#79. This release does not claim
GCC parity on every workload.
Native UI and rendering
- Render clipped widget geometry, rounded edges, concentric borders, soft
shadows, lines and text through a Sokol/OpenGL GPU batch. A dedicated Linux
graphics thread receives immutable geometry/atlas packets; widgets, layout,
interaction and application state remain Maylang. - Cache fractional-position Unicode glyphs in an oversampled atlas, reuse
geometry and framebuffer storage, bound glyph/measurement caches, and upload
atlas content only when it changes. Keep software rendering for headless
surfaces, snapshots and pixel inspection. - Add light/dark themes, primary controls, borders, elevation, cards and
disabled controls, with hover/pressed states and keyboard-focus decoration.
Reduce redundant cursor changes and repeated hit-region searches. Retain
layout recalculation for mutable trees and resizing. - Add
upload_rgba, an aspect-fit framebuffer widget with optional integer
scaling, held/pressed key queries and native focus reporting. Add
poll_for, renderer identification and rendering/cache statistics. - Update the UI scaffold, Mayboard workspace, showcase, package native build,
dependency doctor and library reference for the new renderer. Vendor Sokol
headers and preserve upstream license/provenance records; builds need no
dependency download.
UI build migration: existing native targets compiling window.c must use
sokol.c and link X11, Xi, Xcursor, OpenGL, dl, pthread and m. Install
libx11-dev libxi-dev libxcursor-dev libgl-dev and a TrueType font on
Debian/Ubuntu. Native windows require X11/XWayland and OpenGL 4.3; Mesa software
rendering works. Public Widget/Window records gained fields; prefer the
documented constructors and helpers when updating applications. See the
UI guide.
May NES example application
- Add a Maylang desktop NES player using the vendored MIT-licensed binjnes core
for CPU/PPU/APU/cartridge emulation. Include the original MIT-licensed Starfall
homebrew ROM and its reproducible builder; no other games are bundled. - Support uncompressed iNES 1.0 cartridge loading, recent paths/preferences,
aspect-fit or integer scaling, simultaneous controller keys, pa...
Maylang v0.13.101 — Dahlia
Maylang 0.13.101 — Dahlia
Released 2026-10-17 UTC. This release includes all changes since 0.13.0:
faster Linux x86-64 RAW code generation, native GPU UI rendering, the May NES
example application, and fixes for compiler-build heap fragmentation.
Compiler and RAW code generation
- Use allocated registers and spill homes directly for binary operands and
store values. Forward a single-use accumulator result into its adjacent
consumer, and borrow adjacent local reads as memory or register operands
when snapshots and evaluation order permit it. - Fuse exclusive signed branch comparisons and zero/nonzero power-of-two
remainder tests into direct conditional branches. Keep observable Boolean
and remainder results, short-circuit effects, extra readers and CFG barriers. - Select compact immediate moves with correct sign/zero extension and a
full-width fallback. Rematerialize integer literals and string addresses,
use checked compact ELF address relocations, and retain full-width paths for
high layouts, including Windows PE addresses. - Lower positive non-power-of-two literal division and remainder with verified
signed reciprocal arithmetic. Preserve negative-dividend corrections,
negative-divisor fallbacks, division by zero andINT64_MIN / -1traps.
Proven nonnegative snapshots and bounded scalar recurrences permit shorter
signed arithmetic; multiplication uses shifts or LEA where appropriate. - Pass resolved user-call and syscall arguments directly in their ABI
locations when safe, preserving order, stack arguments, alignment and
clobbers. Keep an additional call-heavy benchmark alongside the six kernels. - Remove unread nontrapping expression trees, address allocations and branch
result copies, including copies with multiple definitions. Preserve calls,
memory operations, faults, observable joins and private spill homes. - Keep frequently used locals in up to five dedicated callee-saved registers
in eligible freestanding scalar functions. Direct counter, affine-update,
signed power-of-two arithmetic and comparison instructions operate on these
homes across joins, nested loops, break and continue. Calls, memory accesses,
captures, boxed values and unknown bindings exclude promotion; virtual
temporary liveness and GC-root rules retain their existing guarantees. - Store relocation kind/offset/target triples in bounded chunks of 1,024
records instead of a doubling list of maps. This fixes compiler-build OOMs
where a 512 KiB contiguous allocation could not fit despite about 162 MiB
of fragmented free heap. x86-64, ARM64 and RISC-V patchers retain relocation
ordering. Production heap sizing and collector policy are unchanged.
Recorded performance
The committed 100-run interleaved experiment on an Intel i5-13500H, performance
CPU 2, GCC 14.2, compares the pre-optimization compiler f551c97 with the
optimized RAW backend. These are saved pre-release measurements, not a new
release-build timing trial. All six checksums match in every sample.
| Measurement | Original RAW | Optimized RAW |
|---|---|---|
| End-to-end median | 44.499 ms | 21.700 ms |
| Standard deviation | 0.772 ms | 0.322 ms |
| Dynamic instructions, five-run median | 778,075,220 | 181,598,885 |
| Cycles, five-run median | 202,904,018 | 96,883,675 |
Median runtime falls 51.2%, a 2.05× speedup; instructions fall 76.7%
and cycles 52.3%. The same trial records GCC at 18.057 ms with
-O3 -march=native, or 17.593 ms with tree vectorization disabled.
The host was pinned, not isolated. Samples, dispersion, source/compiler hashes,
checksums, disassembly notes and PMU coverage are retained in the
design report and
complete measurement data.
No machine-specific speed threshold is added to CI.
Merged PR #77 completes
issue #76. Remaining branch
if-conversion and memory-address/loop-state opportunities are tracked in
#78 and
#79. This release does not claim
GCC parity on every workload.
Native UI and rendering
- Render clipped widget geometry, rounded edges, concentric borders, soft
shadows, lines and text through a Sokol/OpenGL GPU batch. A dedicated Linux
graphics thread receives immutable geometry/atlas packets; widgets, layout,
interaction and application state remain Maylang. - Cache fractional-position Unicode glyphs in an oversampled atlas, reuse
geometry and framebuffer storage, bound glyph/measurement caches, and upload
atlas content only when it changes. Keep software rendering for headless
surfaces, snapshots and pixel inspection. - Add light/dark themes, primary controls, borders, elevation, cards and
disabled controls, with hover/pressed states and keyboard-focus decoration.
Reduce redundant cursor changes and repeated hit-region searches. Retain
layout recalculation for mutable trees and resizing. - Add
upload_rgba, an aspect-fit framebuffer widget with optional integer
scaling, held/pressed key queries and native focus reporting. Add
poll_for, renderer identification and rendering/cache statistics. - Update the UI scaffold, Mayboard workspace, showcase, package native build,
dependency doctor and library reference for the new renderer. Vendor Sokol
headers and preserve upstream license/provenance records; builds need no
dependency download.
UI build migration: existing native targets compiling window.c must use
sokol.c and link X11, Xi, Xcursor, OpenGL, dl, pthread and m. Install
libx11-dev libxi-dev libxcursor-dev libgl-dev and a TrueType font on
Debian/Ubuntu. Native windows require X11/XWayland and OpenGL 4.3; Mesa software
rendering works. Public Widget/Window records gained fields; prefer the
documented constructors and helpers when updating applications. See the
UI guide.
May NES example application
- Add a Maylang desktop NES player using the vendored MIT-licensed binjnes core
for CPU/PPU/APU/cartridge emulation. Include the original MIT-licensed Starfall
homebrew ROM and its reproducible builder; no other games are bundled. - Support uncompressed iNES 1.0 cartridge loading, recent paths/preferences,
aspect-fit or integer scaling, simultaneous controller keys, pause/resume,
frame stepping, reset, mute and NTSC/PAL frame scheduling. - Add optional PulseAudio/PipeWire audio, a file-picker/path-entry workflow,
background/text-entry pause, manual save/restore and periodic battery SRAM
persistence. Validate state identity/size/checksums and write persistence
through exclusive temporary files, synchronization and atomic rename. - Add headless screenshots/reports, deterministic core/state/persistence
checks, sanitizer coverage for cartridge switching and isolated desktop
tests for actual GPU output and interaction. See the
May NES guide for controls,
dependencies, mapper coverage and format limits.
Verification, CI and distribution
- Add RAW execution/IR/disassembly regressions for operand locations, snapshots,
spills, nested loops, effects, full-width signed arithmetic, constant
division, ABI/syscall clobbers and every benchmark checksum. Dedicated-local
arithmetic coverage includes 720 full-width cases across RBX and r12-r15. - Extend Windows emulation to verify RBX preservation. Keep forced-GC,
portable-core and LLVM checks; move interactive UI execution into its
dependency-aware native harness instead of the generic entrypoint runner. - Add the 65,537-relocation ordering, context-isolation and replacement
regression under an 8 MiB runtime heap. The former representation exhausts
that heap. Repeated IR-inspection builds and byte-identical bootstrap
generations verify the compiler-build fix. - The merged source passed 115 compiler verifier checks, 69 compliance
cases, Rust workspace tests, source-bootstrap convergence, LLVM,
documentation/tooling/UI, extracted release/installer checks, portable-core
emulation and native macOS/Windows loader checks. Tagged publication runs
release checks, compares two generated bundles/installers, and publishes the
Linux archive, editor extension, standalone installers and checksums. - Synchronize compiler, release metadata, README and editor extension versions
to 0.13.101. Install the new renderer's development dependencies explicitly
in the tagged-release workflow.
Maylang remains experimental. Compiler hosts and full-runtime release bundles
remain Linux x86-64, including x86-64 WSL 2. The native UI currently supports
one active surface and the Linux OpenGL backend; accessibility integration,
IME composition, rich text and general image collections remain unfinished.
May NES does not implement NES 2.0, ZIP/FDS loading, gamepads or a second
controller; save states are local to the build/architecture. The supported
behavior-contract fragment and its security/resource-proof limits are unchanged
from 0.13.0; see behavior support and the
conformance ledger.
Full Git changelog: v0.13.0...v0.13.101.
Maylang 0.13.0 — Dahlia
Released 2026-10-16 UTC. Closed callable behavior contracts and a broader
checked scalar fragment, with runtime list boundary fixes.
- Write closed effect ceilings on callable types, such as
`Fn(Int) ->...
Maylang v0.13.0 — Dahlia
Maylang 0.13.0 — Dahlia
Released 2026-10-16 UTC. Closed callable behavior contracts and a broader
checked scalar fragment, with runtime list boundary fixes.
- Write closed effect ceilings on callable types, such as
Fn(Int) -> Int ! pureandFn(Int) -> Int ! {output}. Check named source
functions and callback calls against those ceilings, preserving rows through
type identity, substitution, joins, generic inference and function variance.
Reject erasedAny, unchecked foreign declarations and shared-container
storage that could bypass a finite callable contract. - Check
Floatscalar operations and purepi/econstants, private scalar
mutation, andwhileloops withbreakandcontinuein behavior-checked
bodies. Preserve normalized behavior summaries in compiler IR snapshots. - Report shortest call paths for unsupported behavior, including recursive and
competing helper paths. Unknown bodies remain unknown rather than receiving
an inferred pure row. Document the scalar core and outstanding proof work. - Guard list payload access, push/pop and indexed writes in full/core runtimes.
Invalid dynamic list values now report a type failure instead of accessing
unrelated memory. List and string reads reject non-integer indices.
Behavior change: list assignment requires an existing index; usepush
to append. Negative and past-end reads still returnnil, and arbitrary map
keys retain their existing semantics. - Add native, LLVM, portable-core and actual loader regressions, including
recovery after rejected writes. Load GC probes through the runtime ABI while
retaining allocation-identity and root-table boundary checks.
Validation includes 87 compiler verification checks, 90 native/core/LLVM list
boundary cases, compiler-generation convergence, LLVM checks, all five
portable-core ISA/format combinations, and macOS/Windows loader fixtures.
Tagged publication additionally verifies reproducible packages, extracted
installation, standalone installers and the editor extension.
Maylang remains experimental. Closed rows currently cover the documented
scalar/callable fragment and known output/clock effects. Effect polymorphism,
closures in checked bodies, capability containment, ownership, information-flow
security, termination and resource bounds are unfinished. Runtime guards do
not establish memory safety or permit finite callable contracts in mutable
containers. Compiler hosts and full-runtime bundles remain Linux x86-64,
including x86-64 WSL 2. See behavior support and the
design conformance ledger for exact limits.
Maylang 0.12.3 — Clover
Released 2026-10-15 UTC. Improve explanations for scalar behavior contracts.
- Report the shortest call path to a contributing primitive when an inferred
effect exceeds a declared ceiling. Update witnesses across fixed-point
iterations, including recursive graphs; keep equal-length selection stable. - Add regressions for competing paths, propagated improvements, recursion and
equal-length witnesses. Unknown-operation diagnostics still use their
discovery path; the supported behavior fragment is unchanged. - Include the fixes since 0.12.2 for verified optional stable-release updates,
hourly update scheduling and compiler-worker editor-index cleanup.
Maylang remains experimental. These scalar effect checks do not establish
capability containment, termination, failure freedom or resource bounds.
Maylang 0.12.2 — Clover
Released 2026-10-15 UTC. A patch release for the interactive installer following
the terminal UI refactor.
- Allocate terminal state on demand and require both input and output terminals
before enabling interactive rendering. Fall back to plain menus for missing
or dumb terminal settings and small windows. - Poll for escape-sequence input so Escape cancels promptly; restore terminal
settings after selection, cancellation and errors. Preserve queued keys when
moving between menus so fast selections are not discarded. - Use compact menu rows, dedicated folder and shell-profile prompts, bounded
labels and progress indicators, and normalized component selections. Keep
typed answers in the prompt buffer and detect the terminal after reconnecting
input for the one-line curl-to-shell installation.
The complete independent toolchain and one-line installer remain available for
Linux x86-64, including x86-64 WSL 2. The language and runtime limits described
for 0.12.1 are unchanged.
Maylang 0.12.1 — Clover
Released 2026-10-14 UTC. The first published Clover release includes the
one-line installer, interactive setup, independent toolchains and compiler
improvements described below. Check terminal cleanup writes under the same
hardened C compilation flags used in Ubuntu CI; restore terminal state on
interruption. The unpublished v0.12.0 source tag remains immutable.
Maylang 0.12.0 — Clover
Source tagged 2026-10-14 UTC. Publication was held after Ubuntu hardened
compilation caught an unchecked terminal-cleanup write. The immutable tag is
retained; 0.12.1 is the first published Clover bundle.
Install Maylang from one command, then follow the
interactive setup. No checkout or compiler is required to install it.
- Publish a small HTTPS downloader and a prebuilt, self-contained native installer.
The Maylang interface includes arrow-key menus, a recommended setup, custom
tool checkboxes, live file-copy progress, compiler verification, shell setup
and a clear first-project walkthrough. Plain menus and NO_COLOR are supported. - Copy complete independent toolchains into
~/.maylang, with managed shell
integration and an uninstaller. Removing the checkout leaves installed tools
working. Checksum failures and interrupted setup preserve the active install. - Resolve runtime sidecars through PATH/symlinks. Release completed compiler
frontend state so a 4,096-reachable/4,096-dead function graph compiles within
the existing 256 MiB heap. Build ELF string tables without quadratic copying. - Add checksum-verified GC/codegen limit workloads, retained disassembly and
optimized LLVM IR, and measured signed power-of-two division improvements.
Compiler hosts remain Linux x86-64, including x86-64 WSL 2. The existing
sustained-GC investigation #2
remains open. This release does not establish native compiler-host support for
macOS, Windows or ARM64.
Maylang 0.11.2 — Bramble
Released 2026-10-13 UTC. A patch release for workspace runner performance.
- Remove repeated UTF-8 prefix scans from native
split,chars,substring
and environment lookup, and simplify shared path slicing. The same changes
ship in the compiler, workspace runner, legacy project manager, formatter
and language server's native prelude. - In five local samples using the same compiler, environment and cached
executable, median cachedmay runtime fell from 6.10 seconds to 26.6 ms,
and cachedmay buildfrom 4.20 seconds to 23.8 ms. The original reported
workspace ran in 22 ms after installing the optimized runner. Absolute
timings depend on the host and environment; see
the performance report for raw samples and
reproduction instructions. - Preserve content hashing, output verification and atomic publication.
Regressions cover same-size/same-timestamp source, import, compiler and runtime
changes, corrupted outputs, executable permissions, Unicode/NUL strings,
large environments and source-only compiler-generation convergence. - Keep the C bootstrap's string byte storage compatible with the optimized
prelude, and add native/LLVM string checks and an optional CI runner benchmark.
Fixes #31 through
PR #33. The existing sustained-GC
report #2 and JSON/NUL serialization
bug #32 remain open. Tool hosts
remain Linux x86-64; other runtime and native UI limits are unchanged.
Maylang 0.11.1 — Bramble
Released 2026-10-13 UTC. Includes the complete Bramble workspace, GC, formatter,
native UI and Mayboard features described below.
The language server now excludes .may/ build caches from source indexing and
workspace/navigation scans. It distinguishes files from directories before
reading a .may suffix, so legitimate directories such as sources.may/ still
get traversed and their programs get checked. Directory URIs are rejected as
documents instead of triggering a read error. Focused regressions cover cache
contents, directory creation notifications, nested source diagnostics and symbols.
The existing v0.11.0 source tag is retained. Its publication was stopped before
assets were released when running the complete app exposed the cache-directory
interaction. Dates record actual publication separately from version numbers.
Maylang 0.11.0 — Bramble
Source tagged 2026-10-12. Publication was held after the final real-workspace
check found the build-cache directory scan failure. The tag remains immutable;
0.11.1 is the first published Bramble bundle.
Everyday workspaces and the first native desktop UI toolkit.
Everyday ergonomics
- One shared CLI/editor formatter, including Unicode strings and nested comments.
Organize-imports actions sort only complete lexical directives, preserving
attached statements and import-looking text inside comments/strings. - Nested
/* ... */source comments and comment/string-aware import scanning.
Statements and additional imports after a same-line import are preserved,
including their original diagnostic columns. mayworkspaces replace source guessing with an explicitmay.jsongraph of
applications, executable test groups, native build recipes and action tasks.- Content-addressed artifa...
Maylang v0.12.3 — Clover
Maylang 0.12.3 — Clover
Released 2026-10-15 UTC. Improve explanations for scalar behavior contracts.
- Report the shortest call path to a contributing primitive when an inferred
effect exceeds a declared ceiling. Update witnesses across fixed-point
iterations, including recursive graphs; keep equal-length selection stable. - Add regressions for competing paths, propagated improvements, recursion and
equal-length witnesses. Unknown-operation diagnostics still use their
discovery path; the supported behavior fragment is unchanged. - Include the fixes since 0.12.2 for verified optional stable-release updates,
hourly update scheduling and compiler-worker editor-index cleanup.
Maylang remains experimental. These scalar effect checks do not establish
capability containment, termination, failure freedom or resource bounds.
Maylang 0.12.2 — Clover
Released 2026-10-15 UTC. A patch release for the interactive installer following
the terminal UI refactor.
- Allocate terminal state on demand and require both input and output terminals
before enabling interactive rendering. Fall back to plain menus for missing
or dumb terminal settings and small windows. - Poll for escape-sequence input so Escape cancels promptly; restore terminal
settings after selection, cancellation and errors. Preserve queued keys when
moving between menus so fast selections are not discarded. - Use compact menu rows, dedicated folder and shell-profile prompts, bounded
labels and progress indicators, and normalized component selections. Keep
typed answers in the prompt buffer and detect the terminal after reconnecting
input for the one-line curl-to-shell installation.
The complete independent toolchain and one-line installer remain available for
Linux x86-64, including x86-64 WSL 2. The language and runtime limits described
for 0.12.1 are unchanged.
Maylang 0.12.1 — Clover
Released 2026-10-14 UTC. The first published Clover release includes the
one-line installer, interactive setup, independent toolchains and compiler
improvements described below. Check terminal cleanup writes under the same
hardened C compilation flags used in Ubuntu CI; restore terminal state on
interruption. The unpublished v0.12.0 source tag remains immutable.
Maylang 0.12.0 — Clover
Source tagged 2026-10-14 UTC. Publication was held after Ubuntu hardened
compilation caught an unchecked terminal-cleanup write. The immutable tag is
retained; 0.12.1 is the first published Clover bundle.
Install Maylang from one command, then follow the
interactive setup. No checkout or compiler is required to install it.
- Publish a small HTTPS downloader and a prebuilt, self-contained native installer.
The Maylang interface includes arrow-key menus, a recommended setup, custom
tool checkboxes, live file-copy progress, compiler verification, shell setup
and a clear first-project walkthrough. Plain menus and NO_COLOR are supported. - Copy complete independent toolchains into
~/.maylang, with managed shell
integration and an uninstaller. Removing the checkout leaves installed tools
working. Checksum failures and interrupted setup preserve the active install. - Resolve runtime sidecars through PATH/symlinks. Release completed compiler
frontend state so a 4,096-reachable/4,096-dead function graph compiles within
the existing 256 MiB heap. Build ELF string tables without quadratic copying. - Add checksum-verified GC/codegen limit workloads, retained disassembly and
optimized LLVM IR, and measured signed power-of-two division improvements.
Compiler hosts remain Linux x86-64, including x86-64 WSL 2. The existing
sustained-GC investigation #2
remains open. This release does not establish native compiler-host support for
macOS, Windows or ARM64.
Maylang 0.11.2 — Bramble
Released 2026-10-13 UTC. A patch release for workspace runner performance.
- Remove repeated UTF-8 prefix scans from native
split,chars,substring
and environment lookup, and simplify shared path slicing. The same changes
ship in the compiler, workspace runner, legacy project manager, formatter
and language server's native prelude. - In five local samples using the same compiler, environment and cached
executable, median cachedmay runtime fell from 6.10 seconds to 26.6 ms,
and cachedmay buildfrom 4.20 seconds to 23.8 ms. The original reported
workspace ran in 22 ms after installing the optimized runner. Absolute
timings depend on the host and environment; see
the performance report for raw samples and
reproduction instructions. - Preserve content hashing, output verification and atomic publication.
Regressions cover same-size/same-timestamp source, import, compiler and runtime
changes, corrupted outputs, executable permissions, Unicode/NUL strings,
large environments and source-only compiler-generation convergence. - Keep the C bootstrap's string byte storage compatible with the optimized
prelude, and add native/LLVM string checks and an optional CI runner benchmark.
Fixes #31 through
PR #33. The existing sustained-GC
report #2 and JSON/NUL serialization
bug #32 remain open. Tool hosts
remain Linux x86-64; other runtime and native UI limits are unchanged.
Maylang 0.11.1 — Bramble
Released 2026-10-13 UTC. Includes the complete Bramble workspace, GC, formatter,
native UI and Mayboard features described below.
The language server now excludes .may/ build caches from source indexing and
workspace/navigation scans. It distinguishes files from directories before
reading a .may suffix, so legitimate directories such as sources.may/ still
get traversed and their programs get checked. Directory URIs are rejected as
documents instead of triggering a read error. Focused regressions cover cache
contents, directory creation notifications, nested source diagnostics and symbols.
The existing v0.11.0 source tag is retained. Its publication was stopped before
assets were released when running the complete app exposed the cache-directory
interaction. Dates record actual publication separately from version numbers.
Maylang 0.11.0 — Bramble
Source tagged 2026-10-12. Publication was held after the final real-workspace
check found the build-cache directory scan failure. The tag remains immutable;
0.11.1 is the first published Bramble bundle.
Everyday workspaces and the first native desktop UI toolkit.
Everyday ergonomics
- One shared CLI/editor formatter, including Unicode strings and nested comments.
Organize-imports actions sort only complete lexical directives, preserving
attached statements and import-looking text inside comments/strings. - Nested
/* ... */source comments and comment/string-aware import scanning.
Statements and additional imports after a same-line import are preserved,
including their original diagnostic columns. mayworkspaces replace source guessing with an explicitmay.jsongraph of
applications, executable test groups, native build recipes and action tasks.- Content-addressed artifact verification, atomic publication, source-change
detection, build serialization, local dependency content pins and dev/release
profiles. Commands receive literal argument arrays without shell expansion. may devreloads after successful builds, preserves the running app after a
failed edit, and reaps replaced processes.may migratepreserves legacy
mayproj.json;maypkgremains available.
Native UI and a complete application
- Typed Maylang widget trees, row/column flex layout, buttons, checkboxes,
codepoint-safe single-line inputs, focus, clipboard, clipped scrolling and
virtual lists. A small X11/CPU drawing adapter supplies the platform boundary. may new DIRECTORY --uicreates a runnable desktop project with a declared
native adapter prerequisite. Headless rendering supports PNG snapshots.- Mayboard provides task creation, editing, completion, deletion, search and
filters. It validates task files, locks out competing writers, synchronizes
private atomic saves, and preserves corrupt input. A demo mode stores changes
in memory; native X11 tests cover input and persistent reopen behavior.
Runtime and tooling confidence
- Seeded 4 MiB GC stress uses an independent graph model plus heap/free-bin
invariants. Injected corruption verifies that the checkers detect failures;
lists, maps, Unicode copied strings, closures and suspended fibers retain
their values through collection pressure. - Workspace diagnostics isolate imported graphs within a source budget. Worker
stdout cannot contaminate JSON, and crashes report the actual exit/signal. - Bundles include
may,mayfmt, the complete Mayboard workspace, UI adapter
sources, editor tools and
checksums. Extracted installations build a UI scaffold and render a PNG.
Current limits
Tool hosts and interactive UI require Linux x86-64. UI uses the direct native
backend; experimental LLVM currently has no C extern support. UI needs a C compiler,
X11 development headers, a trusted TrueType font, and X11/XWayland for windows.
The toolkit currently supports one window, plain single-line text and whole-input
selection; it has no accessibility bridge or GPU rendering. Dependencies are
local paths with content pins; there is no central registry or host-toolchain
lock. The original sustained-GC report (#2) remains unreproduced; bounded stress
coverage does not prove arbitrary programs correct. See the linked tool/library
READMEs for supported behavior.
Maylang 0.10.0 — Aster
Released 2026-10-12. A fresh starting point after the 0.9.0 line, with verified
native targets, clearer library contracts and a small compiler c...
Maylang v0.12.2 — Clover
Maylang 0.12.2 — Clover
Released 2026-10-15 UTC. A patch release for the interactive installer following
the terminal UI refactor.
- Allocate terminal state on demand and require both input and output terminals
before enabling interactive rendering. Fall back to plain menus for missing
or dumb terminal settings and small windows. - Poll for escape-sequence input so Escape cancels promptly; restore terminal
settings after selection, cancellation and errors. Preserve queued keys when
moving between menus so fast selections are not discarded. - Use compact menu rows, dedicated folder and shell-profile prompts, bounded
labels and progress indicators, and normalized component selections. Keep
typed answers in the prompt buffer and detect the terminal after reconnecting
input for the one-line curl-to-shell installation.
The complete independent toolchain and one-line installer remain available for
Linux x86-64, including x86-64 WSL 2. The language and runtime limits described
for 0.12.1 are unchanged.
Maylang 0.12.1 — Clover
Released 2026-10-14 UTC. The first published Clover release includes the
one-line installer, interactive setup, independent toolchains and compiler
improvements described below. Check terminal cleanup writes under the same
hardened C compilation flags used in Ubuntu CI; restore terminal state on
interruption. The unpublished v0.12.0 source tag remains immutable.
Maylang 0.12.0 — Clover
Source tagged 2026-10-14 UTC. Publication was held after Ubuntu hardened
compilation caught an unchecked terminal-cleanup write. The immutable tag is
retained; 0.12.1 is the first published Clover bundle.
Install Maylang from one command, then follow the
interactive setup. No checkout or compiler is required to install it.
- Publish a small HTTPS downloader and a prebuilt, self-contained native installer.
The Maylang interface includes arrow-key menus, a recommended setup, custom
tool checkboxes, live file-copy progress, compiler verification, shell setup
and a clear first-project walkthrough. Plain menus and NO_COLOR are supported. - Copy complete independent toolchains into
~/.maylang, with managed shell
integration and an uninstaller. Removing the checkout leaves installed tools
working. Checksum failures and interrupted setup preserve the active install. - Resolve runtime sidecars through PATH/symlinks. Release completed compiler
frontend state so a 4,096-reachable/4,096-dead function graph compiles within
the existing 256 MiB heap. Build ELF string tables without quadratic copying. - Add checksum-verified GC/codegen limit workloads, retained disassembly and
optimized LLVM IR, and measured signed power-of-two division improvements.
Compiler hosts remain Linux x86-64, including x86-64 WSL 2. The existing
sustained-GC investigation #2
remains open. This release does not establish native compiler-host support for
macOS, Windows or ARM64.
Maylang 0.11.2 — Bramble
Released 2026-10-13 UTC. A patch release for workspace runner performance.
- Remove repeated UTF-8 prefix scans from native
split,chars,substring
and environment lookup, and simplify shared path slicing. The same changes
ship in the compiler, workspace runner, legacy project manager, formatter
and language server's native prelude. - In five local samples using the same compiler, environment and cached
executable, median cachedmay runtime fell from 6.10 seconds to 26.6 ms,
and cachedmay buildfrom 4.20 seconds to 23.8 ms. The original reported
workspace ran in 22 ms after installing the optimized runner. Absolute
timings depend on the host and environment; see
the performance report for raw samples and
reproduction instructions. - Preserve content hashing, output verification and atomic publication.
Regressions cover same-size/same-timestamp source, import, compiler and runtime
changes, corrupted outputs, executable permissions, Unicode/NUL strings,
large environments and source-only compiler-generation convergence. - Keep the C bootstrap's string byte storage compatible with the optimized
prelude, and add native/LLVM string checks and an optional CI runner benchmark.
Fixes #31 through
PR #33. The existing sustained-GC
report #2 and JSON/NUL serialization
bug #32 remain open. Tool hosts
remain Linux x86-64; other runtime and native UI limits are unchanged.
Maylang 0.11.1 — Bramble
Released 2026-10-13 UTC. Includes the complete Bramble workspace, GC, formatter,
native UI and Mayboard features described below.
The language server now excludes .may/ build caches from source indexing and
workspace/navigation scans. It distinguishes files from directories before
reading a .may suffix, so legitimate directories such as sources.may/ still
get traversed and their programs get checked. Directory URIs are rejected as
documents instead of triggering a read error. Focused regressions cover cache
contents, directory creation notifications, nested source diagnostics and symbols.
The existing v0.11.0 source tag is retained. Its publication was stopped before
assets were released when running the complete app exposed the cache-directory
interaction. Dates record actual publication separately from version numbers.
Maylang 0.11.0 — Bramble
Source tagged 2026-10-12. Publication was held after the final real-workspace
check found the build-cache directory scan failure. The tag remains immutable;
0.11.1 is the first published Bramble bundle.
Everyday workspaces and the first native desktop UI toolkit.
Everyday ergonomics
- One shared CLI/editor formatter, including Unicode strings and nested comments.
Organize-imports actions sort only complete lexical directives, preserving
attached statements and import-looking text inside comments/strings. - Nested
/* ... */source comments and comment/string-aware import scanning.
Statements and additional imports after a same-line import are preserved,
including their original diagnostic columns. mayworkspaces replace source guessing with an explicitmay.jsongraph of
applications, executable test groups, native build recipes and action tasks.- Content-addressed artifact verification, atomic publication, source-change
detection, build serialization, local dependency content pins and dev/release
profiles. Commands receive literal argument arrays without shell expansion. may devreloads after successful builds, preserves the running app after a
failed edit, and reaps replaced processes.may migratepreserves legacy
mayproj.json;maypkgremains available.
Native UI and a complete application
- Typed Maylang widget trees, row/column flex layout, buttons, checkboxes,
codepoint-safe single-line inputs, focus, clipboard, clipped scrolling and
virtual lists. A small X11/CPU drawing adapter supplies the platform boundary. may new DIRECTORY --uicreates a runnable desktop project with a declared
native adapter prerequisite. Headless rendering supports PNG snapshots.- Mayboard provides task creation, editing, completion, deletion, search and
filters. It validates task files, locks out competing writers, synchronizes
private atomic saves, and preserves corrupt input. A demo mode stores changes
in memory; native X11 tests cover input and persistent reopen behavior.
Runtime and tooling confidence
- Seeded 4 MiB GC stress uses an independent graph model plus heap/free-bin
invariants. Injected corruption verifies that the checkers detect failures;
lists, maps, Unicode copied strings, closures and suspended fibers retain
their values through collection pressure. - Workspace diagnostics isolate imported graphs within a source budget. Worker
stdout cannot contaminate JSON, and crashes report the actual exit/signal. - Bundles include
may,mayfmt, the complete Mayboard workspace, UI adapter
sources, editor tools and
checksums. Extracted installations build a UI scaffold and render a PNG.
Current limits
Tool hosts and interactive UI require Linux x86-64. UI uses the direct native
backend; experimental LLVM currently has no C extern support. UI needs a C compiler,
X11 development headers, a trusted TrueType font, and X11/XWayland for windows.
The toolkit currently supports one window, plain single-line text and whole-input
selection; it has no accessibility bridge or GPU rendering. Dependencies are
local paths with content pins; there is no central registry or host-toolchain
lock. The original sustained-GC report (#2) remains unreproduced; bounded stress
coverage does not prove arbitrary programs correct. See the linked tool/library
READMEs for supported behavior.
Maylang 0.10.0 — Aster
Released 2026-10-12. A fresh starting point after the 0.9.0 line, with verified
native targets, clearer library contracts and a small compiler convenience.
New feature
mayc --list-targets lists the six supported targets, their output formats and
default runtimes. It works without a source file or runtime sidecars. The
listing distinguishes full/core defaults and labels the experimental LLVM
backend; the compiler itself still runs on Linux x86-64.
Included improvements
- Real Apple Silicon macOS and Windows loader tests, with PE/Mach-O fixes.
- Explicit core scratch arenas with reset lifetime rules.
- Encoded-pointer GC roots and a checked global-root table capacity.
- Collection, string and path boundary fixes with native/LLVM regressions.
- A dependency-free generated language/library reference and runnable examples.
- Source-tagged, reproducible toolchain bundles and checksummed editor assets.
The original sustained GC corruption report (#2) remains open: both sid...
Maylang v0.12.1 — Clover
Maylang 0.12.1 — Clover
One command. An interactive setup. Your whole toolkit.
curl --proto '=https' --tlsv1.2 -fsSL https://github.com/mirged/maylang/releases/latest/download/maylang-init.sh | shPress Enter for the recommended setup, or choose Customize setup. Use ↑ ↓ to move, Space to toggle individual tools, and Esc to go back. The installer shows progress, checks your compiler, and configures your shell.
No checkout, compiler, Rust, Python or build command is needed. The native installer includes the complete toolchain. It installs into ~/.maylang by default and keeps working if a source checkout is moved or deleted. Choose a different prefix, manual PATH setup, plain menus or an unattended install if you prefer.
After setup, open a new terminal:
may new hello
cd hello
may runThe final screen prints the activation command for your current terminal and an uninstall command too.
Supported compiler hosts: Linux x86-64, including x86-64 WSL 2. Native macOS, Windows and ARM64 host releases are not available. The language remains experimental; the sustained-GC investigation #2 remains open.
Other changes include correct runtime lookup through PATH/symlinks, released compiler frontend state so the 4,096-function graph compiles inside the existing heap, linear ELF string-table construction, and checksum-verified GC/codegen stress workloads with retained assembly and LLVM IR.
Install options and offline downloads · Full changelog · Verified source tag