tolpi/nixos - Change BAO2IEK7OO7NITD5SPGG544GKPAYNAIDS4D6BOCXGO5UVER7D67AC

add templates

Created by 9E8MxN1nvgX4DRC3PhGXug3ydrBXWfmR9XK2eNRJVkA3 on March 29, 2026

BAO2IEK7OO7NITD5SPGG544GKPAYNAIDS4D6BOCXGO5UVER7D67AC

Dependencies

In channels

main

Change contents

File deletion: flake.nix

BF:BFD[3.21] → [3.23:56]

BF:BFD[3.56] → [3.57:57]

B:BD[3.57] → [3.58:341]

∅:D[4.39] → [3.390:460]

B:BD[3.390] → [3.390:460]

B:BD[3.341] → [4.0:39]

{
  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
  inputs.flake-utils.url = "github:numtide/flake-utils";
  outputs = { self, nixpkgs, flake-utils }: flake-utils.lib.eachSystem [
    "x86_64-linux"
  ] (system: let
    pkgs = nixpkgs.legacyPackages.${system};
  in {
      buildInputs = [];
      shellHook = ''
      '';
    };
  });
}
    devShells.default = pkgs.mkShell {

File addition: zig (d--x------)
[3.21]
File addition: src (d--x------)
[0.15]

File addition: main.zig (----------)

[0.32]

const std = @import("std");
pub fn main(init: std.process.Init) !void {
    std.debug.print("passed:\n", .{});
    var it = init.minimal.args.iterate();
    while (it.next()) |arg| std.debug.print("{} ", .{arg});
}
test "simple test" {
    const gpa = std.testing.allocator;
    var list: std.ArrayList(i32) = .empty;
    defer list.deinit(gpa); // Try commenting this out and see if zig detects the memory leak!
    try list.append(gpa, 42);
    try std.testing.expectEqual(@as(i32, 42), list.pop());
}
test "fuzz example" {
    try std.testing.fuzz({}, testOne, .{});
}
fn testOne(context: void, smith: *std.testing.Smith) !void {
    _ = context;
    // Try passing `--fuzz` to `zig build test` and see if it manages to fail this test case!
    const gpa = std.testing.allocator;
    var list: std.ArrayList(u8) = .empty;
    defer list.deinit(gpa);
    while (!smith.eos()) switch (smith.value(enum { add_data, dup_data })) {
        .add_data => {
            const slice = try list.addManyAsSlice(gpa, smith.value(u4));
            smith.bytes(slice);
        },
        .dup_data => {
            if (list.items.len == 0) continue;
            if (list.items.len > std.math.maxInt(u32)) return error.SkipZigTest;
            const len = smith.valueRangeAtMost(u32, 1, @min(32, list.items.len));
            const off = smith.valueRangeAtMost(u32, 0, @intCast(list.items.len - len));
            try list.appendSlice(gpa, list.items[off..][0..len]);
            try std.testing.expectEqualSlices(
                u8,
                list.items[off..][0..len],
                list.items[list.items.len - len ..],
            );
        },
    };
}

File addition: flake.nix (----------)

[0.15]

{
  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
  inputs.flake-utils.url = "github:numtide/flake-utils";
  inputs.zig.url = "github:mitchellh/zig-overlay";
  outputs = { self, nixpkgs, flake-utils, zig }: flake-utils.lib.eachSystem [
    "x86_64-linux"
  ] (system: let
    pkgs = nixpkgs.legacyPackages.${system};
  in {
    devShells.default = pkgs.mkShell {
      buildInputs = [
        zig.packages.${system}.master
        pkgs.zls
      ];
      shellHook = ''
      '';
    };
  });
}

File addition: build.zig (----------)

[0.15]

const std = @import("std");
pub fn build(b: *std.Build) void {
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});
    const exe = b.addExecutable(.{
        .name = "zig",
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/main.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{},
        }),
    });
    b.installArtifact(exe);
    const run_step = b.step("run", "Run the app");
    const run_cmd = b.addRunArtifact(exe);
    run_step.dependOn(&run_cmd.step);
    run_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_cmd.addArgs(args);
    }
    const exe_tests = b.addTest(.{
        .root_module = exe.root_module,
    });
    const run_exe_tests = b.addRunArtifact(exe_tests);
    const test_step = b.step("test", "Run tests");
    test_step.dependOn(&run_exe_tests.step);
}

