Skip to content

About

Nix package overlay for Microchip development tools:

Resources

Stars

4 stars

Watchers

1 watching

Forks

Repository files navigation

Microchip development tools Nix Overlay

A Nix overlay for microchip development – intended for use in per-project environment flakes, home-manager configuration and/or NixOS configuration (for udev rules). See Packaging options and closure sizes to configure compilers and packs.

Table of Contents

Overview

This provides Nix packages for embedded firmware development for the Microchip 8-, 16- and 32-bit PIC families. xc-cli runs selected compilers without the MPLAB-X IDE, and mplab-x provides the IDE with the selection from xc-cli.

The packages included here are derived from original work by https://github.com/nyadiia, in a merge request raised against nixpkgs here: NixOS/nixpkgs#301317

I initially refactored them a bit and packaged as a flake for instant gratification for use in my own personal NixOS/home-manager based development configurations. In October 2026 I embarked on a major LLM-assisted rewrite to streamline packaging and reduce package size with a view to setting up firmware builds in CI. This was unblocked by Microchip’s recent (as of Oct 2026) elimination of the requirement for a paid license to use compiler optimisation.

Currently this provides packages for the following:

PackageLatestOthersLicensed
xc84.00 (xc8_4_00)3.10 (xc8_3_10), 2.50 (xc8_2_50)<= 3.10
xc162.10 (xc16_2_10)1.61 (xc16_1_61), 1.21 (xc16_1_21)<= 2.10
xc-dsc4.00 (xc-dsc_4_00)3.31 (xc-dsc_3_31)<= 3.31
xc326.00 (xc32_6_00)5.19 (xc32_5_19), 5.10 (xc32_5_10)<= 5.10
mplab-x (mplab-x-unwrapped)6.35nonenot applicable

The unversioned attribute of a compiler (e.g. xc16) gives its latest version. Select a versioned attribute (e.g. xc16_1_61) to keep a firmware build on one compiler version. A licensed version checks the shipped Microchip licence and runs in PRO mode; a later version needs no licence. See Compiler licence (PRO optimisations).

Only the latest verified MPLAB-X version is retained. Legacy compiler versions are retained for reproducible firmware builds; compiler-version requirements do not require us to retain older IDE packages.

Adding additional versions is trivial – see instructions in the section Adding packages.

Pull requests adding additional packages and/or addressing any of the project tasks (or others I haven’t considered) welcome.

Usage

The Microchip compilers and MPLAB-X are dynamically linked binaries, so they need an FHS environment on NixOS. The compiler packages are unwrapped. xc-cli wraps selected compilers in an FHS environment without the IDE. mplab-x wraps the IDE and the compiler selection from xc-cli in its FHS environment. I have not tested Microchip programmers because my development flow does not need them (hex image programming via a bootloader and debugging via log trace rather than ICD).

Here’s a sample flake illustrating use from a microchip project. This installs MPLAB-X and XC16 in a bubble-wrapped environment. The packages are for x86_64-linux only.

{
  description = "A Microchip firmware project environment";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
    microchip.url = "github:cormacc/nix-microchip";
  };

  outputs = { self, nixpkgs, microchip }:
    let
      pkgs = import nixpkgs {
        system = "x86_64-linux";
        config.allowUnfree = true;
        overlays = [ microchip.overlays.default ];
      };
      xc-cli = pkgs.xc-cli.override {
        compilers = with pkgs; [ xc16_1_61 ];
      };
      mplab-x = pkgs.mplab-x.override {
        inherit xc-cli;
      };
    in
    {
      devShells.x86_64-linux.default = pkgs.mkShell {
        buildInputs = with pkgs; [
          xc-cli # XC16 1.61 and its default device packs
          mplab-x # IDE with the same XC16 and bundled tool packs
          cmake clang-tools #editor support (emacs/lsp)
        ];
      };
    };
}

Command-line use

Use xc-cli for a compiler-only environment. It has no default compilers. It supplies xc-run <command> [args...], xc-make [args...] and a wrapper for each executable of the first selected compiler of each family. xc-make runs GNU Make in the environment, forwards its arguments and preserves its exit status. See Packaging options and closure sizes for pack selection.

Set the compiler and device-pack selection on xc-cli, then pass that package to mplab-x. Two or more versions of one compiler can coexist. The first compiler of each family in the list supplies the xc-cli command-line wrapper:

