nimlang 0.0.1__tar.gz

nimlang-0.0.1/.github/workflows/ci.yml

@@ -0,0 +1,180 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+    tags: ["v*"]
+  pull_request:
+  workflow_dispatch:
+
+env:
+  # The Nim version bundled in this nimlang release (`nimlang info` reports it).
+  NIM_VERSION: "2.2.6"
+
+jobs:
+  # Official Nim release binaries, repackaged into nimlang wheels.
+  wheel-official:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - archive: linux_x64.tar.xz
+            tag: manylinux_2_17_x86_64
+          - archive: windows_x64.zip
+            tag: win_amd64
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - name: Download Nim ${{ env.NIM_VERSION }}
+        run: |
+          case "${{ matrix.archive }}" in
+            windows_x64.zip) url="https://nim-lang.org/download/nim-${NIM_VERSION}_x64.zip" ;;
+            *) url="https://nim-lang.org/download/nim-${NIM_VERSION}-${{ matrix.archive }}" ;;
+          esac
+          curl -fsSL -o "nim-dist-${{ matrix.archive }}" "$url"
+      - name: Build nimlang wheel with bundled Nim
+        run: |
+          uv run --no-project python scripts/make_wheels.py \
+            --nim-dist "nim-dist-${{ matrix.archive }}" --platform-tag ${{ matrix.tag }} --out-dir wheelhouse
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheel-${{ matrix.tag }}
+          path: wheelhouse/*.whl
+
+  # No official binaries for these platforms: build Nim from its source release.
+  wheel-source:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: macos-14
+            tag: macosx_11_0_arm64
+            deployment-target: "11.0"
+          - os: macos-15-intel
+            tag: macosx_10_13_x86_64
+            deployment-target: "10.13"
+          - os: ubuntu-24.04-arm
+            tag: manylinux_2_17_aarch64
+            # Link against glibc 2.17 with zig cc so the binaries are manylinux-compatible.
+            zig-target: aarch64-linux-gnu.2.17
+    env:
+      MACOSX_DEPLOYMENT_TARGET: ${{ matrix.deployment-target }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      # Only the compiled Nim is cached; the wheel is rebuilt so it carries the current nimlang code.
+      - id: cache
+        uses: actions/cache@v4
+        with:
+          path: nim-${{ env.NIM_VERSION }}
+          key: nim-build-${{ env.NIM_VERSION }}-${{ matrix.tag }}
+      - name: Build Nim ${{ env.NIM_VERSION }} from source
+        if: steps.cache.outputs.cache-hit != 'true'
+        run: |
+          curl -fsSL -o nim-src.tar.xz "https://nim-lang.org/download/nim-${NIM_VERSION}.tar.xz"
+          tar xf nim-src.tar.xz
+          flags=""
+          if [ -n "${{ matrix.zig-target }}" ]; then
+            uv venv zigenv && uv pip install --python zigenv ziglang
+            printf '#!/bin/sh\nexec "%s" -m ziglang cc "$@"\n' "$PWD/zigenv/bin/python" > zigcc && chmod +x zigcc
+            t="${{ matrix.zig-target }}"
+            flags="--cc:clang --clang.exe:$PWD/zigcc --clang.linkerexe:$PWD/zigcc --passC:--target=$t --passL:--target=$t"
+          fi
+          cd "nim-${NIM_VERSION}"
+          sh build.sh
+          bin/nim c -d:release koch
+          ./koch boot -d:release $flags
+          ./koch tools -d:release $flags
+          bin/nim --version
+      - name: Build nimlang wheel with bundled Nim
+        run: |
+          uv run --no-project python scripts/make_wheels.py \
+            --nim-dist "nim-${NIM_VERSION}" --platform-tag ${{ matrix.tag }} --out-dir wheelhouse
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheel-${{ matrix.tag }}
+          path: wheelhouse/*.whl
+
+  test:
+    needs: [wheel-official, wheel-source]
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, ubuntu-24.04-arm, macos-14, macos-15-intel, windows-latest]
+    runs-on: ${{ matrix.os }}
+    env:
+      UV_FIND_LINKS: ${{ github.workspace }}/wheelhouse
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: wheel-*
+          path: wheelhouse
+          merge-multiple: true
+      - name: Install this platform's nimlang wheel
+        run: |
+          uv venv check-env
+          uv pip install --python check-env nimlang pytest hatchling
+          if [ "$RUNNER_OS" = "Windows" ]; then bin=check-env/Scripts; else bin=check-env/bin; fi
+          echo "BIN=$PWD/$bin" >> "$GITHUB_ENV"
+      - name: Unit tests against the installed wheel
+        run: $BIN/python -m pytest -v tests
+      - name: nimlang info
+        run: $BIN/nimlang info
+      - name: Build example package through the hatch hook
+        run: uv build --wheel --out-dir dist-example examples/hello-nim
+      - name: Install and run the example wheel
+        run: |
+          uv pip install --python check-env dist-example/*.whl
+          $BIN/python -c "import hello_nim; print(hello_nim.greet('CI'), hello_nim.fib(20))"
+          $BIN/hello_nim_cli CI
+
+  cross:
+    # One Linux machine builds the example wheel for every platform via zig cc.
+    needs: [wheel-official]
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        target: [x86_64-linux-gnu.2.17, aarch64-linux-gnu.2.17, aarch64-macos, x86_64-macos, x86_64-windows-gnu]
+    env:
+      UV_FIND_LINKS: ${{ github.workspace }}/wheelhouse
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: wheel-*
+          path: wheelhouse
+          merge-multiple: true
+      - name: Cross-build example wheel
+        env:
+          NIMLANG_TARGET: ${{ matrix.target }}
+        run: |
+          uv build --wheel --out-dir dist-example examples/hello-nim
+          ls dist-example
+
+  publish:
+    # Push a vX.Y.Z tag to release nimlang (platform wheels plus sdist) to PyPI.
+    if: startsWith(github.ref, 'refs/tags/v')
+    needs: [test, cross]
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: wheel-*
+          path: dist
+          merge-multiple: true
+      - run: uv build --sdist --out-dir dist
+      - uses: pypa/gh-action-pypi-publish@release/v1

nimlang-0.0.1/.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.egg-info/
+.venv/
+dist/
+build/
+.nimlang/
+src/nimlang/nim/
+*.so
+*.pyd
+*.dll
+*.dylib

nimlang-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 nimlang 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.

nimlang-0.0.1/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.5
+Name: nimlang
+Version: 0.0.1
+Summary: Use Nim in your Python project: `uv add nimlang` gives you a Nim toolchain that compiles with zig cc.
+Project-URL: Repository, https://github.com/pietroppeter/uv-add-nimlang
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.9
+Requires-Dist: tomlkit>=0.12
+Requires-Dist: ziglang>=0.13
+Description-Content-Type: text/markdown
+
+# uv add nimlang
+
+Use [Nim](https://nim-lang.org) in a Python project with nothing but uv.
+
+`nimlang` is a Python package that ships the Nim compiler in its wheels and compiles C through
+`zig cc` from the [ziglang](https://pypi.org/project/ziglang/) package, so you need no system
+Nim and no C compiler.
+
+> Status: early scaffold, not on PyPI yet. See [docs/design.md](docs/design.md) for what works
+> and what is planned.
+
+## Use Nim in your project
+
+```sh
+uv add nimlang
+uv run nim c -r hello.nim          # nim and nimble live in your venv
+uv run nimlang add nimpy           # tracked in [tool.nimlang] in pyproject.toml
+uv run nimlang build-ext fast.nim  # build a nimpy extension module next to fast.nim
+uv run nimlang info                # bundled Nim version and where everything lives
+```
+
+## Ship Nim code in a Python package
+
+```toml
+[build-system]
+requires = ["hatchling", "nimlang"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.hooks.nimlang]
+extensions = ["src/mypkg/nimcore.nim"]  # importable as mypkg.nimcore
+binaries = ["src/mypkg/mytool.nim"]     # installed as the `mytool` command
+
+[tool.nimlang]
+dependencies = ["nimpy"]
+```
+
+`uv build` produces a `py3-none-<platform>` wheel that works on every CPython 3 version.
+On Linux it is manylinux-compliant out of the box, and `NIMLANG_TARGET=aarch64-macos uv build`
+cross-builds for other platforms. See [examples/hello-nim](examples/hello-nim).
+
+## Building nimlang wheels
+
+```sh
+python scripts/make_wheels.py --nim-dist nim-2.2.6-linux_x64.tar.xz --platform-tag manylinux_2_17_x86_64
+```
+
+CI builds them for Linux (x86_64, aarch64), macOS (arm64, x86_64) and Windows x86_64, and
+publishes to PyPI when a `v*` tag is pushed. For development without a bundled Nim, set
+`NIMLANG_NIM_HOME` or put `nim` on `PATH`.
+
+What's next: [ROADMAP.md](ROADMAP.md).

nimlang-0.0.1/README.md

@@ -0,0 +1,51 @@
+# uv add nimlang
+
+Use [Nim](https://nim-lang.org) in a Python project with nothing but uv.
+
+`nimlang` is a Python package that ships the Nim compiler in its wheels and compiles C through
+`zig cc` from the [ziglang](https://pypi.org/project/ziglang/) package, so you need no system
+Nim and no C compiler.
+
+> Status: early scaffold, not on PyPI yet. See [docs/design.md](docs/design.md) for what works
+> and what is planned.
+
+## Use Nim in your project
+
+```sh
+uv add nimlang
+uv run nim c -r hello.nim          # nim and nimble live in your venv
+uv run nimlang add nimpy           # tracked in [tool.nimlang] in pyproject.toml
+uv run nimlang build-ext fast.nim  # build a nimpy extension module next to fast.nim
+uv run nimlang info                # bundled Nim version and where everything lives
+```
+
+## Ship Nim code in a Python package
+
+```toml
+[build-system]
+requires = ["hatchling", "nimlang"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.hooks.nimlang]
+extensions = ["src/mypkg/nimcore.nim"]  # importable as mypkg.nimcore
+binaries = ["src/mypkg/mytool.nim"]     # installed as the `mytool` command
+
+[tool.nimlang]
+dependencies = ["nimpy"]
+```
+
+`uv build` produces a `py3-none-<platform>` wheel that works on every CPython 3 version.
+On Linux it is manylinux-compliant out of the box, and `NIMLANG_TARGET=aarch64-macos uv build`
+cross-builds for other platforms. See [examples/hello-nim](examples/hello-nim).
+
+## Building nimlang wheels
+
+```sh
+python scripts/make_wheels.py --nim-dist nim-2.2.6-linux_x64.tar.xz --platform-tag manylinux_2_17_x86_64
+```
+
+CI builds them for Linux (x86_64, aarch64), macOS (arm64, x86_64) and Windows x86_64, and
+publishes to PyPI when a `v*` tag is pushed. For development without a bundled Nim, set
+`NIMLANG_NIM_HOME` or put `nim` on `PATH`.
+
+What's next: [ROADMAP.md](ROADMAP.md).

nimlang-0.0.1/ROADMAP.md

@@ -0,0 +1,43 @@
+# Roadmap
+
+Ideas for after the first release, roughly in priority order.
+
+## Choose the Nim version per project
+
+Today each nimlang release bundles one Nim version. The goal is for a project to pick its Nim
+(say 2.0 for an older codebase) while keeping `uv add nimlang` as the only setup step.
+
+Two ways to get there:
+
+- **Compiler package (preferred).** Ship Nim in a separate `nimlang-nim` package whose
+  version is the Nim version, with `nimlang` depending on it. A project pins Nim with
+  `uv add "nimlang-nim==2.0.16"` and uv.lock records it. This was prototyped in commit
+  `d81715d` on the scaffold branch: it built a 9.4 MB `nimlang-nim` wheel per platform, and
+  switching a project from Nim 2.2.6 to 2.2.4 worked locally.
+- **Download on demand.** `nim = "2.0"` in `[tool.nimlang]`, with nimlang downloading and
+  caching that compiler on first use, like `uv python`. This is more flexible, but sits
+  outside uv.lock and needs network access at first use.
+
+## Optional nimporter integration (after the first release)
+
+nimlang does not depend on nimporter for now. The idea is an optional `nimlang[import]`
+extra that gives a dev-time `import foo` for `foo.nim`, compiled through nimlang (zig cc and
+the project's `[tool.nimlang]` dependencies). It would likely be a maintained fork of
+nimporter, with fixes also sent upstream. Problems with upstream today:
+
+- The latest real release is 1.1.0 (November 2021). The 2.0.0 uploaded in March 2022 was a
+  release candidate and was yanked, and master has carried the unreleased 2.0 since July 2023.
+- It doesn't declare setuptools, so `import nimporter` fails in a fresh uv venv on Python 3.12.
+- It pulls in about 28 packages, including cookiecutter and icecream.
+- It compiles with `nimble c --accept` against the global `~/.nimble`, not a project's
+  dependencies.
+
+## Other items
+
+- **Lock file for Nim dependencies:** record resolved versions/commits of `[tool.nimlang]`
+  dependencies next to uv.lock.
+- **Native `zigcc` shim on Windows:** a tiny executable instead of the `.cmd` file.
+- **`nimlang init`:** scaffold a mixed Python/Nim project (nimpy module, build hook, tests).
+- **Editor support:** point nimsuggest/nimlangserver at the venv's Nim and the project's
+  dependency paths.
+- **More platforms:** musllinux, Windows arm64, Linux armv7.

nimlang-0.0.1/docs/design.md

@@ -0,0 +1,126 @@
+# nimlang: design notes
+
+Goal: `uv add nimlang` is all a Python project needs to start using Nim.
+
+- `nim` and `nimble` work inside the project (`uv run nim c -r app.nim`), with no system C compiler.
+- Nim dependencies are declared and tracked in `pyproject.toml` (`nimlang add nimpy`).
+- A package can ship Nim-built extension modules and executables in ordinary wheels,
+  with `nimlang` as a build dependency.
+
+## What was verified
+
+All of this ran in a Linux x86_64 sandbox with no Nim install, using Nim 2.2.6 and the
+`ziglang` 0.16.0 wheel from PyPI:
+
+| Check | Result |
+|---|---|
+| Nim compiles with `zig cc` as its C compiler (`--cc:clang --clang.exe:<zigcc shim>`) | works |
+| Cross-compiling a Nim program to Windows x64, macOS arm64 and Linux arm64 from Linux | works (binaries not run on those OSes yet) |
+| nimpy extension module built with zig cc, imported from Python | works |
+| Same extension built against glibc 2.17 (`-target x86_64-linux-gnu.2.17`) | max symbol version GLIBC_2.14, so manylinux_2_17 compliant |
+| Nim distribution repackaged into a `nimlang` platform wheel | 9.4 MB wheel (26 MB unpacked) |
+| `uv add nimlang` (from that wheel) then `uv run nim c -r hello.nim` | works |
+| `nimlang add nimpy` → nimble installs into `.nimlang/`, then `nimlang build-ext` | works |
+| `examples/hello-nim`: `uv build` with the hatch hook | `py3-none-manylinux_2_17_x86_64` wheel with extension + CLI |
+| That one wheel on CPython 3.11 and 3.13 | works on both: nimpy has no compile-time libpython dependency |
+| `NIMLANG_TARGET=aarch64-macos uv build`, `NIMLANG_TARGET=x86_64-windows-gnu uv build` from Linux | correct Mach-O / PE files and wheel tags |
+
+## Architecture
+
+### 1. The toolchain wheel (`nimlang`)
+
+Same trick as [ziglang](https://pypi.org/project/ziglang/): a Python package whose platform
+wheels contain a compiler distribution. `scripts/make_wheels.py` builds the pure-Python wheel
+and injects a Nim distribution (`bin/`, `lib/`, `config/`) under `nimlang/nim/`, retagged as
+`py3-none-<platform>`. Only `nim`, `nimble`, `nimsuggest`, `nimpretty`, `nimgrep` and `atlas`
+(plus DLLs and `cacert.pem` on Windows) are kept from `bin/`. For manylinux tags the script
+checks the binaries' glibc symbol versions against the tag.
+
+Each nimlang release bundles one Nim version (set by `NIM_VERSION` in CI), and nimlang keeps
+its own version numbers; `nimlang info` reports the Nim version. Choosing a Nim version per
+project is on the [roadmap](../ROADMAP.md).
+
+Where the binaries come from: official Nim release builds where they exist (Linux x86_64,
+Windows x86_64), built from the source release elsewhere (macOS arm64 and x86_64 natively;
+Linux aarch64 linked against glibc 2.17 with zig cc).
+
+Lookup order for the compiler: `$NIMLANG_NIM_HOME`, the bundled distribution, then a `nim` on
+`PATH` (choosenim-style proxies are resolved with `nim dump`).
+
+`ziglang` is a regular dependency, so the C compiler arrives with the same `uv add`.
+
+### 2. zig cc wiring
+
+Nim calls its C compiler as a single executable, so it cannot be pointed at `zig cc` directly.
+nimlang writes a two-line shim (`zigcc` shell script, `zigcc.cmd` on Windows) into the user
+cache, keyed by the zig path of the environment, and passes
+`--cc:clang --clang.exe:<shim> --clang.linkerexe:<shim>`.
+
+Flags are inserted right after the Nim command, and only for commands that run the C
+compiler (`c`, `cpp`, `r`, ...). `nim e` is left alone: nimble evaluates `.nimble` files
+with it and NimScript sees every command-line argument (injecting there broke nimble).
+`NIMLANG_CC=system` opts out and uses Nim's default compiler.
+
+Cross-compilation is the same mechanism plus `--os/--cpu` and `-target <zig triple>`.
+
+### 3. Nim dependencies
+
+```toml
+[tool.nimlang]
+dependencies = ["nimpy", "cligen >= 1.7"]
+```
+
+`nimlang add/remove` edit this table (format-preserving, via tomlkit) and `nimlang sync`
+runs the bundled nimble with `--nimbleDir:.nimlang/nimble`. Compiles through nimlang get
+`--noNimblePath` plus one `--path` per installed package, so a build sees exactly the
+project's dependencies and nothing from `~/.nimble`.
+
+### 4. Distributing Nim code in Python packages
+
+A hatchling build hook ships with nimlang (registered through the `hatch` entry point):
+
+```toml
+[build-system]
+requires = ["hatchling", "nimlang"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.hooks.nimlang]
+extensions = ["src/mypkg/nimcore.nim"]  # -> mypkg.nimcore (nimpy)
+binaries = ["src/mypkg/mytool.nim"]     # -> `mytool` on PATH
+```
+
+- Missing `[tool.nimlang]` dependencies are synced before compiling.
+- Extensions use the plain `.so`/`.pyd` suffix and wheels are tagged `py3-none-<platform>`:
+  one wheel per platform covers every CPython 3.
+- On Linux the default target pins glibc 2.17, so native wheels are manylinux-compliant
+  without a manylinux container.
+- `NIMLANG_TARGET` (or `target =` in the hook config) cross-builds: a single Linux CI job can
+  produce wheels for every platform. No cibuildwheel needed.
+- Editable installs (`uv sync`) build extensions in place next to the sources; add
+  `[tool.uv] cache-keys` on `*.nim` so uv rebuilds when they change (see the example).
+
+### nimpy and nimporter
+
+nimpy is the core dependency for extensions and works well with this approach. nimporter's
+last release is 1.1.0 from November 2021 (a 2.0.0 uploaded in March 2022 was yanked). It
+compiles at import time or via setuptools and expects a C compiler on the user's machine,
+which is the problem nimlang removes, so nimlang does not depend on it. Its "import .nim
+files directly" convenience could come back as an optional import hook built on nimlang's
+toolchain (undecided; see the roadmap).
+
+## Decisions (2026-10-04)
+
+1. **Nim binaries:** official release builds where they exist, source builds elsewhere.
+2. **Versioning:** `nimlang` has its own versions and bundles one Nim per release. Per-project
+   Nim versions are on the roadmap.
+3. **Nim dependencies:** `[tool.nimlang]` in pyproject.toml. A lock file is not implemented
+   yet; the likely route is recording resolved versions/commits next to `uv.lock`.
+4. **Build integration:** the hatchling hook (a dedicated PEP 517 backend is more work for
+   little gain right now).
+5. **PyPI:** reserve `nimlang` with an early release, published from CI through trusted
+   publishing when a `v*` tag is pushed.
+
+## Next steps
+
+See [ROADMAP.md](../ROADMAP.md). Building from an sdist needs network access for the nimble
+dependencies, as with any nimble-based build.

nimlang-0.0.1/examples/hello-nim/.gitignore

@@ -0,0 +1,5 @@
+.nimlang/
+.venv/
+dist/
+*.so
+*.pyd

nimlang-0.0.1/examples/hello-nim/README.md

@@ -0,0 +1,12 @@
+# hello-nim
+
+A Python package whose core is written in Nim, built with `nimlang`'s hatch hook:
+
+- `src/hello_nim/nimcore.nim` becomes the extension module `hello_nim.nimcore` (via nimpy)
+- `src/hello_nim/hello_nim_cli.nim` becomes the `hello_nim_cli` executable
+
+```sh
+uv run nimlang sync          # install the Nim deps from [tool.nimlang] (nimpy)
+uv build                     # wheel tagged py3-none-<platform>
+NIMLANG_TARGET=aarch64-macos uv build   # cross-build a macOS arm64 wheel from Linux
+```

nimlang-0.0.1/examples/hello-nim/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "hello-nim"
+version = "0.1.0"
+description = "Example: a Python package with a Nim extension module and a Nim CLI, built with nimlang."
+requires-python = ">=3.9"
+dependencies = []
+
+[build-system]
+requires = ["hatchling", "nimlang"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.hooks.nimlang]
+extensions = ["src/hello_nim/nimcore.nim"]
+binaries = ["src/hello_nim/hello_nim_cli.nim"]
+
+[tool.nimlang]
+dependencies = ["nimpy"]
+
+[tool.uv]
+# Rebuild the editable install (and so the Nim extension) when Nim sources change.
+cache-keys = [{ file = "pyproject.toml" }, { file = "src/**/*.nim" }]
+
+[dependency-groups]
+dev = ["nimlang", "pytest"]

