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
14 July 2022
Nix – taming Unix with functional programming
Nix is all about applying functional programming to files and processes.
2 June 2022
Stack and Nix 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
Why union and intersection contracts are hard in a lazy language, and how Nickel handles them.
11 March 2022
First release of Nickel
I am excited to announce the first release of Nickel! In the original introductory blog post, I’ve written about why we, at Tweag, are developing yet another configuration language. Our goal is to empower people to write correct, programmable and maintainable configurations…
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
In this post we introduce Merkle trees, the data structures needed to make the Trustix log append-only and searchable.
15 December 2021
21.11 Zero Hydra Failure Moscow report
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
17 February 2021
Derivation outputs in a content-addressed world
This is another blog post on the upcoming content-addressed derivations for Nix. We’ve already explained the feature and some of its advantages, as well as the reasons why it isn’t easy to implement. Now we’re going to talk about about a concrete user-facing change that this…
22 January 2021
Programming with contracts in Nickel
Presenting Nickel: better configuration for less Programming with contracts in Nickel Types à la carte in Nickel In a previous post, I gave a taste of Nickel, a configuration language we are developing at Tweag. One cool feature of Nickel is the ability to validate data and…
16 December 2020
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
Presenting Nickel: better configuration for less Programming with contracts in Nickel Types à la carte in Nickel We are making the Nickel repository public. Nickel is an experimental configuration language developed at Tweag. While this is not the time for the first release yet…
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
In making a build system for your software, you codified the dependencies between its parts. But, did you account for implicit software dependencies, like system libraries and compiler toolchains? Implicit dependencies give rise to the biggest and most common problem with…
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
Learn how to use Nix to create highly reproducible Python builds that are aware of native dependencies.
31 July 2020
Nix Flakes (3): Managing NixOS systems
How to manage NixOS systems using Nix flakes.
8 July 2020
Setting up Buildkite for Nix-based projects
How to setup a Buildkite-based CI for Nix projects with workers running on GCP.
25 June 2020
Nix Flakes (2): Evaluation caching
How Nix flakes enable caching of evaluation results of Nix expressions.
18 June 2020
Nix and Software Heritage
How Nix is collaborating with Software Heritage for long-term software reproducibility.
25 May 2020
Nix Flakes (1): Introduction
An introduction to Nix flakes and a tutorial on how to use them.
21 November 2019
Untrusted CI using Nix
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
Today we’re excited to announce lorri, a new tool for NixOS, Linux, and macOS that makes developing with Nix even nicer: When people try lorri, we often hear that it is more magical than they expected. What is lorri? lorri is a nix-shell replacement for project development…
7 March 2019
Kubernetes, KubeNix and kind
In a recent project I was tasked with creating a local testing environment for a Kubernetes cluster the client was actively working on. The main requirements were: Cross platform: It should work on Linux and macOS. Ease of use: The setup should be easy to use. Suitable for CI…
28 February 2019
Declarative, Reproducible Jupyter 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
This is the second post in our series about building polyglot projects using Bazel. You might find it useful to start with our first installment. A is an extraordinary thing. You specify a set of targets, you tell Make what the dependencies are between these targets, and Make…
10 November 2017
Nix on the Windows Subsystem for Linux
Nix on Windows: does it run yet? That’s the question I wondered about while testing the latest NixOS release, version 17.09. To that end, I had the idea of running the Nix installation process from inside the Windows Subsystem for Linux (WSL) see if it worked. And it worked…
23 May 2017
Théophane is a summer intern here at Tweag I/O. Thanks also in part to the financial help from the Nix community, he’s spending six months on devising a type system for the Nix language. Nix, the purely functional package manager Nix is a cross platform tool for managing the…
9 December 2015
Stack + Nix = portable reproducible builds
Stack and Cabal are great tools for incremental development. But before even starting to think about what your first commit will be about on a freshly checked out project, what you have to do is get a working development environment, by which we mean: see if it builds! Stack…