cachix/devenv

Devenv is a Rust-based development environment manager that uses Nix to provision reproducible, isolated shells with language tooling, services, and processes. It features a native process manager for orchestrating local services with readiness probes, a high-performance TUI for real-time activity tracking, and hot-reload capabilities for shell environments. The system supports multi-host deployment, container image generation, and integrates with AI agents and LSPs for enhanced developer workflows.

98 changes.

This period focused on significantly expanding the project's capabilities by adding support for numerous programming languages, services, and integration modules, alongside introducing new process managers and development tools. Concurrently, the team built a robust testing infrastructure, including a dedicated test runner and comprehensive integration tests, to validate the growing feature set and ensure stability.

146 changes.

This period focused on replacing external dependencies with native Rust implementations for process management, shell sessions, and the terminal user interface. The work introduced a new C-Nix backend, a structured activity tracking system, and comprehensive integration tests to ensure stability across these complex subsystems.

A new example configuration for AWS Vault is introduced in the examples/aws-vault directory. It enables the OpenTofu language support and configures AWS Vault with a default profile, including wrappers for both the AWS CLI and OpenTofu to facilitate infrastructure management.

examples/aws-vault · high confidence

An Android development example has been added to the examples directory. This setup enables the Android environment but explicitly disables the Android Studio integration, and restricts supported systems to x86\_64-linux due to compatibility constraints.

examples/android · high confidence

Introduces a new NixOS module for Apache Traffic Server, allowing users to enable and configure the service via \services.trafficserver\. The module provides options for defining caching rules, hosting configurations, parent proxies, and plugin settings, while generating the necessary configuration files (such as \records.config\, \cache.config\, and \logging.yaml\) from Nix options. It includes sensible defaults for IP access control and logging formats, and uses a writable state directory for runtime data like caches and logs.

src/modules/services/trafficserver · high confidence

This change introduces a new ClickHouse example located in the examples/clickhouse directory. It includes a devenv.nix configuration to enable the ClickHouse service and a test script (.test.sh) that verifies connectivity by running a SELECT query. To address stability issues, the .test-config.yml file explicitly marks aarch64-darwin and x86\_64-darwin as broken systems, effectively disabling the test on these platforms in CI.

examples/clickhouse · high confidence

Introduced a new example configuration for CockroachDB in the examples/cockroachdb directory. The devenv.nix file sets up a CockroachDB service that is explicitly enabled only on Linux hosts (via stdenv.hostPlatform.isLinux) to avoid issues with unprivileged user namespaces in test environments. It uses a custom derivation to install the CockroachDB binary, and the devenv.yaml enables unfree packages.

examples/cockroachdb · high confidence

The examples/elasticmq directory now includes a devenv.nix configuration that enables the ElasticMQ service and defines a test-queue, along with a .test.sh script that verifies the service is running on port 9324, checks the health endpoint, and confirms the test queue is created via the ListQueues API.

examples/elasticmq · high confidence

Introduces a new Phoenix example in the examples/phoenix directory, providing a complete development environment configuration. The setup includes Elixir language support, a local PostgreSQL service, and a process definition to run the Phoenix server. It specifically configures the application to connect to the database via a Unix domain socket rather than TCP, ensuring compatibility across Linux and macOS platforms. The entry also includes necessary setup scripts, test automation, and documentation to guide users through initializing the project.

examples/phoenix · high confidence

Added a new example in the examples/fly.io directory that demonstrates how to containerize and deploy a Python Flask application to Fly.io. The entry includes configuration files (devenv.nix, fly.toml), a sample application (hello.py), and documentation (README.md) guiding users through authentication, container building, and deployment steps.

examples/fly.io · high confidence

Added a new example directory for the Gleam programming language, including configuration files for devenv (devenv.nix, devenv.yaml) to enable the language environment, a test script (.test.sh) that verifies the Gleam toolchain installation, and a .gitignore file to exclude generated project artifacts.

examples/gleam · high confidence

A new Go example has been added to the examples directory, providing a complete development environment setup. This includes a devenv configuration that enables Go version 1.26.3, integrates git-hooks for linting and testing (govet, gotest, golangci-lint), and utilizes gomod2nix for dependency management. The example also defines a basic Go application build structure and necessary input overlays for reproducible builds.

examples/go · high confidence

The examples/vault directory now includes a configuration that enables the HashiCorp Vault service and a test script that verifies the service has started and is responsive by checking the vault version and status.

examples/vault · high confidence

The examples/influxdb directory now includes a devenv.nix configuration that enables the InfluxDB service and a .test.sh script that provisions a v2 instance, creates a default user and bucket, and verifies the setup.

examples/influxdb · high confidence

The examples/javascript directory now includes a devenv.nix configuration that enables the JavaScript language and npm, a .gitignore file to exclude node\_modules and lockfiles, and a .test.sh script that verifies the axios package is available. This provides a standardized, runnable example for JavaScript development using devenv.

examples/javascript · high confidence

A new example for the Lean4 language has been added to the examples directory. This includes a devenv.nix configuration that enables the Lean4 language environment, a .test.sh script to automate building and running a test project using the Lake build tool, and a .gitignore file to exclude the generated test project directory.

examples/lean4 · high confidence

Users can now run a Mailpit email testing server using the provided devenv.nix configuration, which enables the mailpit service, and verify its functionality via the included .test.sh script that waits for the service on port 1025 and sends a test email.

examples/mailpit · high confidence

The examples/mysql directory now includes a devenv.nix configuration that enables the MySQL service (defaulting to MariaDB) and provisions a test\_database with a corresponding user. A new .test.sh script has been added to verify the service is running by attempting a connection using the mariadb CLI client.

examples/mysql · high confidence

The examples/nats directory now provides a configurable NATS service that enables HTTP monitoring, JetStream persistence, and user/password authorization. A new test script (.test.sh) verifies the service is healthy and correctly configured by checking the monitoring endpoints.

examples/nats · high confidence

A new example has been added to demonstrate how to integrate the Nix User Repository (NUR) into a devenv project. This includes a \devenv.yaml\ file that configures the NUR input to follow the main \nixpkgs\ input and apply its default overlay, and a \devenv.nix\ file that shows how to install a package from the NUR repository (specifically \mic92.hello-nur\).

examples/nur · high confidence

A new example in the \examples/overmind\ directory demonstrates how to configure the \devenv\ environment to use the Overmind process manager. This example shows setting the \process.manager.implementation\ to \overmind\ and defining specific process execution commands for \foo\ and \bar\.

examples/overmind · high confidence

Introduces a new example demonstrating how to configure a Python development environment using Poetry within devenv. The setup enables the Python language and Poetry package manager, installs specific dependencies like zlib and pjsua2, and includes a test script to verify that the virtual environment is correctly configured and that packages such as numpy and pjsua2 are importable.

examples/python-poetry · high confidence

A new Racket example has been added to the examples directory, providing a devenv configuration that enables the Racket language and installs bash completion for the raco command. To address known issues, the example includes a test configuration that explicitly disables automated testing on macOS platforms (x86\_64-darwin and aarch64-darwin).

examples/racket · high confidence

