nandi/frq · flake.nix

nandi/frqpublic⑂ Fork 0
⑂ 1f55e68cf7056290fe48cbd817e396a8d22df1e2
flake.nix · 555 lines · 27.3 KBNix    Blame HistoryRaw
Build the client with Nix, not just a shell for it   1
# frq is Jolt source, so "building" it is three things, not one:
#   jolt        the runtime that reads it        (github:jolt-lang/jolt)
#   jolt-native libvidya and libjoltmoq, in Rust (gitlab:nandithebull/jolt-native)
#   frq         this tree, with its deps resolved to store paths
# Jolt resolves deps.edn by running git at startup, which a build sandbox has
# no network for — so every dep is fetched by Nix instead and handed back as
# a :local/root through -Sdeps.
#   nix build .#frq && ./result/bin/frq
# On a machine that is not NixOS the GL driver is the host's and the loader
# will not find it, so the window never opens ("GL display: argument does not
Find the host's GL driver when the store's is not the system's   16  # name a valid config"). The launcher handles that itself: off NixOS it hands
# the process to nixGL, which puts the host's driver ahead of the store's.
# Nothing extra to type, and a distrobox/container Arch is the same case as
# a bare one.
Build the client with Nix, not just a shell for it   20  description = "frq — a freeq client in jolt";
inputs = {
  nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
Take jolt and jolt-native as flakes, off my own fork   24    # `git+https` with `?submodules=1` rather than the github scheme: Jolt's
  # own flake declares `self.submodules`, which this Nix rejects when the
  # flake is fetched as `github:`. Its outputs are not what we take — the
  # runtime is built here, by joltFrom — but it is a flake all the same, so
  # its own inputs are locked with ours rather than left to float, and
  # `vendor/` comes along as the submodule the build needs.
Split the tree three ways, and let the phone be Flutter's   31    # The fork rather than jolt-lang/jolt, and unpinned: the desktop follows
  # the fork's main. It used to be paired with a second, pinned input for
  # the APK's boot image; there is no jolt APK now, so there is one runtime
  # and one rev.
Build the client with Nix, not just a shell for it   35    jolt-src = {
Take jolt and jolt-native as flakes, off my own fork   36      url = "git+https://gitlab.com/nandithebull/jolt?submodules=1";
    inputs.nixpkgs.follows = "nixpkgs";
Build the client with Nix, not just a shell for it   38
Take the Android objects from jolt-native's CI, always the latest   40    # The source half of jolt-native: the Jolt code under glimmer-backends/ that
Split the tree three ways, and let the phone be Flutter's   41    # binds the native objects, and the flake that builds them. This input is
  # what `just run` builds against.
Take the jolt-native ahead of the release, since a run can build it   43
Split the tree three ways, and let the phone be Flutter's   44    # It carries both backends that are left — glimmer-cosmic over
  # libjoltcosmic for the window, glimmer-tui over libjolttui for the
  # terminal — and no longer jvui or vidya, which were experiments.
Stop building the media plane frq no longer loads   47
Pin jolt-native at the merge rather than at the branch   48    # Pinned all the same, and pinned to a rev, because an
Pin the native half to the release the rest of the tree names   49    # unpinned `main` is a build whose native half is free to sit at a
  # different commit from the tree that talks to it. It did, and what the
  # drift cost was silence: the Jolt half sent a reaction pill's hover card
  # to a libvidya with no handler for one, and the pill said nothing.
Merge origin/main, and let one jolt-native answer for both backends   53    # It also carries the terminal backend — crates/jolt-tui, the same tree ABI
  # over a grid of cells, and jolt/glimmer-tui beside glimmer-vidya. That was
  # a second input at a second rev while it lived on a branch, which is the
  # drift this comment warns about wearing a different hat: one input, and
  # the window and the terminal are the same library either way.
Build the client with Nix, not just a shell for it   58    jolt-native = {
Split the tree three ways, and let the phone be Flutter's   59      url = "git+https://gitlab.com/nandithebull/jolt-native?rev=4706c920e45ce80b11ee106d05c16d9eacc99fc7";
Take jolt and jolt-native as flakes, off my own fork   60      inputs.nixpkgs.follows = "nixpkgs";
Paint the same screens into a terminal   61
Build the client with Nix, not just a shell for it   63    # The sha deps.edn pins, on the fork with the reconciler fixes.
  glimmer = {
    url = "git+https://gitlab.com/nandithebull/glimmer?rev=399df371c790d690fb6e4560c3d4d7f838502857";
    flake = false;
Find the host's GL driver when the store's is not the system's   68
  # Only ever used off NixOS, to put the host GL driver on the loader path.
  nixgl = {
    url = "github:nix-community/nixGL";
    inputs.nixpkgs.follows = "nixpkgs";
Bundle the closure into one file the AppImage runtime mounts   74
  # Wraps a closure into a single self-extracting file. Only the `appimage`
  # output evaluates it.
  nix-appimage = {
    url = "github:ralismark/nix-appimage";
    inputs.nixpkgs.follows = "nixpkgs";
Build the client with Nix, not just a shell for it   81
Split the tree three ways, and let the phone be Flutter's   83  outputs = { self, nixpkgs, jolt-src, jolt-native, glimmer, nixgl, nix-appimage }:
Build the client with Nix, not just a shell for it   84
    systems = [ "x86_64-linux" "aarch64-linux" ];
    forEachSystem = f:
      nixpkgs.lib.genAttrs systems (system: f nixpkgs.legacyPackages.${system});
Run this tree on a native half the builders made   88
    # Mesa, despite the name: it covers Intel and AMD alike. The NVIDIA
    # wrappers are the ones that need --impure (they read the host kernel
    # module's version), which is why this only ever reaches for Intel.
Stop carrying the 32-bit GL stack and half of git   92
    # Built from nixGL's default.nix rather than taken from its flake
    # outputs, for the one argument the flake hardcodes on: `enable32bits`,
    # which on x86_64 puts a second, i686 copy of mesa, its LLVM, and
    # intel-media-driver into the wrapper. frq is 64-bit on both halves —
    # the Rust cdylibs and the Chez runtime — so nothing here ever opens the
    # 32-bit driver, and carrying it is most of the dev shell's closure.
    nixGLFor = pkgs: (import nixgl {
      inherit pkgs;
      enable32bits = false;
    }).nixGLIntel;
Run this tree on a native half the builders made   103
    # egui reaches for these with dlopen rather than linking them, so being
    # in the cdylib's buildInputs is not enough — whatever starts frq has to
Follow the xorg renames, and stop wrapping nix in distrobox   106      # put them on the loader path itself. Without libx11 here, vidya reports
Run this tree on a native half the builders made   107      # "X11 unavailable", falls back to Wayland, and winit refuses to build a
    # second event loop after the failed first one.
    # Out here rather than beside the package that first needed them: the
    # dev shell starts frq too, on this tree's source rather than the store's
    # copy of it, and a second copy of this list is a second chance for the
    # two ways of running to disagree about what the window needs.
    runtimeLibsFor = pkgs: with pkgs; [
      libGL
      libxkbcommon
      wayland
Follow the xorg renames, and stop wrapping nix in distrobox   118        libx11
      libxcursor
      libxi
      libxrandr
Run this tree on a native half the builders made   122        vulkan-loader
Build the client with Nix, not just a shell for it   124
    packages = forEachSystem (pkgs:
      let
        inherit (pkgs) lib;
Run this tree on a native half the builders made   130          nixGL = nixGLFor pkgs;
Find the host's GL driver when the store's is not the system's   131
Take the native objects from their own flake rather than rebuilding them   132          # libvidya (the retained-tree ABI glimmer-vidya binds, on egui),
        # libjolttui (the same tree over a grid of cells) and libjoltmoq (the
        # AV media plane) — one workspace, three cdylibs, taken from
        # jolt-native's own flake rather than rebuilt here.
        # This used to be a rustPlatform.buildRustPackage over the same
        # source, which meant restating upstream's build: the seven git deps
        # hashed by hand in `cargoLock.outputHashes` and re-hashed whenever
        # its Cargo.lock moved, the linuxHeaders path v4l2r's bindgen wants,
        # and a postPatch dropping the .cargo/config.toml that pointed the
        # build at DotSlash. Upstream's flake says all of that itself now,
        # and says it once. It also builds cpal with the `pipewire` feature,
        # which the restatement did not — so device names in a call are
        # PipeWire's rather than raw ALSA PCMs.
Paint frq with jvui, and take the last Rust out of the window   146          # libjolttui only. Not libjoltmoq, whose job `frq.av.plane` does
        # now, and no longer libvidya either: the window is jvui on SDL,
        # so the only object left out of that Cargo workspace is the
        # terminal backend, and only `just tui` loads it.
Switch frq.av onto the jolt media plane, and stop shipping libjoltmoq   150
        # This makes the closure smaller and the APK smaller. It does NOT
        # make the build shorter, and it is worth being exact about why:
        # jolt-native compiles its external crates ONCE, in a
        # `buildDepsOnly` derivation shared by all three objects, so
        # asking for two of them still builds every dependency the third
        # has — the 440 crates that are jolt-moq's alone. Getting those
        # out of the build is a change in jolt-native, not here: either
        # jolt-moq leaves that workspace, or its deps artifact stops
        # being workspace-wide.
        native =
          let np = jolt-native.packages.${pkgs.stdenv.hostPlatform.system};
          in pkgs.symlinkJoin {
            name = "jolt-native-ui";
Split the tree three ways, and let the phone be Flutter's   164              # Both backends there are. libjoltcosmic is the window —
            # libcosmic behind the same retained-tree ABI — and libjolttui
            # is the terminal. Neither is libvidya and neither is jvui:
            # those were experiments and are gone from this tree entirely.
            paths = [ np.libjolttui np.libjoltcosmic ];
Switch frq.av onto the jolt media plane, and stop shipping libjoltmoq   169
Build the client with Nix, not just a shell for it   170
Fetch libmoq_ffi again, and keep the codecs out of Rust   171          # libmoq_ffi — MoQ over QUIC behind UniFFI's C ABI, FETCHED rather
        # than built. This is the object `frq.moq.raw` is generated from.
Bind libmoq_ffi from the object's own metadata, not from its header   173
Fetch libmoq_ffi again, and keep the codecs out of Rust   174          # Fetched because building it is the thing this whole exercise is
        # about: moq-ffi pulls moq-native, iroh, quinn, rustls and aws-lc-sys
        # behind it, which is 440 crates that nothing else in this tree
        # needs. Upstream already publishes the object for both Linux
        # architectures, so we take those bytes.
Bind libmoq_ffi from the object's own metadata, not from its header   179
Fetch libmoq_ffi again, and keep the codecs out of Rust   180          # Pinned to a release and to a hash, and the hashes below are
        # upstream's own published .sha256 files rather than ones observed
        # here — a `nix-prefetch` of whatever the URL serves today would
        # record that it downloaded something, not that it downloaded the
        # right thing.
        # WHAT THIS BUILD IS NOT: moq-ffi's `audio` and `video` features are
        # on by default upstream and are OFF in these artifacts, so there is
        # no publish_audio/publish_video and no moqaudio*/moqvideo* here —
        # 206 functions where the Apple artifact has 230. That is why the
        # bindings are generated from the object (`just gen-moq`) and not
        # from the C header the release ships, which describes the Apple one.
        moqFfi =
            version = "0.3.17";
            target = {
              "x86_64-linux" = "x86_64-unknown-linux-gnu";
              "aarch64-linux" = "aarch64-unknown-linux-gnu";
            }.${pkgs.stdenv.hostPlatform.system};
            hash = {
              "x86_64-linux" = "sha256-dzQXpV4JgdtD+g33WX51FFAQdfCUXkNsx1xPbobPfUI=";
              "aarch64-linux" = "sha256-PdzRwbJFqOZWRgI0HHX2XUH+Ljh4V3jvQ9asfvCuIPA=";
            }.${pkgs.stdenv.hostPlatform.system};
          pkgs.stdenv.mkDerivation {
            pname = "libmoq-ffi";
            inherit version;
            src = pkgs.fetchurl {
              url = "https://github.com/kixelated/moq/releases/download/moq-ffi-v${version}/moq-ffi-${version}-${target}-libmoq_ffi.so";
              inherit hash;
            dontUnpack = true;
            # It carries no RUNPATH and needs libgcc_s, libm and libc — the
            # host's on an ordinary distro, and nothing at all on NixOS
            # unless they are bound here.
            nativeBuildInputs = [ pkgs.autoPatchelfHook ];
            buildInputs = [ pkgs.stdenv.cc.cc.lib ];
            installPhase = ''
              mkdir -p $out/lib
              cp $src $out/lib/libmoq_ffi.so
              chmod +w $out/lib/libmoq_ffi.so
Bind libmoq_ffi from the object's own metadata, not from its header   223
        # One directory for the loader to look in. jolt resolves every
        # :jolt/native name against JOLT_NATIVE_LIB, and the objects now come
        # from two places — jolt-native's flake, and the moq-ffi release — so
        # they are joined rather than the path being made a list, which the
        # loader does not take.
Bind the C libraries a call actually needs   229          # The C codecs, from nixpkgs. libmoq_ffi carries the transport and
        # nothing else — moq-ffi's `audio` and `video` features would have
        # brought Opus and H.264 with them, at the price of compiling a
        # 1062-crate workspace — so the codecs are linked here instead,
        # where they have always lived.
        # Named in :jolt/native, so the loader resolves them the same way it
        # resolves libvidya: by name, out of one directory.
        # A flat C face for openh264, because openh264 has none. Its
        # `ISVCEncoder` is `const ISVCEncoderVtbl*` — every method is a
        # function pointer in a vtable — and jolt.ffi cannot call one: Chez
        # fixes a foreign procedure's types when it compiles it, and the
        # target must be a literal C symbol name. So the vtable is walked in
        # c/frq_h264.c and jolt binds the five plain symbols it exports.
        # One translation unit against a library nixpkgs already has. It is
        # a calling convention adapter, not a second media plane, and the
        # distinction from the moq-ffi build it replaces is the whole point:
        # this compiles one .c file, not a 1062-crate workspace.
        frqH264 = pkgs.stdenv.mkDerivation {
          pname = "frq-h264";
          version = "0.1";
          src = ./c;
          nativeBuildInputs = [ pkgs.pkg-config ];
          buildInputs = [ pkgs.openh264 ];
          buildPhase = ''
            $CC -O2 -fPIC -shared frq_h264.c -o libfrqh264.so \
              $(pkg-config --cflags --libs openh264)
          installPhase = ''
            mkdir -p $out/lib && cp libfrqh264.so $out/lib/
        # openh264 is here for frqH264's DT_NEEDED; alsa-lib for capture
        # and playback. V4L2 needs nothing: it is ioctls against libc and
        # the kernel, so there is no library to name.
Split the tree three ways, and let the phone be Flutter's   266          # No SDL any more: it was jvui's, declared in jvui's own
        # :jolt/native and dlopened by soname. libcosmic paints through wgpu
        # and takes what it needs from `runtimeLibs` instead.
        codecs = [ pkgs.libopus pkgs.openh264 frqH264 pkgs.alsa-lib ];
Bind the C libraries a call actually needs   270
Let the plane take real devices, not only test thunks   271          # ALSA's PipeWire plugin, which is how `default` resolves to
        # anything on a machine running PipeWire — and every machine frq
        # targets does. Without it alsa-lib fails to dlopen
        # libasound_module_pcm_pipewire.so and the only devices that open
        # are raw hardware ones, which PipeWire is already holding.
        # An environment variable rather than a library in the join:
        # alsa-lib looks plugins up by directory, not by soname.
        alsaPluginDir = "${pkgs.pipewire}/lib/alsa-lib";
Bind libmoq_ffi from the object's own metadata, not from its header   281          nativeAll = pkgs.symlinkJoin {
          name = "frq-native";
Bind the C libraries a call actually needs   283            paths = [ native moqFfi ] ++ codecs;
Bind libmoq_ffi from the object's own metadata, not from its header   284
Build the client with Nix, not just a shell for it   286          # Jolt itself: Clojure on Chez, built the way its own flake builds it.
Split the tree three ways, and let the phone be Flutter's   287
        # Still a function taking its source, though there is only one of
        # them now: the second was the Bionic-addrinfo fork the APK's boot
        # image carried, and there is no jolt APK any more — the phone is
        # ClojureDart and Flutter, and jolt does not run there at all.
Build the APK from the flake, and from nothing   292          joltFrom = src: pkgs.stdenv.mkDerivation {
Build the client with Nix, not just a shell for it   293            pname = "jolt";
          version = "dev";
Build the APK from the flake, and from nothing   295            inherit src;
Build the client with Nix, not just a shell for it   296
          strictDeps = true;
          nativeBuildInputs = with pkgs; [ chez makeWrapper pkg-config xxd ];
          buildInputs = with pkgs; [ lz4 zlib ncurses openssl libuuid ];
          JOLT_VERSION = "dev";
          dontConfigure = true;
          buildPhase = ''
            runHook preBuild
            scheme --script host/chez/build-jolt.ss release target/release/jolt
            runHook postBuild
          installPhase = ''
            runHook preInstall
            mkdir -p "$out/bin"
            install -m755 target/release/jolt "$out/bin/jolt"
            runHook postInstall
          # jolt.deps shells out to git and unzip, and jolt.mvn-http dlopens
Stop carrying the 32-bit GL stack and half of git   318            # OpenSSL through the JOLT_OPENSSL_LIBDIR seam. gitMinimal rather
          # than git: all jolt.deps asks for is clone/fetch/rev-parse, and
          # the full package carries Perl and Python for the subcommands
          # written in them — a quarter of a gigabyte for git-send-email.
Read the clock in the reader's zone when /etc/localtime is a file   322
          # TZDIR so a zone *name* resolves wherever this runs: frq.clock
          # hands one to tzset, and glibc then looks for the tzfile under
          # /usr/share/zoneinfo unless told otherwise — which a NixOS host
          # does not have. The store's own tzdata is there on both kinds of
          # machine. --set-default, so a TZDIR the user set still wins.
Build the client with Nix, not just a shell for it   328            postFixup = ''
            wrapProgram "$out/bin/jolt" \
Stop carrying the 32-bit GL stack and half of git   330                --prefix PATH : "${pkgs.lib.makeBinPath [ pkgs.gitMinimal pkgs.unzip ]}" \
Build the client with Nix, not just a shell for it   331                --set-default JOLT_OPENSSL_LIBDIR "${pkgs.lib.makeLibraryPath [ pkgs.openssl ]}" \
Read the clock in the reader's zone when /etc/localtime is a file   332                --set-default TZDIR "${pkgs.tzdata}/share/zoneinfo" \
Build the client with Nix, not just a shell for it   333                --set-default SSL_CERT_FILE "${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt"
Build the APK from the flake, and from nothing   337          joltRuntime = joltFrom jolt-src;
Split the tree three ways, and let the phone be Flutter's   338
        # The backends' Clojure halves, which live inside the jolt-native
        # checkout beside the objects they bind. Their own deps.edn asks for
        # glimmer by git — the top-level override below answers for both.
        glimmerCosmic = "${jolt-native}/glimmer-backends/glimmer-cosmic";
Take the Android objects from jolt-native's CI, always the latest   343          glimmerTui = "${jolt-native}/glimmer-backends/glimmer-tui";
Build the client with Nix, not just a shell for it   344
Run this tree on a native half the builders made   345          runtimeLibs = runtimeLibsFor pkgs;
Build the client with Nix, not just a shell for it   346
        # The project as jolt sees it: source, deps.edn, nothing else.
        frqSource = pkgs.runCommand "frq-source" { } ''
          mkdir -p "$out"
Split the tree three ways, and let the phone be Flutter's   350            cp -r ${self}/common ${self}/src ${self}/deps.edn "$out/"
Build the client with Nix, not just a shell for it   351          '';
        # Jolt resolves deps.edn from the working directory, so the launcher
        # runs from the store copy. Its .jolt/cpcache write lands on a
        # read-only directory and jolt treats that as a quiet cache miss, so
        # the only cost is re-resolving the (already local) graph per start.
        frqScript = pkgs.writeShellScript "frq" ''
Bind libmoq_ffi from the object's own metadata, not from its header   358            export LD_LIBRARY_PATH="${nativeAll}/lib:${lib.makeLibraryPath runtimeLibs}''${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
Let the plane take real devices, not only test thunks   359            export ALSA_PLUGIN_DIR="${alsaPluginDir}"
Build the client with Nix, not just a shell for it   360            cd ${frqSource}
Find the host's GL driver when the store's is not the system's   361
          # On NixOS the store's Mesa is the system's and the window opens.
          # Anywhere else the real driver is the host's, so defer to nixGL —
          # it prepends the host driver, which has to win over ours.
          runner=""
          [ -e /run/current-system ] || runner="${nixGL}/bin/nixGLIntel"
          exec ''${runner} ${joltRuntime}/bin/jolt \
Split the tree three ways, and let the phone be Flutter's   369              -Sdeps '{:deps {jolt-lang/glimmer {:local/root "${glimmer}"} nandi/glimmer-cosmic {:local/root "${glimmerCosmic}"}}}' \
            -m frq.cosmic "$@"
Build the client with Nix, not just a shell for it   371          '';
Paint the same screens into a terminal   373          # The same source, the other backend. No GL, no nixGL and no X11 —
        # a terminal is the one surface that needs nothing from the host but
        # a terminal, which is the reason this output exists.
        tuiScript = pkgs.writeShellScript "frq-tui" ''
Bind libmoq_ffi from the object's own metadata, not from its header   377            export LD_LIBRARY_PATH="${nativeAll}/lib''${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
Let the plane take real devices, not only test thunks   378            export ALSA_PLUGIN_DIR="${alsaPluginDir}"
Paint the same screens into a terminal   379            cd ${frqSource}
          exec ${joltRuntime}/bin/jolt \
Split the tree three ways, and let the phone be Flutter's   382              -Sdeps '{:deps {jolt-lang/glimmer {:local/root "${glimmer}"} nandi/glimmer-tui {:local/root "${glimmerTui}"}}}' \
Paint the same screens into a terminal   383              -m frq.tui "$@"
        tui = pkgs.runCommand "frq-tui-0.1.0"
            meta = {
              description = "frq's screens in a terminal";
              mainProgram = "frq-tui";
              platforms = systems;
            mkdir -p "$out/bin"
            ln -s ${tuiScript} "$out/bin/frq-tui"
Build the client with Nix, not just a shell for it   399          frq = pkgs.runCommand "frq-0.1.0"
            meta = {
              description = "A freeq client in jolt";
              mainProgram = "frq";
              platforms = systems;
            mkdir -p "$out/bin"
            ln -s ${frqScript} "$out/bin/frq"
Bind the C libraries a call actually needs   413          inherit native moqFfi frqH264 nativeAll frq;
Let the plane take real devices, not only test thunks   414          inherit (pkgs) pipewire;
Merge origin/main, and let one jolt-native answer for both backends   415          inherit tui;
Build the client with Nix, not just a shell for it   416          jolt = joltRuntime;
        default = frq;
Bundle the closure into one file the AppImage runtime mounts   418
        # frq and everything it loads, squashed into one runnable file for
        # hosts without Nix. The whole closure rides along — Mesa included,
        # which is not waste: off NixOS the launcher goes through nixGL, and
        # nixGL needs a store Mesa to put the host's driver in front of.
        appimage =
          nix-appimage.bundlers.${pkgs.stdenv.hostPlatform.system}.default frq;
Build the client with Nix, not just a shell for it   425        });
Run this tree on a native half the builders made   427      # Where `just run` runs, and — because entering it realises what it
    # names — what builds the half of frq that is not this working tree.
    # The two halves, and the split is the whole point of the shell. The frq
    # source is the files on disk, uncommitted edits and all. Everything
    # under it — jolt, glimmer, glimmer-vidya, both native objects — is the
    # flake's, at the revs flake.lock names, so a run says what it ran
    # against and both halves of glimmer-vidya move together. That is the
    # drift the `jolt-native` input's comment is about, and a pin frq can
    # answer for is worth more here than the convenience of a checkout.
Take the native objects from their own flake rather than rebuilding them   438      # `native` is jolt-native's own flake output. It was a buck2 graph when
    # this comment was first written and a cargo build restated here when it
    # was second: buck2 fetches its rustc, zig and every third-party crate as
    # it goes and writes buck-out into the tree it builds, so a sandbox with
    # no network and a read-only store was the one place it could not run.
    # Upstream builds with nix now, so the thing its CI runs and the thing
    # this shell hands a builder are the same derivation.
Run this tree on a native half the builders made   445
    # Nothing here says "nixbuild", though: it is a plain derivation, and
Inline the babashka scripts into the justfile   447      # where it gets built is the machine's business. The `run` recipe asks for
Run this tree on a native half the builders made   448      # the shell with --max-jobs 0, which is what sends it to the `builders`
    # entry rather than compiling egui on a laptop.
    devShells = forEachSystem (pkgs:
      let
        inherit (pkgs) lib;
Bind libmoq_ffi from the object's own metadata, not from its header   453          inherit (self.packages.${pkgs.stdenv.hostPlatform.system}) jolt native nativeAll;
Run this tree on a native half the builders made   454
        default = pkgs.mkShellNoCC {
          name = "frq";
          # jolt, because the runtime frq is run by should be the flake's
          # too. nixGL for the same reason the launcher reaches for it — see
Inline the babashka scripts into the justfile   461            # frqScript. just so the recipe runner comes from here too rather
          # than the host — `nix develop` and then `just run` is the whole of
          # what a machine with nix needs.
          packages = [ jolt pkgs.just (nixGLFor pkgs) ];
          # Read by the recipes rather than baked into a wrapper: the frq
Run this tree on a native half the builders made   467            # source `just run` runs is the working tree, so the launcher has
Inline the babashka scripts into the justfile   468            # to live in that tree and the shell has to hand it its answers.
          # Naming these is also what makes the shell build them.
Bind libmoq_ffi from the object's own metadata, not from its header   470            JOLT_NATIVE_LIB = "${nativeAll}/lib";
Let the plane take real devices, not only test thunks   471            # Spelled out rather than shared with the packages block, which
          # is a different `let`. See `alsaPluginDir` there for why.
          ALSA_PLUGIN_DIR = "${pkgs.pipewire}/lib/alsa-lib";
Run this tree on a native half the builders made   474            GLIMMER_SRC = glimmer;
Split the tree three ways, and let the phone be Flutter's   475            GLIMMER_COSMIC_SRC = "${jolt-native}/glimmer-backends/glimmer-cosmic";
Take the Android objects from jolt-native's CI, always the latest   476            GLIMMER_TUI_SRC = "${jolt-native}/glimmer-backends/glimmer-tui";
Run this tree on a native half the builders made   477            FRQ_LIB_PATH = lib.makeLibraryPath (runtimeLibsFor pkgs);
          NIXGL = "${nixGLFor pkgs}/bin/nixGLIntel";
Take the jolt-native beside this one when there is one   479
          # A checkout of jolt-native beside this one, in place of the pin.
          # The pin is a rev on a server, so the loop for a change to the
          # terminal backend was commit, push, re-pin, re-lock — four steps
          # and an upload for a line of Rust. With a working copy beside this
          # one the loop is `cargo build` and `just tui`, and the shell finds
          # that copy itself: ../jolt-native from the checkout this was run
          # in, which is where it is on the machines this is developed on.
          # A worktree under .claude/worktrees counts as the same checkout —
          # the sibling is the main one's, not the worktree's.
          # Found rather than named, but not silently: it says which tree it
          # took on the way in, because `just tui` running something other
          # than the pin is the sort of thing you have to be able to see.
          # It has to be a built one. A checkout with no target/release/
          # libjolttui.so in it would mean the Jolt half of the backend from
          # the working copy and the shared object from the pin — two halves
          # of two different libraries, which fail in ways that look like
          # neither. So an unbuilt sibling is left alone and the pin stands.
          # FRQ_JOLT_NATIVE overrides the search, and is taken even unbuilt
          # (with a word about what to run): naming a tree is asking for it.
          # Empty is how you say the pin, on a machine that has a sibling and
          # wants what everyone else is running.
          # Only the sources and libjolttui move either way. Everything else
          # on the library path — libopus, libmoq_ffi, the ALSA plugins —
          # stays the pin's, since a checkout has no build of those to offer.
          shellHook = ''
            frq_named=1
            if [ -z "''${FRQ_JOLT_NATIVE+named}" ]; then
              frq_named=
              frq_git="$(git rev-parse --path-format=absolute --git-common-dir 2>/dev/null || true)"
              frq_near="''${frq_git:+$(dirname "$(dirname "$frq_git")")/jolt-native}"
              if [ -n "$frq_near" ] && [ -e "$frq_near/target/release/libjolttui.so" ]; then
                FRQ_JOLT_NATIVE="$frq_near"
                FRQ_JOLT_NATIVE=""
            if [ -n "$FRQ_JOLT_NATIVE" ]; then
              if [ -d "$FRQ_JOLT_NATIVE/crates/jolt-tui" ]; then
                FRQ_JOLT_NATIVE="$(cd "$FRQ_JOLT_NATIVE" && pwd)"
                export FRQ_JOLT_NATIVE
                export GLIMMER_TUI_SRC="$FRQ_JOLT_NATIVE/glimmer-backends/glimmer-tui"
Split the tree three ways, and let the phone be Flutter's   526                  export GLIMMER_COSMIC_SRC="$FRQ_JOLT_NATIVE/glimmer-backends/glimmer-cosmic"
Take the jolt-native beside this one when there is one   527                  # First, so a cargo build wins over the pin's copy of the
                # same object. The rest of the pin's lib directory is still
                # behind it.
                export JOLT_NATIVE_LIB="$FRQ_JOLT_NATIVE/target/release:$JOLT_NATIVE_LIB"
                echo "frq: jolt-native from $FRQ_JOLT_NATIVE, not the pin (FRQ_JOLT_NATIVE= for the pin)" >&2
                if [ ! -e "$FRQ_JOLT_NATIVE/target/release/libjolttui.so" ]; then
                  echo "frq: no libjolttui.so there yet — cargo build --release --features terminal -p jolt-tui" >&2
              elif [ -n "$frq_named" ]; then
                echo "frq: FRQ_JOLT_NATIVE=$FRQ_JOLT_NATIVE is not a jolt-native checkout; using the pin" >&2
            unset frq_named frq_git frq_near
Run this tree on a native half the builders made   541
      });
Build the client with Nix, not just a shell for it   544      apps = forEachSystem (pkgs: {
      default = {
        type = "app";
        program = "${self.packages.${pkgs.stdenv.hostPlatform.system}.frq}/bin/frq";
Paint the same screens into a terminal   549        tui = {
        type = "app";
        program = "${self.packages.${pkgs.stdenv.hostPlatform.system}.tui}/bin/frq-tui";
Build the client with Nix, not just a shell for it   553