{"slug": "show-hn-jacquard-a-programming-language-for-ai-written-human-reviewed-code", "title": "Show HN: Jacquard, a programming language for AI-written, human-reviewed code", "summary": "Jacquard, a research prototype programming language designed for AI-written, human-reviewed code, has been released as version 0.1. The language enforces effect tracking, supports probabilistic simulation, and uses canonical structural identity to help humans verify code written by machines. It is not yet production-ready but demonstrates language-level guarantees for trust and transparency in AI-generated programs.", "body_md": "Jacquard is a research prototype for running, reviewing, simulating, and trusting programs written by models and reviewed by people.\n\nConcretely, it is a small programming language with a compact `.jac`\n\nsurface\nsyntax, an OCaml checker and CPS interpreter, a C-emitting native AOT backend\nthat currently compiles the kernel `.jqd`\n\ncarrier, a command-line tool, a\nJacquard-written standard library, and a test framework called Warp. Version\n0.1 works end to end but is a research prototype, not a production language;\n`docs/release/0.1/LIMITS.md`\n\nis the honest boundary.\n\nInstall the 0.1 release candidate without OCaml or opam:\n\n```\ncurl -fsSL https://raw.githubusercontent.com/jbwinters/jacquard-lang/jacquard-core-0.1-rc3/scripts/install.sh | sh\n~/.local/bin/jac run ~/.local/share/jacquard/demos/basics/m1-fact.jac\n```\n\nThe expected output is `120`\n\n. Linux x86-64, macOS Intel, and macOS Apple\nSilicon binaries are published; development from source is documented below.\n\nThen run one policy under concrete and probabilistic telemetry worlds, followed by sampled and exhaustive Warp checks:\n\n```\nsh ~/.local/share/jacquard/demos/case-studies/release-risk/run.sh\n```\n\nMost languages tell you what a program computes. Jacquard also exposes which effects it may perform, finite discrete uncertainty, and canonical program identity. Tools can inspect all three because they live in the language rather than only in comments, logs, or your memory of the codebase.\n\nThings you can do here that most languages cannot offer:\n\n- Read one line and see the effects a function may perform. A signature like\n`(text) ->{net} text`\n\nsays the function may perform the`net`\n\neffect. The Jacquard runtime rejects unhandled world effects unless their authority is explicitly granted with`--allow`\n\n, including effects performed by dynamic code. This is language-level enforcement in a research runtime, not a substitute for an operating-system sandbox. - Run one program against many worlds. The same code can run against the real network, a scripted fake, a recording of last week's traffic, or a probability model of how servers usually behave. A handler is the piece that answers a program's requests to the outside world; you swap the handler, and the code never changes. This can replace much conventional mocking at effect boundaries and makes \"what would my agent do if the API went down?\" an ordinary test.\n- Enumerate exact probabilities for finite discrete models. A program can sample weighted choices and record evidence, and enumeration lists every reachable outcome with its exact probability. The repair demo below treats a failing test as evidence and computes which patches remain possible and how likely each is.\n- Rename and reformat without changing canonical identity. Jacquard hashes canonical resolved structure rather than source bytes. Comments, formatting, provenance, and ordinary local or term renames are erased; pure tests rerun only when canonical code or dependency content changes. This is structural identity, not a proof that arbitrary programs are behaviorally equivalent.\n\nThe bet behind all of this: when most code is written by machines, the humans reviewing it need the language itself to answer \"what can this touch, and how sure are we\" without reading every line.\n\nRead `docs/SKILL.md`\n\nfirst. It compresses the kernel, the CLI, the prelude,\nWarp testing, and the known gotchas into one file, and it loads as a project\nskill from `docs/SKILL.md`\n\n. Operating rules are in `AGENTS.md`\n\n. What\nwill save you time:\n\n- Behavior is pinned by evidence: cram transcripts under\n`test/cli/`\n\n, corpus goldens, demo scripts, and`docs/release/0.1/CLAIMS.md`\n\n. If a pin fails, treat it as information about your change, and never weaken a pin to make a diff pass. - The kernel is 27 forms (\n`docs/ast.md`\n\n);`.jac`\n\nis a projection onto those forms, and bootstrap`.jqd`\n\nremains permanently supported. Treat the shipped surface boundary and its parked follow-ups as release evidence, not as a frozen grammar; do not add out-of-scope features (`AGENTS.md`\n\nlists them). - The development gate is\n`dune build @all && dune runtest && dune fmt`\n\nfollowed by a clean`git diff --exit-code`\n\n.\n\nFor readers who speak programming languages:\n\n- One uniform representation: every form is a\n`(head, meta, args)`\n\ntriple, and the kernel grammar has 27 forms. Quoted code is ordinary data. - Algebraic effects with deep, multi-shot handlers. A handler can resume a computation zero, one, or many times, which is what makes exhaustive search and exact inference ordinary library code.\n- Explicit capability grants. The runtime installs handlers for the outside\nworld only for effects you pass with\n`--allow`\n\n; there is no ambient authority. - Type-and-effect rows. Every arrow carries the set of effects the function may perform, so a program's inferred row is its authority manifest.\n- Discrete probabilistic programming as a library:\n`sample`\n\nand`observe`\n\nare effect operations, and each inference algorithm is a handler. - Content-addressed definitions. Identity is a hash of canonical resolved structure with non-identity metadata erased, so formatting, comments, and ordinary local or term renames change nothing downstream.\n- Tooling that leans on the above: formatter, structure-aware differ, Warp tests with a content-addressed cache, record/replay, and a reproducible release evidence pack.\n- A native AOT path that emits C, specializes and caches units by content hash, and is differential-tested against the interpreter under clang and gcc.\n\nThe prototype is complete against its original core plan and has since added the public surface syntax, ringed standard library, Warp properties and cache, native compilation, packaged binaries, and product-scale case studies. The RC1 semantic boundary is pinned by 554 Alcotest/QCheck cases, 32 cram transcripts, 21 documentation examples, native sanitizer/leak/fuzz lanes, and a fresh-clone evidence workflow. RC2 repaired binary-demo packaging; RC3 adds an explicit runtime/output license exception and packages the native runtime. The current successor distribution relicenses Jacquard under Apache License 2.0 and keeps that runtime/output permission as an explicit clarification. These licensing and packaging changes do not change the language semantics pinned at RC1.\n\nHere is one handler resuming one continuation twice. The block is copied\nbyte-for-byte to `test/docs-doctest/fixtures/readme-multishot.jac`\n\nand run by\nthe documentation test lane:\n\n``` php\neffect Choice where {\n  choose : () -> Bool\n}\n\nhandle {\n  match choose() {\n    | True -> 1\n    | False -> 2\n  }\n} {\n  | return x -> x\n  | choose() resume continue -> add(continue(True), continue(False))\n}\nbash\n$ jac run test/docs-doctest/fixtures/readme-multishot.jac\n3\n```\n\nThe handler ran the rest of the program once with `true`\n\nand once with\n`false`\n\n, then collected both results. That ability to resume more than once is\nwhy exact Bayesian inference is a library handler here rather than a runtime\nfeature. The repair demo builds on it: mutate a buggy program's quoted AST\ninto candidate patches, treat a failing test as an observation, and read off\nthe updated probabilities. Running candidate code is an authority, so the pure\nstep still runs (it counts eight candidate patches) and then the demo refuses\nuntil you grant the rest:\n\n``` bash\n$ jac run demos/tooling/repair.jac\n8\nerror[E0814]: this program requires the `eval` effect, which is not granted (performed via `posterior-over-patches`)\n  hint: grant it with --allow eval, or handle the effect in the program\n$ jac run demos/tooling/repair.jac --allow eval\n```\n\nUnder the grant, one failing test leaves two surviving patches: the intended\nfix at 0.75 and a patch that games the suite at 0.25. Adding one regression\ntest prunes the impostor, and the surviving fix prints as a one-line canonical\ndiff: `- sub + add`\n\n. See `sh demos/tooling/repair.sh`\n\nfor the full transcript.\n\nMost users do not need OCaml or opam. Install the reviewed 0.1 RC binary with:\n\n```\ncurl -fsSL https://raw.githubusercontent.com/jbwinters/jacquard-lang/jacquard-core-0.1-rc3/scripts/install.sh | sh\n```\n\nThe installer detects your OS and CPU, downloads the matching archive and\nSHA-256 checksum, refuses a checksum mismatch, and installs under `~/.local`\n\nby default. Make sure `~/.local/bin`\n\nis on `PATH`\n\n, then run:\n\n```\njacquard --version\njac --version\n```\n\n`jac`\n\nis the short alias for `jacquard`\n\n. Both commands set `JACQUARD_PRELUDE`\n\nfrom the installed package, so ordinary runs do not need an environment variable:\n\n```\njac run ~/.local/share/jacquard/demos/basics/m1-fact.jac\n```\n\nNarrative demos ship with launchers that choose the installed binary and prelude automatically. They do not require Dune:\n\n```\nDEMO_ROOT=\"$HOME/.local/share/jacquard/demos\"\nsh \"$DEMO_ROOT/case-studies/release-risk/run.sh\"\nsh \"$DEMO_ROOT/worlds/agent-dream.sh\"\nsh \"$DEMO_ROOT/worlds/escrow/run.sh\"\n```\n\nUse these launchers rather than directly running a probabilistic model or a\nmulti-file entrypoint. The launcher selects `infer`\n\nwhere observation requires\nit and assembles related files in isolated scratch space.\n\nTo install under a different user-owned prefix:\n\n```\ncurl -fsSL https://raw.githubusercontent.com/jbwinters/jacquard-lang/jacquard-core-0.1-rc3/scripts/install.sh \\\n  | JACQUARD_INSTALL_PREFIX=\"$HOME/.jacquard\" sh\n```\n\nSet `JACQUARD_INSTALL_VERSION`\n\nto install a different release tag. Supported\nbinary targets are `linux-x86_64`\n\n, `macos-x86_64`\n\n, and `macos-arm64`\n\n; other\nplatforms currently require the development setup.\n\nRelease archives are attached to `jacquard-core-*`\n\nGitHub releases. Each\narchive contains `bin/jacquard`\n\n, `bin/jac`\n\n, `libexec/jacquard/jacquard`\n\n,\n`share/jacquard/prelude`\n\n, `share/jacquard/demos`\n\n, the native C runtime, and the\nlicense, notice, exception, and trademark documents.\n\nThese commands assume a fresh clone and `asdf`\n\navailable for installing `opam`\n\n.\nIf you already have `opam`\n\n2.5.x, start at the local switch step. If `opam`\n\nis already initialized on your machine, skip `opam init`\n\n.\n\n```\ngit clone https://github.com/jbwinters/jacquard-lang.git\ncd jacquard-lang\n\nasdf plugin add opam https://github.com/asdf-community/asdf-opam.git\nasdf install opam 2.5.1\nasdf set opam 2.5.1\nasdf reshim opam 2.5.1\n\nopam init -y --no-setup --bare\nopam switch create . ocaml-base-compiler.5.1.1 -y\neval \"$(opam env)\"\n\nopam install --deps-only . --with-test --with-dev-setup --with-doc -y\nopam exec -- dune build @all\nopam exec -- dune runtest\nopam exec -- dune fmt\ngit diff --exit-code\n```\n\nThe switch step compiles OCaml 5.1.1 from source, so expect the first setup to take around ten minutes.\n\nThe final `git diff --exit-code`\n\nis part of the development contract: formatting\nmust leave the worktree clean unless you intentionally commit the formatting\ndiff.\n\nExpected versions after setup:\n\n`opam`\n\n2.5.1 from`.tool-versions`\n\n- OCaml 5.1.1 from the repo-local\n`_opam/`\n\nswitch `dune`\n\n,`ocamlformat`\n\n,`alcotest`\n\n,`qcheck`\n\n,`digestif`\n\n,`menhir`\n\n,`cmdliner`\n\n,`odoc`\n\n,`utop`\n\n, and`ocaml-lsp-server`\n\nfrom`jacquard.opam`\n\nIn a new shell inside an existing checkout, run:\n\n```\neval \"$(opam env)\"\n```\n\n`_opam/`\n\nis intentionally ignored. It is a local build artifact, not source.\n\nDuring development, use the built binary through Dune:\n\n```\nopam exec -- dune exec jac -- --help\nopam exec -- dune exec jac -- --version\n```\n\nMany direct CLI commands need the prelude. From the repository root:\n\n```\nexport JACQUARD_PRELUDE=$PWD/prelude\nopam exec -- dune exec jac -- run demos/basics/m1-fact.jac\n```\n\nThe main commands are:\n\n```\njac run FILE.jac [--allow fs] [--allow net] [--dry-run]\njac check FILE.jac [--print-sigs] [--manifest fs,net,console]\njac hash FILE.jac\njac fmt FILE.jac\njac diff FILE_A.jac FILE_B.jac\njac diff STORE_A STORE_B\njac infer enumerate MODEL.jac\njac infer lw MODEL.jac --seed 42 --samples 100000\njac replay TRACE.jqd PROGRAM.jqd [--fork '1=(response 500 \"down\")']\njac test TESTS.jac [TESTS.jqd ...] [--exhaustive] [--cache-dir CACHE]\njac build FILE.jqd -o PROG\n```\n\n`.jac`\n\nis the user-facing surface carrier. Bootstrap `.jqd`\n\nremains fully\nsupported as the internal/debug syntax, quote notation, and kernel format of\nrecord. `run`\n\n, `check`\n\n, `hash`\n\n, `fmt`\n\n, `diff`\n\n, `infer`\n\n, and `test`\n\nselect\nsurface syntax by extension; native build, replay programs, the prelude, and\nmany internal fixtures continue to use `.jqd`\n\n.\n\nOrdinary programs and demos need only a `.jac`\n\nsource file. Do not hand-author\na `.jqd`\n\ntwin unless a conformance test specifically needs to prove that both\ncarriers lower to the same kernel and hash. The paired files retained in the\ncorpus and selected demos are evidence fixtures, not an authoring requirement.\n\n`jacquard build`\n\ncurrently accepts the kernel `.jqd`\n\ncarrier and compiles a\nprogram and its reachable declarations to a\nstandalone binary whose output is byte-identical to `jacquard run`\n\n—\nstdout, stderr, and exit codes, pinned by a differential harness in CI\n(`scripts/native-diff.sh`\n\n). The full effect language compiles, including\ncapturing and multi-shot handlers, and code values compile since task\n73 — quotes, splices, and the structural code ops. `eval`\n\nalone stays\non the interpreter tier (E1102 policy: dynamically loaded code runs\nwhere the authority model lives).\n\n```\nexport JACQUARD_PRELUDE=$PWD/prelude\nexport JACQUARD_RUNTIME=$PWD/runtime\njac build demos/tooling/word-count.jqd -o word-count\necho \"some words some\" | ./word-count --allow console\n```\n\nRequirements and knobs:\n\n- Release binaries discover their packaged prelude and C runtime automatically. Source checkouts may set the two variables shown above.\n- A C toolchain: clang (any recent) or gcc. Tail calls are O(1) stack on every toolchain: musttail on clang and gcc 15+, a trampoline below them (the emitted C is identical either way).\n- The binary parses\n`--allow EFFECT`\n\n(console, clock, fs, dist, infer so far),`--seed N`\n\nfor the sampling grant, and refuses`--infer-cache`\n\nand`--dry-run`\n\n(interpreter tooling) with pointed errors. `JACQUARD_STACK_MB`\n\nsizes the program stack (default 1024): deep non-tail recursion is real C recursion in this backend.- Compiled units cache under\n`.jacquard-native/`\n\n, keyed by content, so an unchanged program relinks without recompiling. - Measured performance lives in\n`docs/benchmarks.md`\n\n— nine scenarios with interpreter, native (both toolchains), Python, and hand-C columns — with the claim boundaries in`docs/native-compilation.md`\n\n(reproduce with`scripts/native-bench.sh`\n\n).\n\nStart with these from the repo root after `dune build @all`\n\n. The same scripts\nalso work in an installed bundle without opam or Dune:\n\n```\nopam exec -- sh demos/case-studies/stormglass/run.sh\nopam exec -- sh demos/case-studies/release-risk/run.sh\nopam exec -- sh demos/basics/m1.sh\nopam exec -- sh demos/inference/m3.sh\nopam exec -- sh demos/worlds/agent-dream.sh\nopam exec -- sh demos/worlds/preflight.sh\nopam exec -- sh demos/tooling/repair.sh\n```\n\nWhat they show:\n\n`case-studies/stormglass/`\n\n: one checkout policy under simulated network and clock laws, exact incident forecasts, and Warp proofs over all 27 worlds.`case-studies/release-risk/`\n\n: one release policy under concrete and probabilistic telemetry, plus a Warp safety proof over all 18 worlds.`basics/m1.sh`\n\n: factorial, multi-shot choice, and gated eval.`inference/m3.sh`\n\n: one model under exact enumeration and likelihood weighting; same model hash, different inference handler.`inference/clarifying-question.sh`\n\n: an agent computes whether asking the user a question is worth the interruption (value of information).`worlds/agent-dream.sh`\n\n: one policy under scripted and probabilistic world handlers.`worlds/preflight.sh`\n\n: candidate agent plans scored under alternate worlds; the live policy still needs a Net grant after the dreams pass.`inference/ambiguity-pipeline.sh`\n\n: an extraction pipeline that keeps its uncertainty; the user's click becomes an`observe`\n\n.`tooling/showcase-warp-tests.sh`\n\n: Warp checks for the clarifying-question, dream-mode, and ambiguity demos.`tooling/repair.sh`\n\n: program repair as Bayesian inference; a bug report is an observation over computed single-edit patches, and the most likely patch prints as a one-line canonical-structure diff.`worlds/m4-hostile.sh`\n\n: generated-looking code that reaches for`net`\n\n; signatures and manifests expose the authority.`worlds/escrow/run.sh`\n\n: product-shaped generated workflow with manifest, dry-run, Warp tests, fault exploration, replay, canonical diff, and approval by hash.\n\nDemo paths are canonical within the categorized directories; there are no\nflat compatibility aliases. The full catalog is in `demos/README.md`\n\n.\n\nAll public demo outputs are pinned by cram tests (recorded command-line\ntranscripts that fail on any drift), especially `test/cli/demos.t`\n\n,\n`test/cli/hostile-demo.t`\n\n, `test/cli/escrow.t`\n\n, `test/cli/showcase.t`\n\n, and\n`test/cli/repair.t`\n\n, `test/cli/preflight.t`\n\n, plus `test/cli/case-studies.t`\n\nfor\nthe larger applications.\n\nThe release-candidate evidence pack lives in `docs/release/0.1/`\n\n.\n\nTo reproduce the release evidence from this checkout:\n\n```\nJACQUARD_RELEASE_REF=HEAD JACQUARD_RELEASE_BASE=738dc8e scripts/release/reproduce-0.1.sh\n```\n\nThe script installs dependencies, builds, runs the full test suite, checks\nformatting, runs public demos, runs gauntlet tests, records `jacquard --version`\n\n,\nand writes generated evidence under `.scratch/release/0.1/`\n\n.\n\nKey release docs:\n\n`docs/release/0.1/EVIDENCE.md`\n\n: what was built and what passed`docs/release/0.1/CLAIMS.md`\n\n: semantic claims mapped to tests and caveats`docs/release/0.1/REPRO.md`\n\n: fresh-clone reproduction steps`docs/release/0.1/FREEZE.md`\n\n: frozen version/hash/store/CLI surfaces`docs/release/0.1/GAUNTLET.md`\n\n: adversarial tests present and omitted`docs/release/0.1/LIMITS.md`\n\n: explicit non-goals and caveats`docs/release/0.1/DECISION.md`\n\n: release-candidate decision memo`docs/release/0.1/RELEASE-NOTES.md`\n\n: public RC contents and install command\n\n`.github/`\n\n: CI, release evidence workflow, and PR template.`AGENTS.md`\n\n: operating notes for future coding agents.`bin/`\n\n:`jacquard`\n\nCLI entry point.`corpus/`\n\n: conformance corpus and golden outputs.`demos/`\n\n: runnable examples and product-shaped demos.`docs/`\n\n: design docs, tutorial, CI/CD, Warp, stdlib, errors, release evidence.`prelude/`\n\n: Jacquard standard library and effect declarations.`scripts/release/`\n\n: reproducible release evidence script.`spec/`\n\n: kernel AST and canonical serialization specs.`src/`\n\n: OCaml implementation.`test/`\n\n: Alcotest/QCheck suites plus cram CLI transcripts.`jacquard.opam`\n\n,`dune-project`\n\n: package and build metadata.\n\n`src/form.ml`\n\n,`src/meta.ml`\n\n,`src/span.ml`\n\n: uniform triple and metadata.`src/reader.ml`\n\n,`src/printer.ml`\n\n: bootstrap`.jqd`\n\nnotation and formatter.`src/kernel.ml`\n\n: validator and typed kernel AST.`src/resolve.ml`\n\n: names to content-addressed references.`src/canon.ml`\n\n,`src/hash.ml`\n\n: HASH_V0 canonical serialization and hashing.`src/store.ml`\n\n: object store and mutable name index.`src/value.ml`\n\n,`src/eval.ml`\n\n: CPS evaluator and multi-shot handlers.`src/types.ml`\n\n,`src/check.ml`\n\n: type/effect inference, rows, manifests, exhaustiveness.`src/prelude.ml`\n\n: prelude loader, builtin wiring, and root grants.`src/infer_dist.ml`\n\n: exact enumeration and likelihood weighting.`src/diff.ml`\n\n: canonical-structure diff over stores.`src/warp.ml`\n\n: Warp test discovery, running, cache, and properties.\n\nRead these in order if you are new:\n\n`docs/README.md`\n\n: documentation index and suggested reading paths.`docs/tutorial.md`\n\n: runnable user-facing examples.`demos/README.md`\n\n: demo catalog and what each demo proves.`docs/ci-cd.md`\n\n: GitHub checks and release evidence process.`docs/release/0.1/EVIDENCE.md`\n\n: release-candidate evidence overview.\n\nDeeper design references:\n\n`docs/whitepaper.tex`\n\n: historical initial design thesis, motivation, risks, and related work; its roadmap and implementation-status sections are outdated.`docs/ast.md`\n\n: kernel AST and metadata/hash contract.`spec/jacquard-kernel-ast-m0.md`\n\n: kernel source-of-truth spec.`spec/serialization.md`\n\n: canonical byte format.`docs/stdlib.md`\n\n: prelude and ringed standard library.`docs/warp-testing.md`\n\n: Warp testing model.`docs/errors.md`\n\n: diagnostic catalog.`docs/development-plan.md`\n\n: original implementation plan.\n\nBefore opening a PR:\n\n```\neval \"$(opam env)\"\nopam exec -- dune build @all\nopam exec -- dune runtest\nopam exec -- dune fmt\ngit diff --exit-code\n```\n\nWhen adding valid corpus files, regenerate golden hashes:\n\n```\nopam exec -- dune exec test/gen_goldens.exe\n```\n\nWhen touching release-facing demos, claims, CI, or semantics, also run:\n\n```\nJACQUARD_RELEASE_REF=HEAD JACQUARD_RELEASE_BASE=738dc8e scripts/release/reproduce-0.1.sh\n```\n\nGitHub Actions has three principal workflows:\n\n`CI / Development gate`\n\n: build, full tests, clean formatting, version smoke, and release-doc presence on PRs,`main`\n\n, and`release/**`\n\n.`Release Evidence / Reproduce 0.1 evidence`\n\n: release branches,`jacquard-core-*`\n\ntags, and manual dispatch; runs`scripts/release/reproduce-0.1.sh`\n\nand uploads transcripts.`Release Binaries`\n\n:`jacquard-core-*`\n\ntags and manual dispatch; builds Linux/macOS tarballs with`jacquard`\n\n,`jac`\n\n, the prelude, demos, and native runtime sources.\n\nSee `docs/ci-cd.md`\n\nfor branch protection recommendations.\n\nJacquard is licensed under the Apache License, Version 2.0. See\n[LICENSE](/jbwinters/jacquard-lang/blob/main/LICENSE) and [NOTICE](/jbwinters/jacquard-lang/blob/main/NOTICE).\n\n**Your programs remain yours.** Jacquard claims no copyright in source merely\nbecause it is written, checked, interpreted, or compiled with Jacquard. Native\nexecutables include Jacquard runtime material, so the\n[runtime and generated-output exception](/jbwinters/jacquard-lang/blob/main/RUNTIME-EXCEPTION.md) explicitly\nallows user programs and compiled output to use any license their authors\nchoose, including proprietary licenses. The exception also removes Apache\nLicense notice obligations that would otherwise arise solely from embedded\nRuntime Material in a compiled program. This is a statement of project\nlicensing intent, not legal advice.\n\nThe Jacquard name and project identity are governed by\n[TRADEMARKS.md](/jbwinters/jacquard-lang/blob/main/TRADEMARKS.md). The code license does not grant trademark\nrights.\n\nJacquard core is a research prototype, not a production platform. The `.jac`\n\nsurface is implemented and supported but remains an evolving v0 projection\nonto the permanent 27-form kernel. Native AOT compilation and C-toolchain\noptimization ship; a VM/JIT, concurrency, membrane enforcement, continuous\ndistributions, gradients, typed staging, language package management,\nself-hosting, and formal soundness proofs do not. World grants remain coarse.\nSee `docs/release/0.1/LIMITS.md`\n\nfor the exact Core 0.1 semantic boundary.\n\n`opam: command not found`\n\n: install`opam`\n\nwith asdf using`.tool-versions`\n\n, or install a compatible`opam`\n\nmanually.- Dune cannot find packages: run\n`eval \"$(opam env)\"`\n\nin this shell, then reinstall deps with`opam install --deps-only . --with-test --with-dev-setup --with-doc -y`\n\n. `jacquard`\n\ncannot find names from the prelude: set`JACQUARD_PRELUDE=$PWD/prelude`\n\nor run through Dune from the repo root.- Formatting changed files: run\n`opam exec -- dune fmt`\n\n, inspect the diff, and commit the formatting changes if they are intended. - Release reproduction writes generated evidence under\n`.scratch/release/0.1/`\n\nby default. Set`JACQUARD_RELEASE_OUT`\n\nto use another disposable output path.", "url": "https://wpnews.pro/news/show-hn-jacquard-a-programming-language-for-ai-written-human-reviewed-code", "canonical_source": "https://github.com/jbwinters/jacquard-lang", "published_at": "2026-07-13 15:56:02+00:00", "updated_at": "2026-07-13 16:05:13.671435+00:00", "lang": "en", "topics": ["artificial-intelligence", "ai-safety", "developer-tools"], "entities": ["Jacquard", "OCaml", "Warp", "GitHub"], "alternates": {"html": "https://wpnews.pro/news/show-hn-jacquard-a-programming-language-for-ai-written-human-reviewed-code", "markdown": "https://wpnews.pro/news/show-hn-jacquard-a-programming-language-for-ai-written-human-reviewed-code.md", "text": "https://wpnews.pro/news/show-hn-jacquard-a-programming-language-for-ai-written-human-reviewed-code.txt", "jsonld": "https://wpnews.pro/news/show-hn-jacquard-a-programming-language-for-ai-written-human-reviewed-code.jsonld"}}