File addition: rust (d--x------)
[3.21]
File addition: src (d--x------)
[0.3273]

File addition: main.rs (----------)

[0.3290]

fn main() {
    println!("Hello, world!");
}

File addition: flake.nix (----------)

[0.3273]

{
  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
  inputs.flake-utils.url = "github:numtide/flake-utils";
  inputs.rust.url = "github:oxalica/rust-overlay";
  outputs = { self, nixpkgs, flake-utils, rust }: flake-utils.lib.eachSystem [
    "x86_64-linux"
  ] (system: let
    pkgs = nixpkgs.legacyPackages.${system};
    rust-bin = rust.lib.mkRustBin { } pkgs.buildPackages;
  in {
    devShells.default = pkgs.mkShell {
      buildInputs = [
        rust-bin.stable.latest.minimal
        pkgs.rust-analyzer
      ];
      shellHook = ''
      '';
    };
  });
}

File addition: Cargo.toml (----------)

[0.3273]

[package]
name = "rust"
version = "0.1.0"
edition = "2024"
[dependencies]

File addition: default (d--x------)
[3.21]

File addition: flake.nix (----------)

[0.4119]

{
  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
  inputs.flake-utils.url = "github:numtide/flake-utils";
  outputs = { self, nixpkgs, flake-utils }: flake-utils.lib.eachSystem [
    "x86_64-linux"
  ] (system: let
    pkgs = nixpkgs.legacyPackages.${system};
  in {
    devShells.default = pkgs.mkShell {
      buildInputs = [];
      shellHook = ''
      '';
    };
  });
}

File addition: c-shake (d--x------)
[3.21]

File addition: flake.nix (----------)

[0.4568]

{
  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
  inputs.flake-utils.url = "github:numtide/flake-utils";
  outputs = { self, nixpkgs, flake-utils }: flake-utils.lib.eachSystem [
    "x86_64-linux"
  ] (system: let
    pkgs = nixpkgs.legacyPackages.${system};
  in {
    devShells.default = pkgs.mkShell {
      buildInputs = with pkgs; [
        ccache
        gdb
        (haskellPackages.ghcWithPackages (p: [p.shake]))
      ];
      shellHook = ''
      '';
    };
    packages.${system}.default = {
      pname = "pkg"; # pass
      version = "0.0"; # pass
      src = ./.;
      buildPhase = ''
        shake install --opt-level=3 --prefix=$out
      '';
    };
    apps.${system}.default = {
      type = "app";
      program = "${self.packages.${system}.default}/bin/<app>"; # pass
    };
  });
}

File addition: Shakefile.hs (----------)

[0.4568]

import Development.Shake
import Development.Shake.Command
import Development.Shake.FilePath
import Development.Shake.Util
import System.IO (readFile)
import System.Directory (findExecutable, getCurrentDirectory, removeDirectoryRecursive)
import Data.Foldable (asum)
import System.Console.GetOpt
import Data.Hashable (hash)
import System.Environment
import System.Process (readProcess)
import Data.Maybe (listToMaybe, fromMaybe)
import Data.Function ((&))
flags = fmap (filter (not . null) . lines) . readFile
findExe :: [String] -> IO (Maybe FilePath)
findExe cmds = asum <$> mapM findExecutable cmds
cdir = "src"
incdir = "include"
builddir = "_build"
data BuildTypes = Default | Test | Bench deriving (Read)
data OptLevels = Release | Debug deriving (Read)
data Options
  = BuildType BuildTypes
  | OptLevel OptLevels
  | DisableCCACHE
  | Prefix FilePath