Added a new \gemset.nix\ file to the \src/modules/lib/ruby-lsp\ module, defining the specific versions and checksums for Ruby gems required by the Language Server Protocol implementation. This includes core dependencies such as \prism\ (1.8.0), \parser\ (3.3.10.1), \language\_server-protocol\ (3.17.0.5), and \nokogiri\ (1.18.10), ensuring reproducible builds for the Ruby LSP feature.

src/modules/lib/ruby-lsp · high confidence

A new Ruby example has been added to the examples directory, demonstrating how to configure a devenv for Ruby development. The example sets up Ruby 3.4 via a .ruby-version file, enables the Ruby language module, and includes a test script to verify the Ruby version, Puma availability, and Bundler functionality. It also shows how to handle native extension dependencies by including libyaml and conditionally adding libllvm for macOS.

(repo-wide) · high confidence

A new Ruby on Rails example has been added to the examples directory, providing a ready-to-use development environment configuration. The setup includes Ruby 3.4, PostgreSQL, Redis, and necessary system libraries (OpenSSL, libyaml, libpq) to support the Rails application and its gems. It defines a process for running the Rails server on port 3000, which starts after PostgreSQL is ready, and includes a test script that verifies the server is running and that Puma is compiled with SSL support.

examples/rubyonrails · high confidence

A new Rust example has been added to the examples/rust directory, demonstrating how to integrate Rust development with Nix using crate2nix. The example includes a devenv.nix configuration that enables the Rust language toolchain (nightly channel) and imports a local Rust application via config.languages.rust.import. It also configures git-hooks for rustfmt and clippy, and exposes the built application as a package and output. A test script (.test.sh) verifies the setup by running the application and checking that the crate2nix-imported binary is available in the environment.

examples/rust · high confidence

The examples/solidity directory now includes configuration files to enable a local development environment for Solidity smart contracts. Users can now use devenv to automatically provision the Solidity compiler (solc) and the Foundry toolkit (forge, chisel, anvil) for testing and deployment, ensuring consistent tooling versions across different machines.

examples/solidity · high confidence

Introduces a new example configuration for the Starship shell prompt, providing a devenv.nix setup that enables Starship and allows users to define prompt settings (such as the success symbol) directly within the Nix configuration. The example includes a generated starship.toml file and a test script to verify the configuration is correctly applied.

examples/starship · high confidence

A new \tui-replay\ binary has been added to the \devenv-tui\ crate, allowing users to visualize past \devenv\ activity traces in the terminal. The tool reads JSONL trace files and replays the recorded activity events with a configurable speed multiplier (default 1.0) and loop count. It supports a 'reactive' mode where the replay responds to process start/stop commands from the TUI, enabling deterministic testing and debugging of process interactions. Users can also hold the TUI open after the trace drains or attach interrupt prompts as process sessions.

devenv-tui/src/bin · high confidence

The examples/texlive directory now provides a ready-to-use configuration for a TeX Live development environment. Users can enable the TeX Live language support, select a base package set (such as texliveSmall), and include additional packages like latexmk. A test script is included to verify that latexmk is available in the environment.

examples/texlive · high confidence

This change introduces a new example for the Temporal workflow engine. It adds a devenv.nix configuration that enables the Temporal service on port 17233, creates a 'mynamespace' namespace, and configures the state to use SQLite with WAL journaling instead of ephemeral storage. Additionally, a .test.sh script is added to verify the setup by waiting for cluster health and checking the namespace and system status.

examples/temporal · high confidence

A new Terraform project template is now available, providing a pre-configured Nix flake development shell. This setup automatically provisions Terraform version 1.8.4 and enables the terraform-format git hook for code formatting. The template includes a .envrc file that manages the devenv environment using nix-direnv and a .gitignore file to exclude .devenv artifacts, ensuring a consistent and ready-to-use local development experience.

templates/terraform · high confidence

The examples/terraform directory now includes a complete setup for running Terraform 1.8.4. This includes a devenv.nix configuration that enables the Terraform language with version 1.8.4, a devenv.yaml file specifying the nixpkgs-terraform input, and a .test.sh script that verifies the installed Terraform version matches 1.8.4.

examples/terraform · high confidence

Introduces a new example for Traffic Server that includes a \devenv.nix\ configuration and a \.test.sh\ script. The configuration enables the Traffic Server service with a specific proxy hostname (\devenv.test\), configures it to listen on port 8080, and sets logging to stdout/stderr. The test script waits for the service to be ready on port 8080 and performs a curl request to \/nocache/32\, ensuring the development environment is functional.

examples/trafficserver · high confidence

The examples/vala directory now includes a devenv.nix configuration that enables the Vala language. This setup configures the environment to use the default Vala package from the configured Nix channel and restricts the language support to Linux hosts via the stdenv host platform check. It also includes a shell hook to display the installed Vala version upon entering the shell.

examples/vala · high confidence

A new devenv.nix configuration has been added to the examples/wiremock directory, providing a ready-to-use setup for running a WireMock service. This example configures the service to respond to GET requests on the root URL with a 200 status and a "Hello World!" text body, serving as a reference for integrating WireMock into development environments.

(repo-wide) · high confidence

This change introduces a new example in the \examples/claude-agents\ directory that demonstrates a spec-driven development workflow using Claude Code agents. It configures a \devenv.nix\ environment with four distinct agents—\supervise\, \prepare-tasks\, \implement\, and \review-task\—orchestrated to plan, implement, and review code tasks. The example includes a test script (\.test.sh\) to verify agent registration and tool permissions, a test configuration, and a README explaining the feature specification and agent roles.

examples/claude-agents · high confidence

A new Docker-based development container has been added to support devenv workflows. The setup installs Nix and devenv, configures direnv with workspace whitelisting, and includes a custom entrypoint script to manage the nix-daemon startup and resolve permission issues in the /tmp directory.

containers/devcontainer · high confidence

A new example in the examples/overlays directory shows how to configure devenv to use overlays from external inputs (like rust-overlay) and local subflakes. The example configures devenv.yaml to import overlays from these inputs and demonstrates applying an overlay to modify an existing package (hello) within the devenv.nix configuration, including a test to verify the modification.

examples/overlays · high confidence

A new example in the examples/hivemind directory demonstrates the hivemind process manager implementation. It configures two processes (foo and bar) that use explicit exec commands to ensure proper signal handling, illustrating best practices for process management within the hivemind framework.

examples/hivemind · high confidence

Introduces a new httpbin example module that provides a ready-to-use development environment via devenv.nix, configuring the httpbin service to listen on ports 8080 and 8081 on localhost. Includes a test script (.test.sh) to verify the service is running and responding correctly to requests on both ports.

examples/httpbin · high confidence

This change introduces new service modules for Adminer, Blackfire, CockroachDB, CouchDB, DynamoDB Local, ElasticMQ, InfluxDB, Kafka Connect, and HTTPbin, providing declarative configuration for these tools. Additionally, existing services such as Caddy, Cassandra, ClickHouse, Garage, and Elasticsearch have been migrated to use the native process manager, enabling automatic port allocation, configurable readiness probes, and structured process execution.

src/modules/services · high confidence

The devenv-event-sources module now includes new readiness probe implementations (Exec, HTTP, and TCP) that allow the system to wait for specific conditions—such as a command succeeding, an HTTP endpoint returning 2xx, or a TCP port becoming available—before considering a process ready. Additionally, a systemd-style notify socket implementation has been added to support process health monitoring via READY, WATCHDOG, and STATUS messages.