let
  xc-cli = pkgs.xc-cli.override {
    compilers = with pkgs; [ xc16_1_61 xc16_2_10 ];
    packs = [
      (pkgs.fetchMplabPack {
        name = "dsPIC33E-GM-GP-MC-GU-MU_DFP";
        version = "1.5.258";
        hash = "sha256-GdndiTwmMizusNoGvP3TleTiD9E5LidbJoUEEjS0se0=";
      })
    ];
  };
in [
  xc-cli
  (pkgs.mplab-x.override { inherit xc-cli; })
]

With this devshell, MPLAB-X can use both versions. xc16-gcc from xc-cli runs v1.61, and xc-run /opt/microchip/xc16/v2.10/bin/xc16-gcc or mplab-x-run /opt/microchip/xc16/v2.10/bin/xc16-gcc runs v2.10. The selected DFP is at /opt/microchip/mplabx/v6.35/packs/Microchip/dsPIC33E-GM-GP-MC-GU-MU_DFP/1.5.258/xc16 for -mdfp.

Set withMplabProjects = true on xc-cli to add the command-line MPLAB-X subset and mplab-gen <project>@<configuration>.... It generates MPLAB makefiles with each selected compiler. See MPLAB projects for development-shell, derivation and CI use.

The mplab-x package also supplies these commands:

  • mplab-x-run <command> [args...] runs a command inside the MPLAB-X environment. In this environment, each compiler selected by xc-cli is at /opt/microchip/<compiler>/v<version>, where MPLAB-X expects it.
  • mplab-make [args...] runs the packaged GNU Make inside the MPLAB-X environment. It forwards arguments and preserves its exit status; ordinary make is unchanged.
  • mplab-gen <project>@<configuration>... generates MPLAB makefiles with each compiler selected by xc-cli. This generator uses the full IDE.
  • mplab_ipe starts the IPE GUI, and ipecmd runs the IPE command line.

Only mplab-gen, mplab_ipe and ipecmd bind the IDE or command-line subset at /opt/microchip/mplabx/v<version>, because the makefile generator and IPE derive their paths from their own location. The generated makefiles name /opt/microchip/... paths, not Nix store paths. mplab-make, mplab-x-run, xc-make and compiler wrappers run without this bind.

Before it starts, mplab_ide removes each PATH directory that contains mplab-x-run or xc-run. This prevents the IDE from registering wrapper directories as duplicate toolchains.

The compilers must run unmodified in this environment. A compiler that is patched to run directly on NixOS (autoPatchelfHook) detects the change and runs in Free mode. See Compiler licence (PRO optimisations).

Use mplab-make for MPLAB-generated makefiles. Their local settings prepend the IDE’s unwrapped bin directory to PATH, so a recursive make or another bundled tool can fail on NixOS outside the environment, even when the compiler commands are wrapped. For example, from examples/mplab (see MPLAB projects):

mplab-make -C firmware.X -j8 -f Makefile CONF=default

See Runtime environment for the set-up cost of each call, nested calls, the visible host directories and the limits of the environment.

Nix derivations and CMake

A derivation can use xc-cli as a native build input. This example compiles, links and produces main.hex in the Nix build sandbox; xclm -status confirms PRO mode. Its device needs no DFP, so packs = [ ] keeps the default device packs out of the build.

let
  xc-cli = pkgs.xc-cli.override {
    compilers = with pkgs; [ xc16_1_61 ];
    packs = [ ];
  };
in pkgs.stdenvNoCC.mkDerivation {
  pname = "xc16-firmware";
  version = "1";
  src = ./.;
  nativeBuildInputs = [ xc-cli ];
  buildPhase = ''
    xc16-gcc -mcpu=33EP512MU810 -O3 -c main.c -o main.o
    xc16-gcc -mcpu=33EP512MU810 main.o -Wl,-Tp33EP512MU810.gld -o main.elf
    xc16-bin2hex main.elf
    xclm -status > licence-status.txt
    grep -F 'Mode: PRO' licence-status.txt
  '';
  installPhase = ''
    install -Dm444 main.hex $out/main.hex
  '';
}

For a CMake project, put xc-cli, cmake and gnumake in the development shell:

let
  xc-cli = pkgs.xc-cli.override {
    compilers = with pkgs; [ xc16_1_61 ];
    packs = [ ];
  };