options :: [OptDescr (Either a Options)]
options =
  [ Option "t" ["build-type"]     (ReqArg (Right . BuildType . read) "[default|test|bench]") ""
  , Option "o" ["opt-level"]      (ReqArg (Right . OptLevel . read) "[0-3|g]") ""
  , Option ""  ["disable-ccache"] (NoArg $ Right DisableCCACHE) ""
  , Option "p" ["prefix"]         (ReqArg (Right . Prefix) "/usr/local") ""
  ]
main :: IO ()
main = shakeArgsWith shakeOptions options $ \opts targets -> pure $ Just $ do
  cwd <- liftIO $ getCurrentDirectory
  let proj = takeFileName cwd
  gitBranch <- liftIO $ readProcess "git" ["branch", "--show-current"] ""
  inNixShell <- liftIO $ System.Environment.getEnv "IN_NIX_SHELL"
  cflags <- liftIO $ flags "build/cflags"
  ldflags <- liftIO $ flags "build/ldflags"
  optflags <- liftIO $ flags "build/optflags"
  debugflags <- liftIO $ flags "build/debugflags"
  optldflags <- liftIO $ flags "build/optldflags"
  let typeFlag = [a | BuildType a <- opts] & listToMaybe & fromMaybe Default
  let optFlag = [a | OptLevel a <- opts] & listToMaybe & fromMaybe Debug
  let prefix = [a | Prefix a <- opts] & listToMaybe & fromMaybe (error "missing prefix")
  compile <- do
      Just cc <- liftIO $ findExe ["clang-21", "clang-20", "clang-19", "clang"]
      ccache <- liftIO $ findExe ["ccache"]
      let p DisableCCACHE = True
          p _             = False
      let disable_ccache = any p opts
      case (disable_ccache, ccache) of
        (False, Just ch) -> return [ch, cc]
        _                -> return [cc]
  let typeFlags Default = []
      typeFlags Test    = ["-DTEST_MODE"]
      typeFlags Bench   = ["-DBENCHMARK_MODE"]
  let optFlags Release = optflags
      optFlags Debug   = debugflags
  let optLDFlags Release = optldflags
      optLDFlags Debug   = debugflags
  let compileFlags = cflags ++ typeFlags typeFlag ++ optFlags optFlag ++ ["-I" ++ incdir]
  let linkFlags = ldflags ++ optLDFlags optFlag
  let seed = unwords compile ++ unwords compileFlags ++ unwords linkFlags ++ gitBranch ++ inNixShell
  let h = abs $ hash seed
  let outDir = builddir </> show h
  let target = outDir </> proj
  let bin = builddir </> proj
  want targets
  phony "all" $ do
    need [bin]
  bin %> \out -> do
    need [target]
    copyFileChanged target out
  target %> \out -> do
    cs <- getDirectoryFiles cdir ["*.c"]
    let os = [outDir </> c -<.> "o" | c <- map takeFileName cs]
    need os
    cmd_ compile "-o" [out] os linkFlags
  outDir </> "*.o" %> \out -> do
    let c = cdir </> (takeFileName $ out -<.> "c")
    let m = out -<.> "m"
    cmd_ compile "-o" [out] "-c" [c] "-MMD -MF" [m] compileFlags
    neededMakefileDependencies m
  phony "install" $ do
    copyFileChanged bin (prefix </> "bin" </> proj)
  phony "clean" $ do
    liftIO $ removeDirectoryRecursive outDir
  phony "clean-all" $ do
    liftIO $ removeDirectoryRecursive builddir

File addition: c-make (d--x------)
[3.21]

File addition: makefile (----------)

[0.9226]