devenv-event-sources · high confidence

Introduces a new example demonstrating how to build a Rust WebAssembly project for Node.js using devenv. The example includes configuration for the Rust toolchain (stable channel, wasm32-unknown-unknown target), integration with git-hooks for clippy and rustfmt, and dependencies like wasm-pack, wasm-bindgen-cli, and binaryen. It provides a simple Rust library that binds to console.log and a test script to verify the build and execution.

examples/rust-wasm-cross · high confidence

The \src/modules/languages\ directory now includes configuration modules for 18 new languages: Ansible, Clojure, CUE, Crystal, Dart, Deno, Fortran, GNU Awk, Gleam, Hare, Helm, Idris, Julia, Kotlin, Lean4, Lobster, Pascal, and Perl. These modules provide language-specific tooling, including default language servers (LSP), compilers, and build tools, allowing users to enable development environments for these languages via the \languages.\<name\>.enable\ option.

src/modules/languages · high confidence

The examples/treefmt directory now provides a complete, runnable example demonstrating how to integrate treefmt with git-hooks. It includes a devenv.nix configuration that enables treefmt with formatters for Nix, Rust, and JSON (via a custom yq-json script), along with a devenv.yaml defining the necessary inputs (git-hooks.nix and treefmt-nix). A test script (.test.sh) verifies the setup by running treefmt and checking the output against an original sample file.

examples/treefmt · high confidence

A new devenv.nix configuration has been added to the examples/couchdb directory, enabling the CouchDB service for local development environments.

examples/couchdb · high confidence

The Helm example now includes a devenv.nix configuration that enables the Helm language and installs the helm-unittest plugin, along with a .test.sh script to verify the plugin's presence, allowing users to develop and test Helm charts locally with unit testing capabilities.

examples/helm · high confidence

The examples/rabbitmq directory now includes a devenv.nix configuration that enables the RabbitMQ service and its management plugin. To resolve a crash on macOS where the default memory monitor fails against hardened-runtime targets, the configuration switches to Erlang's allocator accounting strategy. A new .test.sh script has also been added to verify the service is running and the management API is accessible.

examples/rabbitmq · high confidence

The logos directory now includes four new SVG files: a square dark-background logo, a square light-background logo, a horizontal dark-background logo, and a horizontal light-background logo. These assets provide the brand identity in both orientations and color schemes for use across the product.

logos · high confidence

New example directories for the Bun and Yarn JavaScript runtimes have been added. Each example includes a devenv.nix configuration to enable the respective runtime, a .gitignore file covering standard JavaScript artifacts and lockfiles, and a basic test script to verify environment setup.

examples/javascript-bun, examples/javascript-yarn · high confidence

A new example configuration in \examples/mkcert/devenv.nix\ demonstrates how to use mkcert to generate local TLS certificates for \example.com\ and \another-example.com\. The setup configures Caddy to serve these domains using the generated certificates and provides simple 'Hello, world' responses for each host.

examples/mkcert · high confidence

A new \nix-conf-parser\ library has been introduced to parse the output of \nix config show\ into an ordered map of key-value pairs. This component allows the system to read existing Nix configuration values, enabling features such as skipping cache setup errors when those settings are already configured. The parser handles standard key=value lines, trims comments, and ignores include directives, providing a structured way to access Nix settings within the application.

nix-conf-parser · high confidence

A new example file (examples/overlays/subflake/flake.nix) has been added to demonstrate a subflake overlay. This overlay re-exports the 'hello' package as 'hello2', providing a concrete reference for users implementing similar overlay patterns.

examples/overlays/subflake · high confidence

This change introduces the \devenv-nix-backend\, a new Rust-based component that serves as the default Nix backend for devenv. It communicates with Nix via C++ bindings and maintains an in-process \EvalState\ to cache evaluations across calls within a single run. The backend includes modules for input locking, a wrapper around the Nix C store API, a parser for cached environment JSON, and a client for the Cachix push daemon. It also handles thread safety with the Boehm GC and bridges Nix's activity logger to \tracing\. The associated \devenv.nix\ configuration sets up the necessary Rust language support and dependencies, including the Nix C libraries and Boehm GC.

devenv-nix-backend · high confidence

The repository is initialized with a Rust-based Cargo workspace structure, including a generated Cargo.nix for Nix builds. A comprehensive CLAUDE.md is added to guide AI coding agents with architecture details, build commands, and code style rules. The development environment is configured via .editorconfig, .envrc, and .gitignore, while .gitpod.yml enables immediate cloud-based development. The project license is set to Apache 2.0.

(repo-wide) · high confidence

This change adds the core Nix backend components (\bootstrapLib.nix\, \default.nix\, and \resolve-lock.nix\) that handle resolving the \devenv.lock\ file, processing input nodes (including live local paths and git repositories), and constructing the initial Nixpkgs evaluation environment with proper overlay and license configuration. Users benefit from a more robust and standardized foundation for evaluating devenv configurations, ensuring that input resolution and package environment setup are handled consistently by the new bootstrap library.

devenv-nix-backend/bootstrap · high confidence

The devenv-cache-core module introduces a new shared library for file tracking and caching, featuring a SQLite-backed database layer that automatically handles concurrent initialization locks and gracefully falls back from WAL to DELETE journal mode when shared-memory mapping fails. It also adds file change detection using content hashing (including executable bit awareness for Nix store sources) and standardized error types for cache operations.

devenv-cache-core · high confidence

A new Rust library, devenv-reload, is added to manage shell sessions with hot-reload capabilities. It watches specified files and, upon changes, spawns a new shell in the background and seamlessly swaps to it while preserving terminal state using libghostty-rs. The library exposes a ShellManager API that allows consumers to implement a ShellBuilder trait for custom build logic and receive events for reloads or failures.

devenv-reload · high confidence

A new Rust-based terminal UI (devenv-tui) is introduced, replacing the previous output mechanism with a structured, event-driven interface. This new TUI provides a rich, interactive experience featuring a configurable statusline, inline terminal support for process output, and a fullscreen expanded log view with vim-style navigation, text selection, and OSC 52 clipboard integration. It includes a comprehensive configuration system for user preferences (keybindings, themes, viewport settings) and a robust activity model that tracks builds, downloads, evaluations, and managed processes with real-time status indicators and throttled rendering to minimize idle CPU usage.

devenv-tui/src · high confidence

This change adds several new module capabilities: profiles are now a first-class feature allowing users to define reusable environment configurations that can be extended and activated manually or automatically based on hostname and username; a new \cloud\ module provides structured options for detecting GitHub CI environments (exposing actor, event, ref, repository, and SHA details); and a \changelogs\ module enables modules to declare versioned changelog entries that are aggregated into a single JSON file. Additionally, the \machines\ module introduces NixOS deployment capabilities with health checks, rollback timeouts, and state recovery, while the \cachix\ module is formalized with explicit pull/push options and a warning for older CLI versions.

src/modules · high confidence

