voidarc/nixos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chataingne nonsensenes

Browse Source
This commit is contained in:
voidarc
2026-03-12 18:00:53 +00:00
parent cd9716a7f2
commit e3650d5adb
6 changed files with 64 additions and 248 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
modules/chataigne/Chataigne-linux-x64-bleedingedge.AppImage → modules/chataigne/Chataigne-linux-x64-1.10.3.AppImage
View File

Binary file not shown.

131
modules/chataigne/chataigne.nix
View File

@@ -1,131 +0,0 @@
{ pkgs, pinnedPkgs, ... }:
let
# 1. Define the AppImage source.
appImageSrc = ./Chataigne-linux-x64-bleedingedge.AppImage;
# 2a. Libraries pulled from the modern, current Nixpkgs (for small size).
modernLibs = with pkgs; [
freetype
libxrandr
];
# 2b. Libraries pulled from the older, pinned package set (ONLY the ones that failed).
pinnedCurlLibs = with pinnedPkgs; [
curlWithGnuTls # This is the critical component for the CURL_GNUTLS_3 symbol.
alsa-lib
avahi
libglvnd
SDL2
hidapi
curl
gnutls
];
# 3. Combine the modern runtime dependencies with the pinned compatibility libraries.
appImageDeps = [
pkgs.steam-run
pkgs.stdenv.cc.cc.lib # Ensures the modern C++ runtime is available
]
++ modernLibs
++ pinnedCurlLibs;
chataigneDesktopItem = {
desktopName = "Chataigne";
name = "chataigne";
exec = "chataigne"; # The name of the wrapper script in $out/bin
icon = "chataigne"; # The name of the icon file (without extension)
genericName = "Creative Control Software";
comment = "Control and experiment with creative applications, hardware, and media.";
categories = [
"AudioVideo"
"Development"
];
};
in
# 4. Create the final runnable derivation
pkgs.stdenv.mkDerivation {
pname = "chataigne-runner";
version = "1.0";
# --- Attributes needed for AppImage running (not compiling) ---
src = ./.;
dontUnpack = true;
dontBuild = true;
# --------------------------------------------------
# Inject the combined dependencies into the environment
buildInputs = appImageDeps;
# The install phase creates an executable wrapper script, extracts the AppImage,
# and now handles the desktop file and icon.
installPhase = ''
mkdir -p $out/bin
# --- STRATEGY: Extract AppImage contents to bypass FUSE, then fix LD_LIBRARY_PATH ---
echo "Extracting AppImage contents to bypass FUSE requirement..."
# Use the absolute Nix Store path of the AppImage
${appImageSrc} --appimage-extract
echo "appimage extracted"
# 2. Check if extraction worked and move the content to $out
if [ ! -d "squashfs-root" ]; then
echo "Extraction failed. The AppImage may not support --appimage-extract."
exit 1
fi
# 2. CRITICAL FIX: Manually create and install the .desktop file
mkdir -p $out/share/applications
# pkgs.lib.makeDesktopItem takes the metadata and creates a small derivation
# We copy the resulting .desktop file from that derivation's output path ($desktop_file_path)
local desktop_file_path="${pkgs.makeDesktopItem chataigneDesktopItem}"
# The file is typically named $name.desktop inside the share/applications folder of the new derivation
cp $desktop_file_path/share/applications/chataigne.desktop $out/share/applications/
# Copy the extracted contents into the output directory
cp -r squashfs-root $out/
# --- DESKTOP ENTRY & ICON (NEW) ---
echo "Processing icon and desktop file..."
# AppImages usually place the icon in squashfs-root/.DirIcon or similar
# We will assume it's in the root of the extracted content.
local icon_source="$out/squashfs-root/.DirIcon"
local icon_target="$out/share/icons/hicolor/128x128/apps/chataigne.png" # Standard location
# Use the icon if it exists (AppImages often use a .png or .svg)
if [ -f "$icon_source" ]; then
mkdir -p "$(dirname "$icon_target")"
cp "$icon_source" "$icon_target"
else
echo "Warning: Could not find icon at $icon_source. Using default/no icon."
fi
# ----------------------------------
# 3. Create the 'chataigne' executable wrapper
cat > $out/bin/chataigne << EOF
#!${pkgs.stdenv.shell}
# The LD_LIBRARY_PATH is created using all dependencies (excluding the wrapper 'steam-run').
# This ensures the AppImage finds the pinned CURL library.
export LD_LIBRARY_PATH="${pkgs.lib.makeLibraryPath (pkgs.lib.remove pkgs.steam-run appImageDeps)}:$LD_LIBRARY_PATH"
# Use steam-run to launch the main execution script inside the extracted folder.
exec ${pkgs.steam-run}/bin/steam-run "$out/squashfs-root/AppRun" "\$@"
EOF
chmod +x $out/bin/chataigne
'';
meta = {
description = "Declarative runner for the Chataigne AppImage, providing necessary dependencies.";
homepage = "https://chataigne.io/"; # Example: Add the actual homepage
license = pkgs.lib.licenses.unfree; # AppImages are often proprietary/unfree
platforms = [ "x86_64-linux" ];
};
}

