Repository navigation
Releases
v2.3.0
Full Changelog: v2.2.0...v2.3.0
v2.2.0
v2.1.0
v2.0.0
Full Changelog: v1.5.0...v2.0.0
v1.5.0
Jal Pari Language v1.5.0
- #34 Pinning: pin(x); — a pinned binding cannot move or be reassigned
- #35 Zeroing on free (default-on): freed memory is zeroed
- #36 Allocation failure as a value: try_alloc(n) -> Result<[int], str>
- Version is now a single source of truth (forge_lang/init.py version)
- Diwali diya program (examples/diwali_diya.fg)
- TinyStories trainer checkpoint fix: 5-window checkpoints, resume from the saved window
- 7 Nov daily batch: 10 OS drivers + 10 geometry libraries
- Top-500: HAVE 68 / PARTIAL 60 / GAP 372
v1.4.0
1.4.0 — 3 Nov 2026
- Fix: C-helper param-consumption audit (batch-25 follow-up):
write_bytes freed its array parameter while builtin callers
transfer no hold — a sole-holder variable died with
heap-use-after-free on later use, and a shared variable
drove its refcount below the true holder count (both
reproduced under ASan; batch 25 had only tested a fresh
literal). Native gen_expr now wraps a non-fresh array
argument in a temp with forge_arr_inc, exactly the
user-function call pattern; fresh arguments pass as-is
and are freed. All other str/array helpers audited clean
by code reading + probes (file, read/write, mmap, split,
join, substr, trim, parallel dot/matmul, http, refcount,
weak_register). Documented, not fixed here: fresh heap
string temps passed to a builtin and discarded leak, and
weak_new on a fresh temp registers an entry that never
dies — both need semantic follow-ups, not helper edits. - Fix: type aliases inside sized-array spellings
now expand (the batch-12 gap: "[N; 3]" reached
later passes unexpanded and failed as an unknown
field type; expand_aliases now expands the
element part and keeps the literal length). - Fix: nested empty array literals now work
(let x: [[int]] = [[]];, mixed[[], [1]],
call args, assignment, tuples): the checker
accepts types up to[?]holes in
dynamic-array/tuple positions (never sized),
and infer fills literal types from context so
codegen never sees a hole. Bare holes and
genuine mismatches still error. - Fix: nested arrays as struct fields now work
([[int]]and[Point]fields): the typedefs
were collected but emitted after the struct
bodies, which hold array fields by value — the
typedef lines now precede composite bodies
(helpers still follow the bodies). Enum payload
structs with nested-array payloads remain a
documented residual. - Fix: push to a shared nested array now
copies-on-write (the batch-18 gap: the inline
nested-array push path realloced the shared
buffer in place, dangling the other holders and
double-freeing at scope exit — reproduced as a
tcache double free; the path now detaches first
like the scalar push helpers, copying slots and
gaining an inner reference each, so the free
counts stay exact. Inner arrays stay shared by
reference, as elsewhere). - Fix: nested sized-array literals now unify
([[1, 2], [3, 4]]against[[int; 2]; 2]was
rejected as[[int]]: the sized-literal check
compared each element's inferred dynamic type
against the sized element type instead of
recursing; it now recurses into nested literals
at any depth, and under a dynamic outer array
with sized inner arrays, and infer assigns the
sized type to inner literals. Precise count
errors now fire at the offending level, and
wrong inner sizes / element types are still
rejected. Native only; big32/WASM keep their
named sized rejections). - Top-500 batch 1: binary/octal literals and digit separators
(0b1010, 0o777, 1_000; malformed literals are compile errors)
and thecontinuestatement (native, big32, WASM, formatter;
a for-loop continue still runs the increment). - Top-500 batch 2: traits v1 — trait declarations, impl blocks
(with or without a trait), method-call syntax with static
dispatch, and checker-enforced trait conformance. big32 and
WASM reject trait programs in v1 (no struct parameters /
structs there yet); generic traits, trait objects, and
generic bounds are later slices. - Top-500 batch 3: type aliases v1 — transparent
type
shorthands expanded in the checker before other checking,
so they work on every backend for already-supported types.
Chains, arrays, concrete generic instantiations, struct and
enum aliases, and struct literals via bare-struct aliases
are in; aliases take no type arguments. - Top-500 batch 4: wrapping arithmetic (wrapping_add/sub/mul/
neg, never failing, on native + big32 + WASM) and distinct
newtypes v1 (newtype UserId = int;, cast-only crossings,
same-newtype equality, native + big32 verified, WASM a
later slice). - Top-500 batch 5: union types v1 —
int | stras a tagged
value, wrapping at assignment/argument/return/struct-field/
cast sites, narrowing through match arms named by member
type, str-payload copy/free discipline; native verified,
big32/WASM reject union programs in v1. Members are the
four scalars in v1. - Top-500 batch 6: opaque types v1 —
opaque Traitas an
existential over its implementations, tag-dispatched
method calls/copies/frees; native verified, big32/WASM
reject opaque programs in v1. - Top-500 batch 7: fixed-width integers v1 — i8/i16/i32/
u8/u16/u32/u64 as distinct scalars (i64 is int), fitting
literals adapt, checked arithmetic and narrowing casts,
struct fields; native verified, big32/WASM reject
fixed-width programs in v1. - Top-500 batch 8: sized arrays v1 —
[T; N]as a distinct
type from[T], exact-count literals, push rejected,
index/len/iteration like dynamic arrays; native verified,
big32/WASM reject sized programs in v1. - Top-500 batch 9: readonly views v1 —
readonly [T]as a
read-only handle (index/len/iteration work, push and
index assignment rejected), mutable-to-view coercion
within the same array kind; native verified, big32/WASM
reject readonly programs in v1. - Top-500 batch 10: never type v1 —
neveras the bottom
type (never functions must diverge and cannot return,
never values coerce to any expected type at value
sites, diverging bodies satisfy the return rule);
native verified, big32/WASM reject never programs
in v1. - Top-500 batch 11: checked float-to-int casts v1 —
safe mode fails on out-of-range, NaN, or infinite
floats; fast mode keeps the truncating cast; WASM
already traps, big32 already rejects. - Top-500 batch 12: tuple types v1 —
(T1, T2, ...)
with owned elements, flowing through let,
assignment, arguments, returns, and struct fields;
native verified, big32/WASM reject tuple programs
in v1. Also: composite structs now emit in
dependency order (forward struct references work)
and the lexer treats numbers after a dot as tuple
indices. - Top-500 batch 13: local type inference v1 — an
empty array literal infers its element type from
a later constraining use (push, assignment,
annotated let, call argument, return, struct
field, field assignment); unconstrained literals
fail with a clear message. - Top-500 batch 14: first-class ranges v1 — lazy
half-opena..bvalues of typerange, with
len / contains / start / end / sum methods and
for-loop iteration; big32/WASM reject ranges
in v1. - Top-500 batch 15: void/unit consistency v1 —
void is allowed only as a function or method
return type; every other use fails in the
checker with a clear message instead of
invalid C. §1 Types/safety is now complete. - Top-500 batch 16: defer v1 —
defer call();
runs at the enclosing block's exit, LIFO,
including early returns, breaks, and
continues; loop-body defers run each
iteration. big32/WASM reject defer in v1. - Top-500 batch 17: allocator-as-value v1 —
stdlib/allocator.fg, pure Jal Pari: one
Allocator struct passed explicitly to
functions, in bump, freelist, and arena
kinds; out-of-memory returns -1 as a value. - Top-500 batch 18: arena allocation v1 —
stdlib/arena.fg, pure Jal Pari: a growing
region with mark/restore for temporary
allocations. Also fixed two real ownership
bugs: copy-on-write push on shared arrays,
and field-assignment ownership for array and
struct fields. - Top-500 batch 19: reference counting v1 —
arefcountbuiltin plus stdlib/rc.fg:
shared ownership made observable, clone
gains a holder, last drop frees. - Top-500 batch 20: weak references v1 —
a runtime weak table: weak_new registers
without gaining a holder, weak_upgrade
reports the current array while alive and
(false, []) after the last strong holder
drops. - Top-500 batch 21: move semantics v1 —
move(a) transfers the one hold instead of
copying; the source is dead afterwards and
any later use is a checker error. - Top-500 batch 22: copy-on-write arrays v1,
opt-in — stdlib/cow.fg: a Cow shares its
buffer until a write (shared writer gets a
private copy, sole holder writes in place).
Marked partial: language-default CoW needs
an explicit decision (it would break Rc's
shared mutation). - Top-500 batch 23: stack-allocated slices v1
— stdlib/slice.fg: a stack header over an
existing array's buffer, no copy, writes
through, slicing composes. - Top-500 batch 24: lifetime-ordered placement
v1 — stdlib/lifetime.fg: shorts from the
front, longs from the back, one reset frees
all shorts while longs survive. - Top-500 batch 25: memory-mapped files v1 —
a runtime mmap table: open/get/set/close,
writes land in the file itself. Also fixed
two real leaks the demo exposed (read_bytes
freshness, write_bytes param consumption). - Top-500 batch 26: allocator-aware collections
v1 — AVec over the #22 Allocator (one element
per slot; bump stays exhausted after a pop,
freelist reuses the freed slot; OOM is a
value). Pure Jal Pari. Maps are the next
slice, so #32 lands PARTIAL. - Top-500 batch 27: destructor hooks v1 — a
dropmethod runs when an owned binding dies
(block/function end, return, break), before
the free, via an owned copy; the receiver
parameter itself never hooks (else infinite
recursion). Native only.
v1.3.0
1.3.0 — 31 Oct 2026
- Daily batch 31 Oct 2026 (10 OS kernels + 10 libraries, all
verified by real runs): OS kernels, each a new freestanding
big32 kernel with a model test (exact UART transcript,
halted) — rng (LCG driver), beep (note table), rtc (HH:MM:SS
app), editor (type/backspace), fm (file manager), paint (8x8
framebuffer), mon (system monitor), bootmenu (app launcher),
notes (notes app), pipe (byte-stream ring IPC). Libraries,
each a new pure Jal Pari stdlib file with a demo verified by
forge run— uuid, retry-backoff, cli-table, progress,
email-parse, tfidf, ical-lite, config, timers, changelog.
Regression suitetests/run_tests.pypassed. - Language upgrade 30 Oct 2026:
ecall3(eid, arg0, arg1) -> int
(big32 only) — extension id ina7, arguments ina0/a1,
result ina0. Proved byexamples/os/kernel_ecall3.fg+
tests/test_kernel_ecall3.py(exact transcript2 / 141 / -2 / DONE, halted; the 141 proves the second argument arrives ina1).
Scope note: this is the three-register call; real SBI also uses
a6for the function id, so exact firmware-SBI calls remain a
future slice. - Language upgrade 30 Oct 2026: hex integer literals (
0xFF,
0x10000000, uppercase0Xalso accepted) — lexer-only, so
every backend and the checker see a plain int; a bare0xwith
no hex digit is a compile error. Proved by
tests/test_hex_literals.py(native values + a big32 model
kernel using0x10000000as the UART address). - Daily batch 30 Oct 2026 (15 libraries, all pure Jal Pari with a
demo each, verified byforge run): fft (radix-2 + inverse,
Taylor-series twiddles), mathex (erf, gamma), textwrap,
difflib (LCS ratio — documented as not Python's SequenceMatcher
ratio), slugify, markdown-lite (to text; HTML pending),
toml (subset), ini, xml-lite, dotenv, pathlib (POSIX), url
(parse/build/encode of the reserved set), compress (RLE only;
Huffman/gzip pending), nlp-words (tokenize/stopwords/stem-lite),
i18n-lite (two-locale catalog, plural-lite). Two bugs caught by
the demos and fixed before push: mathexsignneededmut,
slugify dropped uppercase letters. No kernel sims this day: a
big32 diagnostic sim (privilege trace, then CSR-write trace)
was running, so per the daily rules the OS track is reported
short honestly instead of colliding with it. - Daily batch 29 Oct 2026 (16 libraries, all pure Jal Pari with a
demo each, verified byforge run): numpy (flat row-major
arrays, matmul, reductions), pandas (flat DataFrame, filter,
sort, means), complex, fractions, statistics (mode, quantiles,
IQR), checksum (crc32/fnv1a/adler32 over byte arrays),
base64 + hex, semver (struct API — no int-to-string builtin
exists yet), units, polynomials, optimization (gradient
descent, least squares), fuzzy (Levenshtein), calendar
(Zeller weekday), template ({{name}} rendering), color
(hex/rgb/hsl), money (integer cents). Checksums cross-checked
against Python; weekdays cross-checked againstdate. - Daily batch 29 Oct 2026 (10 OS kernels, all freestanding big32
verified on the Python big32 model with exact UART transcripts- memory checks): lifetime-ordered allocator (short pool freed
by epoch reset, long pool survives), terminal command core
(prompt/echo/backspace/dispatch over UART RX — the SOC2 window
draw itself is still pending), shell v2 with digit arguments,
page bitmap allocator, IPC ring queue, priority scheduler
policy, filesystem v3 (delete + rename), network loopback
checksum, calculator app, clock app. No SOC2 vvp sims were run
this day: the big32 Linux continuation sim was running.
- memory checks): lifetime-ordered allocator (short pool freed
- Traps + firmware calls (Phase D of the freestanding track;
see docs/FREESTANDING.md): csr_read/csr_write/csr_set/
csr_clear (literal CSR numbers only), trap_handler hook
(mtvec + full register save/restore stub + mret), ecall(eid,
arg) SBI-call primitive; program end clears mtvec before
halting. Checkpoint is ecall-driven (the model has no timer
or SBI emulation) with exact UART transcript SCRTK. --freestandingbuild mode (Phase C of the freestanding
track; see docs/FREESTANDING.md): native builds with
-nostdliband the program's own_start(raw exit_group
syscall, main's return value = exit code); OS needs
(files, sockets, threads, clock, args, print, libm, extern)
are clean checker errors and strings/arrays are clean
codegen errors; big32 runs under the same flag, WASM
refuses it.fail()halts instead of exiting.- Raw memory builtins
peek32/poke32(Phase B of the
freestanding track; see docs/FREESTANDING.md): volatile 32-bit
load/store through a raw address — native via volatile pointer
helpers, big32 vialw/sw, WASM rejects loudly.peek32is
an expression,poke32is statement-only likepush; both
unchecked in every mode, by design. Proven by a big32 model
run (UART byte write, status/RX reads, RAM round-trip) in
tests/test_peek_poke.py. - Bitwise operators
& | ^ << >> ~on ints (first step toward a
freestanding, bare-metal-capable language; see
docs/FREESTANDING.md): C-like precedence, two's-complement
& | ^, wrapping<<, arithmetic>>, shift counts masked
(0..63 native/WASM, 0..31 big32). Native, WASM, and big32
backends;tests/test_bitwise.pycovers all three plus
checker rejections and formatter stability.
v1.2.0 — Proxy + integration
The Jal Pari Language v1.2.0 — Proxy + integration
The follow-up to the 1.1.0 peak-level batch. Full notes in CHANGELOG.md.
- HTTPS proxy (CONNECT) support in
http_get:https_proxy/HTTPS_PROXYtunnels HTTPS through a plain HTTP proxy before the TLS handshake;no_proxybypasses it. Tested end to end with a local CONNECT proxy + local TLS server (6/6). - Repo integration contract: RED-MOON- and BLACK-MOON-OS- now document ownership, explicit interfaces, and a compatibility matrix (
docs/INTEGRATION.md), plus atools/check_jalos_sync.pycombined-workflow check (9/9). - JalOS gains
ai(perceptron) andauditcommands; Kaggle kernel v2 ran the current mains to COMPLETE. - Windows cross-compile port (MinGW-w64) and registry deploy configs (Render/Fly/systemd/Docker).
- Not in this release: Windows run-verification (no Wine here — cross-compile only), macOS binaries, and the distro ISO build/boot test (needs an Arch builder). Those remain honestly unclaimed.
v1.1.0 — Peak-level batch
The Jal Pari Language v1.1.0 — peak-level batch
The follow-up to the 1.0.0 market-ready release. Full notes in CHANGELOG.md.
- Registry seeded 7 → 30 packages (all 0.1.0, self-contained, demo + smoke verified)
- Core gaps closed:
break, string indexings[i], arrays of structs, nested arrays (native) - Killer app: a package registry server written in Jal Pari itself, speaking the reference HTTP API
- Safety benchmarks: published cost of safe mode, shipped vs matched flags
- Check elimination (native): duplicate checks once per statement, guard-interval overflow elimination, allocation-free string-index comparison
- Structured concurrency:
scope { ... }joins direct + transitive spawns at exit, return, and break - WIT-first WASM:
--witchecks the program against its WIT world before codegen (contract checking, not component binary encoding) - Book / Tour / LSP parity + fix-ending diagnostics: BOOK.md rewritten current, 10-step TOUR.md, LSP completions from the checker's own sets, did-you-mean / conversion / fix-line errors, C-keyword name rejection
Still honestly not done: public registry host (needs hosting account + domain + HTTPS), macOS/Windows binaries (investigation + compiler switch shipped; port not done), WASM component binary encoding, LSP hover/rename, debugger, fuzzing.
The Jal Pari Language 1.0.0 — market-ready
The Jal Pari Language 1.0.0 — market-ready release
The first stable release. From here, semver holds for real: 1.x adds, never breaks (see docs/STABILITY.md).
What is new in 1.0.0
- Stability promise (docs/STABILITY.md): the documented language surface, stdlib APIs, jalpari CLI, and package format will not break without a major version.
- Live browser playground (web/playground.html): a real editor — the actual compiler runs under Pyodide, programs run as WebAssembly, no install. Four verified examples. (End-to-end open in a real browser still needs one browser visit to confirm Pyodide loading; the pipeline and JS are verified.)
- HTTP server: six new builtins (http_listen/accept/read_request/respond/respond_status/close) + stdlib/http_server.fg + a routing demo, verified live with curl (200/200/404, correct bodies, clean shutdown). Limits: one request per connection, single 8191-byte read, no TLS, no chunked bodies, IPv4 only.
- Regex engine (stdlib/regex.fg): literals,
.,*+?with backtracking, classes with ranges, \d \w \s, ^ $ anchors. 36-check demo passes. No groups/alternation — those characters are literal in v1. - Seven real registry packages (packages/): units, money, geometry, interest, roman, bases, dice. Remote publish/list/add verified against a local registry; public hosting still needs a host account.
- VS Code extension, packaged (editors/vscode/forge/forge-1.0.0.vsix): grammar updated with the missing keywords and new builtins. Marketplace publish needs a publisher account.
- Honest benchmarks (docs/BENCHMARKS_VS.md): same tasks in Jal Pari, Python, Go, Rust, C, results verified equal. ~31x/49x/259x vs Python; in the compiled cluster with Go/Rust/C.
- Front door + install: MIT LICENSE in the repo root, landing page updated, install re-verified on a clean HOME and a clean pip venv.
What is still not done (honest list)
Fluent generation, full self-hosting compiler, big32 float division/comparisons/printing/casts, PNG/JPEG, nested arrays, arrays of structs, break, string indexing, float printing past 6 significant digits.
Still blocked on the maintainer's own clicks/accounts
Public registry host, CI upload (token lacks workflow scope), repo rename, PyPI publish, VS Code Marketplace publish, GitHub Pages enable for the landing/playground.
Verified numbers behind 1.0.0
Full test suite passes. TinyStories 153,744-param run: held-out perplexity 2129 -> 651 (better, still not fluent). GPU training verified on Tesla T4 (XOR MLP, loss 0.001529). big32 soft-float 60/60 vs Python float32 on model and Verilog.