in pkgs.mkShell {
  packages = [ xc-cli pkgs.cmake pkgs.gnumake ];
}

Use this CMakeLists.txt and toolchain.cmake:

cmake_minimum_required(VERSION 3.20)
project(xc_cli_cmake C)

add_executable(probe main.c)
target_compile_options(probe PRIVATE -mcpu=33EP512MU810)
target_link_options(probe PRIVATE -Wl,-Tp33EP512MU810.gld)
set(CMAKE_SYSTEM_NAME Generic)
set(CMAKE_SYSTEM_PROCESSOR dspic)
set(CMAKE_C_COMPILER xc16-gcc)
cmake -S . -B build -DCMAKE_TOOLCHAIN_FILE="$PWD/toolchain.cmake"
cmake --build build

CMake 4.4.4 configured and built the ELF with these settings. It recognised the compiler as GNU 4.5.1, and needed no compiler-detection workaround.

MPLAB projects

Use the command-line MPLAB-X subset for a project with nbproject/configurations.xml. Select the compiler and DFP, then set withMplabProjects = true:

let
  dfp = pkgs.fetchMplabPack {
    name = "dsPIC33E-GM-GP-MC-GU-MU_DFP";
    version = "1.7.401";
    hash = "sha256-NSLRbSv/UQcvVhFLhqc+eQixQupAA5aFuCwdoHyVEyc=";
  };
  xc-cli = pkgs.xc-cli.override {
    compilers = [ pkgs.xc16_1_61 ];
    packs = [ dfp ];
    withMplabProjects = true;
  };
in pkgs.mkShell {
  packages = [ xc-cli ];
}

examples/mplab/firmware.X is a minimal project for this selection: one C file for the dsPIC33EP512GM710 and one configuration, default. From examples/mplab, generate then build it. The hex file is firmware.X/dist/default/production/firmware.X.production.hex:

mplab-gen firmware.X@default
xc-make -C firmware.X -j8 -f Makefile CONF=default

In CI, either generate with mplab-gen before each xc-make build, or commit and control your own generated makefiles and build them without mplab-gen. Keep the same nbproject/private state when generation must be reproducible: it can change generated output, including the dependency footer. The compiler selection passed by mplab-gen does not use toolchain paths from that directory. Makefiles that the GUI writes contain Nix store paths; regenerate them with mplab-gen before committing them.

A Nix derivation needs a writable home directory that the runner binds, a writable TMPDIR for parallel Make, and JAVA_TOOL_OPTIONS so the pack library uses that home directory. This verified example builds the example project when src is examples/mplab:

let
  dfp = pkgs.fetchMplabPack {
    name = "dsPIC33E-GM-GP-MC-GU-MU_DFP";
    version = "1.7.401";
    hash = "sha256-NSLRbSv/UQcvVhFLhqc+eQixQupAA5aFuCwdoHyVEyc=";
  };
  xc-cli = pkgs.xc-cli.override {
    compilers = [ pkgs.xc16_1_61 ];
    packs = [ dfp ];
    withMplabProjects = true;
  };
in pkgs.stdenvNoCC.mkDerivation {
  pname = "mplab-firmware";
  version = "1";
  src = ./.;
  nativeBuildInputs = [ xc-cli ];
  buildPhase = ''
    export TMPDIR=/tmp
    export HOME=/tmp/mplab-home
    mkdir -p "$HOME"
    rm -f firmware.X/nbproject/Makefile-*.mk
    JAVA_TOOL_OPTIONS="-Duser.home=$HOME" mplab-gen firmware.X@default
    xc-make -C firmware.X -j"$NIX_BUILD_CORES" -f Makefile CONF=default
    xclm -status > licence-status.txt
    grep -F 'Mode: PRO' licence-status.txt
  '';
  installPhase = ''
    install -Dm444 firmware.X/dist/default/production/firmware.X.production.hex "$out/firmware.hex"
  '';
}

CI container images

The MPLAB CI example builds the minimal firmware.X project in a locally built, published toolchain image. It includes two pipelines:

GitHub Actions
firmware.yml pulls the private image with GITHUB_TOKEN, builds the firmware and uploads the hex.
GitLab CI
gitlab-ci.yml runs directly in the same image on a Docker executor and saves the hex artifact. See the example instructions for private-registry authentication and protected-ref setup.

