diff --git a/Cargo.lock b/Cargo.lock
index 416f121..f61c51e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -134,11 +134,11 @@ checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
 
 [[package]]
 name = "home"
-version = "0.5.11"
+version = "0.5.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589533453244b0995c858700322199b2becb13b627df2851f64a2775d024abcf"
+checksum = "cc627f471c528ff0c4a49e1d5e60450c8f6461dd6d10ba9dcd3a61d3dff7728d"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.61.1",
 ]
 
 [[package]]
@@ -209,7 +209,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
 [[package]]
-name = "nix-bindings-bindgen-raw"
+name = "nix-bindings-bdwgc-sys"
 version = "0.1.0"
 dependencies = [
  "bindgen",
@@ -224,12 +224,25 @@ dependencies = [
  "cstr",
  "ctor",
  "lazy_static",
- "nix-bindings-bindgen-raw",
+ "nix-bindings-bdwgc-sys",
+ "nix-bindings-expr-sys",
  "nix-bindings-store",
+ "nix-bindings-store-sys",
  "nix-bindings-util",
+ "nix-bindings-util-sys",
  "tempfile",
 ]
 
+[[package]]
+name = "nix-bindings-expr-sys"
+version = "0.1.0"
+dependencies = [
+ "bindgen",
+ "nix-bindings-store-sys",
+ "nix-bindings-util-sys",
+ "pkg-config",
+]
+
 [[package]]
 name = "nix-bindings-fetchers"
 version = "0.1.0"
@@ -237,12 +250,21 @@ dependencies = [
  "anyhow",
  "cstr",
  "ctor",
- "nix-bindings-bindgen-raw",
+ "nix-bindings-fetchers-sys",
  "nix-bindings-store",
  "nix-bindings-util",
  "tempfile",
 ]
 
+[[package]]
+name = "nix-bindings-fetchers-sys"
+version = "0.1.0"
+dependencies = [
+ "bindgen",
+ "nix-bindings-util-sys",
+ "pkg-config",
+]
+
 [[package]]
 name = "nix-bindings-flake"
 version = "0.1.0"
@@ -251,14 +273,27 @@ dependencies = [
  "cstr",
  "ctor",
  "lazy_static",
- "nix-bindings-bindgen-raw",
  "nix-bindings-expr",
  "nix-bindings-fetchers",
+ "nix-bindings-flake-sys",
  "nix-bindings-store",
  "nix-bindings-util",
  "tempfile",
 ]
 
+[[package]]
+name = "nix-bindings-flake-sys"
+version = "0.1.0"
+dependencies = [
+ "bindgen",
+ "nix-bindings-bdwgc-sys",
+ "nix-bindings-expr-sys",
+ "nix-bindings-fetchers-sys",
+ "nix-bindings-store-sys",
+ "nix-bindings-util-sys",
+ "pkg-config",
+]
+
 [[package]]
 name = "nix-bindings-store"
 version = "0.1.0"
@@ -266,19 +301,37 @@ dependencies = [
  "anyhow",
  "ctor",
  "lazy_static",
- "nix-bindings-bindgen-raw",
+ "nix-bindings-store-sys",
  "nix-bindings-util",
+ "nix-bindings-util-sys",
  "pkg-config",
  "tempfile",
 ]
 
+[[package]]
+name = "nix-bindings-store-sys"
+version = "0.1.0"
+dependencies = [
+ "bindgen",
+ "nix-bindings-util-sys",
+ "pkg-config",
+]
+
 [[package]]
 name = "nix-bindings-util"
 version = "0.1.0"
 dependencies = [
  "anyhow",
  "ctor",
- "nix-bindings-bindgen-raw",
+ "nix-bindings-util-sys",
+]
+
+[[package]]
+name = "nix-bindings-util-sys"
+version = "0.1.0"
+dependencies = [
+ "bindgen",
+ "pkg-config",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index d90bd3c..67da147 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,11 @@
 [workspace]
 members = [
-    "nix-bindings-bindgen-raw",
+    "nix-bindings-bdwgc-sys",
+    "nix-bindings-util-sys",
+    "nix-bindings-store-sys",
+    "nix-bindings-expr-sys",
+    "nix-bindings-fetchers-sys",
+    "nix-bindings-flake-sys",
     "nix-bindings-expr",
     "nix-bindings-fetchers",
     "nix-bindings-flake",
diff --git a/flake.nix b/flake.nix
index 0cd0142..68ccc0e 100644
--- a/flake.nix
+++ b/flake.nix
@@ -29,10 +29,7 @@
           {
             _file = ./flake.nix;
             options.perSystem = flake-parts-lib.mkPerSystemOption (
-              { config, pkgs, ... }:
-              let
-                cfg = config.nix-bindings-rust;
-              in
+              { pkgs, ... }:
               {
                 options.nix-bindings-rust = {
                   nixPackage = lib.mkOption {
@@ -49,10 +46,25 @@
                       A module to load into your nix-cargo-integration
                       [`perSystem.nci.projects.<name>.depsDrvConfig`](https://flake.parts/options/nix-cargo-integration.html#opt-perSystem.nci.projects._name_.depsDrvConfig) or similar such options.
 
+                      This provides common build configuration (pkg-config, libclang, etc.) but you must
+                      add the specific Nix C libraries your crates need to `buildInputs`:
+                      - `nix-bindings-util-sys` needs `nix-util-c`
+                      - `nix-bindings-store-sys` needs `nix-store-c`
+                      - `nix-bindings-expr-sys` needs `nix-expr-c`
+                      - `nix-bindings-fetchers-sys` needs `nix-fetchers-c` (Nix >= 2.29)
+                      - `nix-bindings-flake-sys` needs `nix-flake-c`
+                      - `nix-bindings-bdwgc-sys` needs `boehmgc`
+
                       Example:
                       ```nix
-                      perSystem = perSystem@{ config, ... }: {
-                        nci.projects."my_project".depsDrvConfig = perSystem.config.nix-bindings-rust.nciBuildConfig;
+                      perSystem = perSystem@{ config, pkgs, ... }: {
+                        nci.projects."my_project".depsDrvConfig = {
+                          imports = [ perSystem.config.nix-bindings-rust.nciBuildConfig ];
+                          mkDerivation.buildInputs = [
+                            perSystem.config.nix-bindings-rust.nixPackage.libs.nix-store-c
+                            # ... add other libs as needed
+                          ];
+                        };
                       }
                       ```
                     '';
@@ -64,22 +76,7 @@
                       buildInputs = [
                         # stdbool.h
                         pkgs.stdenv.cc
-                      ]
-                      ++ (
-                        if cfg.nixPackage ? libs then
-                          let
-                            l = cfg.nixPackage.libs;
-                          in
-                          [
-                            l.nix-expr-c
-                            l.nix-store-c
-                            l.nix-util-c
-                            l.nix-fetchers-c or null # Nix >= 2.29
-                            l.nix-flake-c
-                          ]
-                        else
-                          [ cfg.nixPackage ]
-                      );
+                      ];
                       nativeBuildInputs = [
                         pkgs.pkg-config
                       ];
diff --git a/nci.nix b/nci.nix
index 053a832..6faa221 100644
--- a/nci.nix
+++ b/nci.nix
@@ -2,8 +2,24 @@
   perSystem =
     {
       config,
+      pkgs,
       ...
     }:
+    let
+      cfg = config.nix-bindings-rust;
+      nixLibs =
+        if cfg.nixPackage ? libs then
+          cfg.nixPackage.libs
+        else
+          # Fallback for older Nix versions without split libs
+          {
+            nix-util-c = cfg.nixPackage;
+            nix-store-c = cfg.nixPackage;
+            nix-expr-c = cfg.nixPackage;
+            nix-fetchers-c = cfg.nixPackage;
+            nix-flake-c = cfg.nixPackage;
+          };
+    in
     {
       # https://flake.parts/options/nix-cargo-integration
       nci.projects.nix-bindings = {
@@ -38,12 +54,46 @@
               echo "experimental-features = ca-derivations flakes" > "$NIX_CONF_DIR/nix.conf"
 
               # Init ahead of time, because concurrent initialization is flaky
-              ${config.nix-bindings-rust.nixPackage}/bin/nix-store --init
+              ${cfg.nixPackage}/bin/nix-store --init
 
               echo "Store initialized."
             '';
           };
         };
       };
+
+      # Per-crate configuration: only provide the specific Nix libs each crate needs
+      # FIXME should use propagatedBuildInputs
+      nci.crates.nix-bindings-bdwgc-sys.drvConfig.mkDerivation.buildInputs = [
+        pkgs.boehmgc
+      ];
+      nci.crates.nix-bindings-util-sys.drvConfig.mkDerivation.buildInputs = [
+        nixLibs.nix-util-c
+      ];
+      nci.crates.nix-bindings-util.drvConfig.mkDerivation.buildInputs =
+        config.nci.crates.nix-bindings-util-sys.drvConfig.mkDerivation.buildInputs;
+      nci.crates.nix-bindings-store-sys.drvConfig.mkDerivation.buildInputs =
+        config.nci.crates.nix-bindings-util-sys.drvConfig.mkDerivation.buildInputs
+        ++ [ nixLibs.nix-store-c ];
+      nci.crates.nix-bindings-store.drvConfig.mkDerivation.buildInputs =
+        config.nci.crates.nix-bindings-store-sys.drvConfig.mkDerivation.buildInputs;
+      nci.crates.nix-bindings-expr-sys.drvConfig.mkDerivation.buildInputs =
+        config.nci.crates.nix-bindings-store-sys.drvConfig.mkDerivation.buildInputs
+        ++ [
+          nixLibs.nix-expr-c
+          pkgs.boehmgc
+        ];
+      nci.crates.nix-bindings-expr.drvConfig.mkDerivation.buildInputs =
+        config.nci.crates.nix-bindings-expr-sys.drvConfig.mkDerivation.buildInputs;
+      nci.crates.nix-bindings-fetchers-sys.drvConfig.mkDerivation.buildInputs =
+        config.nci.crates.nix-bindings-expr-sys.drvConfig.mkDerivation.buildInputs
+        ++ [ nixLibs.nix-fetchers-c ];
+      nci.crates.nix-bindings-fetchers.drvConfig.mkDerivation.buildInputs =
+        config.nci.crates.nix-bindings-fetchers-sys.drvConfig.mkDerivation.buildInputs;
+      nci.crates.nix-bindings-flake-sys.drvConfig.mkDerivation.buildInputs =
+        config.nci.crates.nix-bindings-fetchers-sys.drvConfig.mkDerivation.buildInputs
+        ++ [ nixLibs.nix-flake-c ];
+      nci.crates.nix-bindings-flake.drvConfig.mkDerivation.buildInputs =
+        config.nci.crates.nix-bindings-flake-sys.drvConfig.mkDerivation.buildInputs;
     };
 }
diff --git a/nix-bindings-bdwgc-sys/Cargo.toml b/nix-bindings-bdwgc-sys/Cargo.toml
new file mode 100644
index 0000000..46c3f15
--- /dev/null
+++ b/nix-bindings-bdwgc-sys/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "nix-bindings-bdwgc-sys"
+version = "0.1.0"
+edition = "2021"
+build = "build.rs"
+license = "LGPL-2.1"
+
+[lib]
+path = "src/lib.rs"
+
+[dependencies]
+
+[build-dependencies]
+bindgen = "0.69"
+pkg-config = "0.3"
diff --git a/nix-bindings-bdwgc-sys/README.md b/nix-bindings-bdwgc-sys/README.md
new file mode 100644
index 0000000..3723e90
--- /dev/null
+++ b/nix-bindings-bdwgc-sys/README.md
@@ -0,0 +1,4 @@
+# nix-bindings-bdwgc-sys
+
+This crate contains generated bindings for the Boehm-Demers-Weiser garbage collector (`bdw-gc`).
+**You should not have to use this crate directly,** and so you should probably not add it to your dependencies.
diff --git a/nix-bindings-bdwgc-sys/build.rs b/nix-bindings-bdwgc-sys/build.rs
new file mode 100644
index 0000000..aed2a8c
--- /dev/null
+++ b/nix-bindings-bdwgc-sys/build.rs
@@ -0,0 +1,27 @@
+use std::env;
+use std::path::PathBuf;
+
+fn main() {
+    println!("cargo:rerun-if-changed=include/bdwgc.h");
+
+    let mut args = Vec::new();
+    for path in pkg_config::probe_library("bdw-gc")
+        .unwrap()
+        .include_paths
+        .iter()
+    {
+        args.push(format!("-I{}", path.to_str().unwrap()));
+    }
+
+    let bindings = bindgen::Builder::default()
+        .header("include/bdwgc.h")
+        .clang_args(args)
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
+        .generate()
+        .expect("Unable to generate bindings");
+
+    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
+    bindings
+        .write_to_file(out_path.join("bindings.rs"))
+        .expect("Couldn't write bindings!");
+}
diff --git a/nix-bindings-bdwgc-sys/include/bdwgc.h b/nix-bindings-bdwgc-sys/include/bdwgc.h
new file mode 100644
index 0000000..2a70434
--- /dev/null
+++ b/nix-bindings-bdwgc-sys/include/bdwgc.h
@@ -0,0 +1,2 @@
+#define GC_THREADS
+#include <gc/gc.h>
diff --git a/nix-bindings-bdwgc-sys/src/lib.rs b/nix-bindings-bdwgc-sys/src/lib.rs
new file mode 100644
index 0000000..0cf64d2
--- /dev/null
+++ b/nix-bindings-bdwgc-sys/src/lib.rs
@@ -0,0 +1,7 @@
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(dead_code)]
+#![allow(clippy::all)]
+
+include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
diff --git a/nix-bindings-bindgen-raw/README.md b/nix-bindings-bindgen-raw/README.md
deleted file mode 100644
index 1c7e5f0..0000000
--- a/nix-bindings-bindgen-raw/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
-# nix-bindings-bindgen-raw
-
-This crate contains generated bindings for the Nix C API.
-**You should not have to use this crate directly,** and so you should probably not add it to your dependencies.
-Instead, use the `nix-bindings-util`, `nix-bindings-store` and `nix-bindings-expr` crates, which _should_ be sufficient.
-
-## Design
-
-Rust bindgen currently does not allow "layered" libraries to be split into separate crates.
-For example, the expr crate would have all-new types that are distinct and incompatible with the store crate.
-
-Ideally bindgen will support reusing already generated modules, and we could move the code generation into the appropriate crates, so that the system dependencies of each crate become accurate.
diff --git a/nix-bindings-bindgen-raw/build.rs b/nix-bindings-bindgen-raw/build.rs
deleted file mode 100644
index 5dbdbc7..0000000
--- a/nix-bindings-bindgen-raw/build.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-use std::env;
-use std::path::PathBuf;
-
-#[derive(Debug)]
-struct StripNixPrefix {}
-impl bindgen::callbacks::ParseCallbacks for StripNixPrefix {
-    fn item_name(&self, name: &str) -> Option<String> {
-        name.strip_prefix("nix_").map(String::from)
-    }
-}
-
-fn main() {
-    // Tell cargo to invalidate the built crate whenever the wrapper changes
-    println!("cargo:rerun-if-changed=include/nix-c-raw.h");
-    println!("cargo:rustc-link-lib=nixflake");
-
-    // https://rust-lang.github.io/rust-bindgen/library-usage.html
-    let bindings = bindgen::Builder::default()
-        .header("include/nix-c-raw.h")
-        // Find the includes
-        .clang_args(c_headers())
-        // Tell cargo to invalidate the built crate whenever any of the
-        // included header files changed.
-        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
-        .parse_callbacks(Box::new(StripNixPrefix {}))
-        // Finish the builder and generate the bindings.
-        .generate()
-        // Unwrap the Result and panic on failure.
-        .expect("Unable to generate bindings");
-
-    // Write the bindings to the $OUT_DIR/bindings.rs file.
-    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
-    bindings
-        .write_to_file(out_path.join("bindings.rs"))
-        .expect("Couldn't write bindings!");
-}
-
-fn c_headers() -> Vec<String> {
-    let mut args = Vec::new();
-    // args.push("-isystem".to_string());
-    for path in pkg_config::probe_library("nix-flake-c")
-        .unwrap()
-        .include_paths
-        .iter()
-    {
-        args.push(format!("-I{}", path.to_str().unwrap()));
-    }
-
-    for path in pkg_config::probe_library("bdw-gc")
-        .unwrap()
-        .include_paths
-        .iter()
-    {
-        args.push(format!("-I{}", path.to_str().unwrap()));
-    }
-
-    // write to stderr for debugging
-    eprintln!("c_headers: {:?}", args);
-    args
-}
diff --git a/nix-bindings-bindgen-raw/include/nix-c-raw.h b/nix-bindings-bindgen-raw/include/nix-c-raw.h
deleted file mode 100644
index 88e252f..0000000
--- a/nix-bindings-bindgen-raw/include/nix-c-raw.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <nix_api_util.h>
-#include <nix_api_store.h>
-#define GC_THREADS
-#include <gc/gc.h>
-#include <nix_api_expr.h>
-#include <nix_api_value.h>
-#include <nix_api_flake.h>
diff --git a/nix-bindings-bindgen-raw/src/lib.rs b/nix-bindings-bindgen-raw/src/lib.rs
deleted file mode 100644
index 05c7e41..0000000
--- a/nix-bindings-bindgen-raw/src/lib.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-//! Raw bindings to Nix C API
-//!
-//! This crate contains automatically generated bindings from the Nix C headers.
-//! The bindings are generated by bindgen and include C-style naming conventions
-//! and documentation comments that don't always conform to Rust standards.
-//!
-//! Normally you don't have to use this crate directly.
-//! Instead use `nix-store` and `nix-expr`.
-
-// Standard bindgen suppressions for C naming conventions
-#![allow(non_upper_case_globals)]
-#![allow(non_camel_case_types)]
-#![allow(non_snake_case)]
-// Rustdoc suppressions for generated C documentation
-// The C headers contain Doxygen-style documentation that doesn't translate
-// well to Rust's rustdoc format, causing various warnings:
-#![allow(rustdoc::broken_intra_doc_links)] // @param[in]/[out] references don't resolve
-#![allow(rustdoc::bare_urls)] // C docs may contain unescaped URLs
-#![allow(rustdoc::invalid_html_tags)] // Doxygen HTML tags like <setting>
-#![allow(rustdoc::invalid_codeblock_attributes)] // C code examples may use unsupported attributes
-
-include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
diff --git a/nix-bindings-expr-sys/Cargo.toml b/nix-bindings-expr-sys/Cargo.toml
new file mode 100644
index 0000000..d1971f2
--- /dev/null
+++ b/nix-bindings-expr-sys/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "nix-bindings-expr-sys"
+version = "0.1.0"
+edition = "2021"
+build = "build.rs"
+license = "LGPL-2.1"
+
+[lib]
+path = "src/lib.rs"
+
+[dependencies]
+nix-bindings-util-sys = { path = "../nix-bindings-util-sys" }
+nix-bindings-store-sys = { path = "../nix-bindings-store-sys" }
+
+[build-dependencies]
+bindgen = "0.69"
+pkg-config = "0.3"
diff --git a/nix-bindings-expr-sys/README.md b/nix-bindings-expr-sys/README.md
new file mode 100644
index 0000000..ccdcc26
--- /dev/null
+++ b/nix-bindings-expr-sys/README.md
@@ -0,0 +1,5 @@
+# nix-bindings-expr-sys
+
+This crate contains generated bindings for the Nix C API (`nix-expr-c`).
+**You should not have to use this crate directly,** and so you should probably not add it to your dependencies.
+Instead, use the `nix-bindings-expr` crate, which _should_ be sufficient.
diff --git a/nix-bindings-expr-sys/build.rs b/nix-bindings-expr-sys/build.rs
new file mode 100644
index 0000000..6e0eed2
--- /dev/null
+++ b/nix-bindings-expr-sys/build.rs
@@ -0,0 +1,42 @@
+use std::path::PathBuf;
+
+#[derive(Debug)]
+struct StripNixPrefix;
+
+impl bindgen::callbacks::ParseCallbacks for StripNixPrefix {
+    fn item_name(&self, name: &str) -> Option<String> {
+        name.strip_prefix("nix_").map(String::from)
+    }
+}
+
+fn main() {
+    println!("cargo:rerun-if-changed=include/nix-c-expr.h");
+    println!("cargo:rustc-link-lib=nixexprc");
+
+    let mut args = Vec::new();
+    for path in pkg_config::probe_library("nix-expr-c")
+        .unwrap()
+        .include_paths
+        .iter()
+    {
+        args.push(format!("-I{}", path.to_str().unwrap()));
+    }
+
+    let out_path = PathBuf::from(std::env::var("OUT_DIR").unwrap());
+
+    let bindings = bindgen::Builder::default()
+        .header("include/nix-c-expr.h")
+        .clang_args(args)
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
+        .parse_callbacks(Box::new(StripNixPrefix))
+        // Blocklist symbols from nix-bindings-util-sys
+        .blocklist_file(".*nix_api_util\\.h")
+        // Blocklist symbols from nix-bindings-store-sys
+        .blocklist_file(".*nix_api_store\\.h")
+        .generate()
+        .expect("Unable to generate bindings");
+
+    bindings
+        .write_to_file(out_path.join("bindings.rs"))
+        .expect("Couldn't write bindings!");
+}
diff --git a/nix-bindings-expr-sys/include/nix-c-expr.h b/nix-bindings-expr-sys/include/nix-c-expr.h
new file mode 100644
index 0000000..c2649a4
--- /dev/null
+++ b/nix-bindings-expr-sys/include/nix-c-expr.h
@@ -0,0 +1,2 @@
+#include <nix_api_expr.h>
+#include <nix_api_value.h>
diff --git a/nix-bindings-expr-sys/src/lib.rs b/nix-bindings-expr-sys/src/lib.rs
new file mode 100644
index 0000000..afd13d3
--- /dev/null
+++ b/nix-bindings-expr-sys/src/lib.rs
@@ -0,0 +1,10 @@
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(dead_code)]
+#![allow(clippy::all)]
+
+use nix_bindings_store_sys::*;
+use nix_bindings_util_sys::*;
+
+include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
diff --git a/nix-bindings-expr/Cargo.toml b/nix-bindings-expr/Cargo.toml
index 044e70a..c06a59b 100644
--- a/nix-bindings-expr/Cargo.toml
+++ b/nix-bindings-expr/Cargo.toml
@@ -11,7 +11,10 @@ path = "src/lib.rs"
 anyhow = "1.0"
 nix-bindings-store = { path = "../nix-bindings-store" }
 nix-bindings-util = { path = "../nix-bindings-util" }
-nix-bindings-bindgen-raw = { path = "../nix-bindings-bindgen-raw" }
+nix-bindings-bdwgc-sys = { path = "../nix-bindings-bdwgc-sys" }
+nix-bindings-util-sys = { path = "../nix-bindings-util-sys" }
+nix-bindings-store-sys = { path = "../nix-bindings-store-sys" }
+nix-bindings-expr-sys = { path = "../nix-bindings-expr-sys" }
 lazy_static = "1.4"
 ctor = "0.2"
 tempfile = "3.10"
diff --git a/nix-bindings-expr/src/eval_state.rs b/nix-bindings-expr/src/eval_state.rs
index 7d0808c..1fb3410 100644
--- a/nix-bindings-expr/src/eval_state.rs
+++ b/nix-bindings-expr/src/eval_state.rs
@@ -134,9 +134,11 @@ use anyhow::Context as _;
 use anyhow::{bail, Result};
 use cstr::cstr;
 use lazy_static::lazy_static;
-use nix_bindings_bindgen_raw as raw;
+use nix_bindings_bdwgc_sys as gc;
+use nix_bindings_expr_sys as raw;
 use nix_bindings_store::path::StorePath;
 use nix_bindings_store::store::{Store, StoreWeak};
+use nix_bindings_store_sys as raw_store;
 use nix_bindings_util::context::Context;
 use nix_bindings_util::string_return::{
     callback_get_result_string, callback_get_result_string_data,
@@ -151,7 +153,7 @@ use std::sync::{Arc, Weak};
 lazy_static! {
     static ref INIT: Result<()> = {
         unsafe {
-            raw::GC_allow_register_threads();
+            gc::GC_allow_register_threads();
             check_call!(raw::libexpr_init(&mut Context::new()))?;
             Ok(())
         }
@@ -887,7 +889,7 @@ impl EvalState {
             let mut paths = Vec::with_capacity(n as usize);
             for i in 0..n {
                 let path = raw::realised_string_get_store_path(rs, i);
-                let path = NonNull::new(path as *mut raw::StorePath).ok_or_else(|| {
+                let path = NonNull::new(path as *mut raw_store::StorePath).ok_or_else(|| {
                     anyhow::format_err!(
                         "nix_realised_string_get_store_path returned a null pointer"
                     )
@@ -1153,7 +1155,7 @@ impl Drop for ThreadRegistrationGuard {
     fn drop(&mut self) {
         if self.must_unregister {
             unsafe {
-                raw::GC_unregister_my_thread();
+                gc::GC_unregister_my_thread();
             }
         }
     }
@@ -1161,14 +1163,14 @@ impl Drop for ThreadRegistrationGuard {
 
 fn gc_register_my_thread_do_it() -> Result<()> {
     unsafe {
-        let mut sb: raw::GC_stack_base = raw::GC_stack_base {
+        let mut sb: gc::GC_stack_base = gc::GC_stack_base {
             mem_base: null_mut(),
         };
-        let r = raw::GC_get_stack_base(&mut sb);
-        if r as u32 != raw::GC_SUCCESS {
+        let r = gc::GC_get_stack_base(&mut sb);
+        if r as u32 != gc::GC_SUCCESS {
             Err(anyhow::format_err!("GC_get_stack_base failed: {}", r))?;
         }
-        raw::GC_register_my_thread(&sb);
+        gc::GC_register_my_thread(&sb);
         Ok(())
     }
 }
@@ -1179,7 +1181,7 @@ fn gc_register_my_thread_do_it() -> Result<()> {
 pub fn gc_register_my_thread() -> Result<ThreadRegistrationGuard> {
     init()?;
     unsafe {
-        let already_done = raw::GC_thread_is_registered();
+        let already_done = gc::GC_thread_is_registered();
         if already_done != 0 {
             return Ok(ThreadRegistrationGuard {
                 must_unregister: false,
diff --git a/nix-bindings-expr/src/primop.rs b/nix-bindings-expr/src/primop.rs
index f430d4d..02410fc 100644
--- a/nix-bindings-expr/src/primop.rs
+++ b/nix-bindings-expr/src/primop.rs
@@ -1,8 +1,9 @@
 use crate::eval_state::{EvalState, EvalStateWeak};
 use crate::value::Value;
 use anyhow::Result;
-use nix_bindings_bindgen_raw as raw;
+use nix_bindings_expr_sys as raw;
 use nix_bindings_util::check_call;
+use nix_bindings_util_sys as raw_util;
 use std::ffi::{c_int, c_void, CStr, CString};
 use std::mem::ManuallyDrop;
 use std::ptr::{null, null_mut};
@@ -84,7 +85,7 @@ struct PrimOpContext {
 
 unsafe extern "C" fn function_adapter(
     user_data: *mut ::std::os::raw::c_void,
-    context_out: *mut raw::c_context,
+    context_out: *mut raw_util::c_context,
     _state: *mut raw::EvalState,
     args: *mut *mut raw::Value,
     ret: *mut raw::Value,
@@ -111,7 +112,7 @@ unsafe extern "C" fn function_adapter(
                 CString::new("<rust nix-expr application error message contained null byte>")
                     .unwrap()
             });
-            raw::set_err_msg(context_out, raw::err_NIX_ERR_UNKNOWN, cstr.as_ptr());
+            raw_util::set_err_msg(context_out, raw_util::err_NIX_ERR_UNKNOWN, cstr.as_ptr());
         },
     }
 }
diff --git a/nix-bindings-expr/src/value.rs b/nix-bindings-expr/src/value.rs
index 086a343..1abe4d5 100644
--- a/nix-bindings-expr/src/value.rs
+++ b/nix-bindings-expr/src/value.rs
@@ -1,6 +1,6 @@
 pub mod __private;
 
-use nix_bindings_bindgen_raw as raw;
+use nix_bindings_expr_sys as raw;
 use nix_bindings_util::{check_call, context::Context};
 use std::ptr::{null_mut, NonNull};
 
diff --git a/nix-bindings-expr/src/value/__private.rs b/nix-bindings-expr/src/value/__private.rs
index 84151e1..770a217 100644
--- a/nix-bindings-expr/src/value/__private.rs
+++ b/nix-bindings-expr/src/value/__private.rs
@@ -1,6 +1,6 @@
 //! Functions that are relevant for other bindings modules, but normally not end users.
 use super::Value;
-use nix_bindings_bindgen_raw as raw;
+use nix_bindings_expr_sys as raw;
 
 /// Take ownership of a new [`Value`].
 ///
diff --git a/nix-bindings-fetchers-sys/Cargo.toml b/nix-bindings-fetchers-sys/Cargo.toml
new file mode 100644
index 0000000..dff5b42
--- /dev/null
+++ b/nix-bindings-fetchers-sys/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "nix-bindings-fetchers-sys"
+version = "0.1.0"
+edition = "2021"
+build = "build.rs"
+license = "LGPL-2.1"
+
+[lib]
+path = "src/lib.rs"
+
+[dependencies]
+nix-bindings-util-sys = { path = "../nix-bindings-util-sys" }
+
+[build-dependencies]
+bindgen = "0.69"
+pkg-config = "0.3"
diff --git a/nix-bindings-fetchers-sys/README.md b/nix-bindings-fetchers-sys/README.md
new file mode 100644
index 0000000..b403eac
--- /dev/null
+++ b/nix-bindings-fetchers-sys/README.md
@@ -0,0 +1,5 @@
+# nix-bindings-fetchers-sys
+
+This crate contains generated bindings for the Nix C API (`nix-fetchers-c`).
+**You should not have to use this crate directly,** and so you should probably not add it to your dependencies.
+Instead, use the `nix-bindings-fetchers` crate, which _should_ be sufficient.
diff --git a/nix-bindings-fetchers-sys/build.rs b/nix-bindings-fetchers-sys/build.rs
new file mode 100644
index 0000000..34f6640
--- /dev/null
+++ b/nix-bindings-fetchers-sys/build.rs
@@ -0,0 +1,40 @@
+use std::path::PathBuf;
+
+#[derive(Debug)]
+struct StripNixPrefix;
+
+impl bindgen::callbacks::ParseCallbacks for StripNixPrefix {
+    fn item_name(&self, name: &str) -> Option<String> {
+        name.strip_prefix("nix_").map(String::from)
+    }
+}
+
+fn main() {
+    println!("cargo:rerun-if-changed=include/nix-c-fetchers.h");
+    println!("cargo:rustc-link-lib=nixfetchersc");
+
+    let mut args = Vec::new();
+    for path in pkg_config::probe_library("nix-fetchers-c")
+        .unwrap()
+        .include_paths
+        .iter()
+    {
+        args.push(format!("-I{}", path.to_str().unwrap()));
+    }
+
+    let out_path = PathBuf::from(std::env::var("OUT_DIR").unwrap());
+
+    let bindings = bindgen::Builder::default()
+        .header("include/nix-c-fetchers.h")
+        .clang_args(args)
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
+        .parse_callbacks(Box::new(StripNixPrefix))
+        // Blocklist symbols from nix-bindings-util-sys
+        .blocklist_file(".*nix_api_util\\.h")
+        .generate()
+        .expect("Unable to generate bindings");
+
+    bindings
+        .write_to_file(out_path.join("bindings.rs"))
+        .expect("Couldn't write bindings!");
+}
diff --git a/nix-bindings-fetchers-sys/include/nix-c-fetchers.h b/nix-bindings-fetchers-sys/include/nix-c-fetchers.h
new file mode 100644
index 0000000..2f4c542
--- /dev/null
+++ b/nix-bindings-fetchers-sys/include/nix-c-fetchers.h
@@ -0,0 +1 @@
+#include <nix_api_fetchers.h>
diff --git a/nix-bindings-fetchers-sys/src/lib.rs b/nix-bindings-fetchers-sys/src/lib.rs
new file mode 100644
index 0000000..4c5c9fe
--- /dev/null
+++ b/nix-bindings-fetchers-sys/src/lib.rs
@@ -0,0 +1,9 @@
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(dead_code)]
+#![allow(clippy::all)]
+
+use nix_bindings_util_sys::*;
+
+include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
diff --git a/nix-bindings-fetchers/Cargo.toml b/nix-bindings-fetchers/Cargo.toml
index 6cbb103..49edb2e 100644
--- a/nix-bindings-fetchers/Cargo.toml
+++ b/nix-bindings-fetchers/Cargo.toml
@@ -11,7 +11,7 @@ path = "src/lib.rs"
 anyhow = "1.0"
 nix-bindings-store = { path = "../nix-bindings-store" }
 nix-bindings-util = { path = "../nix-bindings-util" }
-nix-bindings-bindgen-raw = { path = "../nix-bindings-bindgen-raw" }
+nix-bindings-fetchers-sys = { path = "../nix-bindings-fetchers-sys" }
 ctor = "0.2"
 tempfile = "3.10"
 cstr = "0.2"
diff --git a/nix-bindings-fetchers/src/lib.rs b/nix-bindings-fetchers/src/lib.rs
index 06bf45f..0b7b6cc 100644
--- a/nix-bindings-fetchers/src/lib.rs
+++ b/nix-bindings-fetchers/src/lib.rs
@@ -1,5 +1,5 @@
 use anyhow::{Context as _, Result};
-use nix_bindings_bindgen_raw as raw;
+use nix_bindings_fetchers_sys as raw;
 use nix_bindings_util::context::{self, Context};
 use std::ptr::NonNull;
 
diff --git a/nix-bindings-flake-sys/Cargo.toml b/nix-bindings-flake-sys/Cargo.toml
new file mode 100644
index 0000000..1109b5f
--- /dev/null
+++ b/nix-bindings-flake-sys/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "nix-bindings-flake-sys"
+version = "0.1.0"
+edition = "2021"
+build = "build.rs"
+license = "LGPL-2.1"
+
+[lib]
+path = "src/lib.rs"
+
+[dependencies]
+nix-bindings-util-sys = { path = "../nix-bindings-util-sys" }
+nix-bindings-store-sys = { path = "../nix-bindings-store-sys" }
+nix-bindings-expr-sys = { path = "../nix-bindings-expr-sys" }
+nix-bindings-fetchers-sys = { path = "../nix-bindings-fetchers-sys" }
+nix-bindings-bdwgc-sys = { path = "../nix-bindings-bdwgc-sys" }
+
+[build-dependencies]
+bindgen = "0.69"
+pkg-config = "0.3"
diff --git a/nix-bindings-flake-sys/README.md b/nix-bindings-flake-sys/README.md
new file mode 100644
index 0000000..10a9d96
--- /dev/null
+++ b/nix-bindings-flake-sys/README.md
@@ -0,0 +1,5 @@
+# nix-bindings-flake-sys
+
+This crate contains generated bindings for the Nix C API (`nix-flake-c`).
+**You should not have to use this crate directly,** and so you should probably not add it to your dependencies.
+Instead, use the `nix-bindings-flake` crate, which _should_ be sufficient.
diff --git a/nix-bindings-flake-sys/build.rs b/nix-bindings-flake-sys/build.rs
new file mode 100644
index 0000000..1fb3233
--- /dev/null
+++ b/nix-bindings-flake-sys/build.rs
@@ -0,0 +1,56 @@
+use std::path::PathBuf;
+
+#[derive(Debug)]
+struct StripNixPrefix;
+
+impl bindgen::callbacks::ParseCallbacks for StripNixPrefix {
+    fn item_name(&self, name: &str) -> Option<String> {
+        name.strip_prefix("nix_").map(String::from)
+    }
+}
+
+fn main() {
+    println!("cargo:rerun-if-changed=include/nix-c-flake.h");
+    println!("cargo:rustc-link-lib=nixflakec");
+
+    let mut args = Vec::new();
+    for path in pkg_config::probe_library("nix-flake-c")
+        .unwrap()
+        .include_paths
+        .iter()
+    {
+        args.push(format!("-I{}", path.to_str().unwrap()));
+    }
+    for path in pkg_config::probe_library("bdw-gc")
+        .unwrap()
+        .include_paths
+        .iter()
+    {
+        args.push(format!("-I{}", path.to_str().unwrap()));
+    }
+
+    let out_path = PathBuf::from(std::env::var("OUT_DIR").unwrap());
+
+    let bindings = bindgen::Builder::default()
+        .header("include/nix-c-flake.h")
+        .clang_args(args)
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
+        .parse_callbacks(Box::new(StripNixPrefix))
+        // Blocklist symbols from nix-bindings-util-sys
+        .blocklist_file(".*nix_api_util\\.h")
+        // Blocklist symbols from nix-bindings-store-sys
+        .blocklist_file(".*nix_api_store\\.h")
+        // Blocklist symbols from nix-bindings-expr-sys
+        .blocklist_file(".*nix_api_expr\\.h")
+        .blocklist_file(".*nix_api_value\\.h")
+        // Blocklist symbols from nix-bindings-fetchers-sys
+        .blocklist_file(".*nix_api_fetchers\\.h")
+        // Blocklist symbols from nix-bindings-bdwgc-sys
+        .blocklist_file(".*/gc\\.h")
+        .generate()
+        .expect("Unable to generate bindings");
+
+    bindings
+        .write_to_file(out_path.join("bindings.rs"))
+        .expect("Couldn't write bindings!");
+}
diff --git a/nix-bindings-flake-sys/include/nix-c-flake.h b/nix-bindings-flake-sys/include/nix-c-flake.h
new file mode 100644
index 0000000..89a45f1
--- /dev/null
+++ b/nix-bindings-flake-sys/include/nix-c-flake.h
@@ -0,0 +1,3 @@
+#define GC_THREADS
+#include <gc/gc.h>
+#include <nix_api_flake.h>
diff --git a/nix-bindings-flake-sys/src/lib.rs b/nix-bindings-flake-sys/src/lib.rs
new file mode 100644
index 0000000..1bcac64
--- /dev/null
+++ b/nix-bindings-flake-sys/src/lib.rs
@@ -0,0 +1,11 @@
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(dead_code)]
+#![allow(clippy::all)]
+
+use nix_bindings_expr_sys::*;
+use nix_bindings_fetchers_sys::*;
+use nix_bindings_util_sys::*;
+
+include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
diff --git a/nix-bindings-flake/Cargo.toml b/nix-bindings-flake/Cargo.toml
index 3606a7c..889f830 100644
--- a/nix-bindings-flake/Cargo.toml
+++ b/nix-bindings-flake/Cargo.toml
@@ -13,7 +13,7 @@ nix-bindings-expr = { path = "../nix-bindings-expr" }
 nix-bindings-fetchers = { path = "../nix-bindings-fetchers" }
 nix-bindings-store = { path = "../nix-bindings-store" }
 nix-bindings-util = { path = "../nix-bindings-util" }
-nix-bindings-bindgen-raw = { path = "../nix-bindings-bindgen-raw" }
+nix-bindings-flake-sys = { path = "../nix-bindings-flake-sys" }
 lazy_static = "1.4"
 ctor = "0.2"
 tempfile = "3.10"
diff --git a/nix-bindings-flake/src/lib.rs b/nix-bindings-flake/src/lib.rs
index bd531b9..cb8e850 100644
--- a/nix-bindings-flake/src/lib.rs
+++ b/nix-bindings-flake/src/lib.rs
@@ -1,9 +1,9 @@
 use std::{ffi::CString, os::raw::c_char, ptr::NonNull};
 
 use anyhow::{Context as _, Result};
-use nix_bindings_bindgen_raw as raw;
 use nix_bindings_expr::eval_state::EvalState;
 use nix_bindings_fetchers::FetchersSettings;
+use nix_bindings_flake_sys as raw;
 use nix_bindings_util::{
     context::{self, Context},
     result_string_init,
diff --git a/nix-bindings-store-sys/Cargo.toml b/nix-bindings-store-sys/Cargo.toml
new file mode 100644
index 0000000..d24f30a
--- /dev/null
+++ b/nix-bindings-store-sys/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "nix-bindings-store-sys"
+version = "0.1.0"
+edition = "2021"
+build = "build.rs"
+license = "LGPL-2.1"
+
+[lib]
+path = "src/lib.rs"
+
+[dependencies]
+nix-bindings-util-sys = { path = "../nix-bindings-util-sys" }
+
+[build-dependencies]
+bindgen = "0.69"
+pkg-config = "0.3"
diff --git a/nix-bindings-store-sys/README.md b/nix-bindings-store-sys/README.md
new file mode 100644
index 0000000..73138ee
--- /dev/null
+++ b/nix-bindings-store-sys/README.md
@@ -0,0 +1,5 @@
+# nix-bindings-store-sys
+
+This crate contains generated bindings for the Nix C API (`nix-store-c`).
+**You should not have to use this crate directly,** and so you should probably not add it to your dependencies.
+Instead, use the `nix-bindings-store` crate, which _should_ be sufficient.
diff --git a/nix-bindings-store-sys/build.rs b/nix-bindings-store-sys/build.rs
new file mode 100644
index 0000000..bafdfae
--- /dev/null
+++ b/nix-bindings-store-sys/build.rs
@@ -0,0 +1,40 @@
+use std::path::PathBuf;
+
+#[derive(Debug)]
+struct StripNixPrefix;
+
+impl bindgen::callbacks::ParseCallbacks for StripNixPrefix {
+    fn item_name(&self, name: &str) -> Option<String> {
+        name.strip_prefix("nix_").map(String::from)
+    }
+}
+
+fn main() {
+    println!("cargo:rerun-if-changed=include/nix-c-store.h");
+    println!("cargo:rustc-link-lib=nixstorec");
+
+    let mut args = Vec::new();
+    for path in pkg_config::probe_library("nix-store-c")
+        .unwrap()
+        .include_paths
+        .iter()
+    {
+        args.push(format!("-I{}", path.to_str().unwrap()));
+    }
+
+    let out_path = PathBuf::from(std::env::var("OUT_DIR").unwrap());
+
+    let bindings = bindgen::Builder::default()
+        .header("include/nix-c-store.h")
+        .clang_args(args)
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
+        .parse_callbacks(Box::new(StripNixPrefix))
+        // Blocklist symbols from nix-bindings-util-sys
+        .blocklist_file(".*nix_api_util\\.h")
+        .generate()
+        .expect("Unable to generate bindings");
+
+    bindings
+        .write_to_file(out_path.join("bindings.rs"))
+        .expect("Couldn't write bindings!");
+}
diff --git a/nix-bindings-store-sys/include/nix-c-store.h b/nix-bindings-store-sys/include/nix-c-store.h
new file mode 100644
index 0000000..2c04d1d
--- /dev/null
+++ b/nix-bindings-store-sys/include/nix-c-store.h
@@ -0,0 +1 @@
+#include <nix_api_store.h>
diff --git a/nix-bindings-store-sys/src/lib.rs b/nix-bindings-store-sys/src/lib.rs
new file mode 100644
index 0000000..4c5c9fe
--- /dev/null
+++ b/nix-bindings-store-sys/src/lib.rs
@@ -0,0 +1,9 @@
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(dead_code)]
+#![allow(clippy::all)]
+
+use nix_bindings_util_sys::*;
+
+include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
diff --git a/nix-bindings-store/Cargo.toml b/nix-bindings-store/Cargo.toml
index f3d7211..566a650 100644
--- a/nix-bindings-store/Cargo.toml
+++ b/nix-bindings-store/Cargo.toml
@@ -11,7 +11,8 @@ path = "src/lib.rs"
 [dependencies]
 anyhow = "1.0"
 nix-bindings-util = { path = "../nix-bindings-util" }
-nix-bindings-bindgen-raw = { path = "../nix-bindings-bindgen-raw" }
+nix-bindings-util-sys = { path = "../nix-bindings-util-sys" }
+nix-bindings-store-sys = { path = "../nix-bindings-store-sys" }
 lazy_static = "1.4"
 
 [dev-dependencies]
diff --git a/nix-bindings-store/src/derivation.rs b/nix-bindings-store/src/derivation.rs
index 6be5e75..a1ee1c6 100644
--- a/nix-bindings-store/src/derivation.rs
+++ b/nix-bindings-store/src/derivation.rs
@@ -1,6 +1,6 @@
 #![cfg(nix_at_least = "2.33.0pre")]
 
-use nix_bindings_bindgen_raw as raw;
+use nix_bindings_store_sys as raw;
 use std::ptr::NonNull;
 
 /// A Nix derivation
diff --git a/nix-bindings-store/src/path.rs b/nix-bindings-store/src/path.rs
index b07bf11..51469af 100644
--- a/nix-bindings-store/src/path.rs
+++ b/nix-bindings-store/src/path.rs
@@ -1,7 +1,7 @@
 use std::ptr::NonNull;
 
 use anyhow::Result;
-use nix_bindings_bindgen_raw as raw;
+use nix_bindings_store_sys as raw;
 use nix_bindings_util::{
     result_string_init,
     string_return::{callback_get_result_string, callback_get_result_string_data},
diff --git a/nix-bindings-store/src/store.rs b/nix-bindings-store/src/store.rs
index fa9adad..30d402b 100644
--- a/nix-bindings-store/src/store.rs
+++ b/nix-bindings-store/src/store.rs
@@ -1,11 +1,12 @@
 use anyhow::{bail, Error, Result};
 use lazy_static::lazy_static;
-use nix_bindings_bindgen_raw as raw;
+use nix_bindings_store_sys as raw;
 use nix_bindings_util::context::Context;
 use nix_bindings_util::string_return::{
     callback_get_result_string, callback_get_result_string_data,
 };
 use nix_bindings_util::{check_call, result_string_init};
+use nix_bindings_util_sys as raw_util;
 #[cfg(nix_at_least = "2.33.0pre")]
 use std::collections::BTreeMap;
 use std::collections::HashMap;
@@ -73,7 +74,7 @@ lazy_static! {
 
 #[cfg(nix_at_least = "2.33.0pre")]
 unsafe extern "C" fn callback_get_result_store_path_set(
-    _context: *mut raw::c_context,
+    _context: *mut raw_util::c_context,
     user_data: *mut std::os::raw::c_void,
     store_path: *const raw::StorePath,
 ) {
diff --git a/nix-bindings-bindgen-raw/Cargo.toml b/nix-bindings-util-sys/Cargo.toml
similarity index 78%
rename from nix-bindings-bindgen-raw/Cargo.toml
rename to nix-bindings-util-sys/Cargo.toml
index 7668b60..8811ead 100644
--- a/nix-bindings-bindgen-raw/Cargo.toml
+++ b/nix-bindings-util-sys/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "nix-bindings-bindgen-raw"
+name = "nix-bindings-util-sys"
 version = "0.1.0"
 edition = "2021"
 build = "build.rs"
@@ -8,6 +8,8 @@ license = "LGPL-2.1"
 [lib]
 path = "src/lib.rs"
 
+[dependencies]
+
 [build-dependencies]
 bindgen = "0.69"
 pkg-config = "0.3"
diff --git a/nix-bindings-util-sys/README.md b/nix-bindings-util-sys/README.md
new file mode 100644
index 0000000..82debbf
--- /dev/null
+++ b/nix-bindings-util-sys/README.md
@@ -0,0 +1,5 @@
+# nix-bindings-util-sys
+
+This crate contains generated bindings for the Nix C API (`nix-util-c`).
+**You should not have to use this crate directly,** and so you should probably not add it to your dependencies.
+Instead, use the `nix-bindings-util` crate, which _should_ be sufficient.
diff --git a/nix-bindings-util-sys/build.rs b/nix-bindings-util-sys/build.rs
new file mode 100644
index 0000000..441192a
--- /dev/null
+++ b/nix-bindings-util-sys/build.rs
@@ -0,0 +1,38 @@
+use std::path::PathBuf;
+
+#[derive(Debug)]
+struct StripNixPrefix;
+
+impl bindgen::callbacks::ParseCallbacks for StripNixPrefix {
+    fn item_name(&self, name: &str) -> Option<String> {
+        name.strip_prefix("nix_").map(String::from)
+    }
+}
+
+fn main() {
+    println!("cargo:rerun-if-changed=include/nix-c-util.h");
+    println!("cargo:rustc-link-lib=nixutilc");
+
+    let mut args = Vec::new();
+    for path in pkg_config::probe_library("nix-util-c")
+        .unwrap()
+        .include_paths
+        .iter()
+    {
+        args.push(format!("-I{}", path.to_str().unwrap()));
+    }
+
+    let out_path = PathBuf::from(std::env::var("OUT_DIR").unwrap());
+
+    let bindings = bindgen::Builder::default()
+        .header("include/nix-c-util.h")
+        .clang_args(args)
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
+        .parse_callbacks(Box::new(StripNixPrefix))
+        .generate()
+        .expect("Unable to generate bindings");
+
+    bindings
+        .write_to_file(out_path.join("bindings.rs"))
+        .expect("Couldn't write bindings!");
+}
diff --git a/nix-bindings-util-sys/include/nix-c-util.h b/nix-bindings-util-sys/include/nix-c-util.h
new file mode 100644
index 0000000..7fd0bc6
--- /dev/null
+++ b/nix-bindings-util-sys/include/nix-c-util.h
@@ -0,0 +1 @@
+#include <nix_api_util.h>
diff --git a/nix-bindings-util-sys/src/lib.rs b/nix-bindings-util-sys/src/lib.rs
new file mode 100644
index 0000000..0cf64d2
--- /dev/null
+++ b/nix-bindings-util-sys/src/lib.rs
@@ -0,0 +1,7 @@
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(dead_code)]
+#![allow(clippy::all)]
+
+include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
diff --git a/nix-bindings-util/Cargo.toml b/nix-bindings-util/Cargo.toml
index 9242e99..101e0e8 100644
--- a/nix-bindings-util/Cargo.toml
+++ b/nix-bindings-util/Cargo.toml
@@ -9,7 +9,9 @@ path = "src/lib.rs"
 
 [dependencies]
 anyhow = "1.0"
-nix-bindings-bindgen-raw = { path = "../nix-bindings-bindgen-raw" }
+nix-bindings-util-sys = { path = "../nix-bindings-util-sys" }
+
+[dev-dependencies]
 ctor = "0.2"
 
 [lints.rust]
diff --git a/nix-bindings-util/src/context.rs b/nix-bindings-util/src/context.rs
index 4999a7b..dbb333e 100644
--- a/nix-bindings-util/src/context.rs
+++ b/nix-bindings-util/src/context.rs
@@ -1,9 +1,9 @@
 use anyhow::{bail, Result};
-use nix_bindings_bindgen_raw as raw;
+use nix_bindings_util_sys as raw;
 use std::ptr::null_mut;
 use std::ptr::NonNull;
 
-/// A context for error handling, when interacting directly with the generated bindings for the C API in [nix_bindings_bindgen_raw].
+/// A context for error handling, when interacting directly with the generated bindings for the C API in [nix_bindings_util_sys].
 ///
 /// The `nix-store` and `nix-expr` libraries that consume this type internally store a private context in their `EvalState` and `Store` structs to avoid allocating a new context for each operation. The state of a context is irrelevant when used correctly (e.g. with [check_call!]), so it's safe to reuse, and safe to allocate more contexts in methods such as [Clone::clone].
 pub struct Context {
@@ -113,7 +113,7 @@ macro_rules! check_call_opt_key {
         {
             let ctx : &mut $crate::context::Context = $ctx;
             let ret = $($f)::*(ctx.ptr(), $($arg,)*);
-            if unsafe { raw::err_code(ctx.ptr()) == raw::err_NIX_ERR_KEY } {
+            if unsafe { $crate::raw_sys::err_code(ctx.ptr()) == $crate::raw_sys::err_NIX_ERR_KEY } {
                 ctx.clear();
                 return Ok(None);
             }
diff --git a/nix-bindings-util/src/lib.rs b/nix-bindings-util/src/lib.rs
index c74208c..f626d96 100644
--- a/nix-bindings-util/src/lib.rs
+++ b/nix-bindings-util/src/lib.rs
@@ -3,3 +3,6 @@ pub mod settings;
 #[macro_use]
 pub mod string_return;
 pub mod nix_version;
+
+// Re-export for use in macros
+pub use nix_bindings_util_sys as raw_sys;
diff --git a/nix-bindings-util/src/settings.rs b/nix-bindings-util/src/settings.rs
index 5b5b5ef..8c213aa 100644
--- a/nix-bindings-util/src/settings.rs
+++ b/nix-bindings-util/src/settings.rs
@@ -1,5 +1,5 @@
 use anyhow::Result;
-use nix_bindings_bindgen_raw as raw;
+use nix_bindings_util_sys as raw;
 use std::sync::Mutex;
 
 use crate::{
@@ -74,20 +74,20 @@ mod tests {
     fn setup() {
         let mut ctx = context::Context::new();
         unsafe {
-            check_call!(raw::libstore_init(&mut ctx)).unwrap();
+            check_call!(nix_bindings_util_sys::libutil_init(&mut ctx)).unwrap();
         }
     }
 
     #[test]
     fn set_get() {
         // Something that shouldn't matter if it's a different value temporarily
-        let key = "user-agent-suffix";
+        let key = "json-log-path";
 
         // Save the old value, in case it's important. Probably not.
         // If this doesn't work, pick a different setting to test with
         let old_value = get(key).unwrap();
 
-        let new_value = "just a string that we're storing into some option for testing purposes";
+        let new_value = "/just/a/path/that/we/are/storing/into/some/option/for/testing/purposes";
 
         let res_e = (|| {
             set(key, new_value)?;
diff --git a/nix-bindings-util/src/string_return.rs b/nix-bindings-util/src/string_return.rs
index 9851a0d..205cebe 100644
--- a/nix-bindings-util/src/string_return.rs
+++ b/nix-bindings-util/src/string_return.rs
@@ -52,9 +52,9 @@ macro_rules! result_string_init {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use nix_bindings_bindgen_raw as raw;
+    use nix_bindings_util_sys as raw;
 
-    /// Typecheck the function signature against the generated bindings in nix_bindings_bindgen_raw.
+    /// Typecheck the function signature against the generated bindings in nix_bindings_util_sys.
     static _CALLBACK_GET_RESULT_STRING: raw::get_string_callback = Some(callback_get_result_string);
 
     #[test]