8 October 2026
How to set up and run a Nixpkgs team
Just do it – it’s simpler than you’d think!
5 September 2024
Adding algebraic data types to Nickel
A recent release of Nickel added algebraic data types and pattern matching. This blog post explains the motivation behind this addition, the design choices made, the considerations around backward compatibility and how ADTs can be useful for a configuration language.
20 June 2024
Nickel modules
Implementing an equivalent to the NixOS module system in Nickel
2 May 2024
The right words in the right place
A report on another 18 months in Nix documentation.
25 April 2024
Re-implementing the Nix protocol in Rust
We re-implemented the nix remote protocol, declaratively
18 April 2024
Cloud Native Computing in 2024—feeling the pulse at Kubecon
We just came out of Kubecon 2024. Here are our impressions of the trends and evolutions in infrastructure, configuration management and cloud native computing
12 March 2024
Software Identifiers through the eyes of Nix
This is an answer to a request for comments issued by CISA about software identifiers that CISA encouraged me to publish as a separate blog post.
29 February 2024
Bazel remote execution with rules_nixpkgs
Creating infrastructure for supporting Bazel remote execution with rules_nixpkgs
28 November 2023
Source filtering with file sets
Introducing the lib.fileset Nix library for easy and safe source filtering
16 November 2023
Organist: stay sane managing your development environments
26 October 2023
nixtract 0.1.0
Building the foundation to analyze your Software Supply Chain in Nix
17 May 2023
Announcing Nickel 1.0
23 February 2023
Taking the pulse of infrastructure management in 2023
We went to FOSDEM23 and CfgMgmtCamp23. Here are my impressions of the trends and evolutions in infrastructure and configuration management
16 February 2023
opam-nix: Nixify Your OCaml Projects
We present opam-nix, show how it helps to easily develop, build and test your OCaml projects with Nix
9 February 2023
Running a NixOS VM on macOS
Make your NixOS development on macOS easier with this simple trick...
2 February 2023
announcing jupyenv 0.1.0
jupyterWith gets a new name and updates.
24 January 2023
Nix with; with Nickel
The Nix `with` keyword is challenging, but we transpiled it to Nickel anyway.
15 December 2022
Bazel and Nix: A Migration Experience
Getting an old Make based project building again after 10 years with the help of Bazel and Nix.
13 December 2022
Optimizing NixOS Search
An internship report on my experience working on improving search.nixos.org and my internship at Tweag
17 November 2022
JupyterWith Next
Announcing the next version of jupyterWith.
1 November 2022
Hard user separation with NixOS
Setup two encrypted partitions with a shared Nix store
11 October 2022
Worry-free NixOS refactors
Comparing Nix input hashes can guarantee that some refactors are bug-free.
29 September 2022
Four months into The Nix Book
A comprehensive report on what happened in four months of dedicated work on Nix documentation, and what I learned from it.
22 September 2022
Building Nix flakes from Rust workspaces
Learn the options for building a Nix flake out of a Rust workspace, outputting a mix of native code and WebAssembly.
13 September 2022
Construction and analysis of the build and runtime dependency graph of nixpkgs
A nixpkgs content database with graph building!
1 September 2022
Unit Test Your Nix Code
Cleanly and seamlessly add unit tests to your nix functions.
25 August 2022
Introducing the Scalable Build Systems Team
Introducing the Scalable Build Systems Team
18 August 2022
Introduction to NixOS specialisations
How and when to use NixOS specialisations to manage different boot environments
4 August 2022
Our roadmap for Nix
Tweag's Nix team plans for the coming years
14 July 2022
Nix – taming Unix with functional programming
Nix is all about applying functional programming to files and processes.
2 June 2022
Smooth, non-invasive Haskell Stack and Nix shell integration
Integrating Haskell Stack and Nix in a smooth yet non-invasive way, with an explanation, example and template.
26 May 2022
Reproducible probabilistic programming environments
How to get reproducible development environments for probabilistic programming packages such as PyMC3, Theano or TensorFlow using Nix.
28 April 2022
Union and intersection contracts are hard, actually
Why union and intersection contracts are hard in a lazy language, and how Nickel handles them.
11 March 2022
First release of Nickel
3 February 2022
Trustix - Consensus and voting
We discuss existing consensus models and why no global consensus mode is well suited to Trustix, opting for a user-defined algorithm instead.
14 January 2022
Trustix - Good things come in trees
In this post we introduce Merkle trees, the data structures needed to make the Trustix log append-only and searchable.
20 December 2021
Nix 2.4 and 2.5
Overview of the new features in Nix 2.4 and 2.5
15 December 2021
21.11 Zero Hydra Failures Moscow Hackathon: Report and Suggestions
Details about the 21.11 Nix Moscow Hackaton, and some suggestions for organizers of similar events.
2 December 2021
Implementing a content-addressed Nix
What had to change in the Nix internals to make it able to build content-addressed derivations?
18 March 2021
Types à la carte in Nickel
A dive into Nickel's gradual type system, which mixes dynamic and static typing
4 March 2021
Announcing Gomod2nix
Better Go packaging with Gomod2nix
17 February 2021
Derivation outputs in a content-addressed world
22 January 2021
Programming with contracts in Nickel
16 December 2020
Trustix: Distributed trust and reproducibility tracking for binary caches
Trustix aims at enhancing trust in software binaries and improve reproducibility tracking using distributed binary caches.
18 November 2020
Self-references in a content-addressed Nix
Why wasn't Nix built with a content-addressed store?
22 October 2020
Nickel: better configuration for less
30 September 2020
Fully statically linked Haskell binaries with Bazel
Bazel gains support for creating fully statically linked Haskell binaries with rules_haskell and rules_nixpkgs.
16 September 2020
Implicit Dependencies in Build Systems
10 September 2020
Towards a content-addressed model for Nix
Why content-addressability is desirable for Nix.
20 August 2020
How Nix grew a marketing team
What do we need to focus on to increase adoption of Nix?
12 August 2020
Developing Python with Poetry & Poetry2nix: Reproducible flexible Python environments
Learn how to use Nix to create highly reproducible Python builds that are aware of native dependencies.
31 July 2020
Nix Flakes, Part 3: Managing NixOS systems
How to manage NixOS systems using Nix flakes.
8 July 2020
Setting up Buildkite for Nix-based projects using Terraform and GCP
How to setup a Buildkite-based CI for Nix projects with workers running on GCP.
25 June 2020
Nix Flakes, Part 2: Evaluation caching
How Nix flakes enable caching of evaluation results of Nix expressions.
18 June 2020
Long-term reproducibility with Nix and Software Heritage
How Nix is collaborating with Software Heritage for long-term software reproducibility.
25 May 2020
Nix Flakes, Part 1: An introduction and tutorial
An introduction to Nix flakes and a tutorial on how to use them.
21 November 2019
Untrusted CI: Using Nix to get automatic trusted caching of untrusted builds
Learn how Nix's new post-build hooks feature can automatically sign and upload artifacts to a binary cache in a trusted way.
28 March 2019
Introducing lorri, your project's nix-env
7 March 2019
Configuring and testing Kubernetes clusters with KubeNix and kind
28 February 2019
JupyterWith: Declarative, Reproducible Notebook Environments
Millions of Jupyter notebooks are spread over the internet - machine learning, astrophysics, biology, economy, you name it. What a great age for reproducible science! Or that's what you think until you try to actually run these notebooks. Then you realize that having understandable high-level code alone is not enough to reproduce something on a computer. JupyterWith is a solution to this problem.
6 February 2019
Mapping a Universe of Open Source Software
The repositories of distributions such as Debian and Nixpkgs are among the largest collections of open source (and some unfree) software. They are complex systems that connect and organize many interdependent packages. In this blog post I'll try to shed some light on them from the perspective of Nixpkgs, mostly with visualizations of its complete dependency graph.
15 March 2018
Nix + Bazel = fully reproducible, incremental builds
10 November 2017
Nix on the Windows Subsystem for Linux
23 May 2017
Typing Nix
9 December 2015