The \devenv-processes\ crate now provides a native process manager that replaces the previous implementation, offering granular control over process lifecycle and health. Users can configure readiness probes (exec, HTTP, or systemd notify), define restart policies with rate-limiting windows, and set startup timeouts. The manager supports detached daemon mode (\devenv up -d\) with persistent state, allowing clients to attach later for status, logs, and individual process control (start/stop/restart). On Linux, it includes a privileged capability broker to safely grant specific Linux capabilities to processes without full root access. The system also features a force-exit registry to ensure child process groups are cleaned up even on abrupt termination, and supports socket activation for services.

devenv-processes/src · high confidence

The \devenv-tasks\ module now provides a native Rust-based task runner that replaces the previous shell-based execution model. Users gain declarative task definitions with explicit dependency graphs (supporting \@started\, \@ready\, \@succeeded\, and \@completed\ suffixes), a SQLite-backed cache for \exec\_if\_modified\ patterns to skip unchanged tasks, and a built-in process manager for long-running services. The engine supports hierarchical task names, sudo execution, and integrates with the existing TUI and tracing infrastructure for better visibility into task execution and process lifecycle.

devenv-tasks/src · high confidence

The devenv-proxy now provides a shared reverse proxy for friendly \.localhost\ URLs, allowing multiple local development processes to register routes via a Unix control socket. It defaults to HTTP on port 80, but supports an optional per-process HTTPS listener (enabled via the \--https-listen\ argument) that uses dynamically managed TLS certificates. The proxy validates that upstream routes are loopback-only, handles certificate lifecycle and validation, and ensures that only loopback peers can connect to the low-port listener.

devenv-proxy · high confidence

The \devenv-activity-macros\ crate now provides the \\#\[instrument\_activity\]\ attribute macro, allowing developers to automatically wrap functions with activity tracking. This macro supports specifying activity names, kinds (such as \build\), tracing levels, and argument skipping, simplifying the process of adding observability to devenv operations without manual instrumentation code.

devenv-activity-macros · high confidence

The devenv-activity crate now provides a unified, typed event system for tracking the lifecycle of builds, fetches, evaluations, tasks, commands, and processes. This system uses a task-local stack to maintain parent-child relationships and automatically propagates context across async boundaries. Events are emitted via a dedicated channel for the TUI and mirrored into the tracing layer, where they are serialized efficiently using a zero-allocation bridge to the valuable format. The implementation also includes helpers for trace context propagation to subprocesses and a new \SetExpected\ event to announce aggregate download or build counts.

devenv-activity · high confidence

A new \tokio-shutdown\ crate has been added to manage graceful shutdowns in Tokio-based applications. It provides a \Shutdown\ struct that tracks cleanup tasks via \CleanupGuard\s, ensuring the application waits for registered work to finish before exiting. The crate includes signal handling for graceful termination on the first interrupt (e.g., Ctrl+C) and force-exit on a second interrupt, with a configurable pre-exit hook to restore terminal state or perform critical cleanup. It also offers utilities like \shutdown\_when\_done\ and \cancellable\ to integrate task lifecycle management with the shutdown process.

tokio-shutdown · high confidence

The devenv-eval-cache module now provides a transparent caching layer for Nix evaluation via the FFI backend (NixCBackend). It stores JSON evaluation results in a SQLite database and serves them on subsequent runs when the configuration (NixArgs) and observed inputs—specifically file contents, directory listings, and environment variables—remain unchanged. The cache key is derived from a hash of the serialized NixArgs and the attribute name, while input validation ensures that changes to imported files or environment variables invalidate the cache. Additionally, the system tracks and replays resource allocations (such as port assignments) to maintain consistency when reusing cached evaluation results.

devenv-eval-cache · high confidence

The devenv-mailbox crate now defines the specific message types used for in-process communication between the frontend and backend components. Users benefit from a structured interface for controlling managed processes (start, stop, restart) and managing shell sessions (spawning, file watching, build status updates, and terminal resizing). This establishes the plumbing for coordinating terminal ownership, renderer exit, and interactive backend actions without exposing these internal protocols externally.

devenv-mailbox · high confidence

A new binary entry point for the secretspec component has been added, serving as the executable interface that invokes the underlying secretspec CLI logic.

devenv/src/bin · high confidence

The devenv-nix-backend module introduces a new Rust-based backend for interacting with Nix, featuring structured error diagnostics via miette, a pure-Rust build environment parser to bypass expensive FFI calls on cache hits, and a streaming Cachix daemon client for real-time push progress. It also includes Boehm GC telemetry export over OTLP, proper file limit handling for embedded Nix, and GC root management that supports relocated stores.

devenv-nix-backend/src · high confidence

Added a new example configuration for running PHP with Caddy. The setup enables PHP 8.4 with specific FPM pool settings (dynamic process management) and configures Caddy to serve static files and proxy PHP requests via FastCGI on localhost:8000. It also introduces a dependency on the nix-phps input to manage the PHP environment.

examples/caddy-php · high confidence

Added a new example in the examples/opentelemetry-collector directory that demonstrates an OpenTelemetry Collector setup exporting data to ClickHouse. The configuration includes OTLP receivers, batch processing, and a ClickHouse exporter with a 72-hour TTL for logs, traces, and metrics. The example also sets up a ClickHouse service, creates the necessary database, and includes test scripts to verify the collector's health endpoint, while noting known issues on x86\_64 macOS.

examples/opentelemetry-collector · high confidence

Added a new example configuration that sets up a local development environment with PostgreSQL 16, enabling both the PostGIS and TimescaleDB extensions. The setup preloads the TimescaleDB library and automatically creates the extension in a new database named 'mydb'. A test script is included to verify connectivity by running a simple SQL query against the database.

examples/postgres-timescale · high confidence

This release introduces several new capabilities and architectural improvements. A changelog system is added, allowing users to view new and historical changelog entries with a cache to track what has been shown. An LSP module is introduced to integrate with nixd, providing IDE features like autocomplete and hover documentation for devenv.nix files. Support for the Model Context Protocol (MCP) is added, enabling AI agent integration with tools for searching packages and options, including HTTP transport support. Tracing is significantly enhanced with configurable output formats (JSON, Pretty, Full), multiple trace destinations (stdout, stderr, files), and OpenTelemetry export support. Additionally, automatic HTTPS proxy support is added, using mkcert to generate and manage local certificates for secure process URLs.

devenv/src · high confidence

The examples/scripts directory now includes a complete example showcasing the devenv scripts feature. This example demonstrates how to define custom shell scripts that are automatically added to the development shell's PATH, including support for specifying custom interpreters (like Python or Nushell), loading script content from external files, and declaring private package dependencies for individual scripts. It also shows how to provide descriptions for scripts to generate a help menu upon shell entry and includes tests to verify script execution.

examples/scripts · high confidence

Added a new example in examples/compose that demonstrates how to compose multiple projects using devenv. The setup includes a root configuration importing two sub-projects: projectA (enabling Python) and projectB (enabling Rust). The example is configured to run tests in the actual directory rather than a temporary one to ensure imports work correctly, and the test script verifies that both Python and Cargo are available within the composed environment.

examples/compose · high confidence

