proper nix-based natives build (wip)

.github/workflows/build.yaml

@@ -1,13 +1,6 @@
 name: "Build and Test"
 on:
   push:
-    branches:
-      - '*'
-    tags-ignore:
-      - '*'
-    paths-ignore:
-      - '*.md'
-      - 'docs/**'
   pull_request:
   workflow_dispatch:
   release:
@@ -16,33 +9,42 @@ permissions:
   pull-requests: write
   contents: write
 jobs:
-  linux-x86_64:
+  build-publish:
     runs-on: ubuntu-24.04
     steps:
-      - shell: bash
-        name: "Install mpv"
-        run: |
-          sudo apt-get update -y
-          sudo apt-get install -y libmpv-dev libavformat-dev libavcodec-dev libavutil-dev libswscale-dev libavdevice-dev libavfilter-dev libswresample-dev libpostproc-dev libpipewire-0.3-dev
-      - uses: silenium-dev/actions/jni-natives/ubuntu@main
+      - uses: actions/checkout@v6
+      - uses: cachix/install-nix-action@v31
         with:
-          gradle-cache-encryption-key: ${{ secrets.GRADLE_CACHE_ENCRYPTION_KEY }}
-          snapshot-repo-url: "https://reposilite.silenium.dev/snapshots"
-          release-repo-url: "https://reposilite.silenium.dev/releases"
-          repo-username: ${{ secrets.REPOSILITE_USERNAME }}
-          repo-password: ${{ secrets.REPOSILITE_PASSWORD }}
-          tests: true
-          java-version: 11
-          platform: ${{ github.job }}
-  kotlin:
-    runs-on: ubuntu-24.04
-    steps:
+          nix_path: nixpkgs=channel:nixos-unstable
+          github_access_token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Restore and save Nix store
+        uses: nix-community/cache-nix-action@v7
+        with:
+          # restore and save a cache using this key
+          primary-key: nix-${{ runner.os }}-${{ hashFiles('**/*.nix', '**/flake.lock') }}
+          # if there's no cache hit, restore a cache by this prefix
+          restore-prefixes-first-match: nix-${{ runner.os }}-
+          # collect garbage until the Nix store size (in bytes) is at most this number
+          # before trying to save a new cache
+          # 1G = 1073741824
+          gc-max-store-size-linux: 4G
+          # do purge caches
+          purge: true
+          # purge all versions of the cache
+          purge-prefixes: nix-${{ runner.os }}-
+          # created more than this number of seconds ago
+          purge-created: 0
+          # or last accessed this duration (ISO 8601 duration format)
+          # before the start of the `Post Restore and save Nix store` phase
+          purge-last-accessed: P7D
+          # except any version with the key that is the same as the `primary-key`
+          purge-primary-key: never
       - uses: silenium-dev/actions/kotlin@main
         with:
           gradle-cache-encryption-key: ${{ secrets.GRADLE_CACHE_ENCRYPTION_KEY }}
-          snapshot-repo-url: "https://reposilite.silenium.dev/snapshots"
-          release-repo-url: "https://reposilite.silenium.dev/releases"
-          repo-username: ${{ secrets.REPOSILITE_USERNAME }}
-          repo-password: ${{ secrets.REPOSILITE_PASSWORD }}
+          snapshot-repo-url: "https://repoflow.silenium.dev/api/maven/public/maven-snapshots"
+          release-repo-url: "https://repoflow.silenium.dev/api/maven/public/maven-releases"
+          repo-username: ${{ secrets.REPOFLOW_USERNAME }}
+          repo-password: ${{ secrets.REPOFLOW_PASSWORD }}
           tests: false
-          java-version: 11
+          java-version: 17

.gitignore

@@ -15,7 +15,7 @@ rgb.png
 texture.png
 va_surface.png
 textures/
-
+native/result
 
 ### IntelliJ IDEA ###
 .idea/

.teamcity/settings.kts

