weightlang 0.1.0__tar.gz

weightlang-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 WeightLang contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

weightlang-0.1.0/PKG-INFO

@@ -0,0 +1,286 @@
+Metadata-Version: 2.4
+Name: weightlang
+Version: 0.1.0
+Summary: WeightLang prototype: compile .wgt network descriptions into runnable PyTorch artifacts
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/WeightLang/WeightLang
+Project-URL: Documentation, https://github.com/WeightLang/WeightLang/tree/main/docs
+Project-URL: Releases, https://github.com/WeightLang/WeightLang/releases
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.2
+Requires-Dist: safetensors>=0.4
+Requires-Dist: numpy
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Dynamic: license-file
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/WeightLang/WeightLang/main/assets/logo.png" alt="WeightLang" width="148">
+</p>
+
+<h1 align="center">WeightLang</h1>
+
+<p align="center">
+  <b>A programming language for building neural networks — and shipping their weights.</b>
+</p>
+
+<p align="center">
+  <a href="https://github.com/WeightLang/WeightLang/releases/latest"><img alt="release" src="https://img.shields.io/github/v/release/WeightLang/WeightLang?label=weightc"></a>
+  <img alt="python" src="https://img.shields.io/badge/python-3.10%2B-blue">
+  <img alt="backend" src="https://img.shields.io/badge/backend-PyTorch-ee4c2c">
+  <a href="LICENSE"><img alt="license" src="https://img.shields.io/badge/license-MIT-green"></a>
+  <img alt="status" src="https://img.shields.io/badge/status-0.1%20prototype-orange">
+</p>
+
+<p align="center">
+  <a href="#install">Install</a> ·
+  <a href="#quick-start">Quick start</a> ·
+  <a href="#the-language">Language</a> ·
+  <a href="#reusing-weights">Reuse</a> ·
+  <a href="#packages">Packages</a> ·
+  <a href="#documentation">Docs</a> ·
+  <a href="#limitations">Limitations</a>
+</p>
+
+---
+
+You write a network in a `.wgt` file. `weightc` uses PyTorch to build it,
+initialise it, train it or import weights into it, and writes an **artifact**: a
+directory holding the weights plus everything needed to load and run them —
+architecture, input/output contract, versions, hashes, and where every tensor
+came from. Artifacts can be published as packages addressed by GitHub path,
+Go-style, and their weights reused by other programs.
+
+WeightLang is meant to be written mostly by AI coding models, so the syntax is
+small, line-oriented and strict. It should still be easy for a person to review.
+
+```text
+ xor.wgt ──weightc build──▶ build/xor_mlp/ ──weightc run──▶ {"prob": [[0.00003], [0.9999], ...]}
+                              ├─ manifest.json        structure · I/O · provenance · hashes
+                              ├─ weights.safetensors  float32 tensors, no pickle
+                              └─ source.wgt           the exact source
+```
+
+## Install
+
+**Linux / macOS**
+
+```sh
+curl -fsSL https://github.com/WeightLang/WeightLang/releases/latest/download/install.sh | sh
+```
+
+**Windows (PowerShell)**
+
+```powershell
+irm https://github.com/WeightLang/WeightLang/releases/latest/download/install.ps1 | iex
+```
+
+Both scripts download the `weightlang` wheel from the GitHub release, check its
+sha256 against the release's `SHA256SUMS`, and install it with
+[`uv tool`](https://docs.astral.sh/uv/) if uv is available, otherwise into a
+private virtual environment (no sudo / admin needed). On Linux they install the
+CPU build of PyTorch by default (`WEIGHTLANG_TORCH=default` for PyPI's CUDA
+build). Pin a version with `WEIGHTLANG_VERSION=v0.1.0`. Read the scripts before
+piping them to a shell: [install.sh](install.sh), [install.ps1](install.ps1).
+
+<details>
+<summary><b>Other ways to install</b></summary>
+
+```sh
+# With uv, straight from the release wheel
+uv tool install https://github.com/WeightLang/WeightLang/releases/download/v0.1.0/weightlang-0.1.0-py3-none-any.whl
+
+# From PyPI (once published there; see "Release status" below)
+uv tool install weightlang        # or: pipx install weightlang
+
+# From source, for development
+git clone https://github.com/WeightLang/WeightLang && cd WeightLang
+python -m venv .venv && .venv/bin/pip install -e '.[test]'
+```
+
+If PyTorch is already installed system-wide, reuse it:
+`python -m venv --system-site-packages .venv && .venv/bin/pip install --no-build-isolation --no-deps -e .`
+
+</details>
+
+Requirements: Python ≥ 3.10, PyTorch ≥ 2.2, safetensors ≥ 0.4.
+
+## Quick start
+
+```sh
+weightc check   examples/xor.wgt               # parse and type-check, no build
+weightc build   examples/xor.wgt -o build      # init → train → build/xor_mlp/
+weightc run     build/xor_mlp --input '[[0,0],[0,1],[1,0],[1,1]]'
+weightc inspect build/xor_mlp                  # I/O contract + where each tensor came from
+weightc verify  build/xor_mlp                  # re-check hashes, shapes, loadability
+```
+
+```text
+built build/xor_mlp
+  weights sha256 7969227a9c0e3528317e1cd22b8da766e5b1a7a705e0ba96078a86cde8296ba2
+  tensors trained=4
+  training loss 0.7066 -> 0.0001 on 4 rows (xor), train accuracy 1.00
+```
+
+From Python:
+
+```python
+from weightlang import load_artifact
+
+model = load_artifact("build/xor_mlp")      # verifies hashes and shapes
+model.predict([[0, 1], [1, 1]])             # tensor([[0.9999], [0.0001]])
+model.module                                # a plain torch.nn.Sequential
+```
+
+Artifacts can also be loaded with only `torch` + `safetensors` — see
+[docs/artifact.md](docs/artifact.md).
+
+| Command | What it does |
+|---|---|
+| `weightc check FILE` | Parse and type-check a `.wgt` file |
+| `weightc build FILE -o DIR` | Build an artifact into `DIR/<model>/` |
+| `weightc run ARTIFACT --input JSON` | Run inference; JSON in, JSON out |
+| `weightc inspect ARTIFACT [--json]` | Show interface, layers and tensor provenance |
+| `weightc verify ARTIFACT` | Check hashes, tensor shapes and loadability |
+| `weightc get [DIR]` | Download, verify and lock the packages in `wgt.mod` |
+| `weightc publish PKG --version vX.Y.Z` | Build a package's release assets |
+
+## The language
+
+```wgt
+wgt 0.1
+model xor_mlp
+
+input  bits: f32[2]
+output prob: f32[1]
+
+layer hidden: linear(in=2, out=8)
+layer act:    tanh
+layer head:   linear(in=8, out=1)
+layer out:    sigmoid
+
+data xor:
+  [0, 0] -> [0]
+  [0, 1] -> [1]
+  [1, 0] -> [1]
+  [1, 1] -> [0]
+
+init  seed=42
+train data=xor loss=bce optimizer=adam lr=0.05 epochs=1000
+```
+
+- One statement per line, keyword first, `key=value` options. No expression language.
+- Shapes are checked before anything runs; errors read `xor.wgt:9: shape mismatch: ...`.
+- **Every tensor has an honest origin**, recorded in the manifest:
+
+| origin | meaning |
+|---|---|
+| `random-init` | seeded random values, never trained — outputs are **not meaningful** |
+| `trained` | initialised, then trained by this program |
+| `imported` | copied unchanged from another artifact (`upstream_origin` says what it was there) |
+| `imported+trained` | copied, then fine-tuned |
+
+A program without `train` still builds, but `build`, `run`, `inspect` and the
+Python loader all flag it, and importing an untrained tensor does not make it
+trained. Training metrics are reported on the training rows only.
+
+Full reference: [docs/language.md](docs/language.md).
+
+## Reusing weights
+
+Import a layer from another artifact, optionally pin its hash and freeze it:
+
+```wgt
+init   seed=7
+import hidden from "../build/xor_mlp" layer=hidden freeze
+train  data=xnor loss=bce optimizer=adam lr=0.05 epochs=300
+```
+
+[`examples/xnor_reuse.wgt`](examples/xnor_reuse.wgt) takes the trained hidden
+layer of `xor_mlp`, freezes it and trains only a new head for XNOR. The tests
+check that the imported tensors are bit-identical to the source and stayed
+frozen, that the source hash is recorded (and enforced with `sha256=`), and that
+mismatched layer sizes are rejected. This shows the reuse *mechanism*; with four
+training rows it does not show that reuse helps learning — a fresh network fits
+XNOR too.
+
+## Packages
+
+Packages are identified by GitHub path, versions are Git tags, and weights are
+GitHub release assets — not files in Git history.
+
+```text
+wgt.mod   require github.com/WeightLang/WeightLang/packages/gates v0.1.0
+xnor.wgt  import hidden from "github.com/WeightLang/WeightLang/packages/gates/xor_mlp" layer=hidden freeze
+wgt.sum   commit + sha256 of the index, manifest, weights and source — commit this file
+```
+
+```sh
+weightc get   examples/remote_reuse                  # network: fetch, verify, write wgt.sum
+weightc build examples/remote_reuse/xnor.wgt -o build # offline: cache checked against wgt.sum
+```
+
+`weightc get` resolves the tag to a commit, checks every asset's size and sha256
+against the release's `wgt.index.json`, requires the shipped `source.wgt` to equal
+the file in the repository **at that commit**, and verifies the artifact. A later
+moved tag or replaced asset no longer matches `wgt.sum` and is an error.
+
+The first published package is
+[`packages/gates`](packages/gates) → release
+[`packages/gates/v0.1.0`](https://github.com/WeightLang/WeightLang/releases/tag/packages/gates/v0.1.0).
+Publishing your own:
+
+```sh
+weightc publish path/to/pkg --version v0.1.0 -o dist   # prints the git tag + gh release commands
+```
+
+Design, lock-file format and known gaps: [docs/packages.md](docs/packages.md).
+
+## Documentation
+
+| | |
+|---|---|
+| [docs/language.md](docs/language.md) | Syntax, checks, weight sources and origins |
+| [docs/artifact.md](docs/artifact.md) | Artifact files, manifest fields, verification, loading without WeightLang |
+| [docs/packages.md](docs/packages.md) | Module paths, `wgt.mod`, `wgt.sum`, publishing, fetching, open design |
+
+## Development
+
+```sh
+.venv/bin/python -m pytest                                # no network
+WEIGHTLANG_NETWORK_TESTS=1 .venv/bin/python -m pytest     # + fetch the real gates release
+ruff check src tests && ruff format --check src tests
+```
+
+The suite covers parsing and line-numbered errors, a full XOR build, bit-exact
+outputs after save/reload, byte-stable rebuilds, tamper detection, loading with
+plain PyTorch, untrained labelling, weight reuse, and the package flow (publish,
+get, offline build, tampered assets, moved tags, mismatched source) against an
+in-memory fake of GitHub.
+
+### Release status
+
+| Channel | Status |
+|---|---|
+| GitHub release `v0.1.0` (wheel, sdist, `SHA256SUMS`, install scripts) | published |
+| PyPI `weightlang` | not yet — needs a PyPI trusted publisher, then the manual [`publish-pypi`](.github/workflows/publish-pypi.yml) workflow uploads the same files as the GitHub release |
+
+## Limitations
+
+- **Small language:** sequential networks only (`linear`, `relu`, `tanh`,
+  `sigmoid`), one 1-D `f32` input and output, inline training data, full-batch
+  training, `mse`/`bce`, `sgd`/`adam`.
+- **Imports** copy whole `linear` layers. Packages support direct requirements
+  only, GitHub releases only, and trust-on-first-use hashes without signatures;
+  consumers use the publisher's prebuilt weights.
+- **Reproducibility:** rebuilds are byte-identical on the same PyTorch version and
+  CPU; across versions or hardware weights may differ, and the hashes will show it.
+- **Runtime:** PyTorch only; no ONNX or other exports.
+- **Stability:** 0.x — syntax and formats may change. The Windows installer has
+  not been run on Windows yet.
+
+## License
+
+[MIT](LICENSE)

weightlang-0.1.0/README.md

@@ -0,0 +1,268 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/WeightLang/WeightLang/main/assets/logo.png" alt="WeightLang" width="148">
+</p>
+
+<h1 align="center">WeightLang</h1>
+
+<p align="center">
+  <b>A programming language for building neural networks — and shipping their weights.</b>
+</p>
+
+<p align="center">
+  <a href="https://github.com/WeightLang/WeightLang/releases/latest"><img alt="release" src="https://img.shields.io/github/v/release/WeightLang/WeightLang?label=weightc"></a>
+  <img alt="python" src="https://img.shields.io/badge/python-3.10%2B-blue">
+  <img alt="backend" src="https://img.shields.io/badge/backend-PyTorch-ee4c2c">
+  <a href="LICENSE"><img alt="license" src="https://img.shields.io/badge/license-MIT-green"></a>
+  <img alt="status" src="https://img.shields.io/badge/status-0.1%20prototype-orange">
+</p>
+
+<p align="center">
+  <a href="#install">Install</a> ·
+  <a href="#quick-start">Quick start</a> ·
+  <a href="#the-language">Language</a> ·
+  <a href="#reusing-weights">Reuse</a> ·
+  <a href="#packages">Packages</a> ·
+  <a href="#documentation">Docs</a> ·
+  <a href="#limitations">Limitations</a>
+</p>
+
+---
+
+You write a network in a `.wgt` file. `weightc` uses PyTorch to build it,
+initialise it, train it or import weights into it, and writes an **artifact**: a
+directory holding the weights plus everything needed to load and run them —
+architecture, input/output contract, versions, hashes, and where every tensor
+came from. Artifacts can be published as packages addressed by GitHub path,
+Go-style, and their weights reused by other programs.
+
+WeightLang is meant to be written mostly by AI coding models, so the syntax is
+small, line-oriented and strict. It should still be easy for a person to review.
+
+```text
+ xor.wgt ──weightc build──▶ build/xor_mlp/ ──weightc run──▶ {"prob": [[0.00003], [0.9999], ...]}
+                              ├─ manifest.json        structure · I/O · provenance · hashes
+                              ├─ weights.safetensors  float32 tensors, no pickle
+                              └─ source.wgt           the exact source
+```
+
+## Install
+
+**Linux / macOS**
+
+```sh
+curl -fsSL https://github.com/WeightLang/WeightLang/releases/latest/download/install.sh | sh
+```
+
+**Windows (PowerShell)**
+
+```powershell
+irm https://github.com/WeightLang/WeightLang/releases/latest/download/install.ps1 | iex
+```
+
+Both scripts download the `weightlang` wheel from the GitHub release, check its
+sha256 against the release's `SHA256SUMS`, and install it with
+[`uv tool`](https://docs.astral.sh/uv/) if uv is available, otherwise into a
+private virtual environment (no sudo / admin needed). On Linux they install the
+CPU build of PyTorch by default (`WEIGHTLANG_TORCH=default` for PyPI's CUDA
+build). Pin a version with `WEIGHTLANG_VERSION=v0.1.0`. Read the scripts before
+piping them to a shell: [install.sh](install.sh), [install.ps1](install.ps1).
+
+<details>
+<summary><b>Other ways to install</b></summary>
+
+```sh
+# With uv, straight from the release wheel
+uv tool install https://github.com/WeightLang/WeightLang/releases/download/v0.1.0/weightlang-0.1.0-py3-none-any.whl
+
+# From PyPI (once published there; see "Release status" below)
+uv tool install weightlang        # or: pipx install weightlang
+
+# From source, for development
+git clone https://github.com/WeightLang/WeightLang && cd WeightLang
+python -m venv .venv && .venv/bin/pip install -e '.[test]'
+```
+
+If PyTorch is already installed system-wide, reuse it:
+`python -m venv --system-site-packages .venv && .venv/bin/pip install --no-build-isolation --no-deps -e .`
+
+</details>
+
+Requirements: Python ≥ 3.10, PyTorch ≥ 2.2, safetensors ≥ 0.4.
+
+## Quick start
+
+```sh
+weightc check   examples/xor.wgt               # parse and type-check, no build
+weightc build   examples/xor.wgt -o build      # init → train → build/xor_mlp/
+weightc run     build/xor_mlp --input '[[0,0],[0,1],[1,0],[1,1]]'
+weightc inspect build/xor_mlp                  # I/O contract + where each tensor came from
+weightc verify  build/xor_mlp                  # re-check hashes, shapes, loadability
+```
+
+```text
+built build/xor_mlp
+  weights sha256 7969227a9c0e3528317e1cd22b8da766e5b1a7a705e0ba96078a86cde8296ba2
+  tensors trained=4
+  training loss 0.7066 -> 0.0001 on 4 rows (xor), train accuracy 1.00
+```
+
+From Python:
+
+```python
+from weightlang import load_artifact
+
+model = load_artifact("build/xor_mlp")      # verifies hashes and shapes
+model.predict([[0, 1], [1, 1]])             # tensor([[0.9999], [0.0001]])
+model.module                                # a plain torch.nn.Sequential
+```
+
+Artifacts can also be loaded with only `torch` + `safetensors` — see
+[docs/artifact.md](docs/artifact.md).
+
+| Command | What it does |
+|---|---|
+| `weightc check FILE` | Parse and type-check a `.wgt` file |
+| `weightc build FILE -o DIR` | Build an artifact into `DIR/<model>/` |
+| `weightc run ARTIFACT --input JSON` | Run inference; JSON in, JSON out |
+| `weightc inspect ARTIFACT [--json]` | Show interface, layers and tensor provenance |
+| `weightc verify ARTIFACT` | Check hashes, tensor shapes and loadability |
+| `weightc get [DIR]` | Download, verify and lock the packages in `wgt.mod` |
+| `weightc publish PKG --version vX.Y.Z` | Build a package's release assets |
+
+## The language
+
+```wgt
+wgt 0.1
+model xor_mlp
+
+input  bits: f32[2]
+output prob: f32[1]
+
+layer hidden: linear(in=2, out=8)
+layer act:    tanh
+layer head:   linear(in=8, out=1)
+layer out:    sigmoid
+
+data xor:
+  [0, 0] -> [0]
+  [0, 1] -> [1]
+  [1, 0] -> [1]
+  [1, 1] -> [0]
+
+init  seed=42
+train data=xor loss=bce optimizer=adam lr=0.05 epochs=1000
+```
+
+- One statement per line, keyword first, `key=value` options. No expression language.
+- Shapes are checked before anything runs; errors read `xor.wgt:9: shape mismatch: ...`.
+- **Every tensor has an honest origin**, recorded in the manifest:
+
+| origin | meaning |
+|---|---|
+| `random-init` | seeded random values, never trained — outputs are **not meaningful** |
+| `trained` | initialised, then trained by this program |
+| `imported` | copied unchanged from another artifact (`upstream_origin` says what it was there) |
+| `imported+trained` | copied, then fine-tuned |
+
+A program without `train` still builds, but `build`, `run`, `inspect` and the
+Python loader all flag it, and importing an untrained tensor does not make it
+trained. Training metrics are reported on the training rows only.
+
+Full reference: [docs/language.md](docs/language.md).
+
+## Reusing weights
+
+Import a layer from another artifact, optionally pin its hash and freeze it:
+
+```wgt
+init   seed=7
+import hidden from "../build/xor_mlp" layer=hidden freeze
+train  data=xnor loss=bce optimizer=adam lr=0.05 epochs=300
+```
+
+[`examples/xnor_reuse.wgt`](examples/xnor_reuse.wgt) takes the trained hidden
+layer of `xor_mlp`, freezes it and trains only a new head for XNOR. The tests
+check that the imported tensors are bit-identical to the source and stayed
+frozen, that the source hash is recorded (and enforced with `sha256=`), and that
+mismatched layer sizes are rejected. This shows the reuse *mechanism*; with four
+training rows it does not show that reuse helps learning — a fresh network fits
+XNOR too.
+
+## Packages
+
+Packages are identified by GitHub path, versions are Git tags, and weights are
+GitHub release assets — not files in Git history.
+
+```text
+wgt.mod   require github.com/WeightLang/WeightLang/packages/gates v0.1.0
+xnor.wgt  import hidden from "github.com/WeightLang/WeightLang/packages/gates/xor_mlp" layer=hidden freeze
+wgt.sum   commit + sha256 of the index, manifest, weights and source — commit this file
+```
+
+```sh
+weightc get   examples/remote_reuse                  # network: fetch, verify, write wgt.sum
+weightc build examples/remote_reuse/xnor.wgt -o build # offline: cache checked against wgt.sum
+```
+
+`weightc get` resolves the tag to a commit, checks every asset's size and sha256
+against the release's `wgt.index.json`, requires the shipped `source.wgt` to equal
+the file in the repository **at that commit**, and verifies the artifact. A later
+moved tag or replaced asset no longer matches `wgt.sum` and is an error.
+
+The first published package is
+[`packages/gates`](packages/gates) → release
+[`packages/gates/v0.1.0`](https://github.com/WeightLang/WeightLang/releases/tag/packages/gates/v0.1.0).
+Publishing your own:
+
+```sh
+weightc publish path/to/pkg --version v0.1.0 -o dist   # prints the git tag + gh release commands
+```
+
+Design, lock-file format and known gaps: [docs/packages.md](docs/packages.md).
+
+## Documentation
+
+| | |
+|---|---|
+| [docs/language.md](docs/language.md) | Syntax, checks, weight sources and origins |
+| [docs/artifact.md](docs/artifact.md) | Artifact files, manifest fields, verification, loading without WeightLang |
+| [docs/packages.md](docs/packages.md) | Module paths, `wgt.mod`, `wgt.sum`, publishing, fetching, open design |
+
+## Development
+
+```sh
+.venv/bin/python -m pytest                                # no network
+WEIGHTLANG_NETWORK_TESTS=1 .venv/bin/python -m pytest     # + fetch the real gates release
+ruff check src tests && ruff format --check src tests
+```
+
+The suite covers parsing and line-numbered errors, a full XOR build, bit-exact
+outputs after save/reload, byte-stable rebuilds, tamper detection, loading with
+plain PyTorch, untrained labelling, weight reuse, and the package flow (publish,
+get, offline build, tampered assets, moved tags, mismatched source) against an
+in-memory fake of GitHub.
+
+### Release status
+
+| Channel | Status |
+|---|---|
+| GitHub release `v0.1.0` (wheel, sdist, `SHA256SUMS`, install scripts) | published |
+| PyPI `weightlang` | not yet — needs a PyPI trusted publisher, then the manual [`publish-pypi`](.github/workflows/publish-pypi.yml) workflow uploads the same files as the GitHub release |
+
+## Limitations
+
+- **Small language:** sequential networks only (`linear`, `relu`, `tanh`,
+  `sigmoid`), one 1-D `f32` input and output, inline training data, full-batch
+  training, `mse`/`bce`, `sgd`/`adam`.
+- **Imports** copy whole `linear` layers. Packages support direct requirements
+  only, GitHub releases only, and trust-on-first-use hashes without signatures;
+  consumers use the publisher's prebuilt weights.
+- **Reproducibility:** rebuilds are byte-identical on the same PyTorch version and
+  CPU; across versions or hardware weights may differ, and the hashes will show it.
+- **Runtime:** PyTorch only; no ONNX or other exports.
+- **Stability:** 0.x — syntax and formats may change. The Windows installer has
+  not been run on Windows yet.
+
+## License
+
+[MIT](LICENSE)

weightlang-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "weightlang"
+version = "0.1.0"
+description = "WeightLang prototype: compile .wgt network descriptions into runnable PyTorch artifacts"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+dependencies = [
+    "torch>=2.2",
+    "safetensors>=0.4",
+    "numpy",  # not used directly; avoids torch warning "Failed to initialize NumPy" on every run
+]
+
+[project.urls]
+Homepage = "https://github.com/WeightLang/WeightLang"
+Documentation = "https://github.com/WeightLang/WeightLang/tree/main/docs"
+Releases = "https://github.com/WeightLang/WeightLang/releases"
+
+[project.optional-dependencies]
+test = ["pytest>=8"]
+
+[project.scripts]
+weightc = "weightlang.cli:main"
+
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.ruff]
+line-length = 120

weightlang-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

weightlang-0.1.0/src/weightlang/__init__.py

@@ -0,0 +1,17 @@
+"""WeightLang prototype: compile .wgt network descriptions into runnable PyTorch artifacts."""
+
+__version__ = "0.1.0"
+
+from .artifact import Artifact, UntrainedWeightsWarning, load_artifact  # noqa: E402
+from .syntax import Program, WgtError, parse, parse_file  # noqa: E402
+
+__all__ = [
+    "Artifact",
+    "Program",
+    "UntrainedWeightsWarning",
+    "WgtError",
+    "__version__",
+    "load_artifact",
+    "parse",
+    "parse_file",
+]

weightlang-0.1.0/src/weightlang/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())