A new test runner, devenv-run-tests, is introduced to execute integration tests in isolated temporary directories, ensuring consistent environments across platforms by embedding a Nix-built test environment (test-env.nix) that provides standard tools like git, curl, and jq. The runner supports filtering tests via glob patterns using --only and --exclude flags, allows overriding devenv inputs with --override-input, and reports per-test runtime and shell closure size, including a configurable max\_closure\_size threshold to fail tests that exceed size limits. It also generates JSON metadata for CI integration and supports test configuration via .test-config.yml to control shell usage, git initialization, and system support.

devenv-run-tests · high confidence

A new project template named 'flake' has been added to replace the previous 'simple' template. This template initializes a Nix flake project configured with devenv, including a flake.nix that pulls in the latest rolling nixpkgs and devenv inputs, sets up caching via Cachix, and configures a default development shell that runs the 'hello' command and process. It also includes a .envrc file to automatically load the devenv environment using nix-direnv and a .gitignore to exclude the .devenv directory.

templates/flake · high confidence

This update adds several new integration modules to the \src/modules/integrations\ directory. The Android integration (\android.nix\) provides a configurable SDK environment, supporting both nixpkgs' \androidenv\ and the \android-nixpkgs\ input for newer tool versions. The AWS Vault integration (\aws-vault.nix\) wraps \aws\, \opentofu\, and \terraform\ commands to automatically use \aws-vault\ for credential management. The Claude Code integration (\claude.nix\) adds support for agents, skills, and granular tool permissions. Additionally, new integrations are introduced for \delta\ and \difftastic\ (as git diff tools), \devcontainer\ generation, \gitnr\ for \.gitignore\ generation, \hostctl\ for \/etc/hosts\ management, \mkcert\ for local TLS certificates, \opencode\ configuration, a process proxy, \secretspec\ for secret loading, \starship\ prompt customization, and \treefmt\ for code formatting.

src/modules/integrations · high confidence

Added five new Nix library modules in src/modules/lib to support process management and service configuration. The new ready.nix module defines options for configuring readiness probes (HTTP, exec, systemd notify) with timing and threshold controls. The listen.nix module provides a standardized type for socket definitions (TCP or Unix stream) including address, path, backlog, and permissions. The parse-process-dep.nix module introduces logic to parse process dependency strings with suffix validation (started, ready, completed). The process-manager-types.nix module defines capability contracts and adapter configurations for process managers. The multiverse.nix module adds support for resolving package versions through nixpkgs-multiverse with revision-minimizing pin resolution.

src/modules/lib · high confidence

The process-managers module now supports four additional process managers: hivemind, honcho, mprocs, and a native Rust-based manager, each with their own configuration options and capability profiles. The existing overmind manager has been updated to handle tmux server cleanup on Darwin and uses a dedicated shutdown script to prevent orphaned tmux servers. The process-compose manager now uses unix sockets by default, supports configurable ports, and only exports environment variables when processes are defined.

src/modules/process-managers · high confidence

This change introduces new Cloudflare Worker functions to support interactive documentation features. The \api/generate\ endpoint allows users to request AI-generated development environments by proxying requests to an upstream service, with safeguards for timeouts and response size. The \api/search\ endpoint enables searching packages and options via the MCP protocol, supporting both standard and Server-Sent Events (SSE) responses. Additionally, \api/github\ provides GitHub repository metadata, and a new middleware in \\_middleware.js\ integrates Markdown processing for the documentation site.

functions · high confidence

The tracing subsystem has been rewritten to support multiple simultaneous output destinations (console, file, and OpenTelemetry) via a new \--trace-to\ option. This change introduces a \DevenvLayer\ that emits synthetic start/end events for activity spans, enabling exporters to surface user-friendly messages and total durations. It also adds an \ActivityJsonLayer\ for efficient JSONL export of first-party activity events and integrates OpenTelemetry (OTLP) for exporting traces and Nix GC telemetry. The system now isolates the OTLP exporter's runtime to prevent feedback loops and provides configurable trace formats and filters.

devenv/src/tracing · high confidence

A new \devenv-run-tests\ tool has been added to provide a structured environment for running devenv's integration and example tests. It supports filtering tests via glob patterns, overriding devenv inputs, and configuring test behaviors such as git initialization and temporary directory usage. The harness includes a PTY driver for scripting interactive shell sessions, allowing tests to send input and expect specific outputs, and reports detailed results including test duration and shell closure size.

devenv-run-tests/src · high confidence

The PostgreSQL example has been updated to demonstrate the use of extensions by enabling PostGIS via the \initialScript\ and \extensions\ configuration. Additionally, a new test script (\.test.sh\) has been added to verify the database service is running and accessible using shared shell helpers.

examples/postgres · high confidence

The python-venv example now demonstrates how to enable a Python virtual environment within a devenv shell. By setting \languages.python.venv.enable = true\, the environment ensures that the \python\ and \pip\ commands resolve to the virtual environment binaries located in the state directory, and the \VIRTUAL\_ENV\ variable is correctly set. A test script verifies this behavior, and a README provides usage examples for installing packages like numpy.

examples/python-venv · high confidence

The devenv configuration system now allows importing plain Nix files and entire directories directly, rather than requiring only standard devenv.nix entry points. Users can now specify individual .nix files or folder paths in the imports list within devenv.yaml, enabling more flexible composition of environment configurations.

examples/imports · high confidence

Devenv now supports interactive shell sessions for zsh, fish, and nushell, in addition to the existing bash support. This change introduces a \ShellDialect\ abstraction that generates shell-specific initialization scripts, environment diff helpers, and hot-reload hooks. For fish and nushell, devenv launches a temporary bash process to source the environment and compute diffs before execing into the target shell. For zsh, it uses a custom \ZDOTDIR\ to manage initialization. All dialects support automatic environment reloading at the next prompt and allow users to configure a custom prompt prefix.

devenv-shell/src/dialect · high confidence

The devenv-core library has been restructured to replace the monolithic backend with a generic \Evaluator\ trait and a \Backend\ adapter, allowing for pluggable Nix backends. Configuration is now handled by a new \Config\ struct using the \schematic\ crate, introducing resolved settings structs for Nix, cache, secrets, and shells. The update also adds support for automatic port allocation, a new \require\_version\ field in \devenv.yaml\, and replaces the Nix dotenv parser with the \dotenv-ng\ crate for more reliable environment variable loading.

devenv-core · high confidence

The shell and PTY management logic has been extracted into a new \devenv-shell\ crate, providing a dedicated layer for shell session orchestration, hot-reload support, and terminal handling. This new module introduces a \ShellSession\ that manages the PTY lifecycle, processes escape sequences via \EscapeState\ to track terminal modes (such as alternate screen and DEC private modes), and renders a status line using \iocraft\. It also defines a \protocol\ module for shell commands and events, a \pty\ wrapper for process spawning and exit code reaping, and \keybindings\ for reload and pause actions, effectively separating the interactive shell environment from the main TUI application.

devenv-shell/src · high confidence

The xtask utility now includes dedicated commands to automatically generate and ship project artifacts that were previously handled in production code or manually. Users can now generate JSON schemas for both the main configuration and user settings, produce YAML reference documentation, create man pages, and generate dynamic shell completions for Bash, Zsh, Fish, PowerShell, and Elvish. This centralizes the build-time generation of these resources, ensuring they stay in sync with the current codebase without requiring manual updates.

xtask · high confidence