Use nix build '.#ci-image' to build the example image. The instructions cover publishing to ghcr.io/cormacc/nix-microchip-ci and recording its registry digest. nix develop '.#mplab-example' provides the same compiler and pack selection locally.

Project-specific images with Babashka

Build an image for another MPLAB-X project without writing a Nix expression:

stream=$(bb ci-image --project examples/mplab/firmware.X --name firmware-ci)
"$stream" | docker load

The task accepts a project directory or its nbproject/configurations.xml. It detects the exact compiler version and packs from one configuration; use --configuration <name> if the project has more than one. Alternatively, pass --compiler xc16_1_61 and repeatable --pack Microchip/<name>/<version> arguments. The task builds an MPLAB-capable image and prints its stream script path; it does not load or publish the image. See the image-task instructions for both forms and bb ci-image --help for the options.

Images in a Nix flake

The xc-cli and mplab-x commands run in a bubblewrap environment that needs unprivileged user namespaces. Docker’s default seccomp profile blocks them, so these commands fail in a Docker CI job that does not use --privileged or a changed seccomp profile. For such a runner, mkCiImage builds a Docker image from an xc-cli package. The image root is the root filesystem of the xc-cli environment, so the commands of the development shell run in the image without bubblewrap. mkCiImage is a function in legacyPackages and the overlay:

let
  dfp = pkgs.fetchMplabPack {
    name = "dsPIC33E-GM-GP-MC-GU-MU_DFP";
    version = "1.7.401";
    hash = "sha256-NSLRbSv/UQcvVhFLhqc+eQixQupAA5aFuCwdoHyVEyc=";
  };
  xc-cli = pkgs.xc-cli.override {
    compilers = [ pkgs.xc16_1_61 ];
    packs = [ dfp ];
    withMplabProjects = true;
  };
in {
  packages.x86_64-linux.ci-image = pkgs.mkCiImage {
    inherit xc-cli;
    extraPackages = [ pkgs.git ];
  };
}
xc-cli
the compiler and pack selection.
extraPackages
packages whose bin directories are also on the image PATH. The default is [ ].
name
the image name. The default is "xc-cli".
tag
the image tag. The default, null, gives a tag that Nix derives from the image contents.

The package is a script that writes the image to stdout. Load the image, then run the commands of the development shell in it:

$(nix build --no-link --print-out-paths '.#ci-image') | docker load
docker run --rm -v "$PWD:/src" -w /src xc-cli:<tag> \
  sh -c 'mplab-gen firmware.X@default && xc-make -C firmware.X -j8 -f Makefile CONF=default'

With xc16 1.61, the 1.7.401 DFP and withMplabProjects = true, the image was 3.25 GB. It built an MPLAB project under Docker’s default seccomp profile, without --privileged, to a hex file byte-identical to the development-shell build (measured 2026-10-23, Docker 29.9.1). For mplab-gen, the image contains a real copy of the command-line IDE files (274 MB), because the makefile generator derives its paths from its own location. The image runs commands as root; a non-root container user is not tested. See Runtime environment for the differences from the bubblewrap environment.

Device packs

A device family pack (DFP) gives the compilers the device headers, linker scripts and device data. MPLAB-generated makefiles pass -mdfp to each compile, link and xc16-bin2hex step. XC8 3.10 and later, XC32 and XC-DSC 4.00 need -mdfp for all devices; XC-DSC 3.31 needs it for a device without built-in support, e.g. dsPIC33CK64MP105 (measured 2026-10-21). A tool pack (TP) gives MPLAB-X the support for a programmer or debugger.

The mplab-x environment has one packs folder, /opt/microchip/mplabx/v<version>/packs. The IDE and the MPLAB-X command-line scripts (e.g. prjMakefilesGenerator.sh) use it, and the makefiles that they generate set DFP_DIR to a pack in it, e.g. /opt/microchip/mplabx/v6.35/packs/Microchip/dsPIC33E-GM-GP-MC-GU-MU_DFP/1.5.258. Packs that the IDE downloads go to ~/.mchp_packs, as on other Linux installations.

See Packaging options and closure sizes for the default packs of xc-cli and mplab-x, pack selection, fetchMplabPack pins, compiler -mdfp paths, pack hashes and pack sizes.

Udev rules

Two types of USB access are related to udev rules:

