{"slug": "show-hn-w-isa-an-instruction-set-for-programming-llm-weights", "title": "Show HN: W-ISA – An instruction set for programming LLM weights", "summary": "Ekrem Aksoy released W-ISA v0.1.0, an MIT-licensed instruction set, compiler and Python runtime for reversible, gradient-free editing of live LLM weights on CPU, Apple Silicon and CUDA, backed by two arXiv papers (arXiv:2611.13232 and arXiv:2611.13236). The runtime freezes the model and applies named weight operations under torch.no_grad(), with request-scoped patches and snapshot restoration, defaulting to Qwen/Qwen2.5-0.5B-Instruct and also accepting HuggingFaceTB/SmolLM-135M-Instruct or a local checkpoint. The companion NCP component adds candidate synthesis, verification and rule admission, while the software ships under the MIT License even though both papers use CC BY-NC-ND 4.0.", "body_md": "Reversible, gradient-free weight editing for local language models on CPU, Apple Silicon and CUDA.\n\n**v0.1.0.** W-ISA provides a JSON instruction format, a compiler and a Python\nruntime for named weight operations, request-scoped patches and snapshot restoration.\nThe repository includes executable experiments and their recorded measurements.\n\nCompile a small JSON program, bind it to PyTorch parameter names, and change live\nweights with deterministic linear algebra. The runtime freezes the model and\nperforms edits under `torch.no_grad()`.\n\nThe default loader targets `Qwen/Qwen2.5-0.5B-Instruct`. It also accepts a local\ncheckpoint path or another Transformers causal LM, including\n`HuggingFaceTB/SmolLM-135M-Instruct`. Parameter names and dimensions come from the\nloaded model.\n\nBoth papers are by Ekrem Aksoy and are available on arXiv:\n\n| Paper | Read | DOI | \n|---|---|---|\n| W-ISA: Transactional Execution of Weight-Space Intervention Programs | [arXiv:2611.13232](https://arxiv.org/abs/2611.13232) ·[PDF](https://arxiv.org/pdf/2611.13232) | [10.48550/arXiv.2611.13232](https://doi.org/10.48550/arXiv.2611.13232) | \n| NCP: Verifier-Guided Optimization of Weight-Space Control Policies | [arXiv:2611.13236](https://arxiv.org/abs/2611.13236) ·[PDF](https://arxiv.org/pdf/2611.13236) | [10.48550/arXiv.2611.13236](https://doi.org/10.48550/arXiv.2611.13236) | \n\nW-ISA provides the intervention runtime; [NCP](https://github.com/eax/w-isa/blob/master/NCP/README.md) adds candidate\nsynthesis, verification and rule admission. Cite the paper for the component\nused in your work. [CITATION.cff](https://github.com/eax/w-isa/blob/master/CITATION.cff) provides machine-readable metadata;\nGitHub's **Cite this repository** entry uses the W-ISA paper as its preferred citation.\n\n```\n@misc{aksoy2026wisa,\n\ttitle = {{W-ISA}: Transactional Execution of Weight-Space Intervention Programs},\n\tauthor = {Ekrem Aksoy},\n\tyear = {2026},\n\teprint = {2611.13232},\n\tarchivePrefix = {arXiv},\n\tprimaryClass = {cs.AI},\n\tdoi = {10.48550/arXiv.2611.13232},\n\turl = {https://arxiv.org/abs/2611.13232}\n}\n\n@misc{aksoy2026ncp,\n\ttitle = {{NCP}: Verifier-Guided Optimization of Weight-Space Control Policies},\n\tauthor = {Ekrem Aksoy},\n\tyear = {2026},\n\teprint = {2611.13236},\n\tarchivePrefix = {arXiv},\n\tprimaryClass = {cs.AI},\n\tdoi = {10.48550/arXiv.2611.13236},\n\turl = {https://arxiv.org/abs/2611.13236}\n}\n```\n\nThe software uses the [MIT License](https://github.com/eax/w-isa/blob/master/LICENSE). Both papers use\n[CC BY-NC-ND 4.0](https://creativecommons.org/licenses/by-nc-nd/4.0/);\nthe paper license does not change the software license.\n\nWe credit **Rikiya Takehi, Jayden Teoh, Alex Zhang, and Omar Khattab** for the\nweight-space programming perspective presented in\n[*Sparks of Weight-Space Programming: LLMs can natively read & write neural network weights*](https://rikiyat.github.io/blog/weight-space-programming/)\n(November 2, 2026). Their article explores LLM-native weight inspection and editing.\nW-ISA develops a structured instruction runtime with validation, request scopes\nand restoration around weight interventions.\n\nRelated foundations include Elhage et al.'s\n[*A Mathematical Framework for Transformer Circuits*](https://transformer-circuits.pub/2021/framework/index.html)\nfor head and residual-stream structure, and Arditi et al.'s\n[*Refusal in Language Models Is Mediated by a Single Direction*](https://arxiv.org/abs/2406.11717)\nfor directional behavioral interventions. Both are referenced in the article above.\nThe article also links [*Tracr: Compiled Transformers as a Laboratory for Interpretability*](https://arxiv.org/abs/2301.05062),\nwhich compiles programs into transformer models. W-ISA compiles intervention\ninstructions for the parameters of an existing model.\n\nFrom a checkout, create a virtual environment and install the package:\n\n```\npython3 -m venv .venv\n.venv/bin/python -m pip install -e .\n.venv/bin/wisa demo\n```\n\nInstallation downloads dependencies. The self-contained demo changes a fixed\nmatrix's output from `[5, 11]` to approximately\n`[3, -1]`, then restores `[5, 11]` exactly.\n\nPython 3.10+\nis declared; the tested interpreter is Python 3.12.9. Direct runtime dependencies\nare `torch`, `transformers`, and `numpy`, plus their normal transitive packages.\n\nInspect a cached model with\n`.venv/bin/wisa inspect --local-files-only --contains mlp.down_proj`.\nUse `--model /path/to/checkpoint` for a local checkpoint. Omitting\n`--local-files-only` allows Transformers to download public model files from\nHugging Face; generation runs locally.\n\nFor a before/edit/after/undo comparison on cached Qwen weights:\n\n`.venv/bin/wisa run --local-files-only --program examples/prune.json --prompt \"What is a matrix?\" --max-new-tokens 32 --undo`\n\nRun `.venv/bin/python examples/roundtrip.py` for the pretrained SmolLM experiment.\nThe first run downloads the model when needed; subsequent runs can use\n`--local-files-only`. All model-running commands accept `--device`.\n\nThe pruning example zeros small values in Qwen's first MLP down-projection.\nInspect parameter names before using the example with a different architecture.\nCLI edits operate on in-memory weights for the current process.\nFor an application that keeps a model resident, use `WeightRuntime` directly.\n\n`--device auto` selects CUDA, then MPS, then CPU according to PyTorch availability.\nUse `--device cuda` for the current CUDA device or `--device cuda:1` for an indexed\ndevice. `--device mps` and `--device cpu` select those backends explicitly.\nThe loader checks availability and CUDA indices before loading model files.\nWeights default to FP32; `--dtype float16` and `--dtype bfloat16` select the other\nsupported model dtypes.\n\nFor NVIDIA GPUs, install the CUDA-enabled PyTorch build for your platform using\nthe [PyTorch installation selector](https://pytorch.org/get-started/locally/), then\ninstall W-ISA. Run `.venv/bin/wisa inspect --device cuda --contains mlp.down_proj`\nto inspect a model, or\n`.venv/bin/python examples/roundtrip.py --device cuda --output artifacts/cuda-roundtrip.json`\nfor the head-ablation and projection experiment. Its report records the selected\ndevice, arithmetic dtype, weight changes, undo and replay results.\n\nSource contains `\"version\": 1` and an `\"instructions\"` array. Each instruction\nhas `op` and `target`; the target is a full name from `model.named_parameters()`.\nOperand fields refer to named arrays in an NPZ file supplied by `--operands`, or\nto a mapping of numeric arrays/tensors passed to `compile_program()`.\n\nFor a matrix \n\n| Opcode | Extra fields | Operation | \n|---|---|---|\n| `ADD` | `delta` , optional`alpha=1` |  | \n| `SCALE` | `factor` |  | \n| `RANK1` | `left` ,`right` , optional`alpha=1` |  | \n| `PROJECT_OUT` | `direction` |  | \n| `WRITE_KEY` | `key` ,`value` |  | \n| `PRUNE` | `threshold` | Set entries with $ | \n\n`ADD`, `SCALE`, and `PRUNE` also work on vectors and other dense floating-point\nparameter shapes. The rank-one and projection instructions require matrices\nbecause their operands describe matrix input/output spaces. Thresholds are\nnonnegative. The compiler checks parameter names, operand shapes, finite values,\ninstruction fields and nonzero projection directions before writing weights.\nNPZ loading uses `allow_pickle=False`.\n\nEvery instruction also accepts an optional `slice` array, one entry per parameter\ndimension. `null` selects that entire axis; `[start, stop]` selects a nonempty,\nzero-based, half-open range within the axis. For example, `\"slice\": [null, [0, 64]]`\nselects the first 64 columns of a matrix while preserving the other columns.\nOperand shapes are checked against the selected region. With no `slice`, the\ninstruction retains its original whole-parameter behavior. Reports count changed\nentries and the delta norm in the selected region; entries outside it have zero\ndelta. Backups still cover the whole target parameter, and overlapping slices\nexecute in source order.\n\n`PROJECT_OUT` removes an input direction, so `WRITE_KEY` gives `value`.\n\nFor the demo, \n\nImport `compile_program` and `WeightRuntime` from `wisa`. Construct a runtime\nwith your model, compile a source mapping against that model and an operand\nmapping, then pass the returned `Program` to `runtime.execute(program)`.\n`runtime.undo()` restores the last successful nonempty program.\n`runtime.discard_undo()` releases its saved tensors without changing weights.\n\nThe [compiler](https://github.com/eax/w-isa/blob/master/src/wisa/compiler.py) produces a tuple of bound instructions and\ndetached CPU FP64 operand copies. A compiled program owns its operand copies.\nThe compiled IR contains PyTorch tensors.\nThe [runtime](https://github.com/eax/w-isa/blob/master/src/wisa/runtime.py) rechecks target names and shapes before writing.\nThe [model adapter](https://github.com/eax/w-isa/blob/master/src/wisa/model.py) handles local loading, chat templates, and\ngreedy generation.\n\nExecution preserves `Parameter` identity, including ordinary tied embedding/LM\nhead weights. Instructions run in source order; each result is rounded to the\nparameter's original dtype before the next instruction reads it. Reports contain\nthe norm and number of actually changed entries after that rounding.\n\nAll edited targets are backed up before the first write. An execution exception or cancellation restores those backups and keeps the preceding undo point. Successful execution replaces the undo point; an empty program preserves it. Undo restores the saved parameter values. Before restoration, the runtime checks parameter identity, shape and dtype against the snapshot.\n\n`runtime.temporary(program)` adds an owned request scope: it holds the model's\nreentrant lock, applies the program, and restores the entry state in `finally`.\nNested scopes and additional runtime `execute()`/` undo()` calls are tracked;\nthe preceding public undo point survives the scope. Runtime instances wrapping\nthe same model object share this lock and snapshot state. This includes no-match\nrequests in the controller. Coordination is keyed by the model object and covers\noperations routed through the shared runtime lock.\n\nUse `runtime.lock` around other inference calls sharing that model. After a\nweight change, start generation with a fresh KV cache, as the CLI and controller\ndo. Scope cleanup runs through Python's `finally` mechanism.\n\nThe model stays on its CPU, MPS or CUDA device while edits are calculated on CPU in FP64. Host transfer and dtype conversion are separate operations. Results are checked for finite values, rounded to the original weight dtype and copied back into the existing parameter view. The runtime synchronizes each touched accelerator before snapshots and after writes; restoration also waits for pending device work. CUDA synchronization uses the actual device index of each parameter.\n\nThe arithmetic is deterministic for fixed inputs and execution settings. Reports measure the changes after rounding to the model's dtype. The recorded CPU/MPS tests compare weights bit for bit; generation uses greedy decoding.\n\nEvery matrix instruction takes \n\nBeyond model storage, peak memory includes the previous undo snapshot, the new transaction backups, compiled FP64 operands, and a constant number of dense FP64 work buffers for the largest target. Backups use the original weight dtype on CPU. Snapshots copy the targeted parameters. During normal idle operation, one undo snapshot remains resident. FP32 Qwen 0.5B weights alone are roughly 2 GB; inference activations, caches, and edit workspaces add to that.\n\nUse the VS Code task **W-ISA: offline tests**, or run\n`PYTHONPATH=src HF_HUB_OFFLINE=1 TRANSFORMERS_OFFLINE=1 .venv/bin/python -m unittest discover -s tests -v`.\nThe tests use `unittest`, fixed matrices, and a tiny randomly initialized\n`Qwen2ForCausalLM`. For debugging, place a\nbreakpoint in the runtime and launch the `wisa` module with the `demo` argument\nusing the workspace virtual environment.\n\nThe November 4, 2026 run used ARM64 macOS, Python 3.12.9, PyTorch 2.15.0,\nTransformers 5.22.1 and NumPy 2.5.4: **66 tests passed** in the CPU/MPS environment.\nCoverage includes independent NumPy/hand-derived\nanswers, extreme direction scales, rounding, rollback after partial execution,\ntied parameters, repeated execution, MPS operands, all opcodes on CPU/MPS, and\nQwen logit changes with exact undo/replay. Seven additional slice tests cover\nhead-only ablation, noncontiguous MPS writes, operand shape checks, overlapping\nslices, rollback, projection, and invalid bounds. New evaluation/profile/control\ntests cover token accounting, paired activation means, threshold calibration,\nnested request scopes, cancellation during writes, multiple runtime instances,\nrule ordering, operand snapshots, and streaming close. Dependency checks and the installed\nCLI demo passed. The loader uses the `torch_dtype` argument shared with the\ndeclared Transformers 4.x range.\n\nThe tiny Qwen checkpoint loader test uses real locally saved weights and a mocked tokenizer loader. The separate experiment below exercised real pretrained SmolLM weights, its tokenizer and chat template, and MPS generation. The weights were downloaded from Hugging Face; all inference was local.\n\nCUDA tests cover opcode parity, FP32/FP16/BF16 rounding, sliced writes, rollback,\nrequest cancellation, stream completion, indexed devices and tiny-Qwen inference.\nHardware cases are enabled by `torch.cuda.is_available()` and device count.\nDevice selection and synchronization routing also have mocked backend tests.\n\nRun `.venv/bin/python examples/roundtrip.py --local-files-only` to reproduce the\nexperiment using the cached model. The [runner](https://github.com/eax/w-isa/blob/master/examples/roundtrip.py) accepts\n`--model`, `--device`, `--layer-index`, `--head-index`, repeatable `--prompt`, and\n`--max-new-tokens` options. Defaults use the tenth transformer block\n(`layers[9]`), query head 0, and four fixed prompts with greedy decoding.\n\n`SCALE` with factor 0 zeros only `o_proj.weight[:, 0:64]`. With nine query heads\nof dimension 64, these columns carry head 0's contribution to the residual\nstream. Other heads' columns, and the shared GQA key/value projections, remain\nunchanged. This is output ablation: attention computation runs and the selected\nhead's output contribution is zeroed.\n\n`PROJECT_OUT` edits that block's MLP down-projection. Its fixed direction comes\nfrom the measured down-projection input at the last token of the first prompt,\nbefore either edit. The roundtrip measures the two operations together.\n\nTwo separate process runs matched exactly on saved logits, token sequences,\nmeasured direction, and model-weight hashes. Within each process, the runner\nchecks baseline repeat, edited repeat, undo, and replay. All four prompts changed\nlogits; three changed their generated token sequences. Direction response norm\nfell from 6.4653542 to \n\nSee the [measured results](https://github.com/eax/w-isa/blob/master/artifacts/roundtrip-report.md),\n[first JSON report](https://github.com/eax/w-isa/blob/master/artifacts/smol-roundtrip.json), and\n[independent process report](https://github.com/eax/w-isa/blob/master/artifacts/smol-roundtrip-repeat.json).\nThe runner also saves raw FP32 logits, the measured FP64 operand, and the exact\nJSON program, together with the model revision and execution environment.\n\nThe [rank-one benchmark](https://github.com/eax/w-isa/blob/master/examples/intervention_benchmark.py) compares original\ninference, scoped W-ISA materialization, and a PyTorch forward hook computing\nthe equivalent linear update. The recorded run uses FP32 MPS weights, layer 9's\n1536×8960 MLP down-projection, and normalized sine/cosine vectors with strength\n0.1. A 51-token prompt is decoded for fixed 32-, 128-, and 512-token budgets,\nincluding EOS. Each mode/length has one warm-up and five timed requests; mode\norder rotates between repetitions and every token step is synchronized.\n\nReproduce the two Qwen experiments with the cached checkpoint:\n\n```\nHF_HUB_OFFLINE=1 TRANSFORMERS_OFFLINE=1 .venv/bin/python examples/roundtrip.py \\\n\t--model Qwen/Qwen2.5-1.5B-Instruct --device mps --max-new-tokens 48 \\\n\t--local-files-only --output artifacts/qwen15b-roundtrip.json\nHF_HUB_OFFLINE=1 TRANSFORMERS_OFFLINE=1 .venv/bin/python examples/intervention_benchmark.py \\\n\t--model Qwen/Qwen2.5-1.5B-Instruct --device mps --dtype float32 \\\n\t--lengths 32 128 512 --warmups 1 --repeats 5 --local-files-only \\\n\t--output artifacts/qwen15b-benchmark.json\n```\n\nFor an initial model download, omit the offline environment settings and\n`--local-files-only`. The benchmark accepts caller-selected model, module,\ndevice, dtype, prompt, intervention strength and token budgets.\n\n| Generated tokens | Original request (s) | W-ISA request (s) | Hook request (s) | \n|---|---|---|---|\n| 32 | 1.1858 | 1.2312 | 1.1868 | \n| 128 | 4.7445 | 4.8527 | 4.7873 | \n| 512 | 18.7117 | 19.3735 | 19.4961 | \n\nValues are medians of five complete requests, including setup and restoration.\nThe [graph](https://github.com/eax/w-isa/blob/master/artifacts/qwen15b-benchmark.svg) shows medians and interquartile\nranges. All three modes returned identical token sequences at every measured\nlength. Hook versus materialized prompt logits differed by at most 0.000184;\nthe materialized weights matched the rounded NumPy reference exactly. The\nintervention changed baseline prompt logits by up to 0.041107.\n\nOne target snapshot occupies 52.5 MiB and one full FP64 buffer occupies 105 MiB.\nThe maximum sampled RSS increase during a W-ISA request was 498.94 MiB, with\n10 ms sampling. RSS and MPS allocator counters are recorded separately because\nthey overlap in unified-memory accounting. The [raw JSON](https://github.com/eax/w-isa/blob/master/artifacts/qwen15b-benchmark.json)\nretains all 45 requests, setup/restore times, TTFT, decode times and memory counters.\nThe [CSV](https://github.com/eax/w-isa/blob/master/artifacts/qwen15b-benchmark.csv) tabulates the timing measurements.\nThe runner exports SVG and\n[PGFPlots source](https://github.com/eax/w-isa/blob/master/artifacts/qwen15b-benchmark.tex); the [compiled figure](https://github.com/eax/w-isa/blob/master/artifacts/qwen15b-benchmark.pdf)\nis also included.\n\nThe separate [head/projection roundtrip](https://github.com/eax/w-isa/blob/master/artifacts/qwen15b-roundtrip.json)\nchanged all four prompt-logit distributions and three generated sequences.\nProjection residual was \n\nThe [control-plane report](https://github.com/eax/w-isa/blob/master/artifacts/control-plane-report.md) records full\nWikiText-2 measurements, held-out contrastive-profile results, and real MPS\nrequest-isolation tests. The combined original ablation raised perplexity by\n0.3754%. A separate formal-minus-casual direction raised it by 0.0040%. The\ncontroller gated four of twelve held-out requests: four logit distributions\nchanged and all twelve greedy token sequences were preserved. The report includes\ncompletion-preference scores, trigger counts and generated text.\n\n`perplexity(model, token_ids, context_length, stride)` computes token-weighted NLL.\nIt scores every token except the first exactly once and returns window-level\nlosses, counts, protocol settings, and elapsed time. The\n[four-condition runner](https://github.com/eax/w-isa/blob/master/examples/perplexity.py) compares original weights,\nhead-only ablation, MLP-only projection, and their combination on identical tokens.\n\n`ActivationProfiler(runtime, tokenizer, ActivationSite(...))` captures an input\nor output activation at a named module with last-token or mean-token pooling.\n`contrast(positive, negative)` returns detached CPU FP64 class means and their\ndifference, plus source metadata. `profile.operands(\"v_diff\")` feeds the compiler\ndirectly; `profile.save(...)` stores numeric NPZ arrays and JSON provenance.\nThe [style example](https://github.com/eax/w-isa/blob/master/examples/profile_style.py) uses disjoint topic sets for\nprofiling, threshold calibration, and evaluation. It also saves a symbolic\n`PROJECT_OUT` program. Each profile records its capture location and feature space.\n\n`Rule(name, site, direction, threshold, program)` defines one match-action row.\n`MatchActionController(runtime, tokenizer, rules)` uses caller-supplied rule order:\nthe first rule with `cosine_score > threshold` wins. All scores are measured\nbefore any patch; identical sites share an activation capture. Rule tensors are\ncopied on registration. Threshold calibration is a separate function operating\non the designated calibration set.\n\n`controller.generate(prompt)` wraps local greedy generation. For other synchronous\ninference engines, use `controller.run(prompt, callback)` or hold\n`controller.session(prompt)` for the full inference lifetime. The result separates\ninference time from control time, including restoration and any lock wait.\nThese APIs serialize requests sharing one mutable model.\n\n`controller.stream(prompt, iterator_factory)` keeps the scope open while consuming\na synchronous iterator. Close the returned generator on early disconnect, using\nthe same thread, for example through `contextlib.closing`. The controller owns\ncleanup of the supplied iterator. For an async server, run the entire synchronous\nrequest in a worker rather than holding a thread-owned `RLock` across arbitrary\n`await` points. The API runs inside the caller's Python application.\n\nTo reproduce the measurements, run the following from the workspace:\n\n- `.venv/bin/python examples/fetch_wikitext.py` downloads the public test corpus\nonce, using the standard library. See[data attribution](https://github.com/eax/w-isa/blob/master/data/README.md) .\n- `.venv/bin/python examples/perplexity.py` evaluates the complete cached split.`--max-tokens` explicitly selects a shorter pilot; the report marks whether the\nfull test split was evaluated.\n- `.venv/bin/python examples/profile_style.py --corpus data/wikitext2-test.json` extracts the profile, evaluates held-out behavior, and measures its corpus cost.\n- `.venv/bin/python examples/match_action.py` checks calibrated gating, exact\nundo/repeat, failure injection, stream closure, and two threaded requests.\n\nModel-running examples use cached checkpoints; the roundtrip example also supports initial model download. Runtime dependencies are torch, transformers and numpy.\n\nSee [CONTRIBUTING.md](https://github.com/eax/w-isa/blob/master/CONTRIBUTING.md) for test and experiment conventions and\n[SECURITY.md](https://github.com/eax/w-isa/blob/master/SECURITY.md) for the trust boundary. The GitHub workflow runs CPU\ntests against an installed wheel. The linked experiment reports record local\nMPS measurements and their execution environment.\n\nProject code is licensed under the [MIT License](https://github.com/eax/w-isa/blob/master/LICENSE), copyright 2026 Ekrem Aksoy. Downloaded model weights,\ndependencies, and datasets retain their own licenses. WikiText is fetched on\ndemand and is excluded from Git; see [dataset attribution](https://github.com/eax/w-isa/blob/master/data/README.md).\nReports and small numeric experiment artifacts are included for reproducibility.", "url": "https://wpnews.pro/news/show-hn-w-isa-an-instruction-set-for-programming-llm-weights", "canonical_source": "https://github.com/eax/w-isa", "published_at": "2026-11-11 23:47:21+00:00", "updated_at": "2026-11-12 00:23:04.033569+00:00", "lang": "en", "topics": ["artificial-intelligence", "machine-learning", "large-language-models", "ai-tools", "ai-research"], "entities": ["Ekrem Aksoy", "W-ISA", "NCP", "Qwen2.5-0.5B-Instruct", "SmolLM-135M-Instruct", "arXiv", "PyTorch", "MIT License"], "also_reported_by": [], "alternates": {"html": "https://wpnews.pro/news/show-hn-w-isa-an-instruction-set-for-programming-llm-weights", "markdown": "https://wpnews.pro/news/show-hn-w-isa-an-instruction-set-for-programming-llm-weights.md", "text": "https://wpnews.pro/news/show-hn-w-isa-an-instruction-set-for-programming-llm-weights.txt", "jsonld": "https://wpnews.pro/news/show-hn-w-isa-an-instruction-set-for-programming-llm-weights.jsonld"}}