nixception v0.6.1

nixception 0.6.1

This release fixes two regressions introduced by an unrelated commit back in
July whose "sync tools/ up to the current nixpkgs-fork versions" went
backwards — the nixpkgs fork's copy was actually older, so the sync silently
reverted work that had landed just days earlier. One of the two reverted
pieces (an executable-bit fix) was caught and restored in v0.6.0; these two
were not.

Highlights

• Cache-hit/miss reporting was wrong for every action. The runner had
  stopped writing $out/timing.json, and nixception's cache classification
  treats a missing timing record as proof of a cache hit — so with the file
  never written, every action was reported as cached, regardless of whether
  it actually executed. A freshly cache-cleared, multi-second-long compile
  would print "Execution: none (all actions were cached)" and a 100% hit
  rate. Timing instrumentation (setup/task/wrap-up/nix→runner latency)
  is restored, so both the cache accounting and the "Command execution"
  breakdown in the timing summary are accurate again.
• NIXCEPTION_LOG was not honored. The setup hook had been quietly
  demoted to setting only RUST_LOG, even though the server's own main()
  bridges NIXCEPTION_LOG into RUST_LOG and documents it as taking
  precedence. Anyone with RUST_LOG already set in their environment for
  other tooling would have that value silently used for nixception too,
  instead of NIXCEPTION_LOG. The hook now checks NIXCEPTION_LOG first,
  matching the server's documented precedence.

See the changelog for the full list.

Licensing

The nixception sources are licensed under Apache-2.0. Binary distributions
of the server are additionally governed by GPL-3.0 through the statically
linked nix-compat crate — see NOTICE for full attribution and
licensing details.

Full Changelog: v0.6.0...v0.6.1

nixception v0.6.0

nixception 0.6.0

This release fixes a cache-parity bug: actions built through nix develop
could fail to hit the cache of an otherwise byte-identical action built
through nix build, because of a Nix daemon quirk that had nothing to do
with the actions actually differing.

Highlights

• Discovered /nix/store/… paths are always input sources, never resolved
  to a deriver. Preparing an action's derivation used to ask the Nix daemon
  for each discovered store path's deriver, and reference that deriver
  instead of the path itself when one was found — more precise, but it
  turned out to be unreliable rather than merely unavailable. Inside a
  recursive-nix sandboxed build (every real nix build action goes through
  one), the daemon nixception talks to is Nix's own RestrictedStore, which
  unconditionally strips deriver info from every reply as impure — so a real
  build's actions always resolved paths as plain sources. A caller outside
  that sandbox (nix develop, talking to the host daemon directly) could
  resolve some of the very same paths to derivers instead, giving an
  otherwise identical action a different derivation shape — and hash — than
  the one a real build produced, defeating the cache across that boundary.
  Every discovered path is now an input source, unconditionally: less
  precise, but deterministic from any calling context, with no daemon
  round-trip (and its context-dependent answer) involved.

See the changelog for the full list.

Licensing

The nixception sources are licensed under Apache-2.0. Binary distributions
of the server are additionally governed by GPL-3.0 through the statically
linked nix-compat crate — see NOTICE for full attribution and
licensing details.

Full Changelog: v0.5.0...v0.6.0

nixception v0.5.0

nixception 0.5.0

This release finishes untangling nixception from its NativeLink origins: the
crate is named nixception, the runner's identity is fixed at build time
instead of runtime, and the integration test suite now lives — and runs —
in this repo.

Highlights

• The crate is nixception, not nativelink. Cargo.toml names the
  package after its only binary, and every flake output that used to shadow
  it under the old name is gone. Nothing downstream should have depended on
  the nativelink name, but if you scripted around it, switch to
  nixception.

