菜单
This skill should be used when the user asks to "devenv", "devenv.nix", "languages.*", "services.*", "git-hooks", "devenv shell", "devenv up", "devenv build", or works with devenv development environments. Provides comprehensive devenv configuration patterns.
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
基于 SOC 职业分类
| name | Devenv Ecosystem |
| description | This skill should be used when the user asks to "devenv", "devenv.nix", "languages.*", "services.*", "git-hooks", "devenv shell", "devenv up", "devenv build", or works with devenv development environments. Provides comprehensive devenv configuration patterns. |
| version | 2.0.0 |
<devenv_20> devenv 2.0 released March 2026 — "A Fresh Interface to Nix" Every devenv command now shows a live terminal interface with structured progress: evaluation status, derivation build/download counts, task execution hierarchy, and auto-expanding error details. Background rebuilds while shell stays interactive. Save a file, devenv rebuilds in background, status line shows progress, Ctrl+Alt+R applies new environment. Errors appear in status line without disruption. Replaced multiple nix CLI invocations with C FFI backend (nix-bindings-rust). Calls Nix evaluator and store directly through C API instead of spawning separate processes. Each evaluated attribute cached individually with tracked file/env dependencies. Only changed attributes re-evaluated. Reference outputs from another devenv project (third most upvoted feature request). <breaking_changes> Native process manager is now the default. Set process.manager.implementation = "process-compose" for old behavior. devenv 0.x is deprecated. Support will be dropped in devenv 3. </breaking_changes> </devenv_20>
Enable language support with defaults languages.python.enable = true;
<pattern name="version_specification">
<description>Specify language version (available for some languages)</description>
<example>
languages.python.version = "3.13";
languages.ruby.version = "3.2.1";
languages.rust.channel = "stable";
</example>
</pattern>
<pattern name="package_override">
<description>Use custom package instead of default</description>
<example>
languages.go.package = pkgs.go_1_26;
languages.java.jdk.package = pkgs.jdk17;
</example>
</pattern>
<pattern name="version_file">
<description>Read version from file (Ruby, Python)</description>
<example>
languages.ruby.versionFile = "./.ruby-version";
languages.python.versionFile = "./.python-version";
</example>
</pattern>
<pattern name="dev_tooling">
<description>Configure LSP, debugger, linter, formatter (devenv 1.8+, enhanced in 2.0)</description>
<example>
languages.rust.dev = {
lsp.enable = true;
debugger.enable = true;
linter.enable = true;
formatter.enable = true;
};
</example>
</pattern>
</common_patterns>
System programming languages (C, C++, Rust, Go, Zig, Nim, Odin, V)<language name="rust">
<example>
languages.rust = {
enable = true;
channel = "stable"; # or "nightly", "beta"
edition = "2024"; # Rust edition (2015, 2018, 2021, 2024)
components = [ "rustc" "cargo" "clippy" "rustfmt" "rust-analyzer" ];
targets = [ "wasm32-unknown-unknown" ];
};
</example>
<output_pattern>
outputs.rust-app = config.languages.rust.import ./rust-app {};
</output_pattern>
</language>
<language name="go">
<example>
languages.go = {
enable = true;
package = pkgs.go_1_26;
};
</example>
<output_pattern>
outputs.go-app = config.languages.go.import ./go-app {};
</output_pattern>
</language>
<language name="c_cpp">
<example>
languages.c.enable = true;
languages.cplusplus.enable = true;
</example>
</language>
<language name="zig">
<example>
languages.zig = {
enable = true;
package = pkgs.zig;
zls.package = pkgs.zls;
};
</example>
</language>
<language name="nim">
<example>
languages.nim = {
enable = true;
package = pkgs.nim;
};
</example>
</language>
<language name="odin">
<example>
languages.odin = {
enable = true;
package = pkgs.odin;
};
</example>
</language>
<language name="v">
<example>
languages.v = {
enable = true;
package = pkgs.vlang;
};
</example>
</language>
<language name="python">
<example>
languages.python = {
enable = true;
version = "3.13";
uv.enable = true;
uv.sync.enable = true;
};
</example>
<poetry_example>
languages.python = {
enable = true;
poetry = {
enable = true;
install.enable = true;
install.allExtras = true;
};
};
</poetry_example>
<output_pattern>
outputs.python-app = config.languages.python.import ./python-app {};
</output_pattern>
</language>
<language name="ruby">
<example>
languages.ruby = {
enable = true;
version = "3.3.0";
bundler.enable = true;
};
</example>
</language>
<language name="php">
<example>
languages.php = {
enable = true;
package = pkgs.php85;
extensions = [ "opcache" "redis" ];
};
</example>
</language>
<language name="perl">
<example>
languages.perl.enable = true;
</example>
</language>
<language name="lua">
<example>
languages.lua.enable = true;
</example>
</language>
<language name="java">
<example>
languages.java = {
enable = true;
jdk.package = pkgs.jdk21;
maven.enable = true;
gradle.enable = true;
};
</example>
</language>
<language name="kotlin">
<example>
languages.kotlin.enable = true;
</example>
</language>
<language name="scala">
<example>
languages.scala = {
enable = true;
package = pkgs.scala_3;
sbt.enable = true;
};
</example>
</language>
<language name="clojure">
<example>
languages.clojure.enable = true;
</example>
</language>
<language name="haskell">
<example>
languages.haskell = {
enable = true;
languageServer = pkgs.haskell-language-server;
stack = {
enable = true;
args = [ "--no-nix" "--system-ghc" "--no-install-ghc" ];
};
};
</example>
</language>
<language name="ocaml">
<example>
languages.ocaml = {
enable = true;
packages = pkgs.ocaml-ng.ocamlPackages_5_1;
};
</example>
</language>
<language name="elixir">
<example>
languages.elixir.enable = true;
</example>
</language>
<language name="erlang">
<example>
languages.erlang.enable = true;
</example>
</language>
<language name="elm">
<example>
languages.elm.enable = true;
</example>
</language>
<language name="purescript">
<example>
languages.purescript = {
enable = true;
package = pkgs.purescript;
};
</example>
</language>
<language name="gleam">
<example>
languages.gleam.enable = true;
</example>
</language>
<language name="idris">
<example>
languages.idris = {
enable = true;
package = pkgs.idris2;
};
</example>
</language>
<language name="lean4">
<example>
languages.lean4 = {
enable = true;
package = pkgs.lean4;
};
</example>
</language>
<language name="unison">
<example>
languages.unison.enable = true;
</example>
</language>
<language name="javascript">
<example>
languages.javascript = {
enable = true;
package = pkgs.nodejs_24;
npm.enable = true;
npm.install.enable = true;
};
</example>
<pnpm_example>
languages.javascript = {
enable = true;
pnpm.enable = true;
pnpm.install.enable = true;
};
</pnpm_example>
<bun_example>
languages.javascript = {
enable = true;
bun.enable = true;
bun.install.enable = true;
};
</bun_example>
<yarn_example>
languages.javascript = {
enable = true;
yarn.enable = true;
yarn.install.enable = true;
};
</yarn_example>
<corepack_example>
languages.javascript = {
enable = true;
corepack.enable = true;
};
</corepack_example>
</language>
<language name="typescript">
<example>
languages.typescript.enable = true;
</example>
</language>
<language name="deno">
<example>
languages.deno.enable = true;
</example>
</language>
<language name="nix">
<example>
languages.nix = {
enable = true;
lsp.package = pkgs.nil; # or pkgs.nixd
};
</example>
</language>
<language name="swift">
<example>
languages.swift.enable = true;
</example>
</language>
<language name="crystal">
<example>
languages.crystal.enable = true;
</example>
</language>
<language name="dart">
<example>
languages.dart.enable = true;
</example>
</language>
<language name="r">
<example>
languages.r.enable = true;
</example>
</language>
<language name="julia">
<example>
languages.julia.enable = true;
</example>
</language>
<language name="fortran">
<example>
languages.fortran.enable = true;
</example>
</language>
<language name="pascal">
<example>
languages.pascal = {
enable = true;
lazarus.enable = true;
};
</example>
</language>
<language name="raku">
<example>
languages.raku.enable = true;
</example>
</language>
<language name="racket">
<example>
languages.racket.enable = true;
</example>
</language>
<language name="standardml">
<example>
languages.standardml.enable = true;
</example>
</language>
<language name="solidity">
<example>
languages.solidity = {
enable = true;
package = pkgs.solc;
};
</example>
</language>
<language name="terraform">
<example>
languages.terraform.enable = true;
</example>
</language>
<language name="opentofu">
<example>
languages.opentofu.enable = true;
</example>
</language>
<language name="ansible">
<example>
languages.ansible = {
enable = true;
package = pkgs.ansible;
};
</example>
</language>
<language name="helm">
<example>
languages.helm = {
enable = true;
languageServer.enable = true;
};
</example>
</language>
<language name="cue">
<example>
languages.cue = {
enable = true;
package = pkgs.cue;
};
</example>
</language>
<language name="jsonnet">
<example>
languages.jsonnet.enable = true;
</example>
</language>
<language name="typst">
<example>
languages.typst = {
enable = true;
fontPaths = [ "${pkgs.roboto}/share/fonts/truetype" ];
};
</example>
</language>
<language name="texlive">
<example>
languages.texlive.enable = true;
</example>
</language>
<language name="gawk">
<example>
languages.gawk.enable = true;
</example>
</language>
<language name="shell">
<example>
languages.shell.enable = true;
</example>
</language>
<language name="robotframework">
<example>
languages.robotframework.enable = true;
</example>
</language>
<language name="vala">
<example>
languages.vala.enable = true;
</example>
</language>
<language name="dotnet">
<example>
languages.dotnet.enable = true;
</example>
</language>
<decision_tree name="language_selection"> What type of project are you building? Use Rust, Go, Zig, or C/C++ Use JavaScript/TypeScript, Python, Ruby, Go, or Rust Use JavaScript/TypeScript with npm/pnpm/bun Use Python with uv or poetry Use Haskell, OCaml, Elixir, or Gleam Use Java, Kotlin, or Scala with gradle/maven/sbt Use Terraform, OpenTofu, Ansible, or Nix </decision_tree>
<decision_tree name="package_manager_selection"> Which JavaScript/TypeScript package manager to use? Match existing lock file (package-lock.json=npm, pnpm-lock.yaml=pnpm, yarn.lock=yarn, bun.lockb=bun) Use pnpm or bun Use npm (most widely supported) Use pnpm or yarn with workspaces Use corepack.enable with packageManager in package.json </decision_tree>
<decision_tree name="devenv_vs_flakes"> Should you use devenv or pure Nix flakes? Use devenv - services.* is simpler Use devenv - git-hooks integration built-in Use devenv - native process manager (2.0 default) or process-compose Use devenv - languages.* handles versions Use flakes - devenv adds overhead Use flakes - devenv is for dev environments </decision_tree>
Background services for development environments services.postgres = { enable = true; package = pkgs.postgresql_16; initialDatabases = [{ name = "myapp"; }]; listen_addresses = "127.0.0.1"; port = 5432; extensions = [ "postgis" "pgvector" ]; settings = { max_connections = 100; }; };<service name="mysql">
<example>
services.mysql = {
enable = true;
package = pkgs.mysql80;
initialDatabases = [{ name = "myapp"; }];
};
</example>
</service>
<service name="mongodb">
<example>
services.mongodb = {
enable = true;
};
</example>
</service>
<service name="redis">
<example>
services.redis = {
enable = true;
port = 6379;
};
</example>
</service>
<service name="memcached">
<example>
services.memcached = {
enable = true;
};
</example>
</service>
<service name="minio">
<example>
services.minio = {
enable = true;
};
</example>
</service>
<service name="elasticsearch">
<example>
services.elasticsearch = {
enable = true;
};
</example>
</service>
<service name="opensearch">
<example>
services.opensearch = {
enable = true;
};
</example>
</service>
<service name="kafka">
<example>
services.kafka = {
enable = true;
};
</example>
</service>
<service name="caddy">
<example>
services.caddy = {
enable = true;
};
</example>
</service>
<service name="varnish">
<example>
services.varnish = {
enable = true;
vcl = ''
vcl 4.0;
backend default {
.host = "127.0.0.1";
.port = "8080";
}
'';
};
</example>
</service>
<service name="mailpit">
<example>
services.mailpit.enable = true;
</example>
</service>
<decision_tree name="service_selection"> What type of storage/service do you need? Use postgres or mysql Use mongodb Use redis or memcached Use minio Use elasticsearch or opensearch Use rabbitmq or kafka Use nginx or caddy Use mailhog or mailpit </decision_tree>
Pre-commit hooks via git-hooks.hooks git-hooks.hooks = { # Formatters nixfmt-rfc-style.enable = true; prettier.enable = true; black.enable = true; rustfmt.enable = true; # Linters
eslint.enable = true;
clippy.enable = true;
shellcheck.enable = true;
# Security
detect-private-keys.enable = true;
check-merge-conflicts.enable = true;
# Git hygiene
check-case-conflicts.enable = true;
editorconfig-checker.enable = true;
};
</example>
<custom_hook>
git-hooks.hooks.my-custom-hook = {
enable = true;
name = "my-custom-hook";
entry = "${pkgs.bash}/bin/bash -c 'echo Running custom hook'";
files = "\\.nix$";
pass_filenames = true;
};
</custom_hook>
<common_hooks>
<hook name="nixfmt-rfc-style">Nix code formatter (RFC style)</hook>
<hook name="prettier">JavaScript/TypeScript/CSS/HTML formatter</hook>
<hook name="black">Python code formatter</hook>
<hook name="rustfmt">Rust code formatter</hook>
<hook name="ormolu">Haskell code formatter</hook>
<hook name="gofmt">Go code formatter</hook>
<hook name="eslint">JavaScript/TypeScript linter</hook>
<hook name="clippy">Rust linter</hook>
<hook name="shellcheck">Shell script linter</hook>
<hook name="yamllint">YAML linter</hook>
<hook name="actionlint">GitHub Actions linter</hook>
<hook name="hadolint">Dockerfile linter</hook>
<hook name="markdownlint">Markdown linter</hook>
<hook name="detect-private-keys">Prevent committing private keys</hook>
<hook name="check-merge-conflicts">Prevent committing merge conflicts</hook>
<hook name="check-case-conflicts">Detect case conflicts in filenames</hook>
<hook name="editorconfig-checker">Check editorconfig compliance</hook>
<hook name="treefmt">Universal formatter via treefmt</hook>
</common_hooks>
# With description
deploy = {
exec = "kubectl apply -f k8s/";
description = "Deploy to Kubernetes";
};
# Using packages
migrate = {
exec = "${pkgs.dbmate}/bin/dbmate up";
description = "Run database migrations";
};
};
</example>
<process_compose_example>
# To use process-compose (no longer the default in 2.0):
process.manager.implementation = "process-compose";
processes = {
web = {
exec = "npm run dev";
process-compose = {
depends_on.api.condition = "process_healthy";
readiness_probe = {
http_get = {
host = "localhost";
port = 3000;
};
};
};
};
api = {
exec = "cargo run";
process-compose = {
readiness_probe = {
http_get = {
host = "localhost";
port = 8080;
path = "/health";
};
};
};
};
};
</process_compose_example>
<dotenv_example>
dotenv.enable = true;
dotenv.filename = ".env.local";
</dotenv_example>
outputs = {
rust-app = config.languages.rust.import ./rust-app {};
python-app = config.languages.python.import ./python-app {};
go-app = config.languages.go.import ./go-app {};
};
}
</example>
devenv.shells.ci = {
languages.python.enable = true;
packages = [ pkgs.git pkgs.buildkit ];
env.CI = "true";
};
devenv.shells.docs = {
packages = [ pkgs.mdbook ];
scripts.build-docs.exec = "mdbook build";
};
}
</example>
profiles = {
"python-3.12".config = {
languages.python.version = "3.12";
};
"python-3.11".config = {
languages.python.version = "3.11";
};
};
}
</example>
<usage>devenv shell --profile python-3.12</usage>
profiles = {
backend.module = {
languages.rust.enable = true;
services.postgres.enable = true;
services.redis.enable = true;
};
frontend.module = {
languages.javascript.enable = true;
languages.typescript.enable = true;
};
fullstack.extends = [ "backend" "frontend" ];
};
}
</example>
user."developer".module = {
packages = [ pkgs.gh ];
};
};
}
</example>
languages = {
javascript = {
enable = true;
package = pkgs.nodejs_24;
pnpm.enable = true;
};
typescript.enable = true;
};
services = {
postgres = {
enable = true;
initialDatabases = [{ name = "app_dev"; }];
};
redis.enable = true;
};
processes = {
frontend.exec = "pnpm dev";
api.exec = "pnpm api:dev";
};
scripts = {
db-migrate.exec = "pnpm db:migrate";
db-seed.exec = "pnpm db:seed";
};
git-hooks.hooks = {
prettier.enable = true;
eslint.enable = true;
};
}
</example>
packages = [ pkgs.nixfmt-rfc-style ];
git-hooks.hooks = {
nixfmt-rfc-style.enable = true;
editorconfig-checker.enable = true;
};
}
</example>
<decision_tree name="configuration_approach"> What type of project are you setting up? Use minimal_config pattern Use full_stack pattern Use nix_project pattern Use profiles with team modules </decision_tree>
<context7_integration> <library_id>/cachix/devenv</library_id> <trust_score>9.7</trust_score> 1354 <usage_patterns> Fetch specific language configuration options Fetch service configuration details Fetch available pre-commit hooks Fetch packaging patterns Fetch profile configuration (1.9+) Fetch devenv 2.0 features and migration guide </usage_patterns> </context7_integration>
<best_practices> Use languages.*.enable instead of adding language packages directly to packages list
Keep enterShell fast; move slow operations to tasks or scripts Use git-hooks for consistent code quality across team Use services.* instead of running databases manually Use dotenv.enable for environment-specific configuration In devenv 2.0, prefer the native process manager (default). Only switch to process-compose if you need advanced features like health checks and dependency ordering. Document scripts with description attribute Use profiles for multi-context development (different language versions, team roles) Use outputs for packaging applications when needed<anti_patterns> Hardcoding specific package versions instead of using version options Use languages..version or languages..package with nixpkgs packages
Using shell commands to install packages instead of using packages attribute Use packages = [ pkgs.package-name ]; for declarative package management Using network-dependent commands in enterShell Use tasks or scripts for network operations; keep enterShell fast and offline-capable Running slow operations in enterShell Use tasks with explicit triggers instead of always running in enterShell Enabling multiple conflicting package managers (npm and pnpm and yarn) Choose one package manager per project (npm OR pnpm OR yarn OR bun) Storing production secrets in env attribute Use dotenv.enable with .env files in .gitignore, or use external secret management Assuming process-compose is the default process manager in devenv 2.0 Native process manager is the default in devenv 2.0. Set process.manager.implementation = "process-compose" explicitly if needed. Using manual shell hooks (e.g. shellHook, .bashrc modifications) instead of enterShell Use enterShell for shell initialization. Use scripts for reusable commands. Use tasks for build-time operations. Hardcoding absolute paths instead of using devenv variables (config.devenv.root, config.env.DEVENV_STATE, config.env.DEVENV_DOTFILE) Use config.devenv.root for project root, config.env.DEVENV_STATE for state directory, and config.env.DEVENV_DOTFILE for the .devenv directory path. Using process-compose directly (e.g. adding process-compose.yaml or running process-compose commands) instead of devenv processes Use processes.* with the native process manager (devenv 2.0 default). For advanced features, set process.manager.implementation = "process-compose" and configure via process-compose attribute on each process. Use devenv languages.* options instead of manually adding language packages Use devenv services.* instead of manual service setup Keep enterShell lightweight and fast In devenv 2.0, native process manager is the default; set process.manager.implementation = "process-compose" explicitly for process-compose Enable git-hooks for code quality enforcement Use scripts for common development commands Document configuration with comments Use profiles for environment variations Understand devenv configuration requirements 1. Identify required languages and their versions Workflow guidance Step completed 2. Determine needed services (databases, caches, etc.) Workflow guidance Step completed 3. Plan background processes and scripts Workflow guidance Step completed 4. Consider team profiles if multi-developer project Workflow guidance Step completed Write devenv.nix configuration 1. Start with minimal configuration (packages, primary language) Workflow guidance Step completed 2. Add services with appropriate settings Workflow guidance Step completed 3. Configure git-hooks for code quality Workflow guidance Step completed 4. Add scripts for common operations Workflow guidance Step completed 5. Set up processes for development servers (native process manager is default in 2.0) Workflow guidance Step completed 6. Add profiles if needed Workflow guidance Step completed Verify devenv configuration works 1. Run devenv shell to verify environment Workflow guidance Step completed 2. Run devenv up to verify processes start Workflow guidance Step completed 3. Test git hooks with sample commits Workflow guidance Step completed 4. Verify scripts work as expected Workflow guidance Step completed<error_escalation inherits="core-patterns#error_escalation"> Missing optional configuration attribute Service configuration incomplete or enterShell too slow Configuration fails to evaluate or services fail to start Security issue in configuration (secrets exposed, unsafe permissions) </error_escalation>
Use devenv languages.* options for language configuration Use devenv services.* for service management Follow project existing devenv patterns if present Be aware that native process manager is the default in devenv 2.0 Hardcoding versions instead of using version options Slow operations in enterShell Mixing multiple conflicting package managers Storing secrets in env attribute Assuming process-compose is still the default process manager<related_skills> Nix language fundamentals, flakes, Home Manager (devenv uses Nix) Symbol operations for navigating devenv configurations Fetch latest devenv documentation </related_skills>
<related_agents> Locate code patterns and references in this skill domain Review implementation quality against this skill guidance Analyze code complexity and suggest refactoring improvements </related_agents>
This skill should be used when the user asks to "write common lisp", "CLOS", "ASDF", "defpackage", "defsystem", or works with Common Lisp, SBCL, or Coalton. Provides comprehensive Common Lisp ecosystem patterns and best practices.
Context7 MCP documentation retrieval patterns for up-to-date library and API references. Use this skill whenever current library docs, API signatures, version-specific behavior, or migration notes are needed.
Base templates for error escalation, decision criteria, and enforcement. Referenced by agents and commands to avoid duplication.
This skill should be used when working with C++ projects, CMakeLists.txt, Ninja, clang-tidy, clang-format, GoogleTest, Catch2, or Modern C++ (C++20/23/26) language patterns. Provides comprehensive C++ ecosystem patterns and best practices.
This skill should be used when the user works with Effect (Effect-TS) — writing or reviewing Effect.Service definitions, Layer composition (Layer.provide/provideMerge/mergeAll), Effect.scoped resource handling, converting imperative try/catch/async code to the Effect error channel, deriving types from Schema (Schema-as-SSOT), or testing Effect code with @effect/vitest, TestClock, and Layer-based mocks. Provides generalized design principles and minimal reference patterns for Effect 3.x.
This skill should be used when the user asks to "write elisp", "emacs config", "init.el", "use-package", ".el file", "emacs lisp", or "magit". Provides comprehensive Emacs ecosystem patterns and best practices. For org-mode, use org-ecosystem skill.