Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/cachix/devenv/llms.txt

Use this file to discover all available pages before exploring further.

devenv ships language modules for more than 50 programming languages. Enabling a language takes a single line in devenv.nix and gives you a complete, ready-to-use toolchain: compiler or runtime, language server (LSP), formatter, and any ecosystem tooling — all at a reproducible version, shared identically across every developer on the team.

​
Enabling a Language

Set languages.<name>.enable = true for any language you want in your environment:
devenv.nix
{ pkgs, ... }:

{
  languages.python.enable = true;
  languages.python.version = "3.11.3";

  languages.rust.enable = true;
  # https://devenv.sh/reference/options/#languagesrustchannel
  languages.rust.channel = "stable";
}
After running devenv shell, the executables for all enabled languages are available: 
$ devenv shell
Building shell ...
Entering shell ...

(devenv) $ python --version
Python 3.11.3

​
Rust

The languages.rust module provides a full Rust development environment including rustc, cargo, clippy, rustfmt, and rust-analyzer.

​
Toolchain channels

devenv supports two toolchain approaches: 
{
  languages.rust = {
    enable = true;
    channel = "nixpkgs"; # uses the Rust version in your nixpkgs pin
  };
}

​
Common Rust configurations

{
  languages.rust = {
    enable = true;
    channel = "nightly";
    components = [ "rustc" "cargo" "clippy" "rustfmt" "rust-analyzer" "miri" ];
  };
}

{
  languages.rust = {
    enable = true;
    channel = "stable";
    targets = [ "wasm32-unknown-unknown" "aarch64-unknown-linux-gnu" ];
  };
}

{
  languages.rust = {
    enable = true;
    toolchainFile = ./rust-toolchain.toml;
  };
}
Example rust-toolchain.toml:
[toolchain]
channel = "stable"
components = ["rustfmt", "clippy"]
profile = "minimal"

{
  languages.rust = {
    enable = true;
    channel = "stable";
    mold.enable = true;   # fastest on Linux
    # lld.enable = true;  # recommended on macOS
  };
}

​
Git hooks integration

Rust tools integrate directly with devenv’s git hooks: 
{
  languages.rust.enable = true;

  git-hooks.hooks = {
    rustfmt.enable = true;
    clippy.enable = true;
  };
}

​
Python

The languages.python module provides Python 3, pip, an optional virtual environment, and Pyright as the default LSP.

​
Basic setup with version pinning

devenv.nix
{
  languages.python = {
    enable = true;
    version = "3.11"; # or an exact pin like "3.11.3"
  };
}
Specific version selection uses nixpkgs-python. Add it to your devenv.yaml inputs:
inputs:
  nixpkgs-python:
    url: github:cachix/nixpkgs-python
    inputs:
      nixpkgs:
        follows: nixpkgs

​
Virtual environments and package managers

{
  languages.python = {
    enable = true;
    venv.enable = true;
    venv.requirements = ./requirements.txt;
  };
}
The virtual environment is stored in $DEVENV_STATE/venv and activated automatically when you enter the shell.

​
Nix-packaged Python dependencies

For packages with complex native dependencies (e.g. tkinter, numpy), use withPackages to bundle them into the interpreter: 
{
  languages.python = {
    enable = true;
    package = pkgs.python3.withPackages (ps: [
      ps.numpy
      ps.tkinter
    ]);
    venv.enable = true;
  };
}

​
JavaScript / Node.js

The languages.javascript module enables Node.js with a TypeScript language server and your choice of package manager.
devenv.nix
{
  languages.javascript = {
    enable = true;
    package = pkgs.nodejs_22; # override Node.js version
  };
}

​
Package managers

{
  languages.javascript = {
    enable = true;
    npm.enable = true;
    npm.install.enable = true; # run npm install on shell entry
  };
}
Enable Node.js Corepack to manage npm, pnpm, and Yarn versions declared in package.json:
languages.javascript.corepack.enable = true;

​
All Available Languages

devenv includes modules for all of the following languages. Enable any of them with languages.<name>.enable = true:

Systems & Low-level

  • c — C
  • cplusplus — C++
  • rust — Rust
  • zig — Zig
  • fortran — Fortran
  • odin — Odin
  • hare — Hare
  • v — V
  • lobster — Lobster

Scripting & Dynamic

  • python — Python
  • ruby — Ruby
  • perl — Perl
  • php — PHP
  • lua — Lua
  • r — R
  • gawk — GNU Awk
  • shell — Shell
  • raku — Raku

JVM & .NET

  • java — Java
  • kotlin — Kotlin
  • scala — Scala
  • clojure — Clojure
  • dotnet — .NET

Functional

  • haskell — Haskell
  • elixir — Elixir
  • erlang — Erlang
  • ocaml — OCaml
  • elm — Elm
  • purescript — PureScript
  • gleam — Gleam
  • standardml — Standard ML
  • idris — Idris
  • lean4 — Lean 4
  • unison — Unison
  • racket — Racket

Web & JavaScript

  • javascript — JavaScript / Node.js
  • typescript — TypeScript
  • deno — Deno
  • dart — Dart

Infrastructure & Config

  • terraform — Terraform
  • opentofu — OpenTofu
  • helm — Helm
  • ansible — Ansible
  • nix — Nix
  • cue — CUE
  • jsonnet — Jsonnet
  • pkl — Pkl

Compiled & Systems

  • go — Go
  • swift — Swift
  • crystal — Crystal
  • nim — Nim
  • pascal — Pascal
  • vala — Vala

Specialised

  • julia — Julia
  • solidity — Solidity
  • robotframework — Robot Framework
  • typst — Typst
  • texlive — TeX Live

Build docs developers (and LLMs) love

Get started for freeTalk to us