The CLI command implementations have been extracted from the main entry point into individual modules within the \devenv/src/commands\ directory. This refactoring introduces dedicated files for specific subcommands, including \daemon\_processes\ for the detached process manager, \hook\ for shell auto-activation and trust management, \init\ for scaffolding new projects, \info\ for rendering environment metadata, \inputs\ for managing \devenv.yaml\ inputs, and \version\ for displaying build information. This change improves code maintainability by isolating command logic without altering the user-facing CLI interface.

devenv/src/commands · high confidence

The devenv container image has been reconfigured to run as a non-root user (uid 1000, username 'devenv') instead of root, improving security posture. The image is now built using Nix's \docker.nix\ definition, which allows for custom user/group setup, and includes a cache from \devenv.cachix.org\ to speed up builds. The working directory is set to the user's home directory, and unnecessary packages like Perl and Python support in Git have been removed to reduce image size.

containers/devenv · high confidence

The devenv-shell now includes a dedicated escape sequence parser that correctly handles DEC private modes, OSC sequences, and various terminal queries. This ensures that terminal features such as mouse tracking, bracketed paste, focus events, alternate screen buffers, and synchronized output are properly forwarded to the host terminal. Additionally, the shell now supports in-band resize opt-in, forwards DA1 (Primary Device Attributes) queries, handles cursor position requests, and preserves non-query OSC sequences, resulting in more accurate terminal behavior and compatibility with complex TUI applications.

devenv-shell/src/escape · high confidence

The supported-languages example now includes configuration for additional programming languages, specifically adding support for Shell, JSONnet, Pascal, Hare, and Deno, while also enabling existing languages like Ansible, Gleam, and Helm. To ensure stability across different environments, the example introduces platform-specific overrides that disable certain languages (such as Odin, Swift, and Lobster) on incompatible platforms like macOS or aarch64-linux, and includes a dedicated patch script to manage these conditional enables.

examples/supported-languages · high confidence

The devenv-reload module now supports hot-reloading the shell environment without respawning the shell process. Instead of restarting the shell, the coordinator builds the new environment into a pending file, which is then applied by the shell via a PROMPT\_COMMAND hook. This change includes a new ShellBuilder trait to define build and reload logic, a Config struct to manage watched files and the reload state file, and a ShellCoordinator to orchestrate file watching and build events.

devenv-reload/src · high confidence

The devenv core has been refactored to replace the legacy NixRust backend with a new C-Nix (NixC) backend, which powers the new \devenv machines\ multi-host deployment feature (including SSH-based plan analysis and impact reporting) and the new \devenv container\ commands for building and copying container images. This change also introduces a new \cachix.rs\ module for runtime Cachix integration (daemon management, key caching, and push/pull configuration), a \dotenv.rs\ module for loading and merging \.env\ files into the shell environment, and a \gc.rs\ module for garbage collecting old devenv environments. The \search.rs\ module now uses the C-Nix backend to search for packages and options, and the main \mod.rs\ has been restructured to support these new capabilities, including AI agent detection and improved process/task management.

devenv/src/devenv · high confidence

The MongoDB example has been updated to automatically create an initial root user ('mongouser') upon service startup. This is configured in devenv.nix by setting initDatabaseUsername and initDatabasePassword, and the setup is verified by a new test script that checks for the user's existence and service availability.

examples/mongodb · high confidence

The processes example now uses native process dependencies instead of the external process-compose tool. A new devenv.nix configuration defines a server process (running a Python HTTP server) and a worker process that starts only after the server is ready, establishing a clear startup order. Additionally, a .test.sh script has been added to verify the setup by waiting for processes and curling the server endpoint.

examples/processes · high confidence

The Python language module now uses a new initialization script that supports both standard venv and the uv tool (via cfg.uv.enable), ensuring the correct interpreter is used and requirements are reinstalled when changed. A custom sitecustomize.py is introduced to preserve NIX\_PYTHONPATH in subprocesses, fixing issues where Python tools calling other Python tools failed to find dependencies. Additionally, a .pth file mechanism is added to make Nix profile packages importable within venvs while maintaining venv package priority, and the post-build wrapper is updated to resolve argv0 correctly for symlinked executables.

src/modules/languages/python · high confidence

The Python example has been updated to allow specifying the Python version (set to 3.11.3) and to accept a local file path for the virtual environment requirements (pointing to ./requirements.txt). This change modifies the devenv.nix configuration to use these new settings and includes a test script that verifies the correct Python version is active and the requests library is importable.

examples/python · high confidence

The R example environment has been updated to enable the radian console by default via the devenv configuration. A new test script verifies that radian is available and that the languageserver package is installed, ensuring the example environment is functional for interactive R development.

examples/r · high confidence

The devenv shell hooks for bash, zsh, fish, and nushell have been refactored to prevent redundant nested devenv shells when one is already active (via DEVENV\_ROOT checks) and to ensure the hook-spawned shell terminates correctly when the user changes directory outside the project. The implementation now uses a non-exported guard variable (\_DEVENV\_HOOK\_DIR) to distinguish hook-spawned shells from other environments, preventing variable leakage into descendant shells. Additionally, the hooks now follow the user's directory change after exiting a devenv shell, updating the activation state to allow re-activation upon returning to the project directory, and fish users retain directory history during this process.

devenv/hooks · high confidence

When devenv detects changes and triggers a hot-reload, it now re-executes enterShell tasks (such as those defined in the \files\ option) and updates their environment exports. This ensures that files generated by these tasks are refreshed and their environment variables (like updated PATH entries) are immediately available in the live shell, matching the behavior of a fresh shell entry.

devenv/src/reload · high confidence

The simple example now uses a streamlined configuration structure, replacing the previous devenv.yml with devenv.yaml to define the Nixpkgs input, and introducing devenv.nix to explicitly set environment variables, packages, and scripts. A new .envrc file has been added to integrate with direnv, automatically loading the devenv environment when entering the directory, while .gitignore is updated to exclude devenv-specific artifacts.

examples/simple · high confidence

The devenv tool now uses a streamlined \devenv direnv-export\ command within the \direnvrc\ script, simplifying how the development environment is exported and reducing complexity in shell hook generation. Additionally, a new \build.rs\ script embeds build-time metadata, including the git revision, system architecture, and release status, into the binary to provide more accurate version output and improve build reproducibility.

devenv · high confidence

The Nix build system now supports fully static (musl) builds of devenv, addressing runtime segfaults on musl hosts by enforcing non-PIE code generation and ensuring build scripts link against the correct glibc toolchain. To resolve binary-cache non-determinism caused by randomized hash-map iteration in the \pest\_consume\ macro, a patch is applied to sort generated parser code. Additionally, the build configuration has been updated to use \crate2nix\ for managing Rust crate overrides, including specific linker adjustments for static linking against Nix C libraries and Boost.

nix · high confidence

The files generated by the \devenv init\ command have been refreshed to provide a more comprehensive starting point. The new \devenv.nix\ template now includes examples for environment variables, packages, shell scripts, and test execution via \enterTest\, alongside commented-out sections for languages, processes, services, and git hooks. The \devenv.yaml\ configuration has been updated to reference the \devenv-nixpkgs\ rolling input by default and includes documentation comments for options like \allow\_unfree\ and \allow\_unsupported\_system\. Additionally, a new \envrc\ file is generated to handle direnv integration, and the \.gitignore\ has been expanded to exclude devenv-specific artifacts and pre-commit configurations.

