Zero dependencies, vendored first

mino's distribution philosophy: drop the runtime into your project, own it, no package manager. A C99 compiler plus libm plus pthreads is the entire build environment; the bundled Clojure stdlib (clojure.string, clojure.set, clojure.math, …) lives in-binary as generated C string literals, so there is no on-disk lib/ path required at runtime.

The promise

mino has no transitive build dependencies. The runtime compiles against the C99 standard library only; the platform layer needs libm (math) and pthreads (concurrency). There is no autotools, no cmake, no meson, no bazel. There is no package manager to invoke, no lockfile to commit, no fetch step in the build.

A version of mino in your vendor tree is bit-identical to the one tagged in this repo, frozen until you re-vendor it. If you ship a binary today and rebuild from the same vendor tree six months from now, you get the same runtime byte-for-byte (subject to the host compiler's own determinism).

Why

Borrowed spirit from SQLite, Odin, sokol, and stb: drop the code into your project, own it, no package-manager surprise. The vendor copy is the source of truth for that build; it does not float, does not auto-update, does not phone home.

Embedded scripting hosts make a load-bearing trade-off at integration time: the cost of evaluating, integrating, and shipping a runtime versus the value the runtime adds. A single-file drop-in collapses the first cost to approximately zero. A build-system dependency, a header include chain, a runtime DLL chain, a locale-or-encoding negotiation – every one of these moves the integration cost upward, often enough to defeat the case for embedding.

The vendored corner

src/vendor/imath/ is the only external code in the runtime tree. imath is a small bignum library; mino needs arbitrary-precision integers, mino vendored imath, mino owns the audit surface. There is no plan to add more vendored libraries: every new Clojure-side namespace ships as bundled mino source in lib/clojure/ (escaped into a C string literal at build time), and every new C primitive is written in mino's own style.

The amalgamation

dist/mino.c and dist/mino.h are produced by ./mino task amalgamate and shipped as release assets alongside the binaries. The amalgamation is a single translation unit: every .c file in the runtime, with project-local #include directives pre-expanded inline, and a single bit-identical copy of src/mino.h for the public header.

# Vendor mino into your project:
cp /path/to/mino/dist/mino.c vendor/mino/
cp /path/to/mino/dist/mino.h vendor/mino/

# Build:
cc -std=c99 -O2 -c vendor/mino/mino.c -o vendor/mino/mino.o
cc app.c vendor/mino/mino.o -lm -lpthread -o app

No -I paths beyond the vendor directory. No build-system dependency. No transitive header chain. The amalgamation is reproducible bit-for-bit from any commit by re-running the task.

What you don't have to think about

• No build-system dependency. Use whatever your project already uses (a one-line Makefile rule, a Cargo.toml [build-dependencies] cc block, an MSBuild step, anything that compiles *.c files).
• No transitive header dependency. mino.h includes only <stddef.h>, <stdint.h>, and <stdio.h> from the C standard library.
• No runtime DLL chain. The amalgamation is statically linkable; the binary you ship has no shared-library runtime dependencies beyond libc, libm, and libpthread.
• No locale / encoding negotiation. mino values are UTF-8 byte sequences; the runtime never reads LANG or LC_* environment variables.
• No threading-library selection by the build. The platform layer is pthreads on POSIX, Win32 on Windows, selected at compile time by the host triple.

Where mino diverges from peers

SQLite is the spiritual cousin for distribution shape: one .c file, one .h file, compile, link, ship. Odin is the cousin for the vendor: mindset: every external dependency lives in the project's own tree, version-pinned by the act of copying it there.

Where mino picks differently:

• The bundled Clojure stdlib moves in lockstep with the runtime. Odin's vendor: packages can float independently; mino's bundled namespaces ride with the runtime tag.
• mino does not ship a package manager. (Odin doesn't either; this is where the two are identical.) mino deps resolves git-fetched dependencies for projects that want them, but the runtime itself needs none.
• The C API is the contract, not the CLI. Lua is the cousin for "I am an embedded scripting engine first." An embedder treats mino the binary as a diagnostic tool — useful for trying things out, never in the production critical path.

Pointers

• Embedding mino in your C project — the canonical first-five-minutes integration.
• C API Reference — every public function, type, and macro in mino.h.
• Dependencies — how the bundled stdlib, on-disk lib/, and git-fetched repos compose via mino deps.
• Release assets — pre-built binaries plus the mino-amalgamation-vX.Y.Z.tar.gz bundle for each tag.