Skip to content

Releases

v2.3.0

Choose a tag to compare

@github-actions github-actions released this 16 Nov 09:40

Full Changelog: v2.2.0...v2.3.0

v2.2.0

Choose a tag to compare

@github-actions github-actions released this 12 Nov 10:45

Full Changelog: v2.1.0...v2.2.0

v2.1.0

Choose a tag to compare

@github-actions github-actions released this 11 Nov 14:47

Full Changelog: v2.0.0...v2.1.0

v2.0.0

Choose a tag to compare

@themythofsisyphusjayant themythofsisyphusjayant released this 07 Nov 12:34

Full Changelog: v1.5.0...v2.0.0

v1.5.0

Choose a tag to compare

@themythofsisyphusjayant themythofsisyphusjayant released this 07 Nov 08:41

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

Choose a tag to compare

@themythofsisyphusjayant themythofsisyphusjayant released this 05 Nov 11:41

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 the continue statement (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 | str as 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 Trait as 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 — never as 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-open a..b values of type range, 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 —
    a refcount builtin 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
    drop method 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

Choose a tag to compare

@themythofsisyphusjayant themythofsisyphusjayant released this 31 Oct 06:46

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 suite tests/run_tests.py passed.
  • Language upgrade 30 Oct 2026: ecall3(eid, arg0, arg1) -> int
    (big32 only) — extension id in a7, arguments in a0/a1,
    result in a0. Proved by examples/os/kernel_ecall3.fg +
    tests/test_kernel_ecall3.py (exact transcript 2 / 141 / -2 / DONE, halted; the 141 proves the second argument arrives in a1).
    Scope note: this is the three-register call; real SBI also uses
    a6 for the function id, so exact firmware-SBI calls remain a
    future slice.
  • Language upgrade 30 Oct 2026: hex integer literals (0xFF,
    0x10000000, uppercase 0X also accepted) — lexer-only, so
    every backend and the checker see a plain int; a bare 0x with
    no hex digit is a compile error. Proved by
    tests/test_hex_literals.py (native values + a big32 model
    kernel using 0x10000000 as the UART address).
  • Daily batch 30 Oct 2026 (15 libraries, all pure Jal Pari with a
    demo each, verified by forge 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: mathex sign needed mut,
    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 by forge 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 against date.
  • 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.
  • 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.
  • --freestanding build mode (Phase C of the freestanding
    track; see docs/FREESTANDING.md): native builds with
    -nostdlib and 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 via lw/sw, WASM rejects loudly. peek32 is
    an expression, poke32 is statement-only like push; 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.py covers all three plus
    checker rejections and formatter stability.

v1.2.0 — Proxy + integration

Choose a tag to compare

@themythofsisyphusjayant themythofsisyphusjayant released this 27 Oct 07:07

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_PROXY tunnels HTTPS through a plain HTTP proxy before the TLS handshake; no_proxy bypasses 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 a tools/check_jalos_sync.py combined-workflow check (9/9).
  • JalOS gains ai (perceptron) and audit commands; 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

Choose a tag to compare

@themythofsisyphusjayant themythofsisyphusjayant released this 26 Oct 19:21

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 indexing s[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: --wit checks 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

Choose a tag to compare

@themythofsisyphusjayant themythofsisyphusjayant released this 26 Oct 15:48

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.