Merge master into staging-next

pkgs/applications/audio/snd/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "snd";
-  version = "23.0";
+  version = "23.1";
 
   src = fetchurl {
     url = "mirror://sourceforge/snd/snd-${version}.tar.gz";
-    sha256 = "sha256-WnQtXr1IcOpNJBrSvLf2rNu2XPs8JU01LWsQSzvvivA=";
+    sha256 = "sha256-zNXA/HFUCTxKzeKde/XVK239dInnxkPBmxXrlicl1fI=";
   };
 
   nativeBuildInputs = [ pkg-config ];

pkgs/applications/blockchains/clightning/default.nix

···
 in
 stdenv.mkDerivation rec {
   pname = "clightning";
-  version = "23.02";
+  version = "23.02.2";
 
   src = fetchurl {
     url = "https://github.com/ElementsProject/lightning/releases/download/v${version}/clightning-v${version}.zip";
-    sha256 = "sha256-uvk7sApIwlrkH8eERBetf/nsAkN2d35T/IEtICFflzY=";
+    sha256 = "sha256-fHGBwf79Q0DSLs/b+Lhg9kdIQzDn5rJYEB9yLkLbxlE=";
   };
 
   # when building on darwin we need dawin.cctools to provide the correct libtool

pkgs/applications/editors/leo-editor/default.nix

···
 
 mkDerivation rec {
   pname = "leo-editor";
-  version = "6.7.1";
+  version = "6.7.2";
 
   src = fetchFromGitHub {
     owner = "leo-editor";
     repo = "leo-editor";
     rev = version;
-    sha256 = "sha256-4sD/gN9cbgZ9Z5Xiyx2velX5q6J6vOQAeRor10Zamyw=";
+    sha256 = "sha256-n9Ze02Dvoci3QS5slJNpb3CI3zlTq6FsdVbxvZHCJ2A=";
   };
 
   dontBuild = true;

pkgs/applications/emulators/rpcs3/default.nix

···
 
 let
   # Keep these separate so the update script can regex them
-  rpcs3GitVersion = "14757-3388c8ed0";
-  rpcs3Version = "0.0.26-14757-3388c8ed0";
-  rpcs3Revision = "3388c8ed090afb216f40c1d00361c6f6f1e7a9ba";
-  rpcs3Sha256 = "0w2qsk91dxp0lxy6bdz4yyf79wqfnzyxswrg1kxwm0s7iwwch2pj";
+  rpcs3GitVersion = "14812-cf5346c26";
+  rpcs3Version = "0.0.27-14812-cf5346c26";
+  rpcs3Revision = "cf5346c263111760752cabb94767c07c501207c4";
+  rpcs3Sha256 = "1dkik6r6khmpcbh27n1bzg7y1ws7ljrkn81a7qn21wmh709sscc8";
 
   ittapi = fetchFromGitHub {
     owner = "intel";

pkgs/applications/misc/corectrl/default.nix

···
 
 stdenv.mkDerivation rec{
   pname = "corectrl";
-  version = "1.3.1";
+  version = "1.3.3";
 
   src = fetchFromGitLab {
     owner = "corectrl";
     repo = "corectrl";
     rev = "v${version}";
-    sha256 = "sha256-mVMyXpNhwljxsAvrKeHPxUSfdF/mfxG157T13Kb8PnE=";
+    sha256 = "sha256-WgtLDAjywHd9++7DvPfpfEXGbBQWx8kQxseIadho1YE=";
   };
   patches = [
     ./polkit-dir.patch

pkgs/applications/misc/fluidd/default.nix

···
 
 stdenvNoCC.mkDerivation rec {
   pname = "fluidd";
-  version = "1.23.2";
+  version = "1.23.3";
 
   src = fetchurl {
     name = "fluidd-v${version}.zip";
     url = "https://github.com/cadriel/fluidd/releases/download/v${version}/fluidd.zip";
-    sha256 = "sha256-dSlpCmVtF4H9d2DcOBkybrQz39QRlBCTTuGPA9yH8is=";
+    sha256 = "sha256-CCIu6DNU71oL0JIW3mQ5ThRSjbXeBmJ4FbF6i2dERbc=";
   };
 
   nativeBuildInputs = [ unzip ];

pkgs/applications/misc/holochain-launcher/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "holochain-launcher";
-  version = "0.9.1";
+  version = "0.9.2";
 
   src = fetchurl {
     url = "https://github.com/holochain/launcher/releases/download/v${version}/holochain-launcher_${version}_amd64.deb";
-    sha256 = "sha256-vYsJBMtdkbe87Xn8Ah0eT+azFWfm3ZUooejs7oB2KVQ=";
+    sha256 = "sha256-ipcv1rP4DDjBEybmntsfw2ubjCgm1cGDlYM7sN0jeVo=";
   };
 
   nativeBuildInputs = [

pkgs/applications/misc/kondo/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "kondo";
-  version = "0.5";
+  version = "0.6";
 
   src = fetchFromGitHub {
     owner = "tbillington";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-TTgsfoJ3TEK7wyRJfBIxvPA53wZbq7KJ4LxjUbrHE4Y=";
+    sha256 = "sha256-f0eRM4U2FwMGjmQKb3tjX2TRv1hN//FkoA2h6WmFOQk=";
   };
 
-  cargoSha256 = "sha256-s5e997I7YiDKF6rOB0XwcxbnHR8AifYPX9ctvdz8VTw=";
+  cargoHash = "sha256-DouQN9Lo/CoqZZD3HuO1+Xzvc2yL5l157TeAi+bmfrE=";
 
   meta = with lib; {
     description = "Save disk space by cleaning unneeded files from software projects";

pkgs/applications/misc/spicetify-cli/default.nix

···
 
 buildGoModule rec {
   pname = "spicetify-cli";
-  version = "2.16.1";
+  version = "2.16.2";
 
   src = fetchFromGitHub {
     owner = "spicetify";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-Pq8HjmWSfBgieSJejrlw+FiRdq9NxryYPcw++Pdjsuk=";
+    sha256 = "sha256-13JWceuiNz1FxgVVQ2KV88zYLIBkEVeTfPF5eEK1oe8=";
   };
 
-  vendorSha256 = "sha256-E2Q+mXojMb8E0zSnaCOl9xp5QLeYcuTXjhcp3Hc8gH4=";
+  vendorHash = "sha256-rmQpS4k/G3s/H7sPxVZ70KtJEvYjsDV2htV97viWttM=";
 
   ldflags = [
     "-s -w"

pkgs/applications/networking/browsers/librewolf/src.json

···
 {
-  "packageVersion": "110.0.1-1",
+  "packageVersion": "111.0-2",
   "source": {
-    "rev": "110.0.1-1",
-    "sha256": "06k33gf2q77w3airgbqmki555pp2yv33cbkivbi4hgz80zl1m4i3"
+    "rev": "111.0-2",
+    "sha256": "0kz365pldyancbq029b3v0wpc1jchzywqjriy6276f1kwssyp8pr"
   },
   "firefox": {
-    "version": "110.0.1",
-    "sha512": "42c6a99a3874a0f60121188c43788fb35577734d9366c3f89ad41b8328cc542ce172ec81ca35b9ea551eaa698197ccdb43922ec3215d311e0770aaaa59625d21"
+    "version": "111.0",
+    "sha512": "cdb300fdbb2b60068b0fc10a18df587b417e484901d36f52dd174d320d3440a42b02ea000f325c5781fd8853a5171b1a5184562fb535ece90619e4c64d46bb82"
   }
 }

pkgs/applications/networking/browsers/opera/default.nix

···
 in
 stdenv.mkDerivation rec {
   pname = "opera";
-  version = "95.0.4635.37";
+  version = "96.0.4693.31";
 
   src = fetchurl {
     url = "${mirror}/${version}/linux/${pname}-stable_${version}_amd64.deb";
-    hash = "sha256-NQv9EVaBPfHygr76neYGACuk8A6Oc1GXAgizMa+jngw=";
+    hash = "sha256-ygJmwwwYg5lc7rDMkc8YH7oThET+4reFqPTrojtFowQ=";
   };
 
   unpackPhase = "dpkg-deb -x $src .";

pkgs/applications/networking/cluster/argocd-autopilot/default.nix

···
 
 buildGoModule rec {
   pname = "argocd-autopilot";
-  version = "0.4.12";
+  version = "0.4.13";
 
   src = fetchFromGitHub {
     owner = "argoproj-labs";
     repo = "argocd-autopilot";
     rev = "v${version}";
-    sha256 = "sha256-YYUOW3QWJx+XdrZTaPEGs5TJH2lVUJGPcPYYehR3V0M=";
+    sha256 = "sha256-zmb4T6D7kkAUY+Ky/mpNM6srC0LfzpZ9b1cjFhhKS5A=";
   };
 
   vendorHash = "sha256-p8Q+oQFbkulcDFdHUoQ1qdO1zsi7XmU/IjnScZogz2g=";

pkgs/applications/networking/cluster/argocd/default.nix

···
 
 buildGoModule rec {
   pname = "argocd";
-  version = "2.6.3";
+  version = "2.6.5";
 
   src = fetchFromGitHub {
     owner = "argoproj";
     repo = "argo-cd";
     rev = "v${version}";
-    sha256 = "sha256-l2cuCS5CtAbmv7wHvccNA+DJ8+hN5/xHWTqZFGyBKGQ=";
+    sha256 = "sha256-+3d20bD2sxck8fCrMv6Z9O70g7iWdHA5FdFVoLDtY2k=";
   };
 
   proxyVendor = true; # darwin/linux hash mismatch
-  vendorHash = "sha256-c4KvsHN+2QXk/+MJgRIm5L6LtRe5juUF8rw84aVot38=";
+  vendorHash = "sha256-BqES6nhV17iqK1dsa+2IdNCd1Wl1O6hOBczqxRHewPk=";
 
   # Set target as ./cmd per cli-local
   # https://github.com/argoproj/argo-cd/blob/master/Makefile#L227

pkgs/applications/networking/cluster/glooctl/default.nix

···
 
 buildGoModule rec {
   pname = "glooctl";
-  version = "1.13.9";
+  version = "1.13.10";
 
   src = fetchFromGitHub {
     owner = "solo-io";
     repo = "gloo";
     rev = "v${version}";
-    hash = "sha256-rlZtZC5D5wSYVjP/IHSY9eSfaGRGhtfndkC6PYDMXqg=";
+    hash = "sha256-PsdaGVBEslcBMNCj1NQozwbrRx1Nx7Z5+jtZLCrJwDU=";
   };
 
   subPackages = [ "projects/gloo/cli/cmd" ];

pkgs/applications/networking/cluster/linkerd/edge.nix

···
 
 (callPackage ./generic.nix { }) {
   channel = "edge";
-  version = "23.3.1";
-  sha256 = "10vl3lay9f823qp0cqh4a7fzfkh8qcl0k6jwdjvrd93d4rasvnsm";
-  vendorSha256 = "sha256-DPYGh2lUgyYqquaNVRWb2CCAAFi0bm3ZKHNOoVq6dJ4=";
+  version = "23.3.2";
+  sha256 = "1vbi24nd8mh7vpzxy6qbjd3b7ifg16yc6abb8yvnqvxws8klpj8f";
+  vendorSha256 = "sha256-sWNaCmh1fbtJOIHMwA4XAyGUNWpqME+PfmbxSFfH4ws=";
 }

pkgs/applications/networking/cluster/stern/default.nix

···
 in
 buildGoModule rec {
   pname = "stern";
-  version = "1.23.0";
+  version = "1.24.0";
 
   src = fetchFromGitHub {
     owner = "stern";
     repo = "stern";
     rev = "v${version}";
-    sha256 = "sha256-tqp2H8aWPBgje1zIK673cbr+DShhTQL9VQ0dEL/he7s=";
+    sha256 = "sha256-jJxrBBs8PkYg9oH9MY1RLJb262REmbKciHXiwWTqoRc=";
   };
 
-  vendorHash = "sha256-ud07lWHwQfAHgVenUApwrfxmTjJKVm+pOExdR9pZFxA=";
+  vendorHash = "sha256-1MhscgCGSJXkcj5Rt29+xbBX1uGfOS0kmab+DNY/Bt4=";
 
   subPackages = [ "." ];
 

pkgs/applications/networking/cluster/tubekit/default.nix

···
 
 buildGoModule rec {
   pname = "tubekit";
-  version = "4";
+  version = "5";
 
   src = fetchFromGitHub {
     owner = "reconquest";
     repo = "tubekit";
     rev = "refs/tags/v${version}";
-    hash = "sha256-sq91uR8ITMOv8hivwKQR02mMlJpjDHw6RxiwVUrpwnY=";
+    hash = "sha256-fUe5bMFF569A9Xdx3bfQH2DzbQDRfZ+ewlDL+gK2gWw=";
   };
 
-  vendorHash = "sha256-qrGzmr1dZPn5r2WBJA7FT7RTqP2sxnrXgbrnKlnpF0Y=";
+  vendorHash = "sha256-qAmkUV5l5g8/w8ZTYFGYvd9I8NUk8rMYjutenHvTRnw=";
 
   meta = with lib; {
     description = "Kubectl alternative with quick context switching";

pkgs/applications/office/treesheets/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "treesheets";
-  version = "unstable-2023-03-05";
+  version = "unstable-2023-03-07";
 
   src = fetchFromGitHub {
     owner = "aardappel";
     repo = "treesheets";
-    rev = "0208ba3b43d0618f6d25e99bfb68dcd6f2e19868";
-    sha256 = "bxiAbD9s+O49t2hV0cdbDnSNMkBZOm6Z1cs7sQwlaYQ=";
+    rev = "6672b90aa6310f2a02d9527f500645dd525a8fe3";
+    sha256 = "uf4fSkMGVS1/H5HwKTo0Fp69CjI3C9Bmw07oP9PYvlQ=";
   };
 
   nativeBuildInputs = [

pkgs/applications/science/electronics/openhantek6022/default.nix

···
 
 mkDerivation rec {
   pname = "openhantek6022";
-  version = "3.3.2.1";
+  version = "3.3.2.2";
 
   src = fetchFromGitHub {
     owner = "OpenHantek";
     repo = "OpenHantek6022";
     rev = version;
-    sha256 = "sha256-ysluU3UmWtrTAstnCbSy4TdzbjcnSUeE+d8mpC7Ocvk=";
+    sha256 = "sha256-0k9Q60+T28m1hPYf5viSdpt0s4d828lfjVo3GjLDm7c=";
   };
 
   nativeBuildInputs = [ cmake makeWrapper ];

pkgs/applications/video/ani-cli/default.nix

···
 
 stdenvNoCC.mkDerivation rec {
   pname = "ani-cli";
-  version = "4.1";
+  version = "4.2";
 
   src = fetchFromGitHub {
     owner = "pystardust";
     repo = "ani-cli";
     rev = "v${version}";
-    hash = "sha256-8fpOCyv/XafrVy76jtazRoHW2gidjikgnRdaWzh8kY8=";
+    hash = "sha256-XXD55sxgKg8qSdXV7mbnSCQJ4fNgWFG5IiR1QTjDkHI=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/applications/video/kodi/addons/youtube/default.nix

···
 buildKodiAddon rec {
   pname = "youtube";
   namespace = "plugin.video.youtube";
-  version = "6.8.24+matrix.1";
+  version = "7.0.0";
 
   src = fetchzip {
     url = "https://mirrors.kodi.tv/addons/nexus/${namespace}/${namespace}-${version}.zip";
-    sha256 = "sha256-/yQML2iK5jcIhN6RJC+WJ8EnH640qFJFdaaVeGPEg9U=";
+    sha256 = "sha256-azluf+CATsgjotTqBUAbqB3PvWuHpsS6weakKAbk9F8=";
   };
 
   propagatedBuildInputs = [

pkgs/development/compilers/inform6/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "inform6";
-  version = "6.34-6.12.2";
+  version = "6.41-r3";
 
   src = fetchurl  {
     url = "https://ifarchive.org/if-archive/infocom/compilers/inform6/source/inform-${version}.tar.gz";
-    sha256 = "c149f143f2c29a4cb071e578afef8097647cc9e823f7fcfab518ac321d9d259f";
+    sha256 = "sha256-PqfPRnKb0DD7k1S/Knt1ozlU57LQo1mQjVOkuYK+hBI=";
   };
 
   buildInputs = [ perl ];

pkgs/development/compilers/mercury/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "mercury";
-  version = "22.01.3";
+  version = "22.01.5";
 
   src = fetchurl {
     url    = "https://dl.mercurylang.org/release/mercury-srcdist-${version}.tar.gz";
-    sha256 = "sha256-1bS0t7OkpjoYcx2XA0tE8TG/WJttGxDo68S+zvAA0Eg=";
+    sha256 = "sha256-fhstGxMMCvxlVCvjwuSDmc8sJdegStPEJ+AicVsJig8=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/development/compilers/zig/0.10.nix

···
     llvm
   ]);
 
+  patches = [
+    # Backport alignment related panics from zig-master to 0.10.
+    # Upstream issue: https://github.com/ziglang/zig/issues/14559
+    ./zig_14559.patch
+  ];
+
   preBuild = ''
     export HOME=$TMPDIR;
   '';
···
   cmakeFlags = [
     # file RPATH_CHANGE could not write new RPATH
     "-DCMAKE_SKIP_BUILD_RPATH=ON"
+
+    # always link against static build of LLVM
+    "-DZIG_STATIC_LLVM=ON"
 
     # ensure determinism in the compiler build
     "-DZIG_TARGET_MCPU=baseline"
···
     license = licenses.mit;
     maintainers = with maintainers; [ aiotter andrewrk AndersonTorres ];
     platforms = platforms.unix;
-    # Build fails on Darwin on both AArch64 and x86_64:
-    # https://github.com/NixOS/nixpkgs/pull/210324#issuecomment-1381313616
-    # https://github.com/NixOS/nixpkgs/pull/210324#issuecomment-1381236045
-    broken = stdenv.isDarwin;
   };
 }

pkgs/development/compilers/zig/zig_14559.patch

···
+From 405801d8a8be734425eca4f3eebc56287804ac93 Mon Sep 17 00:00:00 2001
+From: Jakub Konka <[e-mail]>
+Date: Sun, 5 Feb 2023 10:04:34 +0100
+Subject: [PATCH] macho: temp fix alignment and enable some logs
+
+---
+ src/link/MachO/Object.zig  | 80 ++++++++++++++++++++++++++------------
+ src/link/MachO/ZldAtom.zig | 29 +++++++-------
+ src/link/MachO/zld.zig     | 22 +++++------
+ 3 files changed, 79 insertions(+), 52 deletions(-)
+
+diff --git a/src/link/MachO/Object.zig b/src/link/MachO/Object.zig
+index 401184da515..05638c1f858 100644
+--- a/src/link/MachO/Object.zig
++++ b/src/link/MachO/Object.zig
+@@ -54,12 +54,18 @@ atom_by_index_table: []AtomIndex = undefined,
+ /// Can be undefined as set together with in_symtab.
+ globals_lookup: []i64 = undefined,
+ 
++/// All relocs sorted and flattened.
++relocs: std.ArrayListUnmanaged(macho.relocation_info) = .{},
++sect_relocs_lookup: std.ArrayListUnmanaged(u32) = .{},
++
+ atoms: std.ArrayListUnmanaged(AtomIndex) = .{},
+ 
+ pub fn deinit(self: *Object, gpa: Allocator) void {
+     self.atoms.deinit(gpa);
+     gpa.free(self.name);
+     gpa.free(self.contents);
++    self.relocs.deinit(gpa);
++    self.sect_relocs_lookup.deinit(gpa);
+     if (self.in_symtab) |_| {
+         gpa.free(self.source_symtab_lookup);
+         gpa.free(self.source_address_lookup);
+@@ -101,6 +107,10 @@ pub fn parse(self: *Object, allocator: Allocator, cpu_arch: std.Target.Cpu.Arch)
+         return error.MismatchedCpuArchitecture;
+     }
+ 
++    const nsects = self.getSourceSections().len;
++    try self.sect_relocs_lookup.resize(allocator, nsects);
++    mem.set(u32, self.sect_relocs_lookup.items, 0);
++
+     var it = LoadCommandIterator{
+         .ncmds = self.header.ncmds,
+         .buffer = self.contents[@sizeOf(macho.mach_header_64)..][0..self.header.sizeofcmds],
+@@ -110,13 +120,11 @@ pub fn parse(self: *Object, allocator: Allocator, cpu_arch: std.Target.Cpu.Arch)
+             .SYMTAB => {
+                 const symtab = cmd.cast(macho.symtab_command).?;
+                 self.in_symtab = @ptrCast(
+-                    [*]const macho.nlist_64,
+-                    @alignCast(@alignOf(macho.nlist_64), &self.contents[symtab.symoff]),
++                    [*]align(1) const macho.nlist_64,
++                    self.contents.ptr + symtab.symoff,
+                 )[0..symtab.nsyms];
+                 self.in_strtab = self.contents[symtab.stroff..][0..symtab.strsize];
+ 
+-                const nsects = self.getSourceSections().len;
+-
+                 self.symtab = try allocator.alloc(macho.nlist_64, self.in_symtab.?.len + nsects);
+                 self.source_symtab_lookup = try allocator.alloc(u32, self.in_symtab.?.len);
+                 self.strtab_lookup = try allocator.alloc(u32, self.in_symtab.?.len);
+@@ -192,6 +200,17 @@ const SymbolAtIndex = struct {
+         return mem.sliceTo(@ptrCast([*:0]const u8, ctx.in_strtab.?.ptr + off), 0);
+     }
+ 
++    fn getSymbolSeniority(self: SymbolAtIndex, ctx: Context) u2 {
++        const sym = self.getSymbol(ctx);
++        if (!sym.ext()) {
++            const sym_name = self.getSymbolName(ctx);
++            if (mem.startsWith(u8, sym_name, "l") or mem.startsWith(u8, sym_name, "L")) return 0;
++            return 1;
++        }
++        if (sym.weakDef() or sym.pext()) return 2;
++        return 3;
++    }
++
+     /// Performs lexicographic-like check.
+     /// * lhs and rhs defined
+     ///   * if lhs == rhs
+@@ -206,23 +225,15 @@ const SymbolAtIndex = struct {
+         if (lhs.sect() and rhs.sect()) {
+             if (lhs.n_value == rhs.n_value) {
+                 if (lhs.n_sect == rhs.n_sect) {
+-                    if (lhs.ext() and rhs.ext()) {
+-                        if ((lhs.pext() or lhs.weakDef()) and (rhs.pext() or rhs.weakDef())) {
+-                            return false;
+-                        } else return rhs.pext() or rhs.weakDef();
+-                    } else {
+-                        const lhs_name = lhs_index.getSymbolName(ctx);
+-                        const lhs_temp = mem.startsWith(u8, lhs_name, "l") or mem.startsWith(u8, lhs_name, "L");
+-                        const rhs_name = rhs_index.getSymbolName(ctx);
+-                        const rhs_temp = mem.startsWith(u8, rhs_name, "l") or mem.startsWith(u8, rhs_name, "L");
+-                        if (lhs_temp and rhs_temp) {
+-                            return false;
+-                        } else return rhs_temp;
+-                    }
++                    const lhs_senior = lhs_index.getSymbolSeniority(ctx);
++                    const rhs_senior = rhs_index.getSymbolSeniority(ctx);
++                    if (lhs_senior == rhs_senior) {
++                        return lessThanByNStrx(ctx, lhs_index, rhs_index);
++                    } else return lhs_senior < rhs_senior;
+                 } else return lhs.n_sect < rhs.n_sect;
+             } else return lhs.n_value < rhs.n_value;
+         } else if (lhs.undf() and rhs.undf()) {
+-            return false;
++            return lessThanByNStrx(ctx, lhs_index, rhs_index);
+         } else return rhs.undf();
+     }
+ 
+@@ -393,6 +404,16 @@ pub fn splitIntoAtoms(self: *Object, zld: *Zld, object_id: u31) !void {
+             zld.sections.items(.header)[out_sect_id].sectName(),
+         });
+ 
++        // Parse all relocs for the input section, and sort in descending order.
++        // Previously, I have wrongly assumed the compilers output relocations for each
++        // section in a sorted manner which is simply not true.
++        const start = @intCast(u32, self.relocs.items.len);
++        if (self.getSourceRelocs(section.header)) |relocs| {
++            try self.relocs.appendUnalignedSlice(gpa, relocs);
++            std.sort.sort(macho.relocation_info, self.relocs.items[start..], {}, relocGreaterThan);
++        }
++        self.sect_relocs_lookup.items[section.id] = start;
++
+         const cpu_arch = zld.options.target.cpu.arch;
+         const sect_loc = filterSymbolsBySection(symtab[sect_sym_index..], sect_id + 1);
+         const sect_start_index = sect_sym_index + sect_loc.index;
+@@ -559,7 +580,7 @@ pub fn getSourceSections(self: Object) []const macho.section_64 {
+     } else unreachable;
+ }
+ 
+-pub fn parseDataInCode(self: Object) ?[]const macho.data_in_code_entry {
++pub fn parseDataInCode(self: Object) ?[]align(1) const macho.data_in_code_entry {
+     var it = LoadCommandIterator{
+         .ncmds = self.header.ncmds,
+         .buffer = self.contents[@sizeOf(macho.mach_header_64)..][0..self.header.sizeofcmds],
+@@ -569,10 +590,7 @@ pub fn parseDataInCode(self: Object) ?[]const macho.data_in_code_entry {
+             .DATA_IN_CODE => {
+                 const dice = cmd.cast(macho.linkedit_data_command).?;
+                 const ndice = @divExact(dice.datasize, @sizeOf(macho.data_in_code_entry));
+-                return @ptrCast(
+-                    [*]const macho.data_in_code_entry,
+-                    @alignCast(@alignOf(macho.data_in_code_entry), &self.contents[dice.dataoff]),
+-                )[0..ndice];
++                return @ptrCast([*]align(1) const macho.data_in_code_entry, self.contents.ptr + dice.dataoff)[0..ndice];
+             },
+             else => {},
+         }
+@@ -632,11 +650,23 @@ pub fn getSectionAliasSymbolPtr(self: *Object, sect_id: u8) *macho.nlist_64 {
+     return &self.symtab[self.getSectionAliasSymbolIndex(sect_id)];
+ }
+ 
+-pub fn getRelocs(self: Object, sect: macho.section_64) []align(1) const macho.relocation_info {
+-    if (sect.nreloc == 0) return &[0]macho.relocation_info{};
++fn getSourceRelocs(self: Object, sect: macho.section_64) ?[]align(1) const macho.relocation_info {
++    if (sect.nreloc == 0) return null;
+     return @ptrCast([*]align(1) const macho.relocation_info, self.contents.ptr + sect.reloff)[0..sect.nreloc];
+ }
+ 
++pub fn getRelocs(self: Object, sect_id: u16) []const macho.relocation_info {
++    const sect = self.getSourceSection(sect_id);
++    const start = self.sect_relocs_lookup.items[sect_id];
++    const len = sect.nreloc;
++    return self.relocs.items[start..][0..len];
++}
++
++fn relocGreaterThan(ctx: void, lhs: macho.relocation_info, rhs: macho.relocation_info) bool {
++    _ = ctx;
++    return lhs.r_address > rhs.r_address;
++}
++
+ pub fn getSymbolName(self: Object, index: u32) []const u8 {
+     const strtab = self.in_strtab.?;
+     const sym = self.symtab[index];
+diff --git a/src/link/MachO/ZldAtom.zig b/src/link/MachO/ZldAtom.zig
+index 817aa816625..b42309598d7 100644
+--- a/src/link/MachO/ZldAtom.zig
++++ b/src/link/MachO/ZldAtom.zig
+@@ -465,7 +465,7 @@ pub fn resolveRelocs(
+     zld: *Zld,
+     atom_index: AtomIndex,
+     atom_code: []u8,
+-    atom_relocs: []align(1) const macho.relocation_info,
++    atom_relocs: []const macho.relocation_info,
+     reverse_lookup: []u32,
+ ) !void {
+     const arch = zld.options.target.cpu.arch;
+@@ -540,7 +540,7 @@ fn resolveRelocsArm64(
+     zld: *Zld,
+     atom_index: AtomIndex,
+     atom_code: []u8,
+-    atom_relocs: []align(1) const macho.relocation_info,
++    atom_relocs: []const macho.relocation_info,
+     reverse_lookup: []u32,
+     context: RelocContext,
+ ) !void {
+@@ -579,7 +579,6 @@ fn resolveRelocsArm64(
+         }
+ 
+         const target = parseRelocTarget(zld, atom_index, rel, reverse_lookup);
+-        const rel_offset = @intCast(u32, rel.r_address - context.base_offset);
+ 
+         log.debug("  RELA({s}) @ {x} => %{d} ('{s}') in object({?})", .{
+             @tagName(rel_type),
+@@ -589,6 +588,7 @@ fn resolveRelocsArm64(
+             target.file,
+         });
+ 
++        const rel_offset = @intCast(u32, rel.r_address - context.base_offset);
+         const source_addr = blk: {
+             const source_sym = zld.getSymbol(atom.getSymbolWithLoc());
+             break :blk source_sym.n_value + rel_offset;
+@@ -596,7 +596,7 @@ fn resolveRelocsArm64(
+         const is_tlv = is_tlv: {
+             const source_sym = zld.getSymbol(atom.getSymbolWithLoc());
+             const header = zld.sections.items(.header)[source_sym.n_sect - 1];
+-            break :is_tlv header.@"type"() == macho.S_THREAD_LOCAL_VARIABLES;
++            break :is_tlv header.type() == macho.S_THREAD_LOCAL_VARIABLES;
+         };
+         const target_addr = try getRelocTargetAddress(zld, rel, target, is_tlv);
+ 
+@@ -831,7 +831,7 @@ fn resolveRelocsX86(
+     zld: *Zld,
+     atom_index: AtomIndex,
+     atom_code: []u8,
+-    atom_relocs: []align(1) const macho.relocation_info,
++    atom_relocs: []const macho.relocation_info,
+     reverse_lookup: []u32,
+     context: RelocContext,
+ ) !void {
+@@ -877,7 +877,7 @@ fn resolveRelocsX86(
+         const is_tlv = is_tlv: {
+             const source_sym = zld.getSymbol(atom.getSymbolWithLoc());
+             const header = zld.sections.items(.header)[source_sym.n_sect - 1];
+-            break :is_tlv header.@"type"() == macho.S_THREAD_LOCAL_VARIABLES;
++            break :is_tlv header.type() == macho.S_THREAD_LOCAL_VARIABLES;
+         };
+ 
+         log.debug("    | source_addr = 0x{x}", .{source_addr});
+@@ -1015,27 +1015,24 @@ pub fn getAtomCode(zld: *Zld, atom_index: AtomIndex) []const u8 {
+     return code[offset..][0..code_len];
+ }
+ 
+-pub fn getAtomRelocs(zld: *Zld, atom_index: AtomIndex) []align(1) const macho.relocation_info {
++pub fn getAtomRelocs(zld: *Zld, atom_index: AtomIndex) []const macho.relocation_info {
+     const atom = zld.getAtomPtr(atom_index);
+     assert(atom.getFile() != null); // Synthetic atom shouldn't need to unique for relocs.
+     const object = zld.objects.items[atom.getFile().?];
+ 
+-    const source_sect = if (object.getSourceSymbol(atom.sym_index)) |source_sym| blk: {
+-        const source_sect = object.getSourceSection(source_sym.n_sect - 1);
+-        assert(!source_sect.isZerofill());
+-        break :blk source_sect;
++    const source_sect_id = if (object.getSourceSymbol(atom.sym_index)) |source_sym| blk: {
++        break :blk source_sym.n_sect - 1;
+     } else blk: {
+         // If there was no matching symbol present in the source symtab, this means
+         // we are dealing with either an entire section, or part of it, but also
+         // starting at the beginning.
+         const nbase = @intCast(u32, object.in_symtab.?.len);
+         const sect_id = @intCast(u16, atom.sym_index - nbase);
+-        const source_sect = object.getSourceSection(sect_id);
+-        assert(!source_sect.isZerofill());
+-        break :blk source_sect;
++        break :blk sect_id;
+     };
+-
+-    const relocs = object.getRelocs(source_sect);
++    const source_sect = object.getSourceSection(source_sect_id);
++    assert(!source_sect.isZerofill());
++    const relocs = object.getRelocs(source_sect_id);
+ 
+     if (atom.cached_relocs_start == -1) {
+         const indexes = if (object.getSourceSymbol(atom.sym_index)) |source_sym| blk: {
+diff --git a/src/link/MachO/zld.zig b/src/link/MachO/zld.zig
+index 3a2ea79c6ec..cee3f302c08 100644
+--- a/src/link/MachO/zld.zig
++++ b/src/link/MachO/zld.zig
+@@ -396,7 +396,7 @@ pub const Zld = struct {
+                 break :blk null;
+             }
+ 
+-            switch (sect.@"type"()) {
++            switch (sect.type()) {
+                 macho.S_4BYTE_LITERALS,
+                 macho.S_8BYTE_LITERALS,
+                 macho.S_16BYTE_LITERALS,
+@@ -1701,7 +1701,7 @@ pub const Zld = struct {
+                             break :outer;
+                         }
+                     }
+-                    switch (header.@"type"()) {
++                    switch (header.type()) {
+                         macho.S_NON_LAZY_SYMBOL_POINTERS => {
+                             try self.writeGotPointer(count, buffer.writer());
+                         },
+@@ -1718,7 +1718,7 @@ pub const Zld = struct {
+                                     break :outer;
+                                 }
+                             }
+-                            if (header.@"type"() == macho.S_SYMBOL_STUBS) {
++                            if (header.type() == macho.S_SYMBOL_STUBS) {
+                                 try self.writeStubCode(atom_index, count, buffer.writer());
+                             } else if (mem.eql(u8, header.sectName(), "__stub_helper")) {
+                                 try self.writeStubHelperCode(atom_index, buffer.writer());
+@@ -1802,7 +1802,7 @@ pub const Zld = struct {
+         for (slice.items(.header)) |*header, sect_id| {
+             if (header.size == 0) continue;
+             if (self.requiresThunks()) {
+-                if (header.isCode() and !(header.@"type"() == macho.S_SYMBOL_STUBS) and !mem.eql(u8, header.sectName(), "__stub_helper")) continue;
++                if (header.isCode() and !(header.type() == macho.S_SYMBOL_STUBS) and !mem.eql(u8, header.sectName(), "__stub_helper")) continue;
+             }
+ 
+             var atom_index = slice.items(.first_atom_index)[sect_id];
+@@ -1830,7 +1830,7 @@ pub const Zld = struct {
+         if (self.requiresThunks()) {
+             for (slice.items(.header)) |header, sect_id| {
+                 if (!header.isCode()) continue;
+-                if (header.@"type"() == macho.S_SYMBOL_STUBS) continue;
++                if (header.type() == macho.S_SYMBOL_STUBS) continue;
+                 if (mem.eql(u8, header.sectName(), "__stub_helper")) continue;
+ 
+                 // Create jump/branch range extenders if needed.
+@@ -1994,10 +1994,10 @@ pub const Zld = struct {
+         const section_precedence: u4 = blk: {
+             if (header.isCode()) {
+                 if (mem.eql(u8, "__text", header.sectName())) break :blk 0x0;
+-                if (header.@"type"() == macho.S_SYMBOL_STUBS) break :blk 0x1;
++                if (header.type() == macho.S_SYMBOL_STUBS) break :blk 0x1;
+                 break :blk 0x2;
+             }
+-            switch (header.@"type"()) {
++            switch (header.type()) {
+                 macho.S_NON_LAZY_SYMBOL_POINTERS,
+                 macho.S_LAZY_SYMBOL_POINTERS,
+                 => break :blk 0x0,
+@@ -2121,7 +2121,7 @@ pub const Zld = struct {
+ 
+         // Finally, unpack the rest.
+         for (slice.items(.header)) |header, sect_id| {
+-            switch (header.@"type"()) {
++            switch (header.type()) {
+                 macho.S_LITERAL_POINTERS,
+                 macho.S_REGULAR,
+                 macho.S_MOD_INIT_FUNC_POINTERS,
+@@ -2252,7 +2252,7 @@ pub const Zld = struct {
+         // Finally, unpack the rest.
+         const slice = self.sections.slice();
+         for (slice.items(.header)) |header, sect_id| {
+-            switch (header.@"type"()) {
++            switch (header.type()) {
+                 macho.S_LITERAL_POINTERS,
+                 macho.S_REGULAR,
+                 macho.S_MOD_INIT_FUNC_POINTERS,
+@@ -2707,10 +2707,10 @@ pub const Zld = struct {
+     }
+ 
+     fn filterDataInCode(
+-        dices: []const macho.data_in_code_entry,
++        dices: []align(1) const macho.data_in_code_entry,
+         start_addr: u64,
+         end_addr: u64,
+-    ) []const macho.data_in_code_entry {
++    ) []align(1) const macho.data_in_code_entry {
+         const Predicate = struct {
+             addr: u64,
+ 
+

pkgs/development/embedded/stm32/stm32cubemx/default.nix

···
 in
 stdenv.mkDerivation rec {
   pname = "stm32cubemx";
-  version = "6.6.1";
+  version = "6.8.0";
 
   src = fetchzip {
     url = "https://sw-center.st.com/packs/resource/library/stm32cube_mx_v${builtins.replaceStrings ["."] [""] version}-lin.zip";
-    sha256 = "sha256-NfJMXHQ7JXzRSdOAYfx2t0xsi/w2S5FK3NovcsDOi+E=";
+    sha256 = "sha256-jJeJTg2cCO6fqQ4vFq2dXsfsWmlN5ncZJWMoekJXkLQ=";
     stripRoot = false;
   };
 

pkgs/development/libraries/edencommon/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "edencommon";
-  version = "2023.02.13.00";
+  version = "2023.03.06.00";
 
   src = fetchFromGitHub {
     owner = "facebookexperimental";
     repo = "edencommon";
     rev = "v${version}";
-    sha256 = "sha256-WxxE7ePZuNkSKRQG5Vni51xrrZT6BsKwwvhzykQf9X4=";
+    sha256 = "sha256-m54TaxThWe6bUa6Q1t+e99CLFOvut9vq9RSmimTNuaU=";
   };
 
   nativeBuildInputs = [ cmake ];

pkgs/development/libraries/libcouchbase/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "libcouchbase";
-  version = "3.3.4";
+  version = "3.3.5";
 
   src = fetchFromGitHub {
     owner = "couchbase";
     repo = "libcouchbase";
     rev = version;
-    sha256 = "sha256-gyGlx43LdBkZvwN8EeZvaLzdTgYT3PFnSX9eZyAWNc4=";
+    sha256 = "sha256-kaKraMdbA87+7TgauYMkIDSjy8kFpkFX0og9nkuoa84=";
   };
 
   cmakeFlags = [ "-DLCB_NO_MOCK=ON" ];

pkgs/development/libraries/libnats-c/default.nix

···
 
 stdenv.mkDerivation rec {
   pname   = "libnats";
-  version = "3.6.0";
+  version = "3.6.1";
 
   src = fetchFromGitHub {
     owner  = "nats-io";
     repo   = "nats.c";
     rev    = "v${version}";
-    sha256 = "sha256-L/RS/M0TQJEMXRvdwo03st1VAlIlJ/fCmTvx+0+gCGE=";
+    sha256 = "sha256-zqtPBxjTJ+/XxVpfVpyFIwvlj5xCcnTrUv2RGzP8UQc=";
   };
 
   nativeBuildInputs = [ cmake ];

pkgs/development/libraries/log4cplus/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "log4cplus";
-  version = "2.0.8";
+  version = "2.1.0";
 
   src = fetchurl {
     url = "mirror://sourceforge/log4cplus/log4cplus-${version}.tar.bz2";
-    sha256 = "sha256-yjaqNmA20cYfwDZqn/vPMrrVXXSHiyw2qcNNzAC4oMo=";
+    sha256 = "sha256-oElFrKX7wEh1A8hSvvuc3vvDrj/mFLCKkFMz9t91Q4c=";
   };
 
   meta = {

pkgs/development/libraries/openexr/3.nix

···
 
 stdenv.mkDerivation rec {
   pname = "openexr";
-  version = "3.1.5";
+  version = "3.1.6";
 
   src = fetchFromGitHub {
     owner = "AcademySoftwareFoundation";
     repo = "openexr";
     rev = "v${version}";
-    sha256 = "sha256-mmzrMCYyAAa1z8fLZVbaTL1TZzdRaRTLgK+wzPuH4tg=";
+    sha256 = "sha256-rXiltW7PHvye6bIyhDyo8aaVvssfGOwr9TguaYlLuUc=";
   };
 
   outputs = [ "bin" "dev" "out" "doc" ];

pkgs/development/libraries/qxmpp/default.nix

···
 
 mkDerivation rec {
   pname = "qxmpp";
-  version = "1.5.2";
+  version = "1.5.3";
 
   src = fetchFromGitHub {
     owner = "qxmpp-project";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-nwU0Iw3aLv4EyNdblTOQKcCYVYfK8i54c0piks4DoUo=";
+    sha256 = "sha256-h2MBs46E2dvwOhs1cnSvrMll3nZSE9o4oEZV2Bd1Yh0=";
   };
 
   nativeBuildInputs = [

pkgs/development/libraries/recastnavigation/default.nix

···
   pname = "recastai";
   # use latest revision for the CMake build process and OpenMW
   # OpenMW use e75adf86f91eb3082220085e42dda62679f9a3ea
-  version = "unstable-2021-03-05";
+  version = "unstable-2023-01-02";
 
   src = fetchFromGitHub {
     owner = "recastnavigation";
     repo = "recastnavigation";
-    rev = "c5cbd53024c8a9d8d097a4371215e3342d2fdc87";
-    sha256 = "sha256-QP3lMMFR6fiKQTksAkRL6X9yaoVz2xt4QSIP9g6piww=";
+    rev = "405cc095ab3a2df976a298421974a2af83843baf";
+    sha256 = "sha256-WVzDI7+UuAl10Tm1Zjkea/FMk0cIe7pWg0iyFLbwAdI=";
   };
 
   postPatch = ''
···
     substituteInPlace CMakeLists.txt \
       --replace '\$'{exec_prefix}/'$'{CMAKE_INSTALL_LIBDIR} '$'{CMAKE_INSTALL_FULL_LIBDIR} \
       --replace '\$'{prefix}/'$'{CMAKE_INSTALL_INCLUDEDIR} '$'{CMAKE_INSTALL_FULL_INCLUDEDIR}
+  '' + lib.optionalString stdenv.hostPlatform.isDarwin ''
+    # Expects SDL2.framework in specific location, which we don't have
+    # Change where SDL2 headers are searched for to match what we do have
+    substituteInPlace RecastDemo/CMakeLists.txt \
+      --replace 'include_directories(''${SDL2_LIBRARY}/Headers)' 'include_directories(${SDL2.dev}/include/SDL2)'
   '';
 
   doCheck = true;
···
   buildInputs = [ libGL SDL2 libGLU ];
 
   meta = with lib; {
-    broken = stdenv.isDarwin;
     homepage = "https://github.com/recastnavigation/recastnavigation";
     description = "Navigation-mesh Toolset for Games";
     license = licenses.zlib;

pkgs/development/libraries/science/math/libamplsolver/default.nix

···
     install -D -m 0644 *${stdenv.hostPlatform.extensions.sharedLibrary}* -t $out/lib
     install -D -m 0644 *.a -t $out/lib
     popd
+  '' + lib.optionalString stdenv.isDarwin ''
+    install_name_tool -id $out/lib/libamplsolver.dylib $out/lib/libamplsolver.dylib
+  '' + ''
     runHook postInstall
   '';
 

pkgs/development/libraries/simdjson/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "simdjson";
-  version = "3.1.5";
+  version = "3.1.6";
 
   src = fetchFromGitHub {
     owner = "simdjson";
     repo = "simdjson";
     rev = "v${version}";
-    sha256 = "sha256-gBHgPKEeoryjMVL/EonmeY/7imcJej/Yj8ovPk/moTk=";
+    sha256 = "sha256-9WVLvyehbXSLD7HNIwMkkq1XzF0jB8PkltsWSNfXaDk=";
   };
 
   nativeBuildInputs = [ cmake ];

pkgs/development/libraries/wxwidgets/wxGTK31.nix

···
 
 stdenv.mkDerivation rec {
   pname = "wxwidgets";
-  version = "3.1.5";
+  version = "3.1.7";
 
   src = fetchFromGitHub {
     owner = "wxWidgets";
     repo = "wxWidgets";
     rev = "v${version}";
-    hash = "sha256-2zMvcva0GUDmSYK0Wk3/2Y6R3F7MgdqGBrOhmWgVA6g=";
+    hash = "sha256-9qYPatpTT28H+fz77o7/Y3YVmiK0OCsiQT5QAYe93M0=";
     fetchSubmodules = true;
   };
 

pkgs/development/ocaml-modules/spelll/default.nix

···
 { lib, fetchFromGitHub, buildDunePackage
 , seq
+, stdlib-shims
 }:
 
 buildDunePackage rec {
   pname = "spelll";
-  version = "0.3";
+  version = "0.4";
 
-  useDune2 = true;
+  duneVersion = "3";
 
   src = fetchFromGitHub {
     owner = "c-cube";
     repo = pname;
     rev = "v${version}";
-    sha256 = "03adqisgsazsxdkrypp05k3g91hydfgcif2014il63gdbd9nhzlh";
+    hash = "sha256-nI8fdArYynR70PUJIgyogGBCe4gFhfVzuRdZzFGKqOc=";
   };
 
-  propagatedBuildInputs = [ seq ];
+  propagatedBuildInputs = [ seq stdlib-shims ];
 
   meta = {
     inherit (src.meta) homepage;

pkgs/development/python-modules/bash_kernel/default.nix

···
 
 buildPythonPackage rec {
   pname = "bash_kernel";
-  version = "0.7.2";
+  version = "0.9.0";
   format = "flit";
   disabled = isPy27;
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "0w0nbr3iqqsgpk83rgd0f5b02462bkyj2n0h6i9dwyc1vpnq9350";
+    sha256 = "sha256-BCPwUS72+DplThQ5o2lxiJmjjyeUj+IbZlst8dvzp8c=";
   };
 
   patches = [
···
     ${python.pythonForBuild.interpreter} -m bash_kernel.install --prefix $out
   '';
 
-  meta = {
+  meta = with lib; {
     description = "Bash Kernel for Jupyter";
     homepage = "https://github.com/takluyver/bash_kernel";
-    license = lib.licenses.bsd3;
-    maintainers = with lib.maintainers; [ zimbatm ];
+    changelog = "https://github.com/takluyver/bash_kernel/releases/tag/${version}";
+    license = licenses.bsd3;
+    maintainers = with maintainers; [ zimbatm ];
   };
 }

pkgs/development/python-modules/databricks-cli/default.nix

···
 
 buildPythonPackage rec {
   pname = "databricks-cli";
-  version = "0.17.4";
+  version = "0.17.5";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
···
     owner = "databricks";
     repo = pname;
     rev = "refs/tags/${version}";
-    hash = "sha256-srrNxiOGrU1u5shssRssr8Hwdy20U4coOAjYsT7eTSA=";
+    hash = "sha256-HaSSaRd8WFq1g8WT5forBGBz9hSKsyBiTD4FnLprSgE=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/openai/default.nix

···
 
 buildPythonPackage rec {
   pname = "openai";
-  version = "0.27.1";
+  version = "0.27.2";
   format = "setuptools";
 
   disabled = pythonOlder "3.7.1";
···
     owner = "openai";
     repo = "openai-python";
     rev = "refs/tags/v${version}";
-    hash = "sha256-GGwRx5yF/xdtnJiKF1junxuebaaBkGhx+DR4pqChcS4=";
+    hash = "sha256-eHaYOJB/Ujadq71Ow3aTgiahYoiqoHwtNXr68nJUqGc=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/pycm/default.nix

···
       --replace '=get_requires()' '=[]'
   '';
 
-  disabledTests = [
-    # Output formatting error
-    "pycm.pycm_compare.Compare"
-    "plot_test"
-  ];
+  # https://github.com/sepandhaghighi/pycm/issues/488
+  pytestFlagsArray = [ "Test" ];
 
   pythonImportsCheck = [
     "pycm"
···
 
   meta = with lib; {
     description = "Multiclass confusion matrix library";
-    homepage = "https://pycm.ir";
+    homepage = "https://pycm.io";
     license = licenses.mit;
     maintainers = with maintainers; [ bcdarwin ];
   };

pkgs/development/python-modules/pyvista/default.nix

···
 
 buildPythonPackage rec {
   pname = "pyvista";
-  version = "0.38.3";
+  version = "0.38.4";
   format = "setuptools";
 
   src = fetchFromGitHub {
     owner = pname;
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-DkJZfzBS/amQqZDcsmQo+WlSxOYtIwizXJOjF/N2lSE=";
+    hash = "sha256-lOubi5di7K/Q/N/VMPMqC5hr3q69PR+4EgL+zde9j78=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/torch/default.nix

···
   requiredSystemFeatures = [ "big-parallel" ];
 
   passthru = {
-    inherit cudaSupport cudaPackages gpuTargetString;
-    cudaCapabilities = supportedCudaCapabilities;
+    inherit cudaSupport cudaPackages;
     # At least for 1.10.2 `torch.fft` is unavailable unless BLAS provider is MKL. This attribute allows for easy detection of its availability.
     blasProvider = blas.provider;
+  } // lib.optionalAttrs cudaSupport {
+    # NOTE: supportedCudaCapabilities isn't computed unless cudaSupport is true, so we can't use
+    #   it in the passthru set above because a downstream package might try to access it even
+    #   when cudaSupport is false. Better to have it missing than null or an empty list by default.
+    cudaCapabilities = supportedCudaCapabilities;
   };
 
   meta = with lib; {

pkgs/development/python-modules/torchvision/default.nix

···
 { buildPythonPackage
-, cudaSupport ? torch.cudaSupport or false # by default uses the value from torch
 , fetchFromGitHub
 , lib
 , libjpeg_turbo
···
 }:
 
 let
-  inherit (torch) cudaPackages gpuTargetString;
+  inherit (torch) cudaCapabilities cudaPackages cudaSupport;
   inherit (cudaPackages) cudatoolkit cudaFlags cudaVersion;
 
   # NOTE: torchvision doesn't use cudnn; torch does!
···
   + lib.optionalString cudaSupport ''
     export CC=${cudatoolkit.cc}/bin/cc
     export CXX=${cudatoolkit.cc}/bin/c++
-    export TORCH_CUDA_ARCH_LIST="${gpuTargetString}"
+    export TORCH_CUDA_ARCH_LIST="${lib.concatStringsSep ";" cudaCapabilities}"
     export FORCE_CUDA=1
   '';
 

pkgs/development/tools/frugal/default.nix

···
 
 buildGoModule rec {
   pname = "frugal";
-  version = "3.16.14";
+  version = "3.16.15";
 
   src = fetchFromGitHub {
     owner = "Workiva";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-6U4mYS5ukcOaxGeIiI2UFYlz0PpjKdtQH9cOshYRUg0=";
+    sha256 = "sha256-h5uBkScWCBG/yvv43lykBoSdyuIAMbrsUpCNVCPgnx4=";
   };
 
   subPackages = [ "." ];
 
-  vendorHash = "sha256-CbneZtwGab5dlGASZqa69Y70fXgt4PJzAODPJlcpJoA=";
+  vendorHash = "sha256-bkGlheOwy7SbH1cKPAQek2s6TZKc0jp/lGKxDRrxKas=";
 
   meta = with lib; {
     description = "Thrift improved";

pkgs/development/tools/gci/default.nix

···
 }:
 buildGoModule rec {
   pname = "gci";
-  version = "0.9.1";
+  version = "0.10.0";
 
   src = fetchFromGitHub {
     owner = "daixiang0";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-VbN4lRK+6stOApMEdtX32JhKGkCSrafMJbizpWmHRXA=";
+    sha256 = "sha256-zzhQxnFI1xCv+FyP/rrAMX7pCMkGWF/yyVll+zKNo8c=";
   };
 
-  vendorHash = "sha256-dlt+i/pEP3RzW4JwndKTU7my2Nn7/2rLFlk8n1sFR60=";
+  vendorHash = "sha256-g7htGfU6C2rzfu8hAn6SGr0ZRwB8ZzSf9CgHYmdupE8=";
 
   meta = with lib; {
     description = "Controls golang package import order and makes it always deterministic";

pkgs/development/tools/misc/cproto/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "cproto";
-  version = "4.7u";
+  version = "4.7v";
 
   src = fetchurl {
     urls = [
···
       # No version listings and apparently no versioned tarball over http(s).
       "ftp://ftp.invisible-island.net/cproto/cproto-${version}.tgz"
     ];
-    sha256 = "sha256-ZOu7zF4FAa/ylvQx0G+ftwhjr+WwzmbDs0eQcpFPxR4=";
+    sha256 = "sha256-897D9hAncBlpdkWcS0SsJzVfYSDaduUjHsEyPjedFRE=";
   };
 
   # patch made by Joe Khoobyar copied from gentoo bugs

pkgs/development/tools/rust/cargo-dist/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "cargo-dist";
-  version = "0.0.4";
+  version = "0.0.5";
 
   src = fetchFromGitHub {
     owner = "axodotdev";
     repo = "cargo-dist";
     rev = "v${version}";
-    hash = "sha256-7JbWcG5FDJaXvtEQKlOgbsFpFQQ3n02MVFD+lCFXtt0=";
+    hash = "sha256-AbEreN8pv/aZoBX1amoihb6HxWRdMuEX0waBlbvueQw=";
   };
 
-  cargoHash = "sha256-TY1YRtre2rz0Hh+6ca22i+XCBMOEOS3QnSsf/rfY47g=";
+  cargoHash = "sha256-U2pTvTk6oc6PV4W4XBKLzsaqSTb7Oqyw2Ponc9H0xs8=";
 
   nativeBuildInputs = [
     pkg-config

pkgs/development/tools/wails/default.nix

···
 
 buildGoModule rec {
   pname = "wails";
-  version = "2.3.1";
+  version = "2.4.0";
 
   src = fetchFromGitHub {
     owner = "wailsapp";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-WKA21bU7H9V/X3oPGTgf8ysXX91/tjfEqEzkBMgtMRM=";
+    sha256 = "sha256-2MjEVQybSI9gQ/KI4rBbvbqCNhTsXTtWfUl37gVsqK4=";
   } + "/v2";
 
-  vendorSha256 = "sha256-MPdAl8fwIoO+0IDTWVDktQND/BM/v7sms13l9PNjKDY=";
+  vendorSha256 = "sha256-RiectpUhm24xjgfPZEMDVFSEzPtIjn7L/qC2KE2s5aw=";
 
   proxyVendor = true;
 

pkgs/games/megaglest/default.nix

···
 { lib, stdenv, cmake, pkg-config, git, curl, SDL2, xercesc, openal, lua, libvlc
-, libjpeg, wxGTK30, cppunit, ftgl, glew, libogg, libvorbis, buildEnv, libpng
+, libjpeg, wxGTK32, cppunit, ftgl, glew, libogg, libvorbis, buildEnv, libpng
 , fontconfig, freetype, xorg, makeWrapper, bash, which, gnome, libGLU, glib
 , fetchFromGitHub, fetchpatch
 }:
···
     name = "megaglest-lib-env";
     paths = [ SDL2 xorg.libSM xorg.libICE xorg.libX11 xorg.libXext
       xercesc openal libvorbis lua libjpeg libpng curl fontconfig ftgl freetype
-      stdenv.cc.cc glew libGLU wxGTK30 ];
+      stdenv.cc.cc glew libGLU wxGTK32 ];
   };
   path-env = buildEnv {
     name = "megaglest-path-env";
···
       url = "https://github.com/MegaGlest/megaglest-source/commit/5a3520540276a6fd06f7c88e571b6462978e3eab.patch";
       sha256 = "0y554kjw56dikq87vs709pmq97hdx9hvqsk27f81v4g90m3b3qhi";
     })
+    # Pull upstream and Debian fixes for wxWidgets 3.2
+    (fetchpatch {
+      name = "get-rid-of-manual-wxPaintEvent-creation-1.patch";
+      url = "https://github.com/MegaGlest/megaglest-source/commit/e09ba53c436279588f769d6ce8852e74d58f8391.patch";
+      hash = "sha256-1ZG6AjnLXW18wwad05kjH7W5rTaP1SDpZ5zLH4nRQt4=";
+    })
+    (fetchpatch {
+      name = "get-rid-of-manual-wxPaintEvent-creation-2.patch";
+      url = "https://sources.debian.org/data/main/m/megaglest/3.13.0-9/debian/patches/fbd0cfb17ed759d24aeb577a602b0d97f7895cc2.patch";
+      hash = "sha256-aMDDboNdH22r7YOiZCEApwz+FpM60anBp82tLwiIH6g=";
+    })
+    (fetchpatch {
+      name = "get-rid-of-manual-wxPaintEvent-creation-3.patch";
+      url = "https://github.com/MegaGlest/megaglest-source/commit/5801b1fafff8ad9618248d4d5d5c751fdf52be2f.patch";
+      hash = "sha256-/RpBoT1JsSFtOrAXphHrPp9DnTbaEN/2h8EZmQ9PIPU=";
+    })
+    (fetchpatch {
+      name = "fix-editor-and-g3dviewer-for-wx-3.1.x.patch";
+      url = "https://github.com/MegaGlest/megaglest-source/commit/789e1cdf371137b729e832e28a5feb6e97a3a243.patch";
+      hash = "sha256-fK7vkHCu6bqVB6I7vMsWMGiczSdxVgo1KqqBNMkEbfM=";
+    })
   ];
 
   nativeBuildInputs = [ cmake pkg-config makeWrapper git ];
-  buildInputs = [ curl SDL2 xercesc openal lua libpng libjpeg libvlc wxGTK30
+  buildInputs = [ curl SDL2 xercesc openal lua libpng libjpeg libvlc wxGTK32
     glib cppunit fontconfig freetype ftgl glew libogg libvorbis libGLU ];
 
   cmakeFlags = [

pkgs/games/openmw/default.nix

···
 { lib
+, stdenv
 , mkDerivation
 , fetchFromGitHub
 , fetchpatch
···
 , libXt
 , lz4
 , recastnavigation
+, VideoDecodeAcceleration
 }:
 
 let
···
         rev = "bbe61c3bc510a4f5bb4aea21cce506519c2d24e6";
         sha256 = "sha256-t3smLqstp7wWfi9HXJoBCek+3acqt/ySBYF8RJOG6Mo=";
       };
+      patches = [
+        (fetchpatch {
+          # For Darwin, OSG doesn't build some plugins as they're redundant with QuickTime.
+          # OpenMW doesn't like this, and expects them to be there. Apply their patch for it.
+          name = "darwin-osg-plugins-fix.patch";
+          url = "https://gitlab.com/OpenMW/openmw-dep/-/raw/0abe3c9c3858211028d881d7706813d606335f72/macos/osg.patch";
+          sha256 = "sha256-/CLRZofZHot8juH78VG1/qhTHPhy5DoPMN+oH8hC58U=";
+        })
+      ];
     });
 
   bullet_openmw = bullet.overrideDerivation (old: rec {
···
 
   postPatch = ''
     sed '1i#include <memory>' -i components/myguiplatform/myguidatamanager.cpp # gcc12
+  '' + lib.optionalString stdenv.isDarwin ''
+    # Don't fix Darwin app bundle
+    sed -i '/fixup_bundle/d' CMakeLists.txt
   '';
 
   nativeBuildInputs = [ cmake pkg-config wrapQtAppsHook ];
+
+  # If not set, OSG plugin .so files become shell scripts on Darwin.
+  dontWrapQtApps = true;
 
   buildInputs = [
     SDL2
···
     unshield
     lz4
     recastnavigation
+  ] ++ lib.optionals stdenv.isDarwin [
+    VideoDecodeAcceleration
   ];
 
   cmakeFlags = [
     # as of 0.46, openmw is broken with GLVND
     "-DOpenGL_GL_PREFERENCE=LEGACY"
     "-DOPENMW_USE_SYSTEM_RECASTNAVIGATION=1"
+  ] ++ lib.optionals stdenv.isDarwin [
+    "-DOPENMW_OSX_DEPLOYMENT=ON"
   ];
 
   meta = with lib; {
···
     homepage = "https://openmw.org";
     license = licenses.gpl3Plus;
     maintainers = with maintainers; [ abbradar marius851000 ];
-    platforms = platforms.linux;
+    platforms = platforms.linux ++ platforms.darwin;
   };
 }

pkgs/servers/amqp/rabbitmq-server/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "rabbitmq-server";
-  version = "3.11.9";
+  version = "3.11.10";
 
   # when updating, consider bumping elixir version in all-packages.nix
   src = fetchurl {
     url = "https://github.com/rabbitmq/rabbitmq-server/releases/download/v${version}/${pname}-${version}.tar.xz";
-    hash = "sha256-b/SfUyn+x33SnFo/n/zTLxG4PWz34F2qQs4B4p2/Ty4=";
+    hash = "sha256-gZcUWN8SnCb93zUTqWDYtxUrT5655gfEnMax1NLHh+M=";
   };
 
   nativeBuildInputs = [ unzip xmlto docbook_xml_dtd_45 docbook_xsl zip rsync python3 ];

pkgs/servers/jackett/default.nix

···
 
 buildDotnetModule rec {
   pname = "jackett";
-  version = "0.20.3160";
+  version = "0.20.3599";
 
   src = fetchFromGitHub {
     owner = pname;
     repo = pname;
     rev = "v${version}";
-    hash = "sha512-bn41nReIfRs99zwDgTJtQ1hrQRrn7EjQvYh5JDTU9ICBsJangnO8l1o8Xfn4jhxvcDJRDjaA7jG7TAoIC3WAFA==";
+    hash = "sha512-GZCdReOysCkFCkOeaqRivJlKRsuKtRNMPTdKsbj6KqyhPW41GLJffBkl8XKi6pmREp/jCtWs2+tw1D7xcaGNqg==";
   };
 
   projectFile = "src/Jackett.Server/Jackett.Server.csproj";

pkgs/servers/jackett/deps.nix

···
 # Please dont edit it manually, your changes might get overwritten!
 
 { fetchNuGet }: [
-  (fetchNuGet { pname = "AngleSharp"; version = "0.17.1"; sha256 = "038idg33ydy72362qplsd7y8ldifi9zg02dhjli6wy4p47hyqcph"; })
-  (fetchNuGet { pname = "AngleSharp.Xml"; version = "0.17.0"; sha256 = "0yy9xx0qgc9hhbmyy2mkxqmybpwn4q8cmhgss28v90kzzgsghppz"; })
+  (fetchNuGet { pname = "AngleSharp"; version = "1.0.1"; sha256 = "04ivdl3fdhmv0i8n1nnmisbvksxay4axpkp5i4anjwl0571nnyva"; })
+  (fetchNuGet { pname = "AngleSharp.Xml"; version = "1.0.0"; sha256 = "14xjzig65kslr4pfhl11313gcjci0s5jxm3z012606xagrc5fg2k"; })
   (fetchNuGet { pname = "Autofac"; version = "6.5.0"; sha256 = "01sbsids0r7iv2w4wlncyfv410qphjd9w8y9jlaiyrh5y0v6y303"; })
   (fetchNuGet { pname = "Autofac.Extensions.DependencyInjection"; version = "8.0.0"; sha256 = "02pvdn5yrdv44q0hb9qha92b9g4ycpbyymp1jd2z2z6lkwwwzhhp"; })
   (fetchNuGet { pname = "AutoMapper"; version = "10.1.1"; sha256 = "1l1p9g7f7finr8laklbm7h2c45k0swl47iq0ik68js5s6pzvd6f8"; })
···
   (fetchNuGet { pname = "Newtonsoft.Json"; version = "9.0.1"; sha256 = "0mcy0i7pnfpqm4pcaiyzzji4g0c8i3a5gjz28rrr28110np8304r"; })
   (fetchNuGet { pname = "Newtonsoft.Json.Bson"; version = "1.0.1"; sha256 = "1r1hvj5gjl466bya2bfl5aaj8rbwyf5x1msg710wf3k2llbci1xa"; })
   (fetchNuGet { pname = "Newtonsoft.Json.Bson"; version = "1.0.2"; sha256 = "0c27bhy9x3c2n26inq32kmp6drpm71n6mqnmcr19wrlcaihglj35"; })
-  (fetchNuGet { pname = "NLog"; version = "5.1.1"; sha256 = "19m1ivp1cxz1ghlvysrxdhxlj7kzya9m7j812c3ssnxrfrr1077z"; })
+  (fetchNuGet { pname = "NLog"; version = "5.1.2"; sha256 = "1hgb5lqx9c10kw6rjldrkldd70lmkzij4ssgg6msybgz7vpsyhkk"; })
   (fetchNuGet { pname = "NLog.Extensions.Logging"; version = "5.2.1"; sha256 = "1z9ayqag1xncn4cs0cz27gxa5cqk6caq5fd81bczlj4sqff7ah4p"; })
   (fetchNuGet { pname = "NLog.Web.AspNetCore"; version = "5.2.1"; sha256 = "10y03374lza6cjsi01xmql1v6hcjf6x2r7wfnnckzhzs70x2hhnl"; })
   (fetchNuGet { pname = "NuGet.Frameworks"; version = "5.11.0"; sha256 = "0wv26gq39hfqw9md32amr5771s73f5zn1z9vs4y77cgynxr73s4z"; })
···
   (fetchNuGet { pname = "NUnit.ConsoleRunner"; version = "3.16.1"; sha256 = "0bqs72fhqlmmqsvjarsx4hz8d2dj0wgbsx1gr681fcl1pqpm1cgz"; })
   (fetchNuGet { pname = "NUnit3TestAdapter"; version = "4.3.1"; sha256 = "1j80cfrg0fflgw7wxi76mxj1wllwzcg4ck957knmjpghw5cw7lvv"; })
   (fetchNuGet { pname = "Polly"; version = "7.2.3"; sha256 = "1iws4jd5iqj5nlfp16fg9p5vfqqas1si0cgh8xcj64y433a933cv"; })
-  (fetchNuGet { pname = "SharpZipLib"; version = "1.4.1"; sha256 = "1dh1jhgzc9bzd2hvyjp2nblavf0619djniyzalx7kvrbsxhrdjb6"; })
+  (fetchNuGet { pname = "SharpZipLib"; version = "1.4.2"; sha256 = "0ijrzz2szxjmv2cipk7rpmg14dfaigdkg7xabjvb38ih56m9a27y"; })
   (fetchNuGet { pname = "System.AppContext"; version = "4.3.0"; sha256 = "1649qvy3dar900z3g817h17nl8jp4ka5vcfmsr05kh0fshn7j3ya"; })
   (fetchNuGet { pname = "System.Buffers"; version = "4.4.0"; sha256 = "183f8063w8zqn99pv0ni0nnwh7fgx46qzxamwnans55hhs2l0g19"; })
   (fetchNuGet { pname = "System.Buffers"; version = "4.5.0"; sha256 = "1ywfqn4md6g3iilpxjn5dsr0f5lx6z0yvhqp4pgjcamygg73cz2c"; })
···
   (fetchNuGet { pname = "System.Memory"; version = "4.5.1"; sha256 = "0f07d7hny38lq9w69wx4lxkn4wszrqf9m9js6fh9is645csm167c"; })
   (fetchNuGet { pname = "System.Memory"; version = "4.5.3"; sha256 = "0naqahm3wljxb5a911d37mwjqjdxv9l0b49p5dmfyijvni2ppy8a"; })
   (fetchNuGet { pname = "System.Memory"; version = "4.5.4"; sha256 = "14gbbs22mcxwggn0fcfs1b062521azb9fbb7c113x0mq6dzq9h6y"; })
+  (fetchNuGet { pname = "System.Memory"; version = "4.5.5"; sha256 = "08jsfwimcarfzrhlyvjjid61j02irx6xsklf32rv57x2aaikvx0h"; })
   (fetchNuGet { pname = "System.Numerics.Vectors"; version = "4.4.0"; sha256 = "0rdvma399070b0i46c4qq1h2yvjj3k013sqzkilz4bz5cwmx1rba"; })
   (fetchNuGet { pname = "System.Numerics.Vectors"; version = "4.5.0"; sha256 = "1kzrj37yzawf1b19jq0253rcs8hsq1l2q8g69d7ipnhzb0h97m59"; })
   (fetchNuGet { pname = "System.Reflection"; version = "4.3.0"; sha256 = "0xl55k0mw8cd8ra6dxzh974nxif58s3k1rjv1vbd7gjbjr39j11m"; })
···
   (fetchNuGet { pname = "System.ServiceProcess.ServiceController"; version = "6.0.0"; sha256 = "1x4i8jlpfvca3bmsm0fjzq3zswpd2cszjq93v2nxaq3d57vv5npa"; })
   (fetchNuGet { pname = "System.Text.Encoding"; version = "4.3.0"; sha256 = "1f04lkir4iladpp51sdgmis9dj4y8v08cka0mbmsy0frc9a4gjqr"; })
   (fetchNuGet { pname = "System.Text.Encoding.CodePages"; version = "6.0.0"; sha256 = "0gm2kiz2ndm9xyzxgi0jhazgwslcs427waxgfa30m7yqll1kcrww"; })
+  (fetchNuGet { pname = "System.Text.Encoding.CodePages"; version = "7.0.0"; sha256 = "0sn6hxdjm7bw3xgsmg041ccchsa4sp02aa27cislw3x61dbr68kq"; })
   (fetchNuGet { pname = "System.Text.Encoding.Extensions"; version = "4.3.0"; sha256 = "11q1y8hh5hrp5a3kw25cb6l00v5l5dvirkz8jr3sq00h1xgcgrxy"; })
   (fetchNuGet { pname = "System.Text.Encodings.Web"; version = "4.5.0"; sha256 = "0srd5bva52n92i90wd88pzrqjsxnfgka3ilybwh7s6sf469y5s53"; })
   (fetchNuGet { pname = "System.Text.Encodings.Web"; version = "4.5.1"; sha256 = "0pya3ggs4pds6m8hgvjdljpacxwn3qx4bfq59nwi0qrs7zxihxhp"; })
···
   (fetchNuGet { pname = "System.Xml.XmlDocument"; version = "4.3.0"; sha256 = "0bmz1l06dihx52jxjr22dyv5mxv6pj4852lx68grjm7bivhrbfwi"; })
   (fetchNuGet { pname = "System.Xml.XPath"; version = "4.3.0"; sha256 = "1cv2m0p70774a0sd1zxc8fm8jk3i5zk2bla3riqvi8gsm0r4kpci"; })
   (fetchNuGet { pname = "System.Xml.XPath.XDocument"; version = "4.3.0"; sha256 = "1wxckyb7n1pi433xzz0qcwcbl1swpra64065mbwwi8dhdc4kiabn"; })
-  (fetchNuGet { pname = "YamlDotNet"; version = "12.3.1"; sha256 = "159djg21fry5lgqw7bz887zfcayjyh80w3k684axlhhnps2dn23j"; })
+  (fetchNuGet { pname = "YamlDotNet"; version = "13.0.1"; sha256 = "07shrvmc4ks6l8zsjjgmabyg5j6smqqlh3lvz9111d8wf3gfdcxy"; })
 ]

pkgs/servers/pocketbase/default.nix

···
 
 buildGoModule rec {
   pname = "pocketbase";
-  version = "0.13.2";
+  version = "0.13.3";
 
   src = fetchFromGitHub {
     owner = "pocketbase";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-P150wEJHTC294LcRhSHF5/+w08WKBvhUZsJ9ENi1EM8=";
+    sha256 = "sha256-arW8mj2UkQE0285m4HzbcvPkpcohFYYZYUM9A+tZ4yg=";
   };
 
   vendorHash = "sha256-hvziOq5zyYwWcvqa23IzHXj/DT27MAcNVegYR38beJ4=";

pkgs/shells/zsh/oh-my-zsh/default.nix

···
 , git, nix, nixfmt, jq, coreutils, gnused, curl, cacert, bash }:
 
 stdenv.mkDerivation rec {
-  version = "2023-03-06";
+  version = "2023-03-12";
   pname = "oh-my-zsh";
-  rev = "3b759c5dc926d0973d82fa1b8ffed45d770d20e8";
+  rev = "72732a224e886933df6b64a49ec6f5e94c884612";
 
   src = fetchFromGitHub {
     inherit rev;
     owner = "ohmyzsh";
     repo = "ohmyzsh";
-    sha256 = "QObQ2LNWukmtmiHr33T+aV7WT+EhG/KON6/0atPT5tE=";
+    sha256 = "L3cItc1DWNE3MRRlJC9mbOwqA1JuD6k8gqrJc7XpJkk=";
   };
 
   strictDeps = true;

pkgs/tools/archivers/unshield/default.nix

···
     description = "Tool and library to extract CAB files from InstallShield installers";
     homepage = "https://github.com/twogood/unshield";
     license = licenses.mit;
-    platforms = platforms.linux;
+    platforms = platforms.linux ++ platforms.darwin;
   };
 }

pkgs/tools/inputmethods/remote-touchpad/default.nix

···
 
 buildGoModule rec {
   pname = "remote-touchpad";
-  version = "1.2.3";
+  version = "1.3.0";
 
   src = fetchFromGitHub {
     owner = "unrud";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-Yakx4eHcw3p8UAg3zAiWVrZyOFChhC5wWa0uJIKJn5g=";
+    sha256 = "sha256-nsLPqLnup7hGPFzAjxi/40A4fGPB+4m+aIrfNjbxgUY=";
   };
 
   buildInputs = [ libXi libXrandr libXt libXtst ];
   tags = [ "portal,x11" ];
 
-  vendorSha256 = "sha256-xlGAxKr2fav8WgAO+zW6ZTL7QgkdyUqRdQIOErDjRTg=";
+  vendorHash = "sha256-p1XhhXyWdfwgoDEjO/3trB1dm2bAogPydt/MZOg4YmE=";
 
   meta = with lib; {
     description = "Control mouse and keyboard from the webbrowser of a smartphone.";

pkgs/tools/misc/fortune/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "fortune-mod";
-  version = "3.16.0";
+  version = "3.18.0";
 
   # We use fetchurl instead of fetchFromGitHub because the release pack has some
   # special files.
   src = fetchurl {
     url = "https://github.com/shlomif/fortune-mod/releases/download/${pname}-${version}/${pname}-${version}.tar.xz";
-    sha256 = "sha256-dkpkTBulXaN52BHaV4MWEIoQFkmWaG66O9Ppes/GLPo=";
+    sha256 = "sha256-xaaB8aJgG3GG0fYS0vOnxC4RifQybxejS8ysqYE0xCs=";
   };
 
   nativeBuildInputs = [ cmake perl rinutils ];

pkgs/tools/misc/ipxe/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "ipxe";
-  version = "unstable-2023-02-28";
+  version = "unstable-2023-03-07";
 
   nativeBuildInputs = [ gnu-efi mtools openssl perl xorriso xz ] ++ lib.optional stdenv.hostPlatform.isx86 syslinux;
   depsBuildBuild = [ buildPackages.stdenv.cc ];
···
   src = fetchFromGitHub {
     owner = "ipxe";
     repo = "ipxe";
-    rev = "04e60a278abcda47301f6be2c23755e5e1004661";
-    sha256 = "/p+mSn9ZL5H9aTIygpbgFaW5uBBBlSQfh/OksI0bMbY=";
+    rev = "9e1f7a3659071004f4b8c76f2593da6287f0d575";
+    sha256 = "a9YvF/oGnZ/GuBDfWj/Uh6ozY0sTztlCqEMk//lb5Lo=";
   };
 
   postPatch = lib.optionalString stdenv.hostPlatform.isAarch64 ''

pkgs/tools/misc/nurl/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "nurl";
-  version = "0.3.9";
+  version = "0.3.10";
 
   src = fetchFromGitHub {
     owner = "nix-community";
     repo = "nurl";
     rev = "v${version}";
-    hash = "sha256-zImzwNBqNl1Ts3x3EDTfkMYe34j09u3xZDcLMv1DdcM=";
+    hash = "sha256-GMTVv4x5f59FRqdRIOfg92a5JYC+9hiTHiGu5zJKmxg=";
   };
 
-  cargoSha256 = "sha256-avG/mXs3buWeaPqtjvVPrSeua4DqdiF1P6aCmdW0CUY=";
+  cargoSha256 = "sha256-xRUV6ajC/mUE4bQ+BTrcAUmzChu3Lh4uIknEL7+r0d8=";
 
   nativeBuildInputs = [
     installShellFiles

pkgs/tools/misc/plantuml/default.nix

···
 { lib, stdenv, fetchurl, makeWrapper, jre, graphviz }:
 
 stdenv.mkDerivation rec {
-  version = "1.2023.2";
+  version = "1.2023.4";
   pname = "plantuml";
 
   src = fetchurl {
     url = "https://github.com/plantuml/plantuml/releases/download/v${version}/plantuml-pdf-${version}.jar";
-    sha256 = "sha256-E3ipqlf5VWNkYioEC5g/33rmMS1ahV960Tx9HiGH++U=";
+    sha256 = "sha256-7upbzDRfAFdUuH4uYPWnMfQk40guJnz4EBFkme1kRA8=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/tools/misc/steampipe/default.nix

···
 
 buildGoModule rec {
   pname = "steampipe";
-  version = "0.18.6";
+  version = "0.19.1";
 
   src = fetchFromGitHub {
     owner = "turbot";
     repo = "steampipe";
     rev = "v${version}";
-    sha256 = "sha256-H/R+NXFaZ23vWN16/Ft5oP+Xvc97VY98cQth5+LtqnA=";
+    sha256 = "sha256-7UisJORLGGt3Uk7/MOOTHMdotjHgD+tZ0pWzzRbM6Ag=";
   };
 
-  vendorHash = "sha256-W30f7QYgm+QyLDJICpjMn7mtUIziTR1igThEbv+Aa7M=";
+  vendorHash = "sha256-XrEdaNLG46BwMEF/vhAk9+A6vH4mpbtH7vWXd01Y7ME=";
   proxyVendor = true;
 
   patchPhase = ''

pkgs/tools/misc/watchexec/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "watchexec";
-  version = "1.20.6";
+  version = "1.21.1";
 
   src = fetchFromGitHub {
     owner = pname;
     repo = pname;
-    rev = "cli-v${version}";
-    sha256 = "sha256-IF0VnFh3UeJ6pB/DvwlKXzivZqRYzOE4/39qHNcPVcc=";
+    rev = "v${version}";
+    sha256 = "sha256-RwzbPMSQqEdsJ+EEZBP8Tn8AueLmvDJcPFzdFg1/bro=";
   };
 
-  cargoSha256 = "sha256-9XUZL34yHNIOq9Z9xP2+h8C4KUMkl8wAZbKnzppn300=";
+  cargoSha256 = "sha256-xugAMfg9S/gGtiry78xX6JaSHWlFofo2qZaBjh0fHec=";
 
   nativeBuildInputs = [ installShellFiles ];
 
···
   NIX_LDFLAGS = lib.optionalString stdenv.isDarwin "-framework AppKit";
 
   checkFlags = [ "--skip=help" "--skip=help_short" ];
+
+  postPatch = ''
+    rm .cargo/config
+  '';
 
   postInstall = ''
     installManPage doc/watchexec.1

pkgs/tools/networking/gvproxy/default.nix

···
 
 buildGoModule rec {
   pname = "gvproxy";
-  version = "0.6.0";
+  version = "0.6.1";
 
   src = fetchFromGitHub {
     owner = "containers";
     repo = "gvisor-tap-vsock";
     rev = "v${version}";
-    hash = "sha256-FycYBNFHo8lYI5jX5Fogu+bsJ63z40zUJTC+dIKESkA=";
+    hash = "sha256-LkSKJVnWwqWSId/qdb7hTIiryxdazjW4oluZZN47orQ=";
   };
 
   vendorHash = null;

pkgs/tools/networking/i2pd/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "i2pd";
-  version = "2.46.1";
+  version = "2.47.0";
 
   src = fetchFromGitHub {
     owner = "PurpleI2P";
     repo = pname;
     rev = version;
-    sha256 = "sha256-9qk3oRNM/xmKQQGIx44R79JYUK/J7rOrR+la+lnu74s=";
+    sha256 = "sha256-sgaNrRRAINMI0utLQ6o6zcI5ImaDrYho9WeFiJg7WuE=";
   };
 
   buildInputs = [ boost zlib openssl ]

pkgs/tools/networking/pritunl-client/default.nix

···
 
 buildGoModule rec {
   pname = "pritunl-client";
-  version = "1.3.3457.61";
+  version = "1.3.3467.51";
 
   src = fetchFromGitHub {
     owner = "pritunl";
     repo = "pritunl-client-electron";
     rev = version;
-    sha256 = "sha256-tX+AUm8X1bRvR1Lb93Bwlxx+gm9Xvyw8Fn2odmEqiJA=";
+    sha256 = "sha256-US1A3PjWxycXzOW/1Mi8GVkxvH6xCFq4mo5gU49vytU=";
   };
 
   modRoot = "cli";

pkgs/tools/networking/xdp-tools/default.nix

···
     zlib
   ];
 
+  depsBuildBuild = [
+    emacs-nox # to generate man pages from .org
+  ];
   nativeBuildInputs = [
     llvmPackages.clang
     llvmPackages.llvm
     pkg-config
     m4
-    emacs-nox # to generate man pages from .org
     nukeReferences
   ];
   nativeCheckInputs = [

pkgs/tools/networking/xray/default.nix

···
 in
 buildGoModule rec {
   pname = "xray";
-  version = "1.7.5";
+  version = "1.8.0";
 
   src = fetchFromGitHub {
     owner = "XTLS";
     repo = "Xray-core";
     rev = "v${version}";
-    sha256 = "sha256-WCku/7eczcsGiIuTy0sSQKUKXlH14TpdVg2/ZPdaiHQ=";
+    sha256 = "sha256-YonO856ax0RTkM3SwgsS/1HxijkaV5XUXvWYDL3NyvM=";
   };
 
-  vendorSha256 = "sha256-2P7fI7fUnShsAl95mPiJgtr/eobt+DMmaoxZcox0eu8=";
+  vendorSha256 = "sha256-lWeYuyzW8bR51LrFguOxOyNzihMuFF6MkFeGuNv8Vyc=";
 
   nativeBuildInputs = [ makeWrapper ];
 

pkgs/tools/package-management/apt/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "apt";
-  version = "2.5.6";
+  version = "2.6.0";
 
   src = fetchurl {
     url = "mirror://debian/pool/main/a/apt/apt_${version}.tar.xz";
-    hash = "sha256-jAhIpNjWtcm1DEoz1XnzYiuEwxiwLotNxpbwcDcRxPM=";
+    hash = "sha256-Q0Z9HKfebAlV/ZkZJUM+IvpmIwhw5fZsRJhnXQF3bCo=";
   };
 
   nativeBuildInputs = [

pkgs/tools/security/hcxtools/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "hcxtools";
-  version = "6.2.7";
+  version = "6.2.9";
 
   src = fetchFromGitHub {
     owner = "ZerBea";
     repo = pname;
     rev = version;
-    sha256 = "sha256-C9Vh8PEbxNm+8KnE6F++2CzvDwAzG/AGBYYTwFZvwBA=";
+    sha256 = "sha256-oDAyK3/+X7fmaRoK4AUbczQJk+sHrNTeTfHcMoDFTjQ=";
   };
 
   nativeBuildInputs = [ pkg-config ];

pkgs/top-level/all-packages.nix

···
   pcem = callPackage ../applications/emulators/pcem { };
 
   pcsx2 = callPackage ../applications/emulators/pcsx2 {
-    wxGTK = wxGTK30;
+    wxGTK = wxGTK32;
   };
 
   pcsxr = callPackage ../applications/emulators/pcsxr { };
···
   zig_0_10 = darwin.apple_sdk_11_0.callPackage ../development/compilers/zig/0.10.nix {
     llvmPackages = llvmPackages_15;
   };
-  # Zig 0.10.1 is broken on Darwin, so use 0.9.1 on Darwin instead.
-  zig = if stdenv.isDarwin then zig_0_9 else zig_0_10;
+  zig = zig_0_10;
 
   zimlib = callPackage ../development/libraries/zimlib { };
 
···
 
   openloco = pkgsi686Linux.callPackage ../games/openloco { };
 
-  openmw = libsForQt5.callPackage ../games/openmw { };
+  openmw = libsForQt5.callPackage ../games/openmw {
+    inherit (darwin.apple_sdk.frameworks) VideoDecodeAcceleration;
+  };
 
   openmw-tes3mp = libsForQt5.callPackage ../games/openmw/tes3mp.nix { };