v0.1.0 scheduled for 5 August 2026

Roadmap

v0.1.0 is a useful preview for early adopters, not a declaration that Netsuke is finished. This page tracks what shipped, what is honestly still rough, and the order of the work ahead.

Shipped in v0.1.0

The core build-system compiler is implemented and packaged for Linux, macOS, and Windows. The first public release covers:

Manifest language

  • YAML 1.2 parsing with duplicate-key and schema validation
  • Jinja variables, macros, foreach, when, and globbing
  • Environment helpers, executable discovery, and opt-in network helpers
  • Rules, targets, actions, defaults, and explicit, implicit, and order-only dependencies

Compiler & execution

  • A deterministic build graph with duplicate-output, missing-rule, and cycle checks
  • Ninja generation and execution, plus clean and standalone manifest generation
  • Dependency graphs as Graphviz DOT or self-contained, accessible HTML

Operator experience

  • Layered configuration, localized output, and accessibility preferences
  • Progress reporting, stage timings, and versioned JSON results or diagnostics

Confidence & packaging

  • Unit, behavioural, integration, property, snapshot, and initial Kani verification coverage
  • Packages for Linux (.deb, .rpm), macOS (.pkg), and Windows (.msi)

Known limitations

The compiler pipeline and ordinary local-build workflow are substantial; the command-line interface, configuration vocabulary, and advanced recipe model are still evolving. Pin the Netsuke version in automation and expect some command names, flags, diagnostic schemas, and manifest details to change before 1.0.

Recipes are shell strings; structured executable arguments and recipe environment mappings are not implemented yet.

Literal shell dollar expressions still need Ninja-aware escaping in manifests.

Compiler-generated dependency imports, such as GCC depfiles, are planned but not yet part of the manifest model.

--json emits exactly one versioned result or diagnostic document per command, but the schema may still change before 1.0.

Accessibility, terminal rendering, configuration precedence, and cross-platform compiler invariants need broader verification.

A Netsukefile can execute commands and use impure template helpers. Treat it with the same care as a Makefile: review untrusted manifests before running them. Netsuke quotes supported path substitutions, but it is not a sandbox.

The road ahead

Work after the first release is organized around three phases, each validating one hypothesis. The detailed roadmap tracks the task-level sequence; completed foundations live in a separate archive so the active list stays honest.

Stabilize the command-line contract

Keep a pleasant, accessible local experience while making every command predictable for CI, editors, and agents.

In progress
  • Canonical command and flag names replacing the pre-0.1.0 surface
  • Non-interactive and mutation-safety guarantees (--no-input, --force, --dry-run)
  • Canonical structured --json output with stable exit codes and enumerable errors
  • Bounded output for every large response
  • Assistive-technology verification of accessible output
  • Regression coverage for configuration precedence and terminal rendering

Make recipes safer and clearer

Close the gap between shell-string recipes and a structured, argv-safe recipe model.

In progress
  • Structured exec recipes for argv-safe commands
  • Structured recipe environment mappings
  • Rule-level deps_from for compiler dependency imports (GCC depfiles)
  • Backend dollar escaping after placeholder lowering
  • Clearer feedback when conditional actions are selected

Strengthen confidence

State and check the core compiler invariants strongly enough that future features cannot erode deterministic builds.

Started
  • Kani tooling, CI smoke job, and harnesses for manifest-to-IR safety and cycle canonicalization
  • Kani harnesses for command interpolation
  • Property tests for deterministic Ninja emission, expansion invariants, and render stability
  • Documented placeholder and cycle-detection contracts; evaluation of a minimal Verus proof kernel

Compounding features for humans and agents

Make repeated human, CI, editor, and agent usage improve through introspection, memory, and delivery.

Planned
  • Machine-readable context: netsuke context --json and skill-path
  • A run ledger: runs list, runs get, and runs prune
  • Named profiles with redaction and secret handling
  • Structured artefact delivery and local-first feedback