FilesExpand file tree

 master

/

flake.nix

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

180 lines (165 loc) · 7.07 KB

 master

/

flake.nix

Copy path

Top

File metadata and controls

• Code
• Blame

180 lines (165 loc) · 7.07 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

# The flake interface to llama.cpp's Nix expressions. The flake is used as a

# more discoverable entry-point, as well as a way to pin the dependencies and

# expose default outputs, including the outputs built by the CI.

# For more serious applications involving some kind of customization you may

# want to consider consuming the overlay, or instantiating `llamaPackages`

# directly:

#

# ```nix

# pkgs.callPackage ${llama-cpp-root}/.devops/nix/scope.nix { }`

# ```

# Cf. https://jade.fyi/blog/flakes-arent-real/ for a more detailed exposition

# of the relation between Nix and the Nix Flakes.

{

description = "Port of Facebook's LLaMA model in C/C++";

inputs = {

nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";

flake-parts.url = "github:hercules-ci/flake-parts";

};

# There's an optional binary cache available. The details are below, but they're commented out.

#

# Why? The terrible experience of being prompted to accept them on every single Nix command run.

# Plus, there are warnings shown about not being a trusted user on a default Nix install

# if you *do* say yes to the prompts.

#

# This experience makes having `nixConfig` in a flake a persistent UX problem.

#

# To make use of the binary cache, please add the relevant settings to your `nix.conf`.

# It's located at `/etc/nix/nix.conf` on non-NixOS systems. On NixOS, adjust the `nix.settings`

# option in your NixOS configuration to add `extra-substituters` and `extra-trusted-public-keys`,

# as shown below.

#

# ```

# nixConfig = {

# extra-substituters = [

# # A development cache for nixpkgs imported with `config.cudaSupport = true`.

# # Populated by https://hercules-ci.com/github/SomeoneSerge/nixpkgs-cuda-ci.

# # This lets one skip building e.g. the CUDA-enabled openmpi.

# # TODO: Replace once nix-community obtains an official one.

# "https://cuda-maintainers.cachix.org"

# ];

#

# # Verify these are the same keys as published on

# # - https://app.cachix.org/cache/cuda-maintainers

# extra-trusted-public-keys = [

# "cuda-maintainers.cachix.org-1:0dq3bujKpuEPMCX6U4WylrUDZ9JyUG0VpVZa7CNfq5E="

# ];

# };

# ```

# For inspection, use `nix flake show github:ggml-org/llama.cpp` or the nix repl:

#

# ```bash

# ❯ nix repl

# nix-repl> :lf github:ggml-org/llama.cpp

# Added 13 variables.

# nix-repl> outputs.apps.x86_64-linux.quantize

# { program = "/nix/store/00000000000000000000000000000000-llama.cpp/bin/llama-quantize"; type = "app"; }

# ```

outputs =

{ self, flake-parts, ... }@inputs:

let

# We could include the git revisions in the package names but those would

# needlessly trigger rebuilds:

# llamaVersion = self.dirtyShortRev or self.shortRev;

# Nix already uses cryptographic hashes for versioning, so we'll just fix

# the fake semver for now:

llamaVersion = "0.0.0";

in

flake-parts.lib.mkFlake { inherit inputs; }

{

imports = [

.devops/nix/nixpkgs-instances.nix

.devops/nix/apps.nix

.devops/nix/devshells.nix

.devops/nix/jetson-support.nix

];

# An overlay can be used to have a more granular control over llama-cpp's

# dependencies and configuration, than that offered by the `.override`

# mechanism. Cf. https://nixos.org/manual/nixpkgs/stable/#chap-overlays.

#

# E.g. in a flake:

# ```

# { nixpkgs, llama-cpp, ... }:

# let pkgs = import nixpkgs {

# overlays = [ (llama-cpp.overlays.default) ];

# system = "aarch64-linux";

# config.allowUnfree = true;

# config.cudaSupport = true;

# config.cudaCapabilities = [ "7.2" ];

# config.cudaEnableForwardCompat = false;

# }; in {

# packages.aarch64-linux.llamaJetsonXavier = pkgs.llamaPackages.llama-cpp;

# }

# ```

#

# Cf. https://nixos.org/manual/nix/unstable/command-ref/new-cli/nix3-flake.html?highlight=flake#flake-format

flake.overlays.default = (

final: prev: {

llamaPackages = final.callPackage .devops/nix/scope.nix { inherit llamaVersion; };

inherit (final.llamaPackages) llama-cpp;

}

);

systems = [

"aarch64-darwin"

"aarch64-linux"

"x86_64-darwin" # x86_64-darwin isn't tested (and likely isn't relevant)

"x86_64-linux"

];

perSystem =

{

config,

lib,

system,

pkgs,

pkgsCuda,

pkgsRocm,

...

}:

{

# For standardised reproducible formatting with `nix fmt`

formatter = pkgs.nixfmt-rfc-style;

# Unlike `.#packages`, legacyPackages may contain values of

# arbitrary types (including nested attrsets) and may even throw

# exceptions. This attribute isn't recursed into by `nix flake

# show` either.

#

# You can add arbitrary scripts to `.devops/nix/scope.nix` and

# access them as `nix build .#llamaPackages.${scriptName}` using

# the same path you would with an overlay.

legacyPackages = {

llamaPackages = pkgs.callPackage .devops/nix/scope.nix { inherit llamaVersion; };

llamaPackagesWindows = pkgs.pkgsCross.mingwW64.callPackage .devops/nix/scope.nix {

inherit llamaVersion;

};

llamaPackagesCuda = pkgsCuda.callPackage .devops/nix/scope.nix { inherit llamaVersion; };

llamaPackagesRocm = pkgsRocm.callPackage .devops/nix/scope.nix { inherit llamaVersion; };

};

# We don't use the overlay here so as to avoid making too many instances of nixpkgs,

# cf. https://zimbatm.com/notes/1000-instances-of-nixpkgs

packages =

{

default = config.legacyPackages.llamaPackages.llama-cpp;

vulkan = config.packages.default.override { useVulkan = true; };

windows = config.legacyPackages.llamaPackagesWindows.llama-cpp;

python-scripts = config.legacyPackages.llamaPackages.python-scripts;

}

// lib.optionalAttrs pkgs.stdenv.isLinux {

cuda = config.legacyPackages.llamaPackagesCuda.llama-cpp;

mpi-cpu = config.packages.default.override { useMpi = true; };

mpi-cuda = config.packages.default.override { useMpi = true; };

}

// lib.optionalAttrs (system == "x86_64-linux") {

rocm = config.legacyPackages.llamaPackagesRocm.llama-cpp;

};

# Packages exposed in `.#checks` will be built by the CI and by

# `nix flake check`.

#

# We could test all outputs e.g. as `checks = confg.packages`.

#

# TODO: Build more once https://github.com/ggml-org/llama.cpp/issues/6346 has been addressed

checks = {

inherit (config.packages) default vulkan;

};

};

};

}