Hardware tools
MPLAB-X uses a programmer or debugger (PICkit, ICD, SNAP etc.) only if the user can open its USB device. The mplab-x-unwrapped package ships Microchip’s udev rules in lib/udev/rules.d. They give world read/write access (MODE“666”=) to Microchip, Atmel and J-Link USB devices, so no group membership is necessary.
Licence dongle scan
The licence manager of the licensed compilers (xclm) opens every USB device on the bus to look for a licence dongle, and prints Error getting handle for device N: Access denied (insufficient permissions) for each device that the user cannot open. The messages do not change the exit status, and Microchip’s rules do not remove them. See Compiler licence.

To remove the messages, also give the user access to all USB devices with the uaccess tag. systemd-logind then gives the user of the active local session an ACL on each USB device. A user without an active local session (e.g. a CI runner) still gets the messages. Do not add this rule if local users must not have raw access to all USB devices, such as keyboards and security keys. The uaccess tag has an effect only in a rules file that sorts before 73-seat-late.rules. Thus, on NixOS, services.udev.extraRules (which writes 99-local.rules) is too late.

udev runs on the host, outside the bubblewrap environment, so install the rules at system level. On NixOS:

# In a NixOS module. The NixOS pkgs set is separate from any Home Manager or
# devShell pkgs set, so apply the overlay here too:
nixpkgs.overlays = [ microchip.overlays.default ];
services.udev.packages = [
  pkgs.mplab-x-unwrapped
  # or, without the overlay:
  # microchip.packages.x86_64-linux.mplab-x-unwrapped

  # Optional: access to all USB devices, which removes the licence dongle scan messages.
  (pkgs.writeTextDir "lib/udev/rules.d/71-usb-uaccess.rules" ''
    SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_device", TAG+="uaccess"
  '')
];

…then rebuild and replug the device (or run sudo udevadm control --reload-rules && sudo udevadm trigger).

On other distros, copy the rules into /etc/udev/rules.d/ instead:

