just learned about this project erjic that does seccomp+bwrap sandboxing https://codeberg.org/prisixia/erjic the interface is really nicely designed and i believe will fit the needs of my build system perfectly

[hipsterelectron@circumstances.run]

now, i fully believe in and trust the guix project not to force monopolies. and indeed, the guix form of "reproducibility" is very specifically defined in a communal manner: trust is when my friends and organizations i trust agree upon the checksum together. this is very thoughtful, and makes "trust" a bottom-up process instead of a top-down hierarchy.

guix making use of guile scheme is also much more appropriate—the language semantics are recursively defined in scheme (which unlike lisp, really does believe in constructing a tower of IRs—instead of implementation-defined, it's protocols all the way down).

[alina@girldick.gay]

@terezi @hipsterelectron the usual way to pass libraries into stdenv.mkDerivation is by referencing nixpkgs in the attrs to pkgs.callPackage like this https://github.com/NixOS/nixpkgs/blob/e99d0bffd2a4cafb19335ea4ec95edc9ca23a0a4/pkgs/os-specific/linux/systemd/default.nix#L36

and then pass them into nativeBuildInputs or buildInputs https://github.com/NixOS/nixpkgs/blob/e99d0bffd2a4cafb19335ea4ec95edc9ca23a0a4/pkgs/os-specific/linux/systemd/default.nix#L342

also nix is not an operating system, the OS is called NixOS. there is a functional programming language called nix, with its stdlib designed to write package expressions and declare & define options in a module system which NixOS builds upon

you can have multiple versions of a library but you have to pin the specific revision/tag/commit of nixpkgs from which you want to source the package definition as flake input (or with npins or fetching a specific git archive revision of nixpkgs with a trivial fetcher), or write it yourself and pin the revision/tag/commit of the source archive you want to build the same way

possibly you will have to use autoPatchelfHook to do the linking properly, but outside of library/binary contexts you can just template a package using a function with the library package and the binary name as parameters and have differently named binaries in your $PATH, or use multiple $PATH environments like `nix shell` and switch between contexts using direnv or tmux for example

[alina@girldick.gay]

@terezi @hipsterelectron here's how to do the ELF patching / relinking manually by the example of the package i wrote for binary ninja

each source tree file path i reference in a path literal value gets passed to its nativeBuildInputs and then string interpolated to in the call to patchelf in the installPhase shell script. declaring nativeBuildInputs is needed to ensure availability of the referenced nix package during build time, and due to the sandboxed environment also access to the nix store path in the builder's mount namespace

{
inputs = {
flake-parts.url = "github:hercules-ci/flake-parts";
nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
};

outputs =
inputs@{ flake-parts, ... }:
flake-parts.lib.mkFlake { inherit inputs; } {
systems = [
"x86_64-linux"
];
perSystem =
{
config,
self',
inputs',
pkgs,
system,
lib,
...
}:
{
packages.default = (
pkgs.callPackage (
{
curl,
lib,
qt6,
patchelf,
pkg-config,
pkgsStatic,
stdenv,
...
}:
let
inherit (lib)
concatStringsSep
concatMapStringsSep
getExe
;
qt6libs = (qt6.qtbase.overrideAttrs { dontWrapQtApps = true; });
libdrv =
name: path:
stdenv.mkDerivation {
dontWrapQtApps = true;
dontUnpack = true;
dontConfigure = true;
dontBuild = true;
src = path;
version = "1.0.0";
inherit name;
installPhase = ''
install -m755 -D $src $out/lib/${name}
'';
};
dynamicDeps = map (x: libdrv x) [
(libdrv "libbinaryninjacore.so.1" ./src/libbinaryninjacore.so.1)
(libdrv "libbinaryninjaui.so.1" ./src/libbinaryninjaui.so.1)
(libdrv "libQt6Widgets.so.6" ./src/libQt6Widgets.so.6)
(libdrv "libQt6Gui.so.6" ./src/libQt6Gui.so.6)
(libdrv "libQt6Core.so.6" ./src/libQt6Core.so.6)
(libdrv "libQt6DBus.so.6" ./src/libQt6DBus.so.6)
(libdrv "libQt6OpenGL.so.0" ./src/libQt6OpenGL.so.6)
];
includePath = concatStringsSep "/lib:" dynamicDeps;
in
stdenv.mkDerivation {
src = ./src/binaryninja;
name = "binja";
nativeBuildInputs = [
# autoPatchelfHook
pkg-config
curl.dev
stdenv.cc.cc.lib
qt6.wrapQtAppsHook
# qt6libs
# curl.dev
# stdenv.cc.cc.lib
];
buildInputs = [ qt6libs ];
# ++ dynamicDeps;
dontWrapQtApps = true;
dontUnpack = true;
dontConfigure = true;
dontBuild = true;
installPhase =
let
optionFormat = opt: {
option = "--${opt}";
sep = " ";
explicitBool = false;
};
argv = (
concatStringsSep " " (
lib.cli.toCommandLine optionFormat {
set-interpreter = "${stdenv.cc}/nix-support/dynamic-linker";
set-rpath = ''"${builtins.trace includePath includePath}"'';

}
)
);
in
''
runHook preInstall
install -m755 -D $src $out/bin/binja
${getExe patchelf} ${builtins.trace argv argv} $out/bin/binja
${
concatMapStringsSep "\n" (
x: "${getExe patchelf} --replace-needed ${x.meta.name} ${x}/lib/${x.name} $out/bin/binja"
) dynamicDeps
}
runHook postInstall
'';
# preFixup = ''
# wrapQtApp $out/bin/binja --prefix ${./src} : $out/bin/binja
# '';
meta = with lib; {
homepage = "https://binary.ninja";
description = "an interactive decompiler, disassembler, debugger, and binary analysis platform";
license = licenses.unfree;
platforms = platforms.linux;
};
}
) { }
);
};
flake = {
nixosModules.default = { lib, config, ... }: {
options.programs.binja = with lib.types; {
enable = lib.mkEnableOption "binary ninja";
};
};
};
};
}

[hipsterelectron@circumstances.run]

so this is not a moral accusation but rather a technological observation: the bit-for-bit indifferentiability through cryptographic checksums tends toward a thin form of "reproducibility" which means:

• if you do everything exactly like everyone else, you will get the same result!
• if you do things differently, you can't reuse anything—you have to rebuild your new dependency graph from scratch.

i believe this (unintentionally) incentivizes the production of fiefdoms and silos, and especially makes it easier for capital to subvert guix freedoms. i have not observed any example of the latter in guix, but it is at this point trivial and well-understood to be a flaw of nix. lix is heroic, but swimming upstream is made more difficult in this shallow cryptographic reproducibility regime.

[c0dec0dec0de@hachyderm.io]

@hipsterelectron @janneke oh, FUSE! That’s an interesting idea.

[hipsterelectron@circumstances.run]

the distinction i happened upon today was "b2b vs b2c". "c" here means "end user", while "b" is "packager or codebase maintainer" (i.e. someone who agreed to take on responsibility for the end user's safety). this was inspired by the json profile format for the erjic sandboxing tool, which means my build tool can use it for sandboxing reliably (i'm "b" because i maintain the build tool, erjic is "b" because it's a codebase with a maintainer, and i'm taking responsibility for executing compiler subprocesses safely)

[hipsterelectron@circumstances.run]

the packager who builds a codebase using my build tool? that's "b" too! the end user "c" is someone executing code built with my tool—and while i only interface with "b"s, we're all serving "c" together.

this formulation allows for "c" to be their own "b"(s), but it doesn't force them to, because it doesn't ablate the handoffs of accountability across the dependency hypergraph. while cryptographic indifferentiability is related to the problems of "reproducibility", it mostly just reflects the ablation of responsibility that removes standard trust boundaries.

[hipsterelectron@circumstances.run]

["we're all serving 'c' together" is intended to pun on queers serving cunt collectively. we're in your dependency graph and we are teaching the graph about gender]

[hipsterelectron@circumstances.run]

so of course i spack immensely and one of the reasons why is because it maintains the capability of nix and guix in which end users and/or sysadmins are empowered to extend package recipes, but it works incredibly hard to reuse work as much as possible. a spack package recipe, at any time, describes every single version of a package at once—its build environment, its dependencies, where to fetch the sources, and how to configure and build and install it.

[hipsterelectron@circumstances.run]

we also have a checksum graph and achieve bit-for-bit reproducibility, and we also (as of v1) build in a sandbox, because sandboxing is actually the easiest part of all this

[stilic@fedi.kitty.tel]

@hipsterelectron an optional dep for what?

[c0dec0dec0de@hachyderm.io]

@janneke @hipsterelectron @guix @nixos_org @reproducible_builds I/we do this at work. Of corse, we’re beholden to RPM so nothing is _binary_ reproducible.

[hipsterelectron@circumstances.run]

this is why erjic can be an optional dependency for my build system. because sandboxing is not standardized by POSIX, it will need OS-specific implementations anyway. if you make sandboxing a core assumption of your dependency graph architecture, your dependency graph too will need to be replicated across OSes. and if you have no concept of a dependency except a checksum, you have no capability to make any universally-quantified logical statements—it's (at best) existential

[hipsterelectron@circumstances.run]

and i do in fact mean higher-order mathematical logic. i'm not a logician, but i believe the analogy of cryptographic reproducibility is somewhere between propositional and first-order logic—while the checksum graph is starkly propositional, i suspect the nix and guix languages support enough abstraction for parameterized recipes, which seems first-order to me (but this is not my field).

[hipsterelectron@circumstances.run]

the spack model would be appropriately summarized with BE NOT AFRAID: https://spack.readthedocs.io/en/latest/spec_syntax.html

Here is an example of using a complex spec to install a very specific configuration of mpileaks:

spack install mpileaks@1.2:1.4 +debug ~qt target=x86_64_v3 %gcc@15 ^libelf@1.1 %clang@20

The figure below helps you get a sense of the various parts that compose this spec:

[hipsterelectron@circumstances.run]

we do happen to employ the ASP logic language through the clingo ASP solver. lots of good resources on ASP https://potassco.org/resources/, which is kind of like SAT/SMT except that universal quantifier expressions can be stated and solved over infinite graph-structured solution spaces

[hipsterelectron@circumstances.run]

i was hired by LLNL right as spack was transitioning from a messy non-backtracking serial graph solver (our own, in python, grown organically over the decade since spack was created) to clingo (this was a huge risk). the reason we could do this was because package recipes were already declarative, and already described all versions of a package across all architectures at once.

this is super important: we already had a logical model—we just needed a more powerful solver. the solver did not dictate our logic. we applied the solver to our use case.

[hipsterelectron@circumstances.run]

this is the advantage of protocols. spack was made for LLNL to provide a service to our physicists. these physicists encompass mathematicians and programmers—LLNL does simulations, so like the spack team, they're necessarily applied scientists. the tools development group (TDG) does spack, but our larger org within LLNL computing also developed parallelism libraries, which themselves made use of memory management primitives

[hipsterelectron@circumstances.run]

the purpose of all of this is to bring deep hardware-dependent concerns all the way up to the application layer, because HPC is generally one of the fields that requires this at all times. but notice something very important—the application layer is not the spack team, nor the RAJA team, but the scientists we serve.

our goal is to make their scientific work more efficient than any alternative. that's how we broke the nuclear fusion net-positive efficiency barrier after 60 years. that's what differentiates LLNL from LANL, who still pretends quantum computing is totally real.

[hipsterelectron@circumstances.run]

the point of this hagiography is not to claim the US is good at science, or that the spack team is smarter than anyone else (except LANL, who is overrated). in fact, i believe the netherlands is far better at funding science, and i fervently hope their physicists develop better silicon fabrication techniques soon.

the US is in fact terrible at funding science. but government employees are different from military generals or failson politicians. and in this hostile environment with funding swings every 4 years, this is what we arrived at to defend science from being beholden to IBM