NPROC != nproc
MAKEFLAGS += -j$(NPROC)
MAKEFLAGS += -r -R
DEFAULT_OPTLEVEL := g
DEFAULT_PREFIX := /usr/local
DEFAULT_TYPE := default
DEFAULT_USE_CCACHE := y
DEFAULT_EMIT_LLVM := n
DEFAULT_BUILD_FROM_ASM := n
.PHONY: $(shell grep -ho "^[0-9a-z-]\\+:" $(MAKEFILE_LIST) | sed -e "s/://")
define ERROR_INVALID_VALUE
  $(error invalid value for $$($1): expected one of $(or $2,[yn]) but got $($1))
endef
CLANG21 != command -v clang-21
CLANG20 != command -v clang-20
CLANG19 != command -v clang-19
CLANG != command -v clang
CC := $(or $(CLANG21),$(CLANG20),$(CLANG19),$(CLANG),$(error CC not found: install clang (>=19)))
USE_CCACHE ?= $(DEFAULT_USE_CCACHE) ## use ccache [yn] (default: y)
ifeq ($(strip $(USE_CCACHE)),y)
  CCACHE != command -v ccache
  CC := $(CCACHE) $(CC)
else ifeq ($(strip $(USE_CCACHE)),n)
else
  $(call ERROR_INVALID_VALUE,USE_CCACHE)
endif
PROJECT_NAME := $(notdir $(CURDIR))
CDIR := src
INCDIR := include
BUILDDIR := .build
PREFIX ?= $(DEFAULT_PREFIX) ## install prefix (default: /usr/local)
OPTLEVEL ?= $(or $(OL), $(DEFAULT_OPTLEVEL)) ## optimization level [0-3|g] (default: g)
LOGLEVEL ?= $(or $(LL), $(DEFAULT_LOGLEVEL))
TYPE ?= $(or $(T), $(DEFAULT_TYPE)) ## build type [test|bench|default]
# compiler flags
CFLAGS != cat build/cflags
OPTFLAGS != cat build/optflags
# linker flags
LDFLAGS != cat build/ldflags
OPTLDFLAGS != cat build/optldflags
DEBUGFLAGS != cat build/debugflags
ASMFLAGS != cat build/asmflags
# Enables macro in the source
CFLAGS += -DLOGLEVEL=$(LOGLEVEL)
ifdef ASAN
  CFLAGS += -fsanitize=$(ASAN)
  LDFLAGS += -fsanitize=$(ASAN)
endif
ifeq ($(MAKECMDGOALS),coverage)
  CFLAGS += -fprofile-instr-generate -fcoverage-mapping
  LDFLAGS += -fprofile-instr-generate
  TYPE := test
  OPTLEVEL := 0
endif
ifeq ($(strip $(TYPE)),test)
  CFLAGS += -DTEST_MODE
else ifeq ($(strip $(TYPE)),bench)
  CFLAGS += -DBENCHMARK_MODE
else ifeq ($(strip $(TYPE)),default)
else
  $(call ERROR_INVALID_VALUE,TYPE,[test|bench|default])
endif
ifeq ($(strip $(OPTLEVEL)),g)
  CFLAGS += $(DEBUGFLAGS)
  LDFLAGS += $(DEBUGFLAGS)
  RUNNER ?= gdb ## runner (default in debug run: gdb)
else ifneq ($(filter 1 2 3,$(OPTLEVEL)),)
  CFLAGS += $(OPTFLAGS) -O$(OPTLEVEL)
  LDFLAGS += $(OPTLDFLAGS) -O$(OPTLEVEL)
else ifeq ($(strip $(OPTLEVEL)),0)
else
  $(call ERROR_INVALID_VALUE,OPTLEVEL,[0-3|g])
endif
ifeq ($(MAKECMDGOALS),profile)
  CFLAGS += -pg
  LDFLAGS += -pg
  LDFLAGS := $(filter-out -s,$(LDFLAGS))
endif
ifdef TEST_FILTER
  CFLAGS += -DTEST_FILTER="\"$(TEST_FILTER)\""
