v0.6.0

0.6.0 (2026-11-04)

Changed

• Breaking: A program reads one of a fixed run inside an element of an array at an index worked out while running, wherever the run sits in the element. When the run was not the element's first field, the program was refused under every build and switch as a fault in the compiler, with K0505 ("this leaves the stack 1 deep and a statement leaves it as it found it"): with struct Row { tag: i32; count: [i32; 3] }, a function returning rows[k].count[at] did not compile, and now, with rows holding Row(7, [10, 20, 30]), it answers 30 for k 0 and at 2. The same held for a run of bool and for a run inside a struct inside the element. A program that compiled before compiles to the same instructions. (#246)
• Breaking: A program writes one of a fixed run inside an element of an array at an index worked out while running, with =, +=, -=, *= or /=. Every such write was refused as a fault in the compiler, with K0505 ("this assigns to something that is not a place, which the checker allowed"), whichever field the run was; only a run held in a local could be written at such an index. With struct Row { count: [i32; 3] }, rows holding Row([10, 20, 30]) and at worked out while running as 1, rows[0].count[at] = 99 followed by rows[0].count[at - 1] += 5 now leaves the run 15 99 30. An index past the run is refused with K0604 ("index 3 is outside 3 of them"), the sentence a run in a local gets, in every engine and in a body compiled to C. A write whose right-hand side grows the array is written into the array as it is after it grew. kest emit writes these as two new instructions, load.elem.run and store.elem.run. A program that compiled before compiles to the same instructions. A run of runs written at two indexes worked out while running (grid[i][j] = 9) is still refused, in a local as well as in an element (#249). (#250)
• A bool, or a set of flags, read through an address worked out before the read (load.at) is looked at only when the address is in memory a host lent, as a read that knows its array already was. Every such read was looked at, of the machine's own memory too. Nothing a program or a host sees changes: every read refused before is refused with the same line. A program reading rows[k].cells[i] 800,000 times from a [Row] of 1000 struct Row { cells: [bool; 4] } it filled itself runs in 131,499,448 instructions where it took 162,700,128, under perf stat -e instructions:u with the program and commands the pull request gives. (#247)