20
modules/chataigne/flake.lock generated
View File

@@ -16,27 +16,9 @@
"type": "github"
}
},
"pinned-nixpkgs": {
"flake": false,
"locked": {
"lastModified": 1708756934,
"narHash": "sha256-WqpheJblJ901Svd5NmLJYLmZ3f4fYLkSOyx9i06+un0=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "5171d7b0a9fbaaf216c873622eb5115b6db97957",
"type": "github"
},
"original": {
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "5171d7b0a9fbaaf216c873622eb5115b6db97957",
"type": "github"
}
},
"root": {
"inputs": {
"nixpkgs": "nixpkgs",
"pinned-nixpkgs": "pinned-nixpkgs"
"nixpkgs": "nixpkgs"
}
}
},

72
modules/chataigne/flake.nix
View File

@@ -1,51 +1,49 @@
{
description = "A flake for running the Chataigne AppImage with necessary patched dependencies.";
description = "A flake to run a specific AppImage with custom dependencies";
inputs = {
nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable"; # Modern Nixpkgs
# Pinned Nixpkgs for compatibility (the commit that fixes the CURL_GNUTLS_3 issue)
pinned-nixpkgs = {
url = "github:NixOS/nixpkgs/5171d7b0a9fbaaf216c873622eb5115b6db97957";
flake = false; # Treat as a tarball input, not a flake
};
nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
};
outputs =
{
self,
nixpkgs,
pinned-nixpkgs,
...
}:
{ self, nixpkgs }:
let
# Supported systems
supportedSystems = [ "x86_64-linux" ];
system = "x86_64-linux"; # Adjust if you're on a different architecture
pkgs = import nixpkgs { inherit system; };
# The main package definition logic is imported as a function
chataigne-appimage-runner = import ./chataigne.nix;
# Define your AppImage wrapper here
myApp = pkgs.appimageTools.wrapType2 {
pname = "my-appimage-app";
version = "1.0.0";
# Function to generate the package set for each system
forAllSystems = f: nixpkgs.lib.genAttrs supportedSystems (system: f system);
# The source can be a local file or a URL
src = ./Chataigne-linux-x64-1.10.3.AppImage;
# Add specific dependencies the AppImage is missing
extraPkgs =
pkgs: with pkgs; [
lz4
libbsd
(curlWithGnuTls.override { gnutlsSupport = true; })
gnutls
libgnurl
openssl
];
};
in
{
packages = forAllSystems (
system:
let
pkgs = import nixpkgs {
inherit system;
config.allowUnfree = true;
};
pinnedPkgs = import pinned-nixpkgs { inherit system; };
in
{
chataigne = chataigne-appimage-runner {
inherit pkgs pinnedPkgs;
};
# This allows you to run it via 'nix run'
apps.${system}.default = {
type = "app";
program = "${myApp}/bin/my-appimage-app";
};
# Also expose the default package for convenience
default = self.packages.${system}.chataigne;
}
);
# This allows you to add it to your shell via 'nix develop'
devShells.${system}.default = pkgs.mkShell {
buildInputs = [ myApp ];
};
# The package itself
packages.${system}.default = myApp;
};
}