Move build scripts from skia-pack to skia repo (#1183)

[SKIKO-1095](https://youtrack.jetbrains.com/issue/SKIKO-1095) Move build
scripts from `skia-pack` to `skia` fork

https://github.com/JetBrains/skia/pull/15

skiko/build-with-local-skia.sh

@@ -3,53 +3,50 @@
 #
 # This script handles git operations and delegates configuration to Gradle.
 # For more control, use Gradle tasks directly:
-#   ./gradlew prepareLocalSkiaBuild -Pskia.pack.dir=/path/to/skia-pack
+#   ./gradlew prepareLocalSkiaBuild -Pskia.repo.dir=/path/to/skia
 #   ./gradlew publishToMavenLocal -Pskia.dir=/path/to/skia
 #
 # Environment variables:
 #   SKIA_VERSION   - Skia version to build (default: from gradle.properties)
 #   SKIA_TARGET    - Target platform: ios, iosSim, macos, windows, linux, wasm (default: current OS)
-#   SKIA_PACK_DIR  - Skia-pack repository directory with tools/skia_release/ (default: ./skia-pack)
-#   SKIA_DIR       - Skia source directory for publishing (default: $SKIA_PACK_DIR/skia)
+#   SKIA_REPO_DIR  - Skia repository directory with tools/skia_release/ (default: ./skia)
+#   SKIA_DIR       - Skia source directory for publishing (default: $SKIA_REPO_DIR)
 
 set -e  # Exit on error
 cd "$(dirname "$0")"
 SCRIPT_DIR="$(pwd)"
 
-# Use provided skia-pack directory or default
-SKIA_PACK_DIR="${SKIA_PACK_DIR:-$SCRIPT_DIR/skia-pack}"
+# Use provided Skia repository directory or default
+SKIA_REPO_DIR="${SKIA_REPO_DIR:-${SKIA_PACK_DIR:-$SCRIPT_DIR/skia}}"
 
 # Clone if needed
-if [ ! -d "$SKIA_PACK_DIR" ]; then
-    echo "Cloning skia-pack repository to $SKIA_PACK_DIR..."
-    git clone https://github.com/JetBrains/skia-pack.git "$SKIA_PACK_DIR"
+if [ ! -d "$SKIA_REPO_DIR" ]; then
+    echo "Cloning skia repository to $SKIA_REPO_DIR..."
+    git clone https://github.com/JetBrains/skia.git "$SKIA_REPO_DIR"
 fi
 
 # Convert to absolute path if relative
-if [[ "$SKIA_PACK_DIR" != /* ]]; then
-    SKIA_PACK_DIR="$(cd "$SKIA_PACK_DIR" && pwd)"
+if [[ "$SKIA_REPO_DIR" != /* ]]; then
+    SKIA_REPO_DIR="$(cd "$SKIA_REPO_DIR" && pwd)"
 fi
 
-echo "Using skia-pack directory: $SKIA_PACK_DIR"
-cd "$SKIA_PACK_DIR"
+echo "Using skia repository: $SKIA_REPO_DIR"
+cd "$SKIA_REPO_DIR"
 
 # Get version from Gradle (respects SKIA_VERSION env var)
 SKIA_VERSION=$(cd "$SCRIPT_DIR" && ./gradlew -q printSkiaVersion)
 echo "Using Skia version: $SKIA_VERSION"
 
-# Checkout the Skia sources corresponding to the selected version
-echo "Checking out Skia sources for version: $SKIA_VERSION"
-python3 script/checkout.py --version "$SKIA_VERSION"
-
 # Build Skia binaries
 cd "$SCRIPT_DIR"
 echo "Building Skia binaries with Gradle..."
-./gradlew prepareLocalSkiaBuild -Pskia.pack.dir="$SKIA_PACK_DIR"
+./gradlew prepareLocalSkiaBuild -Pskia.repo.dir="$SKIA_REPO_DIR"
 
 # Publish Skiko to Maven Local with the built Skia binaries
-# If SKIA_DIR not explicitly set, use the default location where Python scripts output built Skia
+# If SKIA_DIR is not explicitly set, use the same checkout that contains the
+# integrated release scripts and the built outputs.
 if [ -z "$SKIA_DIR" ]; then
-    SKIA_DIR="$SKIA_PACK_DIR/skia"
+    SKIA_DIR="$SKIA_REPO_DIR"
 fi
 
 echo "Publishing Skiko to Maven Local..."

skiko/build.gradle.kts

@@ -378,13 +378,11 @@ tasks.register<BuildLocalSkiaTask>("prepareLocalSkiaBuild") {
     skiaTarget.set(provider { skiko.skiaTarget })
     buildType.set(skiko.buildType)
 
-    // Set skiaPackDir - either from property or default location
-    val skiaPackDir = skiko.skiaPackDir
-    if (skiaPackDir != null) {
-        this.skiaPackDir.set(skiaPackDir)
+    val skiaRepoDir = skiko.skiaRepoDir
+    if (skiaRepoDir != null) {
+        this.skiaRepoDir.set(skiaRepoDir)
     } else {
-        // Will be set by bash script via -Pskia.pack.dir, or use default skia-pack
-        this.skiaPackDir.set(project.file("skia-pack"))
+        this.skiaRepoDir.set(project.file("skia"))
     }
 
     skikoTargetFlags.set(provider {

skiko/buildSrc/src/main/kotlin/BuildLocalSkiaTask.kt

@@ -19,7 +19,7 @@ abstract class BuildLocalSkiaTask : DefaultTask() {
     abstract val buildType: Property<SkiaBuildType>
 
     @get:InputDirectory
-    abstract val skiaPackDir: DirectoryProperty
+    abstract val skiaRepoDir: DirectoryProperty
 
     @get:Internal
     abstract val skikoTargetFlags: ListProperty<String>
@@ -29,15 +29,14 @@ abstract class BuildLocalSkiaTask : DefaultTask() {
         val version = skiaVersion.get()
         val target = skiaTarget.get()
         val type = buildType.get()
-        val skiaPackRoot = skiaPackDir.get().asFile
+        val skiaRepoRoot = skiaRepoDir.get().asFile
 
-        // Validate that skiaPackDir points to skia-pack repository root
-        val scriptsDir = File(skiaPackRoot, "script")
+        val scriptsDir = File(skiaRepoRoot, "tools/skia_release")
         if (!scriptsDir.isDirectory) {
             throw GradleException(
-                "Directory script not found in ${skiaPackRoot.absolutePath}\n" +
-                "Expected: skia-pack repository root containing script/\n" +
-                "Ensure skia.pack.dir points to the correct skia-pack directory"
+                "Directory tools/skia_release not found in ${skiaRepoRoot.absolutePath}\n" +
+                "Expected: skia repository root containing tools/skia_release/\n" +
+                "Ensure skia.repo.dir points to the correct skia checkout"
             )
         }
 
@@ -51,8 +50,8 @@ abstract class BuildLocalSkiaTask : DefaultTask() {
         }
 
         logger.lifecycle("Building Skia $version for target ${target.id} in ${type.id} mode")
-        logger.lifecycle("Using skia-pack directory: ${skiaPackRoot.absolutePath}")
-        logger.lifecycle("Using scripts directory: script")
+        logger.lifecycle("Using skia repository: ${skiaRepoRoot.absolutePath}")
+        logger.lifecycle("Using scripts directory: tools/skia_release")
 
         // Determine host architecture
         val hostArch = when (System.getProperty("os.arch")) {
@@ -64,14 +63,12 @@ abstract class BuildLocalSkiaTask : DefaultTask() {
         val machines = target.machines(hostArch)
         logger.lifecycle("Building for architectures: ${machines.joinToString { it.id }}")
 
-        // Checkout Skia dependencies
-        runPythonScript(skiaPackRoot, "checkout.py", "--version", version)
-
         // Build and archive for each machine
         machines.forEach { machine ->
             logger.lifecycle("Building for ${machine.id}...")
             runPythonScript(
-                skiaPackRoot, "build.py",
+                skiaRepoRoot, "build.py",
+                "--skia-dir", ".",
                 "--target", target.id,
                 "--machine", machine.id,
                 "--build-type", type.id
@@ -79,7 +76,8 @@ abstract class BuildLocalSkiaTask : DefaultTask() {
 
             logger.lifecycle("Archiving ${machine.id}...")
             runPythonScript(
-                skiaPackRoot, "archive.py",
+                skiaRepoRoot, "archive.py",
+                "--skia-dir", ".",
                 "--version", version,
                 "--target", target.id,
                 "--machine", machine.id,
@@ -92,19 +90,19 @@ abstract class BuildLocalSkiaTask : DefaultTask() {
         project.file("build/classes/kotlin").deleteRecursively()
 
         logger.lifecycle("Skia binaries built successfully")
-        logger.lifecycle("Next: Run './gradlew publishToMavenLocal -Pskia.dir=<skia-source-dir>' to publish")
+        logger.lifecycle("Next: Run './gradlew publishToMavenLocal -Pskia.dir=<skia-repo-dir>' to publish")
     }
 
-    private fun runPythonScript(skiaPackRoot: File, script: String, vararg args: String) {
-        val scriptPath = "script/$script"
-        val scriptFile = File(skiaPackRoot, scriptPath)
+    private fun runPythonScript(skiaRepoRoot: File, script: String, vararg args: String) {
+        val scriptPath = "tools/skia_release/$script"
+        val scriptFile = File(skiaRepoRoot, scriptPath)
 
         // Validate script file exists
         if (!scriptFile.exists()) {
             throw GradleException(
                 "Python script not found: ${scriptFile.absolutePath}\n" +
-                "Expected: skia-pack directory with script/$script\n" +
-                "Ensure skia.pack.dir points to correct skia-pack directory"
+                "Expected: skia directory with tools/skia_release/$script\n" +
+                "Ensure skia.repo.dir points to the correct skia checkout"
             )
         }
 
@@ -114,7 +112,7 @@ abstract class BuildLocalSkiaTask : DefaultTask() {
 
         val output = ByteArrayOutputStream()
         val result = project.exec {
-            workingDir = skiaPackRoot
+            workingDir = skiaRepoRoot
             commandLine = fullCommand
             standardOutput = output
             errorOutput = output

skiko/buildSrc/src/main/kotlin/SkikoProjectContext.kt

@@ -29,16 +29,24 @@ class SkikoProjectContext(
 }
 
 fun SkikoProjectContext.declareSkiaTasks() {
-    val basicConfigs = listOf("android", "ios", "iosSim", "linux", "macos", "tvos", "tvosSim", "wasm", "windows")
-
-    basicConfigs.forEach { config ->
-        (if (config == "wasm") listOf("wasm") else listOf("arm64", "x64")).forEach { arch ->
+    mapOf(
+        "android" to listOf("arm64", "x64"),
+        "ios" to listOf("arm64", "x64"),
+        "iosSim" to listOf("arm64", "x64"),
+        "linux" to listOf("arm64", "x64"),
+        "macos" to listOf("arm64", "x64"),
+        "tvos" to listOf("arm64"),
+        "tvosSim" to listOf("arm64", "x64"),
+        "wasm" to listOf("wasm"),
+        "windows" to listOf("arm64", "x64"),
+    ).forEach { (config, architectures) ->
+        architectures.forEach { arch ->
             val taskNameSuffix = joinToTitleCamelCase(config, arch)
             val target = "$config-$arch"
 
             val skiaReleaseTag = project.skiaVersion(target)
 
-            val skiaBaseUrl = "https://github.com/JetBrains/skia-pack/releases/download/$skiaReleaseTag"
+            val skiaBaseUrl = "https://github.com/JetBrains/skia/releases/download/$skiaReleaseTag"
 
             val artifactId = "Skia-${skiaReleaseTag}-${config}-$buildType-${arch}"
 

skiko/buildSrc/src/main/kotlin/properties.kt

@@ -158,23 +158,34 @@ class SkikoProperties(private val myProject: Project) {
         get() = System.getenv()["SKIKO_VSBT_PATH"]?.let { File(it) }?.takeIf { it.isDirectory }
 
     /**
-     * Skia-pack repository root directory for building Skia from source.
+     * Skia repository root directory for building Skia from source.
      *
      * Property naming conventions:
-     * - Gradle property: `-Pskia.pack.dir=...` (kebab-case, Gradle convention)
-     * - Kotlin accessor: `skiaPackDir` (camelCase, Kotlin convention)
-     * - Environment variable: `SKIA_PACK_DIR`
+     * - Gradle property: `-Pskia.repo.dir=...` (preferred)
+     * - Kotlin accessor: `skiaRepoDir`
+     * - Environment variable: `SKIA_REPO_DIR`
      *
-     * Usage: `-Pskia.pack.dir=/path/to/skia-pack`
+     * Legacy `skia.pack.dir` and `SKIA_PACK_DIR` are still accepted to keep
+     * existing local workflows working while the standalone repo is retired.
      *
-     * Note: Must point to skia-pack repository root containing script/ with Python build scripts.
+     * Usage: `-Pskia.repo.dir=/path/to/skia`
+     *
+     * Note: Must point to skia repository root containing tools/skia_release/.
      */
     // todo: make compatible with the configuration cache
-    val skiaPackDir: File?
-        get() = (System.getenv()["SKIA_PACK_DIR"] ?: System.getProperty("skia.pack.dir") ?: myProject.findProperty("skia.pack.dir")
-            ?.toString())?.let { skiaPackDirProp ->
-                val file = File(skiaPackDirProp)
-                if (!file.isDirectory) throw (GradleException("\"skia.pack.dir\" property was explicitly set to ${skiaPackDirProp} which is not resolved as a directory"))
+    val skiaRepoDir: File?
+        get() = (
+            System.getenv()["SKIA_REPO_DIR"]
+                ?: System.getenv()["SKIA_PACK_DIR"]
+                ?: System.getProperty("skia.repo.dir")
+                ?: System.getProperty("skia.pack.dir")
+                ?: myProject.findProperty("skia.repo.dir")?.toString()
+                ?: myProject.findProperty("skia.pack.dir")?.toString()
+            )?.let { skiaRepoDirProp ->
+                val file = File(skiaRepoDirProp)
+                if (!file.isDirectory) {
+                    throw GradleException("\"skia.repo.dir\" property was explicitly set to $skiaRepoDirProp which is not resolved as a directory")
+                }
                 file
             }
 
@@ -189,6 +200,7 @@ class SkikoProperties(private val myProject: Project) {
      * Usage: `-Pskia.dir=/path/to/skia`
      *
      * Note: Must point to directory containing built Skia source code and headers.
+     * When using the integrated release scripts this is typically the same path as `skia.repo.dir`.
      */
     // todo: make compatible with the configuration cache
     val skiaDir: File?

skiko/buildSrc/src/main/kotlin/tasks/configuration/CommonTasksConfiguration.kt

@@ -24,6 +24,21 @@ import supportWeb
 import toTitleCase
 import java.io.File
 
+private fun Project.appleToolchainOutputOrNull(vararg args: String): String? =
+    runCatching {
+        providers.exec {
+            commandLine("xcrun", *args)
+        }.standardOutput.asText.get().trim()
+    }.getOrNull()?.ifBlank { null }
+
+fun Project.appleToolchainExecutableOrDefault(tool: String, fallback: String): String =
+    appleToolchainOutputOrNull("--find", tool) ?: fallback
+
+fun Project.appleMacOsSdkFlags(): List<String> =
+    appleToolchainOutputOrNull("--sdk", "macosx", "--show-sdk-path")
+        ?.let { listOf("-isysroot", it) }
+        ?: emptyList()
+
 fun skiaHeadersDirs(skiaDir: File): List<File> =
     listOf(
         skiaDir,

skiko/buildSrc/src/main/kotlin/tasks/configuration/JvmTasksConfiguration.kt

@@ -72,8 +72,10 @@ fun SkikoProjectContext.createCompileJvmBindingsTask(
     val osFlags: Array<String>
     when (targetOs) {
         OS.MacOS -> {
+            compiler.set(project.appleToolchainExecutableOrDefault("clang++", compiler.get()))
             includeHeadersNonRecursive(jdkHome.resolve("include/darwin"))
             osFlags = arrayOf(
+                *project.appleMacOsSdkFlags().toTypedArray(),
                 *targetOs.clangFlags,
                 *buildType.clangFlags,
                 "-arch", if (targetArch == Arch.Arm64) "arm64" else "x86_64",
@@ -199,7 +201,7 @@ fun SkikoProjectContext.createObjcCompileTask(
     includeHeadersNonRecursive(projectDir.resolve("src/commonMain/cpp/common/include"))
     includeHeadersNonRecursive(projectDir.resolve("src/jvmMain/cpp"))
 
-    compiler.set("clang")
+    compiler.set(project.appleToolchainExecutableOrDefault("clang", "clang"))
     buildVariant.set(buildType)
     buildTargetOS.set(os)
     buildTargetArch.set(arch)
@@ -207,6 +209,7 @@ fun SkikoProjectContext.createObjcCompileTask(
         listOf(
             "-fobjc-arc",
             "-arch", if (arch == Arch.Arm64) "arm64" else "x86_64",
+            *project.appleMacOsSdkFlags().toTypedArray(),
             *os.clangFlags,
             *buildType.clangFlags,
             *skiaPreprocessorFlags(os, buildType),

skiko/buildSrc/src/main/kotlin/tasks/configuration/NativeTasksConfiguration.kt

@@ -116,7 +116,9 @@ fun SkikoProjectContext.compileNativeBridgesTask(
                 ))
             }
             OS.MacOS -> {
+                compiler.set(project.appleToolchainExecutableOrDefault("clang++", compiler.get()))
                 flags.set(listOf(
+                    *project.appleMacOsSdkFlags().toTypedArray(),
                     *buildType.clangFlags,
                     *skiaPreprocessorFlags(OS.MacOS, buildType),
                     when(arch) {

skiko/gradle.properties

@@ -6,8 +6,8 @@ kotlin.mpp.enableCInteropCommonization=true
 
 deploy.version=0.0.0
 
-# a tag from https://github.com/JetBrains/skia-pack
-dependencies.skia=m144-e2e6623374-4
+# a tag from https://github.com/JetBrains/skia/releases
+dependencies.skia=m144-22f58c9fd4
 
 # a tag from https://github.com/JetBrains/angle-pack
 dependencies.angle=ec4d8f8e4d
@@ -24,7 +24,6 @@ dependencies.angle=ec4d8f8e4d
 # dependencies.skia.macos-arm64
 # dependencies.skia.macos-x64
 # dependencies.skia.tvos-arm64
-# dependencies.skia.tvos-x64
 # dependencies.skia.tvosSim-arm64
 # dependencies.skia.tvosSim-x64
 # dependencies.skia.wasm-wasm