nimlang-0.0.1/examples/hello-nim/src/hello_nim/__init__.py

@@ -0,0 +1,3 @@
+from hello_nim.nimcore import fib, greet
+
+__all__ = ["fib", "greet"]

nimlang-0.0.1/examples/hello-nim/src/hello_nim/hello_nim_cli.nim

@@ -0,0 +1,4 @@
+import std/os
+
+let name = if paramCount() > 0: paramStr(1) else: "world"
+echo "Hello, ", name, " from a Nim binary!"

nimlang-0.0.1/examples/hello-nim/src/hello_nim/nimcore.nim

@@ -0,0 +1,10 @@
+import nimpy
+
+proc greet(name: string): string {.exportpy.} =
+  "Hello, " & name & " from Nim!"
+
+proc fib(n: int): int {.exportpy.} =
+  var (a, b) = (0, 1)
+  for _ in 0 ..< n:
+    (a, b) = (b, a + b)
+  a

nimlang-0.0.1/examples/hello-nim/tests/test_hello.py

@@ -0,0 +1,9 @@
+import hello_nim
+
+
+def test_greet():
+    assert hello_nim.greet("Python") == "Hello, Python from Nim!"
+
+
+def test_fib():
+    assert [hello_nim.fib(n) for n in range(8)] == [0, 1, 1, 2, 3, 5, 8, 13]

nimlang-0.0.1/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "nimlang"
+version = "0.0.1"
+description = "Use Nim in your Python project: `uv add nimlang` gives you a Nim toolchain that compiles with zig cc."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+dependencies = [
+    "ziglang>=0.13",
+    "tomlkit>=0.12",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Compilers",
+]
+
+[project.urls]
+Repository = "https://github.com/pietroppeter/uv-add-nimlang"
+
+[project.scripts]
+nimlang = "nimlang.cli:main"
+nim = "nimlang.cli:nim_main"
+nimble = "nimlang.cli:nimble_main"
+
+[project.entry-points.hatch]
+nimlang = "nimlang.hatch_hook"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/nimlang"]
+# The Nim distribution is injected by scripts/make_wheels.py into platform wheels;
+# a local checkout may have one unpacked under src/nimlang/nim for testing.
+exclude = ["src/nimlang/nim"]
+
+[dependency-groups]
+dev = ["pytest>=8", "hatchling"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 110