Using Minimal Emacs with Nix

(defun gds-nix-flake-load () ... )

(defun gds-nix-unflake () ... )

git clone https://kindness.city/git/gds-elisp.git

;;; gds-nix-tools.el --- Use nix from emacs -*- lexical-binding: t; -*-

;; Copyright (C) 2026 Gareth Smith

;; Author: Gareth Smith
;; Created: 2 Feb 2026
;; Keywords: tools
;; URL: https://www.kindness.city/blog/2026-02-02-minimal-emacs-and-nix.html

;; This file is not part of GNU Emacs.

;;; Commentary:

;;   A couple of tiny functions for managing my $PATH in a world that
;; contains nix flakes.
;;
;;   From any directory that contains a `flake.nix', you can run
;; `gds-nix-flake-load'.  That function will add the PATH from the
;; flake to your current PATH environment variable.  At any time you
;; can run `gds-nix-unflake'.  That function will re-set the PATH
;; environment variable to its original value from when you first
;; loaded this package.
;;
;;   You can call `gds-nix-flake-load' multiple times without calling
;; `gds-nix-unflake' in between.  This is like calling `nix develop'
;; within a shell from a previous `nix develop' call.
;;
;;   This code only sets your PATH.  It does not attempt to mess with
;; LOAD_PATH or PYTHON_PATH or anything else that your nix flake
;; might manage for you.
;;
;;   If you want smarter management of more environment variables, I
;; recommend `direnv' with the `use flake' directive, and the Emacs
;; direnv package:
;;          https://github.com/wbolster/emacs-direnv

;;; Code:

(defvar gds-nix-default-PATH (getenv "PATH")
  "This is the 'default' or 'original' value of the PATH environment variable.

The one we return to when we're not operating within a nix flake.  You
can set it if you like, but you shouldn't need to.  We grab it from the
environment when the package is loaded.")

(defun gds-nix-flake-load ()
  "Load the PATH env var described by the flake in the current dir.

We use `nix develop --command' to get the PATH we should be
using."
  (interactive)
  (message "Evaluating flake...")
  (let* ((echoheader "echo \"********gds-nix-flake-load********\"")
         (echopath "echo \"${PATH}\"")
         (echocmd (format "%s ; %s" echoheader echopath))
         (proc (start-process
               "eval-flake" "*Flake Path*"
               "nix" "develop" "--command" "sh" "-c" echocmd)))
    (set-process-sentinel proc 'gds-nix-flake-set-path-from-buffer)))

(defun gds-nix-flake-set-path-from-buffer (process event)
  "When EVENT happens to PROCESS, set the current PATH env var.

EVENT must be a successful completion of PROCESS, or we'll error
out.  PROCESS must have printed a desired PATH into its buffer.  This
function is intended for use with `gds-nix-flake-load'."
  (unless (string-equal event "finished\n")
    (error "Failed to get nix-path in current directory: %s" event))

  (with-current-buffer (process-buffer process)
    (gds-nix-clear-buffer-of-all-but-latest-path)
    (let ((desired-path (buffer-string)))
      (setenv "PATH" desired-path)))
  (message "PATH has been set according to flake"))

(defun gds-nix-clear-buffer-of-all-but-latest-path ()
  "Clear extra gumph from this buffer.

Assuming this buffer has recieved the stdout and stderr of a call to
echopath, then everything above the line
'********gds-nix-flake-load********' will be nix build output, and
possibly output from previous calls to `gds-nix-flake-load'.  We don't
want any of that, so we delete it."
  (end-of-buffer)
  (search-backward "********gds-nix-flake-load********")
  (end-of-line)
  (delete-region 1 (point))
  (delete-char 1))

(defun gds-nix-unflake ()
  "Re-set the PATH env var to `gds-nix-default-PATH'."
  (interactive)
  (setenv "PATH" gds-nix-default-PATH))

(provide 'gds-nix-tools)

;;; gds-nix-tools.el ends here