devenv/init · high confidence

The flake-parts template now includes a .envrc file that sources nix-direnv version 3.1.0 and explicitly manages the devenv root path via a .devenv directory and a root file, ensuring consistent environment loading. The template's flake.nix has been updated to include the devenv flakeModule import and configure nixConfig with the devenv cachix substituters, while .gitignore is added to exclude the .devenv directory.

templates/flake-parts · high confidence

The Varnish example has been rewritten in Rust, replacing the previous implementation. To address platform compatibility issues, a test configuration has been added to restrict execution to Linux systems (aarch64 and x86\_64), acknowledging that Varnish is poorly tested on macOS. The example now includes a unified test script that validates the setup by comparing responses from a local Caddy server against the Varnish service, ensuring they match before marking the test as passed.

examples/varnish · high confidence

The devenv-tasks binary is now built using the specific nixpkgs version locked in flake.lock rather than the user's potentially different nixpkgs. This ensures that the resulting store path matches the pre-built binary cached on devenv.cachix.org, fixing reproducibility issues where local builds would fail to find the cached artifact due to path mismatches.

src/modules/tasks · high confidence

The simple-remote example now correctly inherits environment variables from the base simple example. The devenv.yaml imports the simple example, and devenv.nix defines GREET2, ensuring the test script can verify both GREET and GREET2 are present in the environment.

examples/simple-remote · high confidence

The \\#\[nix\_test\]\ attribute macro now wraps async test functions to ensure that Tokio worker threads are registered with the Boehm garbage collector before execution. This prevents race conditions during parallel garbage collection by guaranteeing that all threads modifying memory are properly paused during stop-the-world collection phases, thereby stabilizing test runs that interact with Nix's parallel marking system.

devenv-nix-backend-macros · high confidence

Add CLI integration tests for flake, flake-parts, and init workflows; Add deterministic replay fixtures for TUI configuration and activity tracing; Add test infrastructure for the Garage example; Added Kafka integration test infrastructure; Added Keycloak certificate test fixtures and configuration; Added Meilisearch development environment configuration; Added MySQL integration tests; Added OpenSearch test configuration and environment setup; Added PTY-based smoke tests and Rust session tests for devenv-shell; Added Perl test environment with Mojolicious and Text::Markdown::Hoedown; Added closure size regression tests for devenv; Added comprehensive integration tests for the tasks subsystem; Added comprehensive test suite for profiles feature; Added comprehensive test suite for the machines subsystem; Added comprehensive test suite for the task execution engine; Added comprehensive tests for dotenv parsing, precedence, and task integration; Added deterministic PTY replay and property-based tests for TUI stability; Added end-to-end fuzzing for the TUI using Bombadil; Added end-to-end tests for \devenv tasks run\ process and task chains; Added integration test for automatic port allocation; Added integration test for the RustFS service; Added integration tests for PostgreSQL service configurations; Added integration tests for Prometheus service; Added integration tests for Python package importability and venv priority; Added integration tests for SecretSpec configuration and provider resolution; Added integration tests for direnv environment management; Added integration tests for flake locking and Nix backend operations; Added integration tests for gitignore generation; Added integration tests for process cleanup on owner exit; Added integration tests for process startup, dependencies, and readiness; Added integration tests for the OpenCode module; Added integration tests for the devenv CLI; Added integration tests for the devenv process manager; Added lifecycle and capability tests for process managers; Added monorepo test suite for devenv import resolution; Added multiverse package version tests; Added regression test for CA derivations environment output; Added regression test for CLI and module compatibility; Added regression test for git hooks in subdirectory roots; Added regression test for missing input error handling; Added regression test for syntax error reporting; Added regression tests for Python uv integration; Added regression tests for dynamic process port allocation across repositories; Added regression tests for shell hook behavior and robustness; Added shared test utilities for devenv-processes integration tests; Added test coverage for Garage named bucket creation; Added test coverage for JavaScript environment configurations; Added test coverage for Python native libraries using uv; Added test coverage for Python native libraries with Poetry; Added test coverage for Python native library integration; Added test coverage for Python uv dependency groups; Added test coverage for Python withPackages and virtual environments; Added test coverage for devenv configuration merging and environment variable handling; Added test coverage for nixpkgs configuration options; Added test coverage for process task failure and dependency propagation; Added test coverage for soft-failure task dependencies; Added test coverage for the --impure option; Added test coverage for the clean environment variable stripping feature; Added test coverage for treefmt integration; Added test environment for Ruby documentation generation; Added test fixture for complex task dependencies and execution conditions; Added test fixtures for uv2nix Python packaging integration; Added test for @completed dependency execution with start.enable=false; Added test for CLI command exit code propagation; Added test for Cachix public key fetching; Added test for PostgreSQL PGHOST and listen\_address configuration; Added test for Python subprocess package importability; Added test for RUSTDOCFLAGS extension; Added test for Rust toolchain file configuration; Added test for alternate-screen input handling on Darwin; Added test for cachix.pull deduplication; Added test for cargo subcommand path precedence; Added test for concurrent cold shell initialization; Added test for git.root configuration; Added test for inputsFrom option; Added test for local path input cache invalidation; Added test for non-fatal task failures before shell entry; Added test for permitted\_unfree\_packages configuration; Added test for pre-commit Python path leakage; Added test for process watch restart and capability preservation; Added test for process-compose interactive process handling; Added test for profile output selection and collision avoidance; Added test for removing .pre-commit-config.yaml when all hooks are disabled; Added test for shell environment variable propagation; Added test for short-lived process completion under process-compose; Added test for task execution order relative to processes; Added test for unversioned devenv.nix support; Added test for uv sync allGroups configuration; Added test infrastructure and configuration for sqld service; Added test infrastructure for Python directory example; Added test suite for Kafka Connect readiness; Added test suite for Python uv sync and uv2nix integration; Added test suite for Redis Unix socket connectivity; Added test suite for direnv and secretspec integration; Added test suite for glibc locales; Added test suite for the changelog system; Added test to verify ZIG\_GLOBAL\_CACHE\_DIR validity; Added test to verify man page resolution via MANPATH; Added tests for .NET globalization and LD\_LIBRARY\_PATH handling; Added tests for CLI option overrides; Added tests for CLI subdirectory discovery; Added tests for Claude Code skill frontmatter options; Added tests for PTY session management; Added tests for PostgreSQL socket-only configuration; Added tests for Rust clang linker driver configuration; Added tests for container base image support; Added tests for container copyToRoot functionality; Added tests for custom and default macOS SDK configuration; Added tests for daemon lifecycle and orphan prevention; Added tests for devenv.local.nix loading in imported directories; Added tests for devenv.yaml import configuration merging; Added tests for eval cache behavior in git and non-git repositories; Added tests for file copy and seed modes; Added tests for files feature cleanup and format support; Added tests for git-hooks installation caching; Added tests for git-hooks with custom core.hooksPath configurations; Added tests for interactive process attach and dependency scheduling; Added tests for package profile priority resolution; Added tests for primary and sub-agent reporting in devenv info; Added tests for process manager attach and lifecycle behavior; Added tests for process-compose manager compatibility; Added tests for process-compose merge logic and shutdown behavior; Added tests for task execution and environment variable handling; Added tests for the \devenv eval\ command; Added tests for the outputs feature; Added tests for tracing auto-activation scenarios; Added tests for treefmt ordering and atomic file copying; New shared test utilities for the NixC backend; Snapshot tests for devenv-shell TUI states and output; Updated TUI snapshot tests for new rendering behaviors.