endif
# generate output path
GITBRANCH != git branch --show-current 2>/dev/null
SEED = $(CC)$(CFLAGS)$(LDFLAGS)$(GITBRANCH)$(IN_NIX_SHELL)
HASH != echo '$(SEED)' | md5sum | cut -d' ' -f1
OUTDIR := $(BUILDDIR)/$(HASH)
TARGET := $(OUTDIR)/$(PROJECT_NAME)
EMIT_LLVM ?= $(DEFAULT_EMIT_LLVM) ## use llvmIR instead of asm [yn] (default: n)
ifeq ($(strip $(EMIT_LLVM)),y)
  ASMFLAGS += -emit-llvm
  ASMEXT := ll
else ifeq ($(strip $(EMIT_LLVM)),n)
  ASMEXT := s
else
  $(call ERROR_INVALID_VALUE,EMIT_LLVM)
endif
# source files
SRCS := $(wildcard $(CDIR)/*.c)
OBJS := $(patsubst $(CDIR)/%.c,$(OUTDIR)/%.o,$(SRCS))
DEPS := $(OBJS:.o=.d)
ASMS := $(OBJS:.o=.$(ASMEXT))
# e.g.)
# $ make asm OL=3
# $ # edit asm files...
# $ make BUILD_FROM_ASM=y OL=3
BUILD_FROM_ASM ?= $(DEFAULT_BUILD_FROM_ASM) ## use asm instead of c files [yn] (default: n)
ifeq ($(strip $(BUILD_FROM_ASM)),y)
  SRCDIR := $(OUTDIR)
  SRCEXT := $(ASMEXT)
  CFLAGS =
else ifeq ($(strip $(BUILD_FROM_ASM)),n)
  SRCDIR := $(CDIR)
  SRCEXT := c
else
  $(call ERROR_INVALID_VALUE,BUILD_FROM_ASM)
endif
include $(realpath $(DEPS))
### build rules
.DEFAULT_GOAL := $(TARGET)
# link
$(TARGET): $(OBJS)
	$(CC) $(LDFLAGS) $^ -o $@
# compile
$(OBJS): $(OUTDIR)/%.o: $(SRCDIR)/%.$(SRCEXT) $(OUTDIR)/%.d | $(OUTDIR)/
	$(CC) $< $(CFLAGS) -c -o $@
define DEPFLAGS
  -MM -MP -MT $1.o -MF $1.d
endef
$(DEPS): $(OUTDIR)/%.d: $(CDIR)/%.c | $(OUTDIR)/
	$(CC) $< $(CFLAGS) $(call DEPFLAGS,$(@:.d=))
# e.g.) run with valgrind
# make run RUNNER=valgrind
# e.g.) don't use gdb (default debug RUNNER) in debug run
# make run RUNNER=
run: $(TARGET) ## run target
	$(RUNNER) $<
# `make run-foo` is same as `make run RUNNER=foo`
run-%: $(TARGET)
	$* $<
test: ; $(MAKE) run TYPE=test RUNNER= ## run test
asm: $(ASMS) ## generate asm files
$(ASMS): $(OUTDIR)/%.$(ASMEXT): $(CDIR)/%.c | $(OUTDIR)/
	$(CC) $< $(ASMFLAGS) $(CFLAGS) -o $@
clean-all: ; rm -rf $(BUILDDIR)
# e.g.) remove test build for opt level 3
# make clean OPTLEVEL=3 TYPE=test
clean:
ifneq ($(realpath $(OUTDIR)),)
	rm -rf $(OUTDIR)
endif
$(PREFIX)/bin/$(PROJECT_NAME): $(TARGET) | $(PREFIX)/bin/
	cp $< $@
install: $(PREFIX)/bin/$(PROJECT_NAME)
uninstall: ; rm $(PREFIX)/bin/$(PROJECT_NAME)
doc: doc/Doxyfile ## generate doc
	doxygen $<
doc/Doxyfile: doc/
	doxygen -g $@
fmt: ; clang-format -Werror --dry-run $(SRCS) $(INCDIR)/*.h
lint: $(SRCS)
	clang-tidy $^ -- $(CFLAGS)
	flawfinder $^
	cppcheck $^ --enable=all --suppress=missingIncludeSystem -I$(INCDIR)
pre-commit: fmt test ## .git/hooks/pre-commit
FP ?= /dev/stdout
log: ## show build flags
	@echo "Compiler: $(CC)" > $(FP)
	@echo "CFLAGS: $(CFLAGS)" >> $(FP)
	@echo "LDFLAGS: $(LDFLAGS)" >> $(FP)
	@echo "TARGET: $(TARGET)" >> $(FP)
	@echo "SRCS: $(SRCS)" >> $(FP)
	@echo "OBJS: $(OBJS)" >> $(FP)
	@echo "DEPS: $(DEPS)" >> $(FP)
info: $(TARGET) ## show target info
	@echo "target file size:"
	@size $(TARGET)
help: ## show help
	@echo "$$ make          # debug build"
	@echo "$$ make test     # run test"
	@echo "$$ make run OL=3 # run release build"
	@echo
	@echo "build files: .build/HASH/*"
	@echo
	@echo "Variables:"
	@grep -h "^[^\t].* ## " $(MAKEFILE_LIST) \
	| sed -En "s/^ *([0-9A-Z_]+) .?= .*## (.*)$$/\\1 = \\2/p"
	@echo
	@echo "Targets:"
	@grep -h "^[^\t].* ## " $(MAKEFILE_LIST) \
	| sed -En "s/^([0-9a-z-]+): .*## (.*)$$/\\1: \\2/p"
### llmfile
LLMFILE ?= llmfile.txt
FILES ?= makefile build.zig Shakefile.hs doc/t.typ doc/readme.typ doc/manual.typ
DIRS ?= build include src
FILES_IN_DIRS := $(wildcard $(addsuffix /*, $(DIRS)))
SORTED_FILES_IN_DIRS := $(sort $(notdir $(basename $(FILES_IN_DIRS))))
REAL_PATH_FILES_IN_DIRS := $(foreach f,$(SORTED_FILES_IN_DIRS),$(wildcard */$f.[ch]))
LIST_FILES ?= $(FILES) $(REAL_PATH_FILES_IN_DIRS)
$(LLMFILE): $(LIST_FILES)
	echo $^ | sed 's/ /\n/g' > $@
	echo >> $@ # newline
	# `head` automatically inserts the file name at the start of the file
	head -n 9999 $^ >> $@
