clean up & consoldiation of custom pkgs from flakes & herdr

This commit is contained in:
ari committed 2026-09-09 11:46:46 -04:00
1 parent 6229440107
commit bdfcb9e814
22 files changed
+207 -446

No files matched your search

-2
View File
@@ -11,9 +11,7 @@ Packages here are exposed via an overlay defined in `modules/core/default.nix`.
| `ds4/` | DwarfStar (`antirez/ds4`) DeepSeek V4 local inference engine, built from source. Backend-parameterized (`backend = "cpu" \| "rocm" \| "cuda"`); tracks `main` and builds per-host. Exposed as `pkgs.ds4` (cpu, default), `pkgs.ds4-rocm` (Strix Halo / gfx1151), `pkgs.ds4-cuda`. Installs the `ds4`, `ds4-server`, `ds4-bench`, `ds4-eval`, `ds4-agent` binaries plus a `ds4-download-model` helper for fetching GGUF weights. Model weights are a runtime concern and not packaged. |
| `colibri/` | colibrì (`JustVugg/colibri`) — GLM-5.2/OLMoE local inference engine, built from source, pinned to a tagged release. Backend-parameterized (`backend = "cpu" \| "rocm"`). Exposed as `pkgs.colibri` (cpu, default), `pkgs.colibri-rocm` (Strix Halo / gfx1151). Installs the `coli` CLI (wrapped with the Python env its converter/bench subcommands need) plus the bundled `colibri`/`olmoe` engine binaries. Model weights are a runtime concern and not packaged. |
| `niri-touchscreen-gestures/` | Python daemon that reads multi-touch events from a touchscreen via `evdev`, detects 2/3/4-finger swipes (up/down/left/right), and dispatches configurable `niri msg action` commands. Configured via TOML; exposed as `pkgs.niri-touchscreen-gestures`. |
| `ollama/` | Ollama local LLM inference server, pinned ahead of nixpkgs (0.32.14 vs 0.32.7 in stable/unstable). Derived from nixpkgs master's 0.32.13 derivation (FetchContent-based llama.cpp, Vulkan/ROCm backends) bumped to 0.32.14. Exposed as `pkgs.ollama` (cpu), `pkgs.ollama-rocm` (Strix Halo / gfx1151), `pkgs.ollama-vulkan`. |
| `buzz-desktop/` | Block Buzz desktop (Type-2 AppImage from `block/buzz`). Wrapped with `appimageTools.wrapType2` plus extra FHS libs (`elfutils`, `zstd`, WebKit/tray, GStreamer good/bad) so it runs on NixOS. Exposed as `pkgs.buzz-desktop` (`buzz-desktop` binary + desktop entry / icons). |
| `claude-desktop/` | Claude Desktop (Linux) — `.deb` fetched from `downloads.claude.ai`, unpacked and re-wrapped with `makeWrapper` (binary moved aside, `LD_LIBRARY_PATH` pointed at its bundled libs). Exposed as the `claude-desktop` flake output (via `pkgs.callPackage` in `flake.nix`, not the core overlay) and installed on `fwbook`. |
## Adding a New Package
-339
View File
@@ -1,339 +0,0 @@
# ollama — local LLM inference server, version-pinned ahead of nixpkgs.
#
# Derived from nixpkgs master's ollama package.nix at the 0.32.13 commit
# (which introduced the FetchContent-based llama.cpp build, Vulkan/ROCm/CUDA
# backends, and spirv-headers). Updated to 0.32.14.
#
# UPDATING THIS PACKAGE
# =====================
# 1. Set `version` to the new tag (without "v").
# 2. Set `src.hash` to `lib.fakeHash` and attempt a build.
# Copy the "got: sha256-..." value from the Nix error output.
# 3. Set `vendorHash` to `lib.fakeHash` and attempt a build again.
# Copy the "got: sha256-..." value from the Nix error output.
# 4. Check whether LLAMA_CPP_VERSION changed in the new release tag.
# If so, also update `llamaCppVersion` and `llamaCppSrc.hash`.
{ lib
, buildGoModule
, fetchFromGitHub
, buildEnv
, makeBinaryWrapper
, stdenv
, addDriverRunpath
, cmake
, gitMinimal
, clblast
, libdrm
, rocmPackages
, rocmGpuTargets ? rocmPackages.clr.localGpuTargets or (rocmPackages.clr.gpuTargets or [ ])
, cudaPackages
, cudaArches ? cudaPackages.flags.realArches or [ ]
, autoAddDriverRunpath
, apple-sdk_15
, vulkan-tools
, vulkan-headers
, vulkan-loader
, spirv-headers
, shaderc
, ccache
, versionCheckHook
, writableTmpDirAsHomeHook
, config
, # one of `[ null false "rocm" "cuda" "vulkan" ]`
acceleration ? null
,
}:
assert builtins.elem acceleration [
null
false
"rocm"
"cuda"
"vulkan"
];
let
validateFallback = lib.warnIf (config.rocmSupport && config.cudaSupport)
(lib.concatStrings [
"both `nixpkgs.config.rocmSupport` and `nixpkgs.config.cudaSupport` are enabled, "
"but they are mutually exclusive; falling back to cpu"
])
(!(config.rocmSupport && config.cudaSupport));
shouldEnable =
mode: fallback: (acceleration == mode) || (fallback && acceleration == null && validateFallback);
rocmRequested = shouldEnable "rocm" config.rocmSupport;
cudaRequested = shouldEnable "cuda" config.cudaSupport;
vulkanRequested = acceleration == "vulkan";
enableRocm = rocmRequested && stdenv.hostPlatform.isLinux;
enableCuda = cudaRequested && stdenv.hostPlatform.isLinux;
enableVulkan = vulkanRequested && stdenv.hostPlatform.isLinux;
rocmLibs = [
rocmPackages.clr
rocmPackages.hipblas-common
rocmPackages.hipblas
rocmPackages.rocblas
rocmPackages.rocsolver
rocmPackages.rocsparse
rocmPackages.rocm-device-libs
rocmPackages.rocm-smi
];
rocmPath = buildEnv {
name = "rocm-path";
paths = rocmLibs;
};
cudaLibs = [
cudaPackages.cuda_cudart
cudaPackages.libcublas
cudaPackages.cccl
];
vulkanLibs = [
vulkan-headers
vulkan-loader
];
cudaMajorVersion = lib.versions.major cudaPackages.cuda_cudart.version;
cudaToolkit = buildEnv {
name = "cuda-merged-${cudaMajorVersion}";
paths = map lib.getLib cudaLibs ++ [
(lib.getOutput "static" cudaPackages.cuda_cudart)
(lib.getBin (cudaPackages.cuda_nvcc.__spliced.buildHost or cudaPackages.cuda_nvcc))
];
ignoreCollisions = true;
};
cudaPath = lib.removeSuffix "-${cudaMajorVersion}" cudaToolkit;
# Since v0.30, llama.cpp is consumed via CMake FetchContent rather than
# vendored in-tree. Pre-stage the pin so the FetchContent step uses our
# copy instead of trying to clone over the network in the sandbox.
# Check LLAMA_CPP_VERSION in the ollama source tree when bumping.
llamaCppVersion = "b10434";
llamaCppSrc = fetchFromGitHub {
owner = "ggml-org";
repo = "llama.cpp";
tag = llamaCppVersion;
hash = "sha256-Sz0kW1q91YzdrKbZUqMbFJ0DLZrzARSGheUrtCKcoQo=";
};
wrapperOptions = [
"--suffix LD_LIBRARY_PATH : '${addDriverRunpath.driverLink}/lib'"
]
++ lib.optionals enableRocm [
"--suffix LD_LIBRARY_PATH : '${rocmPath}/lib'"
"--set-default HIP_PATH '${rocmPath}'"
]
++ lib.optionals enableCuda [
"--suffix LD_LIBRARY_PATH : '${lib.makeLibraryPath (map lib.getLib cudaLibs)}'"
]
++ lib.optionals enableVulkan [
"--suffix LD_LIBRARY_PATH : '${lib.makeLibraryPath (map lib.getLib vulkanLibs)}'"
"--set-default OLLAMA_VULKAN '1'"
];
wrapperArgs = builtins.concatStringsSep " " wrapperOptions;
goBuild =
if enableCuda then
buildGoModule.override { stdenv = cudaPackages.backendStdenv; }
else if enableRocm then
buildGoModule.override { inherit (rocmPackages) stdenv; }
else if enableVulkan then
buildGoModule.override { inherit (vulkan-tools) stdenv; }
else
buildGoModule;
inherit (lib) licenses platforms maintainers;
in
goBuild (finalAttrs: {
pname = "ollama";
version = "0.32.14";
src = fetchFromGitHub {
owner = "ollama";
repo = "ollama";
tag = "v${finalAttrs.version}";
hash = "sha256-wvEG7L61gYI63pfHZ9UnTVQh8QMG3wHMfxEBeshtIKQ=";
};
vendorHash = "sha256-HMwoaFBMbpoy8f0I+O+i7kIa9BslLu3FcVWeaIOkpvs=";
proxyVendor = true;
env =
lib.optionalAttrs enableRocm
{
ROCM_PATH = rocmPath;
CLBlast_DIR = "${clblast}/lib/cmake/CLBlast";
HIP_PATH = rocmPath;
CFLAGS = "-Wno-c++17-extensions -I${rocmPath}/include";
CXXFLAGS = "-Wno-c++17-extensions -I${rocmPath}/include";
}
// lib.optionalAttrs enableCuda { CUDA_PATH = cudaPath; }
// lib.optionalAttrs enableVulkan { VULKAN_SDK = shaderc.bin; };
nativeBuildInputs = [
cmake
gitMinimal
]
++ lib.optionals enableRocm (
rocmLibs
++ [
rocmPackages.llvm.bintools
]
)
++ lib.optionals enableCuda [ cudaPackages.cuda_nvcc ]
++ lib.optionals (enableRocm || enableCuda) [
makeBinaryWrapper
autoAddDriverRunpath
]
++ lib.optionals enableVulkan [
ccache
spirv-headers
];
buildInputs =
lib.optionals enableRocm (rocmLibs ++ [ libdrm ])
++ lib.optionals enableCuda cudaLibs
++ lib.optionals stdenv.hostPlatform.isDarwin [ apple-sdk_15 ]
++ lib.optionals enableVulkan vulkanLibs;
postPatch = ''
substituteInPlace version/version.go \
--replace-fail 0.0.0 '${finalAttrs.version}'
rm cmd/launch/*_test.go
rm -r app
if [[ ${llamaCppVersion} != $(cat LLAMA_CPP_VERSION) ]]; then
echo "llama-cpp version mismatch, expected ${llamaCppVersion}, but found $(cat LLAMA_CPP_VERSION)"
exit 1
fi
cp -r ${llamaCppSrc} $TMPDIR/llama-cpp-src
chmod -R +w $TMPDIR/llama-cpp-src
( cd $TMPDIR/llama-cpp-src && \
cmake -DPATCH_DIR=$NIX_BUILD_TOP/source/llama/compat \
-P $NIX_BUILD_TOP/source/llama/compat/apply-patch.cmake )
'';
overrideModAttrs = _: _: {
preBuild = "";
};
preBuild =
let
removeSMPrefix =
str:
let
matched = builtins.match "sm_(.*)" str;
in
if matched == null then str else builtins.head matched;
cudaArchitectures = builtins.concatStringsSep ";" (map removeSMPrefix cudaArches);
rocmTargets = builtins.concatStringsSep ";" rocmGpuTargets;
rocmMajorVersion = lib.versions.major rocmPackages.clr.version;
rocmMinorVersion = lib.versions.minor rocmPackages.clr.version;
llamaBackend =
if enableCuda then
"cuda_v${cudaMajorVersion}"
else if enableRocm then
"rocm_v${rocmMajorVersion}_${rocmMinorVersion}"
else if enableVulkan then
"vulkan"
else
"";
cmakeFlagsCudaArchitectures = lib.optionalString enableCuda "-DCMAKE_CUDA_ARCHITECTURES='${cudaArchitectures}'";
cmakeFlagsRocmTargets = lib.optionalString enableRocm "-DAMDGPU_TARGETS='${rocmTargets}'";
cmakeFlagsBackend = lib.optionalString
(
llamaBackend != ""
) "-DOLLAMA_LLAMA_BACKENDS=${llamaBackend}";
in
''
${lib.optionalString enableVulkan ''
export CMAKE_PREFIX_PATH="${spirv-headers}''${CMAKE_PREFIX_PATH:+:$CMAKE_PREFIX_PATH}"
export NIX_CFLAGS_COMPILE="-isystem ${spirv-headers}/include $NIX_CFLAGS_COMPILE"
''}
cmake -B build \
-DCMAKE_SKIP_BUILD_RPATH=ON \
-DCMAKE_BUILD_WITH_INSTALL_RPATH=ON \
-DFETCHCONTENT_SOURCE_DIR_LLAMA_CPP="$TMPDIR/llama-cpp-src" \
-DOLLAMA_MLX_BACKENDS="" \
$cmakeFlags \
${cmakeFlagsCudaArchitectures} \
${cmakeFlagsRocmTargets} \
${cmakeFlagsBackend}
cmake --build build -j $NIX_BUILD_CORES
'';
preFixup = lib.optionalString stdenv.hostPlatform.isLinux ''
find $out/lib/ollama -type f \( -name '*.so' -o -name '*.so.*' \) \
-exec patchelf --shrink-rpath --allowed-rpath-prefixes /nix/store {} +
'';
postInstall = ''
mkdir -p $out/lib
cp -r build/lib/ollama $out/lib/
'';
postFixup =
lib.optionalString (enableRocm || enableCuda) ''
wrapProgram "$out/bin/ollama" ${wrapperArgs}
'';
ldflags = [
"-X=github.com/ollama/ollama/version.Version=${finalAttrs.version}"
"-X=github.com/ollama/ollama/server.mode=release"
];
__darwinAllowLocalNetworking = true;
sandboxProfile = lib.optionalString stdenv.hostPlatform.isDarwin ''
(allow file-read* (subpath "/System/Library/Extensions"))
(allow iokit-open (iokit-user-client-class "AGXDeviceUserClient"))
'';
checkFlags =
let
skippedTests = [
"TestPushHandler/unauthorized_push"
"TestPiRun_InstallAndWebSearchLifecycle"
];
in
[ "-skip=^${builtins.concatStringsSep "$|^" skippedTests}$" ];
doInstallCheck = true;
nativeInstallCheckInputs = [
versionCheckHook
writableTmpDirAsHomeHook
];
versionCheckKeepEnvironment = "HOME";
passthru = {
inherit llamaCppSrc llamaCppVersion;
};
meta = {
description =
"Get up and running with large language models locally"
+ lib.optionalString rocmRequested ", using ROCm for AMD GPU acceleration"
+ lib.optionalString cudaRequested ", using CUDA for NVIDIA GPU acceleration"
+ lib.optionalString vulkanRequested ", using Vulkan for generic GPU acceleration";
homepage = "https://github.com/ollama/ollama";
changelog = "https://github.com/ollama/ollama/releases/tag/v${finalAttrs.version}";
license = licenses.mit;
platforms =
if (rocmRequested || cudaRequested || vulkanRequested) then platforms.linux else platforms.unix;
mainProgram = "ollama";
maintainers = with maintainers; [ prusnak ];
broken = stdenv.buildPlatform != stdenv.hostPlatform;
};
})