The project has upgraded its Rust edition from 2021 to 2024 across the entire workspace, as defined in the root \Cargo.toml\. This change is accompanied by a version bump of the devenv package to 2.4.1. The update also includes synchronization of the \Cargo.lock\ file to reflect the new edition and any associated dependency adjustments.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 66 → 62 (-3.3)
• Rubric changed (rubric-2026.09.9 → rubric-2026.09.17) — scores are not directly comparable.

• Code Health 84 → 61 (-22.4)
• Architecture 100 → 67 (-33.0)
• Maturity 74 → 76 (+1.2)
• Readiness 74 → 69 (-5.2)
• Security 51 → 63 (+11.5)
• Event Sourcing 100 → 100 (+0.0)
• Performance 60 (new)

• Documentation: no installation or build instructions (README.md)
• Hotspot: devenv-core/src/nix_args.rs (devenv-core/src/nix_args.rs)
• Hotspot: devenv-nix-backend/src/cachix_daemon.rs (devenv-nix-backend/src/cachix_daemon.rs)
• Hotspot: devenv-processes/src/capabilities.rs (devenv-processes/src/capabilities.rs)
• Hotspot: devenv-processes/src/log_tailer.rs (devenv-processes/src/log_tailer.rs)
• Hotspot: devenv-processes/src/process_scope.rs (devenv-processes/src/process_scope.rs)
• Hotspot: devenv-processes/src/supervisor_state.rs (devenv-processes/src/supervisor_state.rs)
• Hotspot: devenv-shell/src/escape/mod.rs (devenv-shell/src/escape/mod.rs)
• Hotspot: devenv-tasks/src/native_manager.rs (devenv-tasks/src/native_manager.rs)
• Hotspot: devenv-tasks/src/task_cache.rs (devenv-tasks/src/task_cache.rs)
• Hotspot: devenv-tasks/src/ui.rs (devenv-tasks/src/ui.rs)
• Hotspot: devenv-tui/src/config.rs (devenv-tui/src/config.rs)
• Hotspot: devenv-tui/src/model.rs (devenv-tui/src/model.rs)
• Hotspot: docs/src/lib/landing-environment-core.ts (docs/src/lib/landing-environment-core.ts)
• Hotspot: xtask/src/config_docs.rs (xtask/src/config_docs.rs)
• No ADRs found
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #2
• TodoComment (devenv-core/src/config.rs)
• TodoComment (devenv-core/src/config.rs)
• …and 12 more

• Devenv::apply_machine_plan (cognitive 31) (devenv/src/devenv/machines.rs)
• Devenv::apply_machine_plan (cyclomatic 17) (devenv/src/devenv/machines.rs)
• Devenv::install_one_machine (cognitive 24) (devenv/src/devenv/machines.rs)
• Devenv::install_one_machine (cyclomatic 21) (devenv/src/devenv/machines.rs)
• Devenv::machines_install (cognitive 95) (devenv/src/devenv/machines.rs)
• Devenv::machines_install (cyclomatic 45) (devenv/src/devenv/machines.rs)
• Devenv::machines_plan (cognitive 29) (devenv/src/devenv/machines.rs)
• Devenv::machines_plan (cyclomatic 16) (devenv/src/devenv/machines.rs)
• Devenv::new (cognitive 17) (devenv/src/devenv/mod.rs)
• Devenv::new (cyclomatic 16) (devenv/src/devenv/mod.rs)
• Devenv::resolve_launch_processes (cognitive 17) (devenv/src/devenv/mod.rs)
• Duplicate type definitions Input and FlakeInput with nearly identical structures (url, follows, inputs, flake). This suggests a lack of polymorphism or a shared base trait/interface where one should likely be an enum variant or a generic struct.
• Duplicated block (12 lines × 2) (devenv-nix-backend/src/build_environment.rs)
• Duplicated block (15–17 lines × 2) (devenv/src/devenv/machines.rs)
• Duplicated block (19 lines × 2) (devenv/src/devenv/machines.rs)
• Duplicated block (7 lines × 4) (devenv/src/devenv/machines.rs)
• Duplicated block (9 lines × 2) (devenv/src/devenv/machines.rs)
• Duplicated block (9 lines × 2) (devenv/src/devenv/machines.rs)
• Executor.start (cognitive 28) (src/modules/machines/deploy.py)
• Executor.start (cyclomatic 25) (src/modules/machines/deploy.py)
• …and 46 more

• 43 commits — 20 feature/other, 23 fixes

• docs/src — 11 commits
• (root) — 10 commits
• src/modules — 4 commits
• .github/workflows — 2 commits
• devenv-shell/src — 2 commits
• devenv/src — 2 commits
• devenv-run-tests/src — 1 commit
• devenv-shell/tests — 1 commit
• devenv-tasks/src — 1 commit
• docs/astro.config.mjs — 1 commit
• docs/scripts — 1 commit
• examples/claude-agents — 1 commit
• tests/dotnet — 1 commit
• tests/files-treefmt-order — 1 commit
• tests/mysql-named-up — 1 commit
• tests/postgres-allocated-port-shell — 1 commit
• tests/process-compose-interactive — 1 commit
• tests/reload-alternate-screen-input — 1 commit

• fix: fix(ci): update docs generator to devenv 2.3.1 (#3218)
• fix: fix(cli): fix a regression where quoted commands failed with "not found"
• fix: fix(cli): fix regression handling quoted commands in devenv shell
• fix: fix(docs): correct edit page links
• fix: fix(dotnet): preserve inherited LD_LIBRARY_PATH (#3180) (#3209)
• fix: fix(examples): prevent npm from installing uncompatible pnpm
• fix: fix(files): order treefmt after devenv:files, copy atomically (#3173)
• fix: fix(fish): exit hook shell on cd before prompt (#3210)
• fix: fix(hook): use command env in fish hook (#3223)
• fix: fix(javascript): support new pnpm nodejs override (#3195)
• fix: fix(lsp): prevent duplicate Nix store registration in bundled nixd (#3213)
• fix: fix(mcp): release evaluation memory after cache initialization (#3200)
• fix: fix(mysql): run configuration when MySQL starts (#3219)
• fix: fix(opentofu): default lsp.package to tofu-ls (#3225)
• fix: fix(rustfs): use rustfs from nixpkgs (#3144)
• fix: fix(shell): don't panic printing the final error to a dead terminal
• fix: fix(shell): preserve structured Nushell env on reload (#3231)
• fix: fix(shell): resolve allocated ports from running manager (#3211)
• fix: fix(tasks): add wantedBy for shell entry and Garage setup (#3207)
• fix: fix(tasks): reject task names containing "::" (#3228)
• …and 23 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

cachix/devenv was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.