sudo cp $(nix build .#mplab-x-unwrapped --print-out-paths)/lib/udev/rules.d/* /etc/udev/rules.d/
# Optional: access to all USB devices, which removes the licence dongle scan messages.
echo 'SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_device", TAG+="uaccess"' | sudo tee /etc/udev/rules.d/71-usb-uaccess.rules
sudo udevadm control --reload-rules && sudo udevadm trigger

Compiler licence (PRO optimisations)

Microchip gives the previously paid MPLAB XC PRO licence free of charge. The microchip-xclm-license package ships it, and each licensed compiler version (see the package table in Overview) points its licence manager at that package, so the compilers run in PRO mode without a manual licence step. Without the licence, they run in Free mode, which limits the optimisation levels.

See Compiler licence for the licence features, the details for each compiler version, the two PRO-mode probes (xclm -status and an -O3 compile) and what to do if Microchip reissues the licence.

Installers that need a Microchip login

Microchip serves some older installers only after a login to a Microchip account, so Nix cannot download them. On 2026-11-13, this applied to the installers of xc16_1_61, xc8_2_50 and xc-dsc_3_31. Their version files set loginRequired = true: while such an installer is not in the Nix store (e.g. after garbage collection), a build that needs it stops with a message that names the file and the steps below. If Microchip moves another installer behind a login, its download redirects to Microchip’s file handler or login page, and the build stops with the same steps; set loginRequired = true in that version file to skip the download attempt. Microchip’s file handler also takes URLs that do not exist, so the message cannot tell a login gate from a moved file. This includes a local CI image build (bb ci-image or mkCiImage). CI pipelines that pull a published image do not download installers, so they are not affected.

To add such an installer to the store:

  1. Log in to your Microchip account, and download the installer from the MPLAB XC compiler archive.
  2. Put the file in installers/ in this checkout. Git ignores this folder.
  3. Run bb installers import. The task adds each file in installers/ to the Nix store as the path that its package expects, and stops if a file does not match the pinned hash.

The store path depends only on the file name and hash, so the imported installer also serves flakes that use this repository as an input. bb installers shows, for each packaged installer, whether it is in the store and in installers/. bb installers save copies each packaged installer that is in the store into installers/. Run it before garbage collection to keep the installers for later builds.

Adding packages

Compilers

For a new Linux release of an existing compiler family, bb package downloads/hashes the installer and previews the version file and registration. The default dry run does not execute the installer or change package files:

bb package --url \
  'https://ww1.microchip.com/downloads/aemDocuments/documents/DEV/ProductDocuments/SoftwareTools/xc16-v2.10-full-install-linux64-installer.run'
bb package --family xc16 --version 2.10 --verify

The existing 2.10 package can be previewed or verified, not overwritten. For an installer that needs a Microchip login, download it and give --file <installer> instead of --url; the version file then sets loginRequired = true. For a new release, add --write to apply the preview and --verify to require a successful version/compile/link/licence check before writing. The task leaves default versions, flake.lock and Git staging unchanged. See Packaging options and closure sizes for supported URLs, verification profiles and the manual staging step.

Each compiler directory (./pkgs/xc8, ./pkgs/xc16, ./pkgs/xc32 and ./pkgs/xc-dsc) has a shared common.nix, which holds the packaging work derived from nyadiia’s. To add a version manually, create a file with the version and installer archive hash in that directory, for example ./pkgs/xc16/1.61.nix:

import ./common.nix {
  version = "1.61";
  hash = "sha256-Wi0vhJWt+WiNq41daf7e7tJeJmt3/M3t2TJbkJQTNEg=";
  loginRequired = true;
}

Set loginRequired = true only if Microchip serves the installer only after a login (see Installers that need a Microchip login).

Then add a line to ./pkgs/default.nix:

xc16_1_61 = pkgs.callPackage ./xc16/1.61.nix { inherit microchip-xclm-license; };

Pass microchip-xclm-license explicitly for every compiler: both packages and overlays.default in ./flake.nix give pkgs/default.nix a nixpkgs set without this flake’s packages, so callPackage cannot find it in pkgs. See Compiler licence (PRO optimisations).

Version-specific packaging:

  • XC16 before 1.50 is 32-bit. For these versions, ./pkgs/xc16/common.nix fetches xc16-v<version>-linux-installer.run.tar from the DeviceDoc location, installs with 32-bit glibc, and does not give the --LicenseType option, which these installers do not have. This is verified for 1.21 only.
  • The XC32 and XC-DSC package files gate the xclm.conf rewrite and the installer licence flags on the version (XC32 below 5.19, XC-DSC below 4.00).
  • The environment links each compiler as /opt/microchip/<compiler>/v<version>, which is where the installers install by default.

MPLAB-X

To upgrade MPLAB-X, add a version file in ./pkgs/mplab-x-unwrapped/ and register it in ./pkgs/default.nix. Build and verify the new IDE before changing mplab-x-unwrapped to point to it. Once verified, remove the superseded IDE version files and their package attributes.

The version file, e.g. ./pkgs/mplab-x-unwrapped/6.35.nix, calls common.nix with the version and installer hash, and builds commandLineSubset from the inventory of that version, <version>-headless-files.txt:

unwrapped = callPackage (import ./common.nix {
  version = "6.35";
  hash = "sha256-THRzY9z7MVcmQ5+WjQ4lsLFyFLubpdL9Sn87qyjFZwU=";
}) { };

The corresponding entries in ./pkgs/default.nix are:

mplab-x-unwrapped_6_35 = pkgs.callPackage ./mplab-x-unwrapped/6.35.nix { };
mplab-x-unwrapped = mplab-x-unwrapped_6_35;

To regenerate an inventory after tracing one generator run and one or more builds, first build the unwrapped IDE and record the generator and build traces with strace -f -e trace=%file,%process. Then run:

ide=$(nix build '.#mplab-x-unwrapped' --no-link --print-out-paths)
bb pkgs/mplab-x-unwrapped/regenerate-headless-files.clj \
  "$ide/opt/microchip/mplabx/v6.35" \
  /opt/microchip/mplabx/v6.35 \
  generator.trace build.trace > pkgs/mplab-x-unwrapped/6.35-headless-files.txt

The first path is the installed payload, and the second is the IDE path in the traced environment. Give each build trace as an additional final argument. Review the generated inventory before committing it; the script retains the conservative fixDeps, extractobjectdependencies.jar and en_msgs.txt additions.

Improvement opportunities

See ./TASKS.org

LLM usage statement

This flake was originally written and maintained by humans. Commits from 20/10/2026 forward are all robot-authored. Because life’s too short to write nix by hand.

About

Nix package overlay for Microchip development tools:

Resources

Stars

4 stars

Watchers

1 watching

Forks

Releases

Packages

Contributors

Languages