llmfile: $(LLMFILE) ## for the llm to read
### compiledb
, = ,
LOCAL_CCJ = $(OUTDIR)/compile_commands.json
define STRINGIFY
  $(foreach f,$1,"$f"$,)
endef
$(LOCAL_CCJ).%: | $(dir $(LOCAL_CCJ))
	echo '{"arguments":[' > $@
	echo '"$(lastword $(CC))",' >> $@
	echo '$(call STRINGIFY,$(CFLAGS))' >> $@
	echo '$(call STRINGIFY,$(call COMPILEFLAGS,$(OUTDIR)/$*.o))' >> $@
	echo '"$(SRCDIR)/$*.c"],' >> $@
	echo '"directory":"$(CURDIR)",' >> $@
	echo '"file":"$(CURDIR)/$(SRCDIR)/$*.c",' >> $@
	echo '"output":"$(CURDIR)/$(OUTDIR)/$*.o"},' >> $@
$(LOCAL_CCJ): $(addprefix $(LOCAL_CCJ)., $(basename $(notdir $(SRCS))))
	echo "[" > $@
	cat $^ >> $@
	sed -i "\$$s/,$$/]/" $@
compile_commands.json: $(LOCAL_CCJ)
	cp $< $@
compiledb: compile_commands.json ## for lsp
### coverage
COVDIR ?= $(OUTDIR)/coverage-report
PROFRAW := $(OUTDIR)/default.profraw
PROFDATA := $(OUTDIR)/coverage.profdata
$(PROFRAW): $(TARGET)
	LLVM_PROFILE_FILE=$@ ./$<
