stanli 0.3.0__py3-none-win_amd64.whl

stanli/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Sean Talts
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

stanli/THIRD_PARTY_LICENSES.md

@@ -0,0 +1,31 @@
+# Third-party components in the stanli binary
+
+The stanli shared library is self-contained: it links only the system C
+and C++ runtimes, and everything else is compiled in. This file lists what
+is compiled in and under what terms, because distributing the binary
+distributes those components too.
+
+| Component | Role in the binary | License |
+| --- | --- | --- |
+| [Stan math library](https://github.com/stan-dev/math) | every density, constraint transform, and reverse-mode derivative | BSD 3-Clause |
+| [Stan](https://github.com/stan-dev/stan) | NUTS sampler and adaptation | BSD 3-Clause |
+| [stanc3](https://github.com/stan-dev/stanc3) | the Stan compiler, compiled to a self-contained object and linked in | BSD 3-Clause |
+| OCaml runtime | required by the compiled stanc3 object | LGPL 2.1 with the OCaml linking exception, which explicitly permits linking into a binary under other terms |
+| [Eigen](https://eigen.tuxfamily.org) | dense linear algebra behind stan-math | MPL 2.0 |
+| [Boost](https://www.boost.org) | math special functions and utilities used by stan-math | Boost Software License 1.0 |
+| [SUNDIALS / CVODES](https://computing.llnl.gov/projects/sundials) | ODE integration for `integrate_ode_rk45` and `integrate_ode_bdf` | BSD 3-Clause |
+| [nlohmann/json](https://github.com/nlohmann/json) | reading CmdStan-format JSON data | MIT |
+
+Full license texts ship with the vendored sources fetched by
+`deps/fetch.sh`; see `deps/math/LICENSE.md`, `deps/stan/LICENSE.md`, and
+the license files under `deps/math/lib/`.
+
+Notes on the two that carry conditions beyond attribution:
+
+- **Eigen (MPL 2.0)** is a file-level copyleft: distributing the binary is
+  fine, and modifications to Eigen's own files would have to be published.
+  stanli does not modify Eigen.
+- **OCaml runtime (LGPL 2.1)** ships with a linking exception written for
+  exactly this case ("you may link this library into an executable and
+  distribute that executable under terms of your choice"), so no relinking
+  obligation attaches to the stanli binary.

stanli/__init__.py

@@ -0,0 +1,225 @@
+"""stanli: the Stan Language Interpreter.
+
+Compiles a .stan model with stanc3 (linked into the bundled shared library,
+or a bundled stanc binary as a subprocess where it is not), lowers it to an
+op graph in-process, and samples with NUTS. No C++ toolchain, no model
+compilation on this machine.
+"""
+import ctypes
+import json
+import pathlib
+import subprocess
+import sys
+
+import numpy as np
+
+__all__ = ["Model", "__version__"]
+# The one place the version lives. setup.py and the release workflow both
+# read it from here.
+__version__ = "0.3.0"
+
+_BIN = pathlib.Path(__file__).parent / "_bin"
+
+
+def _load_lib():
+    names = {"darwin": "libstanli.dylib", "linux": "libstanli.so"}
+    lib = ctypes.CDLL(str(_BIN / names.get(sys.platform, "stanli.dll")))
+    lib.stanli_model_new.restype = ctypes.c_void_p
+    lib.stanli_model_new.argtypes = [ctypes.c_char_p, ctypes.c_char_p,
+                                     ctypes.c_char_p, ctypes.c_size_t]
+    lib.stanli_model_free.argtypes = [ctypes.c_void_p]
+    lib.stanli_n_unconstrained.restype = ctypes.c_int64
+    lib.stanli_n_unconstrained.argtypes = [ctypes.c_void_p]
+    lib.stanli_grad.restype = ctypes.c_int
+    lib.stanli_grad.argtypes = [ctypes.c_void_p,
+                                ctypes.POINTER(ctypes.c_double),
+                                ctypes.POINTER(ctypes.c_double),
+                                ctypes.POINTER(ctypes.c_double)]
+    lib.stanli_sample.restype = ctypes.c_int
+    lib.stanli_sample.argtypes = [ctypes.c_void_p, ctypes.c_uint32,
+                                  ctypes.c_int, ctypes.c_int, ctypes.c_double,
+                                  ctypes.POINTER(ctypes.c_double),
+                                  ctypes.c_char_p, ctypes.c_size_t]
+    lib.stanli_n_constrained.restype = ctypes.c_int64
+    lib.stanli_n_constrained.argtypes = [ctypes.c_void_p]
+    lib.stanli_constrained_name.restype = ctypes.c_char_p
+    lib.stanli_constrained_name.argtypes = [ctypes.c_void_p, ctypes.c_int64]
+    lib.stanli_constrain.restype = ctypes.c_int
+    lib.stanli_constrain.argtypes = [ctypes.c_void_p,
+                                     ctypes.POINTER(ctypes.c_double),
+                                     ctypes.POINTER(ctypes.c_double)]
+    lib.stanli_has_embedded_stanc.restype = ctypes.c_int
+    lib.stanli_exact_lp.restype = ctypes.c_int
+    lib.stanli_model_new_from_stan.restype = ctypes.c_void_p
+    lib.stanli_model_new_from_stan.argtypes = [ctypes.c_char_p,
+                                               ctypes.c_char_p,
+                                               ctypes.c_char_p,
+                                               ctypes.c_size_t]
+    lib.stanli_wa_n_columns.restype = ctypes.c_int64
+    lib.stanli_wa_n_columns.argtypes = [ctypes.c_void_p]
+    lib.stanli_wa_column_name.restype = ctypes.c_char_p
+    lib.stanli_wa_column_name.argtypes = [ctypes.c_void_p, ctypes.c_int64]
+    lib.stanli_wa_seed.argtypes = [ctypes.c_void_p, ctypes.c_uint32]
+    lib.stanli_wa_row.restype = ctypes.c_int
+    lib.stanli_wa_row.argtypes = [ctypes.c_void_p,
+                                  ctypes.POINTER(ctypes.c_double),
+                                  ctypes.POINTER(ctypes.c_double)]
+    return lib
+
+
+_lib = _load_lib()
+
+
+def _stanc_mir(model_path: pathlib.Path) -> str:
+    stanc = _BIN / ("stanc.exe" if sys.platform == "win32" else "stanc")
+    r = subprocess.run([str(stanc), "--debug-transformed-mir",
+                        str(model_path)],
+                       capture_output=True, text=True)
+    if r.returncode != 0 or not r.stdout:
+        raise RuntimeError(f"stanc failed:\n{r.stderr}")
+    return r.stdout
+
+
+def _data_to_json(data) -> str:
+    """Accept what callers naturally have: a dict, a path, or JSON text.
+
+    numpy arrays are converted, since data almost always arrives as one.
+    """
+    if data is None:
+        return "{}"
+    if isinstance(data, pathlib.Path):
+        return data.read_text()
+    if isinstance(data, str):
+        stripped = data.lstrip()
+        if stripped.startswith("{"):
+            return data
+        return pathlib.Path(data).read_text()
+
+    def encode(value):
+        if hasattr(value, "tolist"):
+            return value.tolist()
+        raise TypeError(f"cannot serialise {type(value).__name__} as Stan data")
+
+    return json.dumps(data, default=encode)
+
+
+def exact_lp() -> bool:
+    """True if lp__ reproduces CmdStan's exactly.
+
+    The wheel is built this way and always has been. A STANLI_LITE_LP
+    build -- which is what ships to the browser -- drops stan-math's
+    propto instantiations to halve the library, leaving every gradient
+    bitwise identical and lp__ a per-model constant higher. A pinned seed
+    still gives a different chain there: lp is added to the kinetic
+    energy, so shifting it changes the rounding, and NUTS amplifies that
+    into a different (equally valid) trajectory.
+    """
+    return bool(_lib.stanli_exact_lp())
+
+
+class Model:
+    """A compiled (model, data) pair."""
+
+    def __init__(self, stan_file=None, data=None, stan_code=None):
+        if stan_code is None:
+            if stan_file is None:
+                raise ValueError("provide stan_file or stan_code")
+            stan_code = pathlib.Path(stan_file).read_text()
+        data_json = _data_to_json(data)
+
+        err = ctypes.create_string_buffer(8192)
+        if _lib.stanli_has_embedded_stanc():
+            # Fully in-process: embedded stanc3 compiles the model.
+            self._m = _lib.stanli_model_new_from_stan(
+                stan_code.encode(), data_json.encode(), err, len(err))
+        else:
+            # Fallback: bundled stanc binary as a subprocess.
+            import tempfile
+            tmp = pathlib.Path(tempfile.mkdtemp()) / "model.stan"
+            tmp.write_text(stan_code)
+            mir = _stanc_mir(tmp)
+            self._m = _lib.stanli_model_new(mir.encode(), data_json.encode(),
+                                            err, len(err))
+        if not self._m:
+            raise RuntimeError(err.value.decode())
+        self.n_unconstrained = _lib.stanli_n_unconstrained(self._m)
+        n_con = _lib.stanli_n_constrained(self._m)
+        self.constrained_names = [
+            _lib.stanli_constrained_name(self._m, i).decode()
+            for i in range(n_con)
+        ]
+
+    def __del__(self):
+        if getattr(self, "_m", None):
+            _lib.stanli_model_free(self._m)
+            self._m = None
+
+    def log_prob_grad(self, q):
+        """log density (jacobian included) and gradient at unconstrained q."""
+        q = np.ascontiguousarray(q, dtype=np.float64)
+        if q.size != self.n_unconstrained:
+            raise ValueError(f"q has {q.size} elements, model has "
+                             f"{self.n_unconstrained} unconstrained parameters")
+        lp = ctypes.c_double()
+        grad = np.empty(self.n_unconstrained)
+        rc = _lib.stanli_grad(
+            self._m,
+            q.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
+            ctypes.byref(lp),
+            grad.ctypes.data_as(ctypes.POINTER(ctypes.c_double)))
+        if rc != 0:
+            # The gradient buffer is uninitialized on failure; never let a
+            # caller see it.
+            raise RuntimeError("log density evaluation failed at this point "
+                               "(domain error in a distribution or function)")
+        return lp.value, grad
+
+    def sample(self, *, seed=1, warmup=1000, samples=1000, delta=0.8):
+        """NUTS draws as {name: array} of CSV columns.
+
+        Models with a generate_quantities section return every column
+        CmdStan's CSV would carry: constrained parameters, transformed
+        parameters, and generated quantities, with RNG draws streamed
+        from `seed`. Models without one return the constrained
+        parameters.
+        """
+        n = self.n_unconstrained
+        draws = np.empty((samples, n))
+        err = ctypes.create_string_buffer(4096)
+        rc = _lib.stanli_sample(
+            self._m, seed, warmup, samples, delta,
+            draws.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
+            err, len(err))
+        if rc != 0:
+            raise RuntimeError(err.value.decode())
+
+        n_wa = _lib.stanli_wa_n_columns(self._m)
+        if n_wa > 0:
+            names = [_lib.stanli_wa_column_name(self._m, i).decode()
+                     for i in range(n_wa)]
+            _lib.stanli_wa_seed(self._m, seed)
+            out = np.empty((samples, n_wa))
+            row = np.empty(n_wa)
+            for s in range(samples):
+                if _lib.stanli_wa_row(
+                        self._m,
+                        draws[s].ctypes.data_as(
+                            ctypes.POINTER(ctypes.c_double)),
+                        row.ctypes.data_as(
+                            ctypes.POINTER(ctypes.c_double))) != 0:
+                    raise RuntimeError(
+                        f"write_array failed on draw {s}")
+                out[s] = row
+            return {name: out[:, i] for i, name in enumerate(names)}
+
+        n_con = len(self.constrained_names)
+        con = np.empty((samples, n_con))
+        row = np.empty(n_con)
+        for s in range(samples):
+            _lib.stanli_constrain(
+                self._m,
+                draws[s].ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
+                row.ctypes.data_as(ctypes.POINTER(ctypes.c_double)))
+            con[s] = row
+        return {name: con[:, i]
+                for i, name in enumerate(self.constrained_names)}

stanli-0.3.0.dist-info/METADATA

@@ -0,0 +1,243 @@
+Metadata-Version: 2.4
+Name: stanli
+Version: 0.3.0
+Summary: Stan Language Interpreter: compile and sample Stan models with no C++ toolchain
+Home-page: https://github.com/seantalts/stanli
+Author: Sean Talts
+License: BSD-3-Clause
+Project-URL: Source, https://github.com/seantalts/stanli
+Project-URL: Issues, https://github.com/seantalts/stanli/issues
+Project-URL: Changelog, https://github.com/seantalts/stanli/blob/main/CHANGELOG.md
+Project-URL: Benchmarks, https://github.com/seantalts/stanli/blob/main/docs/benchmarks.md
+Project-URL: Model coverage, https://github.com/seantalts/stanli/blob/main/docs/corpus-status.md
+Keywords: stan,bayesian,mcmc,nuts,hmc,statistics,probabilistic-programming,inference,autodiff
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: C++
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: stanli/LICENSE
+Requires-Dist: numpy>=1.22
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# stanli
+
+**The Stan Language Interpreter.** Compile and sample Stan models with no
+C++ toolchain on the machine.
+
+[![PyPI](https://img.shields.io/pypi/v/stanli.svg)](https://pypi.org/project/stanli/)
+[![Python](https://img.shields.io/pypi/pyversions/stanli.svg)](https://pypi.org/project/stanli/)
+[![License](https://img.shields.io/pypi/l/stanli.svg)](https://github.com/seantalts/stanli/blob/main/LICENSE)
+[![wheels](https://github.com/seantalts/stanli/actions/workflows/wheels.yml/badge.svg)](https://github.com/seantalts/stanli/actions/workflows/wheels.yml)
+
+```console
+pip install stanli
+```
+
+That is the whole install. No compiler, no `make`, no CmdStan checkout, no
+multi-minute first-run build. One wheel, one shared library, under seven
+megabytes.
+
+```python
+import stanli
+
+model = stanli.Model(stan_file="eight_schools.stan", data="data.json")
+draws = model.sample(seed=1, warmup=1000, samples=1000)
+
+draws["mu"].mean()      # one numpy array of draws per constrained parameter
+```
+
+Model preparation takes milliseconds, so the first draw arrives about 20x
+sooner than a toolchain that compiles C++ per model.
+
+## How it works
+
+Every Stan model is a composition of a fixed vocabulary of operations:
+densities, constraint transforms, linear algebra, elementwise math. stanli
+ships those precompiled and turns each model into *data*, a static graph of
+ops over flat preallocated buffers, instead of generating and compiling C++
+per model.
+
+```
+model.stan + data.json
+  |  stanc3, the official OCaml compiler, linked into the library
+  v
+transformed MIR
+  |  lowering: transformed data evaluated eagerly, data-bound loops unrolled,
+  |            then periodic regions re-rolled back into vectorized ops
+  v
+op graph over preallocated value/adjoint arenas
+  |  forward sweep = log density, reverse sweep = gradient
+  v
+NUTS with diagonal-metric adaptation -> draws
+```
+
+The graph doubles as the autodiff tape, so a reverse sweep is a backwards
+loop over an array rather than a walk through a pointer-chasing tape, and
+steady-state gradient evaluation allocates nothing.
+
+Two things are not reimplemented, which is what makes the results
+trustworthy: the compiler is the real stanc3, linked in-process, so the
+Stan language behaves as the official toolchain makes it behave; and the
+math is unmodified stan-math, the same code CmdStan runs.
+
+## Correctness
+
+Nothing here ships on "looks close".
+
+**<!--gen:corpus_verified_of-->118 of 120<!--/gen--> posteriordb models**
+are differentially verified against CmdStan: same model, same data, same
+evaluation point, comparing the log density and every single gradient
+component. **<!--gen:corpus_bitwise-->45<!--/gen--> agree bitwise.** The
+worst deviation across the entire corpus is
+**<!--gen:corpus_worst-->2.6e-12<!--/gen--> relative**.
+
+The two exceptions are documented rather than hidden. `sir`'s ODE solution
+dips about 1e-9 below a declared lower bound at the shared evaluation point,
+where CmdStan rejects it too; `kronecker_gp` matches on the log density and
+436 of 438 gradients, differing on the two that flow through eigenvectors of
+a nearly degenerate covariance matrix.
+
+Full per-model accuracy table:
+[docs/corpus-status.md](https://github.com/seantalts/stanli/blob/main/docs/corpus-status.md)
+
+## Performance
+
+Per-gradient latency against CmdStan, same models, same evaluation point,
+both sides `-O3` with FP contraction pinned off:
+
+<!--gen:bench_table_us-->
+| model | params | stanli | CmdStan | speedup |
+| --- | ---: | ---: | ---: | ---: |
+| `radon_pooled` | 3 | 52.9 us | 320.9 us | **6.1x** |
+| `arK` | 7 | 2.4 us | 12.5 us | **5.2x** |
+| `radon_hierarchical_intercept_centered` | 391 | 111.6 us | 569.1 us | **5.1x** |
+| `radon_county_intercept` | 388 | 89.7 us | 431.6 us | **4.8x** |
+| `nes` | 10 | 19.7 us | 69.3 us | **3.5x** |
+| `eight_schools_noncentered` | 10 | 0.23 us | 0.74 us | **3.3x** |
+| `election88_full` | 90 | 295.3 us | 902.0 us | **3.0x** |
+| `bym2_offset_only` | 3845 | 39.6 us | 114.6 us | **2.9x** |
+| `dogs` | 3 | 22.0 us | 63.7 us | **2.9x** |
+| `kidscore_momiq` | 3 | 1.9 us | 4.9 us | **2.6x** |
+| `lsat_model` | 1006 | 45.5 us | 91.2 us | **2.0x** |
+| `state_space_stochastic_level_stochastic_seasonal` | 389 | 17.2 us | 26.3 us | **1.5x** |
+| `normal_mixture` | 3 | 79.0 us | 88.2 us | **1.1x** |
+| `low_dim_gauss_mix` | 5 | 88.9 us | 98.3 us | **1.1x** |
+| `wells_dist100ars_model` | 3 | 17.4 us | 19.0 us | **1.1x** |
+| `radon_county` | 389 | 83.2 us | 82.1 us | **1.0x** |
+| `arma11` | 4 | 6.7 us | 6.2 us | 0.93x |
+| `diamonds` | 26 | 35.4 us | 31.5 us | 0.89x |
+| `garch11` | 4 | 11.2 us | 9.7 us | 0.86x |
+| `hmm_drive_0` | 6 | 173.0 us | 132.8 us | 0.77x |
+| `hmm_example` | 4 | 36.3 us | 27.1 us | 0.75x |
+| `ldaK2` | 7 | 145.9 us | 104.1 us | 0.71x |
+| `iohmm_reg` | 29 | 545.2 us | 320.3 us | 0.59x |
+<!--/gen-->
+
+The wins come from op granularity. CmdStan's var tape allocates, walks, and
+frees one node per scalar operation per leapfrog step; stanli pays a fixed
+cost per *op*, and a vectorized statement over N elements amortizes that to
+nothing. Across the whole posteriordb corpus the median is
+<!--gen:corpus_median-->2.07x<!--/gen--> and
+<!--gen:corpus_at_par-->93<!--/gen--> of
+<!--gen:corpus_n_grad-->119<!--/gen--> models are at or above CmdStan.
+
+The losses are honest and understood, and they are all one shape: a
+recurrence. `hmm_*`, `garch11` and `arma11` step through time with each
+step reading the last one's parameter-dependent result, which nothing can
+vectorize, so the work is scalar on both sides and CmdStan's generated C++
+is the faster way to run scalar work. `ldaK2` is a mixture over more than
+two components, which the fusion pass does not yet widen.
+
+ODE models are the other place stanli is still behind. An ODE right-hand
+side is the one user function that cannot be inlined at lowering time,
+since the integrator picks the times; it now compiles into a flat register
+machine instead of being tree-walked, and the forward sweep keeps the
+sensitivities it was already computing instead of solving twice. Together
+that is 29x to 39x faster than the tree-walking interpreter it replaces,
+which puts `lotka_volterra` and `soil_incubation` at 0.58x and 0.63x of
+CmdStan rather than 0.015x.
+
+Method and full table:
+[docs/benchmarks.md](https://github.com/seantalts/stanli/blob/main/docs/benchmarks.md)
+
+## API
+
+The surface is small on purpose.
+
+```python
+import stanli
+
+# A path to a .stan file, or the model source directly.
+model = stanli.Model(stan_file="model.stan", data="data.json")
+model = stanli.Model(stan_code=src, data={"J": 8, "y": y, "sigma": sigma})
+
+model.n_unconstrained               # length of the unconstrained vector
+model.constrained_names             # ['mu', 'tau', 'theta.1', ...]
+
+lp, grad = model.log_prob_grad(q)   # sampling log density and its gradient
+
+draws = model.sample(seed=1, warmup=1000, samples=1000, delta=0.8)
+draws["mu"]                         # ndarray of length `samples`
+```
+
+`data` accepts a path to a JSON file or a dict of Python scalars, lists, and
+numpy arrays. `sample` returns one array of constrained draws per scalar
+parameter, named the way CmdStan names them, so `theta` declared as
+`vector[8]` arrives as `theta.1` through `theta.8`.
+
+## Platforms
+
+Wheels for macOS (arm64 and x86_64) and Linux (x86_64 and aarch64,
+manylinux_2_28). Windows is not built yet; it needs a mingw-w64 toolchain,
+because stan-math does not build under MSVC.
+
+The installed library is 21.3 MB, which is the trade this design makes:
+ship the compiler and every kernel once, so that nothing is ever built on
+the user's machine. Roughly half of that is the embedded stanc3 and
+somewhat under half is stan-math. The interpreter and NUTS together are
+about 410 KB.
+
+## Status
+
+Early, and deliberately narrow. The sampler is Stan's own NUTS with
+diagonal-metric adaptation. Known limits, stated plainly:
+
+- `sample()` returns declared parameters only. Transformed parameters and
+  generated quantities are computed by the runtime and written by the
+  command line tool, but are not exposed through the Python API yet, so
+  the non-centered eight schools gives you `mu`, `tau`, and
+  `theta_tilde`, not `theta`.
+- No variational inference, no optimization, no multi-chain threading.
+- No convergence diagnostics. Pair it with ArviZ or similar for now.
+
+What is here is verified against CmdStan model by model, and every number
+on this page is reproducible from the repository.
+
+- Source, issues, and roadmap:
+  [github.com/seantalts/stanli](https://github.com/seantalts/stanli)
+- License: BSD-3-Clause, matching Stan's own.

stanli-0.3.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+stanli/LICENSE,sha256=1rSQPamG3JBHPWryYJwX8eNWFCQpIESVpgnjdgBgXeY,1526
+stanli/THIRD_PARTY_LICENSES.md,sha256=KR6DxDOiUX_CAd-JCKAL-5LXivN8C72H-MZfAADC-ic,2071
+stanli/__init__.py,sha256=6lFYuf2lXiCIVPqIQKPhdfVu_mHioS43SC5zNZjmev0,9692
+stanli/_bin/stanc.exe,sha256=5TCCyJXWfWVFWpETWNApeM1bqcH7hkXCcLQ-bNjlcjQ,12322816
+stanli/_bin/stanli.dll,sha256=tVFEK5GzeyBraK7zjSmPdp3yv3XxJH7RlSg2GWyACpc,16671329
+stanli-0.3.0.dist-info/licenses/stanli/LICENSE,sha256=1rSQPamG3JBHPWryYJwX8eNWFCQpIESVpgnjdgBgXeY,1526
+stanli-0.3.0.dist-info/METADATA,sha256=w6sDUwsNuNnmNMQAuGj7w-VAggk7b9n_PGq4ea2HhGc,10739
+stanli-0.3.0.dist-info/WHEEL,sha256=D6hG7Lx54YqYkSprY2f2Fnm_KmrXgxuCq8q_2w9SpLg,98
+stanli-0.3.0.dist-info/top_level.txt,sha256=jDP3ch9Mp2Ug4AO8eePaYqwHMVhcnPKmifI5FZ95a4A,7
+stanli-0.3.0.dist-info/RECORD,,

stanli-0.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (81.0.0)
+Root-Is-Purelib: false
+Tag: py3-none-win_amd64
+

stanli-0.3.0.dist-info/licenses/stanli/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Sean Talts
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

stanli-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+stanli