@@ -1,35 +1,18 @@
-import jetbrains.buildServer.configs.kotlin.*
+import jetbrains.buildServer.configs.kotlin.BuildType
 import jetbrains.buildServer.configs.kotlin.buildFeatures.perfmon
+import jetbrains.buildServer.configs.kotlin.buildFeatures.pullRequests
+import jetbrains.buildServer.configs.kotlin.buildSteps.gradle
+import jetbrains.buildServer.configs.kotlin.project
 import jetbrains.buildServer.configs.kotlin.projectFeatures.githubConnection
+import jetbrains.buildServer.configs.kotlin.triggers.VcsTrigger
 import jetbrains.buildServer.configs.kotlin.triggers.vcs
-
-/*
-The settings script is an entry point for defining a TeamCity
-project hierarchy. The script should contain a single call to the
-project() function with a Project instance or an init function as
-an argument.
-
-VcsRoots, BuildTypes, Templates, and subprojects can be
-registered inside the project using the vcsRoot(), buildType(),
-template(), and subProject() methods respectively.
-
-To debug settings scripts in command-line, run the
-
-    mvnDebug org.jetbrains.teamcity:teamcity-configs-maven-plugin:generate
-
-command and attach your debugger to the port 8000.
-
-To debug in IntelliJ Idea, open the 'Maven Projects' tool window (View
--> Tool Windows -> Maven Projects), find the generate task node
-(Plugins -> teamcity-configs -> teamcity-configs:generate), the
-'Debug' option is available in the context menu for the task.
-*/
+import jetbrains.buildServer.configs.kotlin.version
 
 version = "2025.11"
 
 project {
-
-    buildType(Build)
+    buildType(BuildSnapshot)
+    buildType(BuildRelease)
 
     features {
         githubConnection {
@@ -41,16 +24,65 @@ project {
     }
 }
 
-object Build : BuildType({
-    name = "Build"
+abstract class Build(
+    val publishRepository: String,
+    val publishUsername: String,
+    val publishPassword: String,
+    val publishVersion: String,
+    val trigger: VcsTrigger.() -> Unit,
+) : BuildType({
+    name = "Build and Publish"
 
     triggers {
         vcs {
+            branchFilter = "+:refs/heads/*"
         }
     }
 
     features {
         perfmon {
         }
+
+        pullRequests {
+            provider = github {
+                authType = vcsRoot()
+                ignoreDrafts = true
+            }
+        }
+    }
+
+    requirements {
+        exists("system.nix.store")
+    }
+
+    steps {
+        gradle {
+            tasks = "build publish"
+            gradleParams = "-Pdeploy.version=${publishVersion} -Pdeploy.kotlin=true"
+            incremental = true
+            param("env.MAVEN_REPO_URL", publishRepository)
+            param("env.MAVEN_REPO_USERNAME", publishUsername)
+            param("env.MAVEN_REPO_PASSWORD", publishPassword)
+        }
     }
 })
+
+object BuildSnapshot : Build(
+    publishRepository = "https://repoflow.silenium.dev/api/maven/public/maven-snapshots",
+    publishUsername = "teamcitypublic",
+    publishPassword = "credentialsJSON:c8524851-3a17-4ea4-ac26-49a99c5c387c",
+    publishVersion = "%build.vcs.number%",
+    trigger = {
+        branchFilter = "+:refs/heads/*"
+    }
+)
+
+object BuildRelease : Build(
+    publishRepository = "https://repoflow.silenium.dev/api/maven/public/maven-releases",
+    publishUsername = "teamcitypublic",
+    publishPassword = "credentialsJSON:c8524851-3a17-4ea4-ac26-49a99c5c387c",
+    publishVersion = "%build.vcs.number%",
+    trigger = {
+        branchFilter = "+:refs/tags/*"
+    }
+)

build-logic/build.gradle.kts

@@ -0,0 +1,33 @@
+plugins {
+    `kotlin-dsl`
+    `java-gradle-plugin`
+}
+
+repositories {
+    maven("https://reposilite.silenium.dev/releases") {
+        name = "silenium-releases"
+    }
+    google()
+    mavenCentral()
+    gradlePluginPortal()
+}
+
+dependencies {
+    implementation(files(libs.javaClass.superclass.protectionDomain.codeSource.location))
+    api(libs.bundles.gradle.plugins)
+    libs.bundles.kotlin.plugins.get().forEach {
+        api(variantOf(provider { it }) {
+            classifier("gradle813")
+        })
+    }
+    api(libs.jni.utils)
+}
+
+gradlePlugin {
+    plugins {
+        register("natives") {
+            id = "av-natives"
+            implementationClass = "dev.silenium.compose.av.build.NativesPlugin"
+        }
+    }
+}

build-logic/settings.gradle.kts

@@ -0,0 +1,13 @@
+dependencyResolutionManagement {
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+
+    versionCatalogs {
+        create("libs") {
+            from(files("../gradle/libs.versions.toml"))
+        }
+    }
+}

build-logic/src/main/kotlin/dev/silenium/compose/av/build/DownloadFile.kt

@@ -0,0 +1,53 @@
+package dev.silenium.compose.av.build
+
+import org.gradle.api.logging.Logger
+import org.gradle.internal.logging.progress.ProgressLogger
+import java.io.OutputStream
+import java.net.URI
+import kotlin.time.Clock
+import kotlin.time.Duration.Companion.seconds
+import kotlin.time.ExperimentalTime
+
+@OptIn(ExperimentalTime::class)
+fun downloadFile(progressLogger: ProgressLogger, logger: Logger, uri: URI, outputStream: OutputStream) {
+    try {
+        val conn = uri.toURL().openConnection()
+        conn.connect()
+        val size = conn.contentLengthLong
+        progressLogger.progress("${size.toMB()} MB")
+
+        var downloaded = 0L
+        var lastLog = Clock.System.now()
+        val buf = ByteArray(1024)
+        conn.inputStream.use { input ->
+            while (true) {
+                if (Thread.currentThread().isInterrupted) {
+                    throw InterruptedException("Download interrupted")
+                }
+                val read = input.read(buf)
+                if (read == -1) break
+                outputStream.write(buf, 0, read)
+
+                downloaded += read
+                if (downloaded > 0) {
+                    progressLogger.progress("${downloaded.toMB()} MB / ${size.toMB()} MB (${downloaded partOf size}%)")
+                } else {
+                    progressLogger.progress("${size.toMB()} MB")
+                }
+                val now = Clock.System.now()
+                if (now - lastLog > 1.seconds) {
+                    lastLog = now
+                    logger.lifecycle("${progressLogger.description}: ${downloaded.toMB()} MB / ${size.toMB()} MB (${downloaded partOf size}%)")
+                }
+            }
+        }
+        progressLogger.completed()
+        logger.lifecycle("${progressLogger.description}: ${downloaded.toMB()} MB / ${size.toMB()} MB (${downloaded partOf size}%)")
+    } catch (e: Exception) {
+        progressLogger.completed(e.message ?: "Unknown error", true)
+        throw e
+    }
+}
+
+private fun Long.toMB() = this / 1024 / 1024
+private infix fun Long.partOf(full: Long) = (this * 100) / full

build-logic/src/main/kotlin/dev/silenium/compose/av/build/NativesExtension.kt

@@ -0,0 +1,15 @@
+package dev.silenium.compose.av.build
+
+import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.Property
+
+interface NativesExtension {
+    val sourceFiles: ConfigurableFileCollection
+    val libName: Property<String>
+    val libVersion: Property<String>
+
+    val nixFlake: RegularFileProperty
+    val nixFlakeLock: RegularFileProperty
+    val showLogs: Property<Boolean>
+}