$(PROFDATA): $(PROFRAW)
	llvm-profdata merge --sparse $< -o $@
$(COVDIR): $(PROFDATA)
	llvm-cov show $(TARGET) --format=html --instr-profile=$< --output-dir=$@
BROWSER ?= cha
coverage: $(COVDIR) ## report test coverage
	$(BROWSER) $</index.html
### perf
$(OUTDIR)/perf.data: $(TARGET)
	perf record -o $@ -g ./$<
perf: $(OUTDIR)/perf.data ## run perf analysis
	perf report -i $<
### profile
gmon.out: $(TARGET) ; ./$<
$(OUTDIR)/gmon.out: gmon.out | $(OUTDIR)/
	mv $< $@
$(OUTDIR)/profile.txt: $(OUTDIR)/gmon.out
	gprof $(TARGET) $< > $@
profile: $(OUTDIR)/profile.txt
	less $<
### last resort
%/: ; mkdir -p $@

File addition: flake.nix (----------)

[0.9226]

{
  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
  inputs.flake-utils.url = "github:numtide/flake-utils";
  outputs = { self, nixpkgs, flake-utils }: flake-utils.lib.eachSystem [
    "x86_64-linux"
  ] (system: let
    pkgs = nixpkgs.legacyPackages.${system};
  in {
    devShells.default = pkgs.mkShell {
      buildInputs = with pkgs; [
        ccache
        gnumake
        gdb
        cppcheck
        flawfinder
        doxygen
        llvmPackages_21.bintools-unwrapped
        llvmPackages_21.clangUseLLVM
        llvmPackages_21.clang-tools
        llvmPackages_21.llvm
      ];
      shellHook = ''
      '';
    };
    packages.default = {
      pname = "pkg"; # pass
      version = "0.0"; # pass
      src = ./.;
      buildPhase = ''
        make install OPTLEVEL=3 PREFIX=$out
      '';
    };
    apps.default = {
      type = "app";
      program = "${self.packages.${system}.default}/bin/<app>"; # pass
    };
  });
}

Replacement in shell/default.nix at line 17 [5.23808]
B:BD[5.24167] → [2.20:56]
```
      hooks.display_outputy = null;
```
[5.24167]
[5.24167]
```
      hooks.display_output = null;
```

Replacement in flake.nix at line 51 [6.96017]

B:BD[3.462] → [3.462:555]

      templates.default = {
        path = ./templates;
        description = "basic flake";

[3.462]

[3.555]

      templates = {
        default = {
          path = ./templates/default;
          description = "basic flake";
        };
        c-make = {
          path = ./templates/c-make;
          description = "c dev with make";
        };
        c-shake = {
          path = ./templates/c-shake;
          description = "c dev with shake";
        };
        zig = {
          path = ./templates/zig;
          description = "zig dev";
        };
        rust = {
          path = ./templates/rust;
          description = "rust dev";
        };

add templates

Dependencies

In channels

Change contents

File deletion: flake.nix

File addition: zig (d--x------)

File addition: src (d--x------)

File addition: main.zig (----------)

File addition: flake.nix (----------)

File addition: build.zig (----------)

File addition: rust (d--x------)

File addition: src (d--x------)

File addition: main.rs (----------)

File addition: flake.nix (----------)

File addition: Cargo.toml (----------)

File addition: default (d--x------)

File addition: flake.nix (----------)

File addition: c-shake (d--x------)

File addition: flake.nix (----------)

File addition: Shakefile.hs (----------)

File addition: c-make (d--x------)

File addition: makefile (----------)

File addition: flake.nix (----------)

Replacement in shell/default.nix at line 17 [5.23808]

Replacement in flake.nix at line 51 [6.96017]