• The runner is baked into the binary, not passed at start-up. Packaging
  (the nixpkgs nixception package, or this repo's own flake) builds the
  runner first and compiles its store paths directly into the server —
  NIXCEPTION_RUNNER_OUT/NIXCEPTION_RUNNER_DRV are no longer runtime
  configuration. The untested self-build fallback that used to reconstruct
  the runner via nix build at start-up is gone with it.

• NIXCEPTION_EXTRA_SANDBOX_PATHS replaces per-caller runner
  customization. Need a compiler or other tool inside a remote action's
  sandbox? Set this env var (colon-separated /nix/store/… paths) on the
  server process instead of building a custom runner via
  nixceptionHook.withPackages, which no longer exists.

• The integration suite lives here now. recc-smoke-test, recc-hello,
  recc-spdlog, recc-nix, the two Bazel checks, and
  protoc-gen-js-with-nixception moved from the private orchestration
  workspace into checks/ in this repo, and test this repo's own source —
  run them all with nix flake check.

• Fixed a Permission denied regression on actions that execute a tool
  built by an earlier remote action (e.g. Bazel running its own
  remotely-built protoc) — a fix from earlier development had been
  silently lost in a later sync and is now restored.

See the changelog for the full list.

Licensing

The nixception sources are licensed under Apache-2.0. Binary distributions
of the server are additionally governed by GPL-3.0 through the statically
linked nix-compat crate — see NOTICE for full attribution and
licensing details.

Full Changelog: v0.4.0...v0.5.0

nixception v0.4.0

nixception 0.4.0

This release makes nixception usable outside a build sandbox and adds a real
integration test suite around that.

Highlights

• Isolated store support. NIXCEPTION_STORE_ROOT (or the store_root
  config field) relocates the server's store reads to <root>/nix/store/..., so
  nixception can run against an isolated Nix daemon whose physical store lives
  outside the real /nix/store. Paths on the wire and in derivations stay
  logical; it's off by default and inert when unset.

• Standalone integration tests. A new Rust suite spins up a throwaway chroot
  store + isolated daemon, points a standalone nixception at it, drives recc
  compiles, and asserts on the resulting store (a compile lands as a
  -reapi-action path, distinct compiles differ, an identical re-compile is a
  cache hit). This exercises the non-sandbox path and enables store-level
  assertions the derivation-based checks can't. Run with just test-standalone.

• Quieter builds by default. The recurring nixception-hook: mem … cgroup
  memory sampler is now off by default (set NIXCEPTION_DEBUG_MEM=1 to
  re-enable); the on-failure OOM report still runs.

See the changelog for the full list.

Licensing

The nixception sources are licensed under Apache-2.0. Binary distributions
of the server are additionally governed by GPL-3.0 through the statically
linked nix-compat crate — see NOTICE for full attribution and
licensing details.

Full Changelog: v0.3.0...v0.4.0

nixception v0.3.0

nixception 0.3.0

This release focuses on timing and cache observability — making it clear
where time actually goes and how much the Nix cache is saving.

Highlights

• Runner-phase timing. The runner now measures its own setup, task, and
  wrap-up phases and reports them back, so the previously opaque
  "command execution" span is broken down into the time spent in Nix (the
  nix→runner latency: daemon scheduling and sandbox setup) versus the
  runner's setup, the task itself, and wrap-up.

• Honest wall-clock, parallelism, and throughput. The summary no longer
  mislabels the sum of per-action spans as wall-clock. It now reports the real
  elapsed wall-clock separately from cumulative action time, and adds average /
  peak parallelism and throughput (actions per second).

• Cache accounting. Actions served from the Nix cache are now distinguished
  from executed ones. The summary reports the cache hit ratio, the estimated
  time the cache saved, and the resulting speedup.

• Three-section summary. The timing report is reorganized into
  Preparation (common to all actions), Execution (executed actions
  only, so cache hits don't dilute the real-work averages), and Cached
  (hits, with the benefit estimate).

See the changelog for the full list, including the earlier
0.2.x fixes carried into this release.

Licensing

The nixception sources are licensed under Apache-2.0. Binary distributions
of the server are additionally governed by GPL-3.0 through the statically
linked nix-compat crate — see NOTICE for full attribution and
licensing details.

Full Changelog: v0.2.1...v0.3.0

nixception v0.2.1

nixception 0.2.1

nixception is a tool that turns REAPI build-tool actions into Nix builds. This
release makes a bare nixception binary self-sufficient — it now builds its
own runner through the recursive-nix daemon when the runner environment
variables aren't set, so it no longer refuses to start outside the setup hook.
Default logging is also much quieter (per-action and per-request chatter moved
to debug), and the server's log level is now configured with NIXCEPTION_LOG
instead of RUST_LOG.

0.2.1 fixes a build regression that prevented 0.2.0 from producing release
artifacts (the embedded runner sources were dropped by the flake source filter).
See the changelog for the full list.

What's nixception?

nixception turns ordinary build-tool actions into Nix builds, using the Nix
store as a content-addressed cache.

It's a server that speaks the Remote Execution API (REAPI) — the same
protocol used by Bazel,
recc, and other build tools to offload
work to a remote executor. Instead of running each action on a pool of remote
workers, nixception translates every action it receives — a single compiler
invocation, a Bazel rule — into a Nix derivation and realises it through the
recursive-nix daemon.

 build tool ──REAPI──▶  nixception  ──recursive-nix──▶  /nix/store
 (bazel, recc, …)                                       (content-addressed cache)

Because the Nix store is content-addressed, identical actions are built exactly
once and reused across runs, across projects, and across machines that share
the store. The result is a shared, reproducible, deduplicated cache at the
granularity of individual build actions — not just whole packages.

Point any REAPI-speaking build tool at a nixception endpoint and its
fine-grained actions become cacheable Nix builds, with no change to the build
tool itself.

Using it

• Build the server from source with Nix (nix build), or run it from the
  released static Linux binary attached below.
• The intended integration for Nix builds is a nixpkgs setup hook that
  starts the server before a derivation's configure phase and tears it down on
  exit. See the README for details.

Status

nixception is experimental. The server topology, the setup-hook contract,
and the derivation encoding are still evolving; interfaces may change between
releases.

Credits and licensing

nixception is built on top of
NativeLink by Trace Machina, Inc.
and the NativeLink authors, and derives from its last Apache-2.0 licensed
commit. All credit for the underlying build-cache and remote-execution
infrastructure belongs to them.

The nixception sources are licensed under Apache-2.0. Binary distributions
of the server are additionally governed by GPL-3.0 through the statically
linked nix-compat crate — see NOTICE for full attribution and
licensing details.

Full Changelog: v0.2.0...v0.2.1

nixception v0.1.1

nixception 0.1.1

nixception is a tool that turns REAPI build-tool actions into Nix builds. This
patch release trims the published artifacts down to the nixception binary
only; the upstream nativelink binary is no longer redistributed.

What's nixception?

nixception turns ordinary build-tool actions into Nix builds, using the Nix
store as a content-addressed cache.

It's a server that speaks the Remote Execution API (REAPI) — the same
protocol used by Bazel,
recc, and other build tools to offload
work to a remote executor. Instead of running each action on a pool of remote
workers, nixception translates every action it receives — a single compiler
invocation, a Bazel rule — into a Nix derivation and realises it through the
recursive-nix daemon.

 build tool ──REAPI──▶  nixception  ──recursive-nix──▶  /nix/store
 (bazel, recc, …)                                       (content-addressed cache)

Because the Nix store is content-addressed, identical actions are built exactly
once and reused across runs, across projects, and across machines that share
the store. The result is a shared, reproducible, deduplicated cache at the
granularity of individual build actions — not just whole packages.

Point any REAPI-speaking build tool at a nixception endpoint and its
fine-grained actions become cacheable Nix builds, with no change to the build
tool itself.

Using it

• Build the server from source with Nix (nix build), or run it from the
  released static Linux binary attached below.
• The intended integration for Nix builds is a nixpkgs setup hook that
  starts the server before a derivation's configure phase and tears it down on
  exit. See the README for details.

Status

nixception is experimental. The server topology, the setup-hook contract,
and the derivation encoding are still evolving; interfaces may change between
releases.

Credits and licensing

nixception is built on top of
NativeLink by Trace Machina, Inc.
and the NativeLink authors, and derives from its last Apache-2.0 licensed
commit. All credit for the underlying build-cache and remote-execution
infrastructure belongs to them.

The nixception sources are licensed under Apache-2.0. Binary distributions
of the server are additionally governed by GPL-3.0 through the statically
linked nix-compat crate — see NOTICE for full attribution and
licensing details.

Full Changelog: v0.1.0...v0.1.1

nixception v0.1.0

nixception 0.1.0

The first release of nixception.

What's nixception?

nixception turns ordinary build-tool actions into Nix builds, using the Nix
store as a content-addressed cache.

It's a server that speaks the Remote Execution API (REAPI) — the same
protocol used by Bazel,
recc, and other build tools to offload
work to a remote executor. Instead of running each action on a pool of remote
workers, nixception translates every action it receives — a single compiler
invocation, a Bazel rule — into a Nix derivation and realises it through the
recursive-nix daemon.

 build tool ──REAPI──▶  nixception  ──recursive-nix──▶  /nix/store
 (bazel, recc, …)                                       (content-addressed cache)

Because the Nix store is content-addressed, identical actions are built exactly
once and reused across runs, across projects, and across machines that share
the store. The result is a shared, reproducible, deduplicated cache at the
granularity of individual build actions — not just whole packages.

Point any REAPI-speaking build tool at a nixception endpoint and its
fine-grained actions become cacheable Nix builds, with no change to the build
tool itself.

Using it

• Build the server from source with Nix (nix build), or run it from the
  released static Linux binary attached below.
• The intended integration for Nix builds is a nixpkgs setup hook that
  starts the server before a derivation's configure phase and tears it down on
  exit. See the README for details.

Status

nixception is experimental. The server topology, the setup-hook contract,
and the derivation encoding are still evolving; interfaces may change between
releases.

Credits and licensing

nixception is built on top of
NativeLink by Trace Machina, Inc.
and the NativeLink authors, and derives from its last Apache-2.0 licensed
commit. All credit for the underlying build-cache and remote-execution
infrastructure belongs to them.

The nixception sources are licensed under Apache-2.0. Binary distributions
of the server are additionally governed by GPL-3.0 through the statically
linked nix-compat crate — see NOTICE for full attribution and
licensing details.

Full Changelog: https://github.com/layus/nixception/commits/v0.1.0