diff --git a/bench/bench.gradle.kts b/bench/bench.gradle.kts
index 0a2aa63c..a4d68e9f 100644
--- a/bench/bench.gradle.kts
+++ b/bench/bench.gradle.kts
@@ -19,8 +19,8 @@ plugins {
   id("me.champeau.jmh")
 }
 
-val truffle: Configuration by configurations.creating
-val graal: Configuration by configurations.creating
+val truffle: Configuration = configurations.create("truffle")
+val graal: Configuration = configurations.create("graal")
 
 dependencies {
   jmh(projects.pklCore)
diff --git a/build-logic/src/main/kotlin/PklPublishing.kt b/build-logic/src/main/kotlin/PklPublishing.kt
index 07ea6f32..fe69b47c 100644
--- a/build-logic/src/main/kotlin/PklPublishing.kt
+++ b/build-logic/src/main/kotlin/PklPublishing.kt
@@ -63,58 +63,60 @@ fun Project.configurePklPomMetadata() {
 
 /** Configures POM validation task to check for unresolved versions and snapshots in releases. */
 fun Project.configurePomValidation() {
-  val validatePom by tasks.registering {
-    if (tasks.findByName("generatePomFileForLibraryPublication") == null) {
-      return@registering
-    }
-    val generatePomFileForLibraryPublication by tasks.existing(GenerateMavenPom::class)
-    val outputFile =
-      layout.buildDirectory.file("validatePom") // dummy output to satisfy up-to-date check
+  val validatePom =
+    tasks.register("validatePom") {
+      if (tasks.findByName("generatePomFileForLibraryPublication") == null) {
+        return@register
+      }
+      val generatePomFileForLibraryPublication =
+        tasks.named<GenerateMavenPom>("generatePomFileForLibraryPublication")
+      val outputFile =
+        layout.buildDirectory.file("validatePom") // dummy output to satisfy up-to-date check
 
-    dependsOn(generatePomFileForLibraryPublication)
-    inputs.file(generatePomFileForLibraryPublication.get().destination)
-    outputs.file(outputFile)
+      dependsOn(generatePomFileForLibraryPublication)
+      inputs.file(generatePomFileForLibraryPublication.get().destination)
+      outputs.file(outputFile)
 
-    doLast {
-      outputFile.get().asFile.delete()
+      doLast {
+        outputFile.get().asFile.delete()
 
-      val pomFile = generatePomFileForLibraryPublication.get().destination
-      assert(pomFile.exists())
+        val pomFile = generatePomFileForLibraryPublication.get().destination
+        assert(pomFile.exists())
 
-      val text = pomFile.readText()
+        val text = pomFile.readText()
 
-      run {
-        val unresolvedVersion = Regex("<version>.*[+,()\\[\\]].*</version>")
-        val matches = unresolvedVersion.findAll(text).toList()
-        if (matches.isNotEmpty()) {
-          throw org.gradle.api.GradleException(
-            """
+        run {
+          val unresolvedVersion = Regex("<version>.*[+,()\\[\\]].*</version>")
+          val matches = unresolvedVersion.findAll(text).toList()
+          if (matches.isNotEmpty()) {
+            throw org.gradle.api.GradleException(
+              """
         Found unresolved version selector(s) in generated POM:
         ${matches.joinToString("\n") { it.groupValues[0] }}
       """
-              .trimIndent()
-          )
+                .trimIndent()
+            )
+          }
         }
-      }
 
-      val buildInfo = project.extensions.getByType<BuildInfo>()
-      if (buildInfo.isReleaseBuild) {
-        val snapshotVersion = Regex("<version>.*-SNAPSHOT</version>")
-        val matches = snapshotVersion.findAll(text).toList()
-        if (matches.isNotEmpty()) {
-          throw org.gradle.api.GradleException(
-            """
+        val buildInfo = project.extensions.getByType<BuildInfo>()
+        if (buildInfo.isReleaseBuild) {
+          val snapshotVersion = Regex("<version>.*-SNAPSHOT</version>")
+          val matches = snapshotVersion.findAll(text).toList()
+          if (matches.isNotEmpty()) {
+            throw org.gradle.api.GradleException(
+              """
         Found snapshot version(s) in generated POM of Pkl release version:
         ${matches.joinToString("\n") { it.groupValues[0] }}
       """
-              .trimIndent()
-          )
+                .trimIndent()
+            )
+          }
         }
-      }
 
-      outputFile.get().asFile.writeText("OK")
+        outputFile.get().asFile.writeText("OK")
+      }
     }
-  }
 
   tasks.named("publish") { dependsOn(validatePom) }
 }
diff --git a/build-logic/src/main/kotlin/pklAllProjects.gradle.kts b/build-logic/src/main/kotlin/pklAllProjects.gradle.kts
index e486963d..5f52f5d0 100644
--- a/build-logic/src/main/kotlin/pklAllProjects.gradle.kts
+++ b/build-logic/src/main/kotlin/pklAllProjects.gradle.kts
@@ -79,7 +79,7 @@ plugins.withType(MavenPublishPlugin::class).configureEach {
   }
 }
 
-val allDependencies by tasks.registering(DependencyReportTask::class)
+val allDependencies = tasks.register<DependencyReportTask>("allDependencies")
 
 tasks.withType(Test::class).configureEach {
   System.getProperty("testReportsDir")?.let { reportsDir ->
diff --git a/build-logic/src/main/kotlin/pklFatJar.gradle.kts b/build-logic/src/main/kotlin/pklFatJar.gradle.kts
index 90734918..af209c4b 100644
--- a/build-logic/src/main/kotlin/pklFatJar.gradle.kts
+++ b/build-logic/src/main/kotlin/pklFatJar.gradle.kts
@@ -132,8 +132,8 @@ tasks.shadowJar {
 
 shadow { addShadowVariantIntoJavaComponent = false }
 
-val testFatJar by
-  tasks.registering(Test::class) {
+val testFatJar =
+  tasks.register<Test>("testFatJar") {
     testClassesDirs = files(tasks.test.get().testClassesDirs)
     classpath =
       // compiled test classes
@@ -148,47 +148,48 @@ val testFatJar by
 
 tasks.check { dependsOn(testFatJar) }
 
-val validateFatJar by tasks.registering {
-  val outputFile = layout.buildDirectory.file("validateFatJar/result.txt")
-  inputs.files(tasks.shadowJar)
-  inputs.property("nonRelocations", nonRelocations)
-  outputs.file(outputFile)
+val validateFatJar =
+  tasks.register("validateFatJar") {
+    val outputFile = layout.buildDirectory.file("validateFatJar/result.txt")
+    inputs.files(tasks.shadowJar)
+    inputs.property("nonRelocations", nonRelocations)
+    outputs.file(outputFile)
 
-  doLast {
-    val unshadowedFiles = mutableListOf<String>()
-    zipTree(tasks.shadowJar.get().outputs.files.singleFile).visit {
-      val fileDetails = this
-      val path = fileDetails.relativePath.pathString
-      if (
-        !(fileDetails.isDirectory ||
-          path.startsWith("org/pkl/") ||
-          path.startsWith("META-INF/") ||
-          nonRelocations.any { path.startsWith(it) })
-      ) {
-        // don't throw exception inside `visit`
-        // as this gives a misleading "Could not expand ZIP" error message
-        unshadowedFiles.add(path)
+    doLast {
+      val unshadowedFiles = mutableListOf<String>()
+      zipTree(tasks.shadowJar.get().outputs.files.singleFile).visit {
+        val fileDetails = this
+        val path = fileDetails.relativePath.pathString
+        if (
+          !(fileDetails.isDirectory ||
+            path.startsWith("org/pkl/") ||
+            path.startsWith("META-INF/") ||
+            nonRelocations.any { path.startsWith(it) })
+        ) {
+          // don't throw exception inside `visit`
+          // as this gives a misleading "Could not expand ZIP" error message
+          unshadowedFiles.add(path)
+        }
+      }
+      if (unshadowedFiles.isEmpty()) {
+        outputFile.get().asFile.writeText("SUCCESS")
+      } else {
+        outputFile.get().asFile.writeText("FAILURE")
+        throw GradleException("Found unshadowed files:\n" + unshadowedFiles.joinToString("\n"))
       }
     }
-    if (unshadowedFiles.isEmpty()) {
-      outputFile.get().asFile.writeText("SUCCESS")
-    } else {
-      outputFile.get().asFile.writeText("FAILURE")
-      throw GradleException("Found unshadowed files:\n" + unshadowedFiles.joinToString("\n"))
-    }
   }
-}
 
 tasks.check { dependsOn(validateFatJar) }
 
-val resolveSourcesJars by
-  tasks.registering(ResolveSourcesJars::class) {
+val resolveSourcesJars =
+  tasks.register<ResolveSourcesJars>("resolveSourcesJars") {
     configuration.set(configurations.runtimeClasspath)
     outputDir.set(layout.buildDirectory.dir("resolveSourcesJars"))
   }
 
-val fatSourcesJar by
-  tasks.registering(MergeSourcesJars::class) {
+val fatSourcesJar =
+  tasks.register<MergeSourcesJars>("fatSourcesJar") {
     plugins.withId("pklJavaLibrary") { inputJars.from(tasks.named("sourcesJar")) }
     inputJars.from(firstPartySourcesJarsConfiguration)
     inputJars.from(resolveSourcesJars.map { fileTree(it.outputDir) })
@@ -213,7 +214,7 @@ publishing {
       artifact(fatSourcesJar.flatMap { it.outputJar.asFile }) { classifier = "sources" }
 
       plugins.withId("pklJavaLibrary") {
-        val javadocJar by tasks.existing(Jar::class)
+        val javadocJar = tasks.named<Jar>("javadocJar")
         // Javadoc Jar is not fat (didn't invest effort)
         artifact(javadocJar.flatMap { it.archiveFile }) { classifier = "javadoc" }
       }
diff --git a/build-logic/src/main/kotlin/pklGraalVm.gradle.kts b/build-logic/src/main/kotlin/pklGraalVm.gradle.kts
index 95351beb..6f1d629a 100644
--- a/build-logic/src/main/kotlin/pklGraalVm.gradle.kts
+++ b/build-logic/src/main/kotlin/pklGraalVm.gradle.kts
@@ -21,11 +21,15 @@ plugins { id("de.undercouch.download") }
 val buildInfo = project.extensions.getByType<BuildInfo>()
 
 // tries to minimize chance of corruption by download-to-temp-file-and-move
-val downloadGraalVmAarch64 by
-  tasks.registering(Download::class) { configureDownloadGraalVm(buildInfo.graalVmAarch64) }
+val downloadGraalVmAarch64 =
+  tasks.register<Download>("downloadGraalVmAarch64") {
+    configureDownloadGraalVm(buildInfo.graalVmAarch64)
+  }
 
-val downloadGraalVmAmd64 by
-  tasks.registering(Download::class) { configureDownloadGraalVm(buildInfo.graalVmAmd64) }
+val downloadGraalVmAmd64 =
+  tasks.register<Download>("downloadGraalVmAmd64") {
+    configureDownloadGraalVm(buildInfo.graalVmAmd64)
+  }
 
 fun Download.configureDownloadGraalVm(graalvm: BuildInfo.GraalVm) {
   onlyIf { !graalvm.installDir.exists() }
@@ -37,14 +41,14 @@ fun Download.configureDownloadGraalVm(graalvm: BuildInfo.GraalVm) {
   tempAndMove(true)
 }
 
-val verifyGraalVmAarch64 by
-  tasks.registering(Verify::class) {
+val verifyGraalVmAarch64 =
+  tasks.register<Verify>("verifyGraalVmAarch64") {
     configureVerifyGraalVm(buildInfo.graalVmAarch64)
     dependsOn(downloadGraalVmAarch64)
   }
 
-val verifyGraalVmAmd64 by
-  tasks.registering(Verify::class) {
+val verifyGraalVmAmd64 =
+  tasks.register<Verify>("verifyGraalVmAmd64") {
     configureVerifyGraalVm(buildInfo.graalVmAmd64)
     dependsOn(downloadGraalVmAmd64)
   }
@@ -60,15 +64,15 @@ fun Verify.configureVerifyGraalVm(graalvm: BuildInfo.GraalVm) {
 }
 
 @Suppress("unused")
-val installGraalVmAarch64 by
-  tasks.registering(InstallGraalVm::class) {
+val installGraalVmAarch64 =
+  tasks.register<InstallGraalVm>("installGraalVmAarch64") {
     dependsOn(verifyGraalVmAarch64)
     graalVm = buildInfo.graalVmAarch64
   }
 
 @Suppress("unused")
-val installGraalVmAmd64 by
-  tasks.registering(InstallGraalVm::class) {
+val installGraalVmAmd64 =
+  tasks.register<InstallGraalVm>("installGraalVmAmd64") {
     dependsOn(verifyGraalVmAmd64)
     graalVm = buildInfo.graalVmAmd64
   }
diff --git a/build-logic/src/main/kotlin/pklHtmlValidator.gradle.kts b/build-logic/src/main/kotlin/pklHtmlValidator.gradle.kts
index 69c9ed80..cf187d3c 100644
--- a/build-logic/src/main/kotlin/pklHtmlValidator.gradle.kts
+++ b/build-logic/src/main/kotlin/pklHtmlValidator.gradle.kts
@@ -47,8 +47,8 @@ dependencies {
   }
 }
 
-val validateHtml by
-  tasks.registering(JavaExec::class) {
+val validateHtml =
+  tasks.register<JavaExec>("validateHtml") {
     val resultFile = layout.buildDirectory.file("validateHtml/result.txt")
     inputs.files(htmlValidator.sources)
     outputs.file(resultFile)
diff --git a/build-logic/src/main/kotlin/pklJavaExecutable.gradle.kts b/build-logic/src/main/kotlin/pklJavaExecutable.gradle.kts
index d05bb185..e2fd0aeb 100644
--- a/build-logic/src/main/kotlin/pklJavaExecutable.gradle.kts
+++ b/build-logic/src/main/kotlin/pklJavaExecutable.gradle.kts
@@ -26,8 +26,8 @@ plugins {
 val executableSpec = project.extensions.create("executable", ExecutableSpec::class.java)
 val buildInfo = project.extensions.getByType<BuildInfo>()
 
-val javaExecutable by
-  tasks.registering(ExecutableJar::class) {
+val javaExecutable =
+  tasks.register<ExecutableJar>("javaExecutable") {
     group = "build"
     dependsOn(tasks.jar)
     inJar = tasks.shadowJar.flatMap { it.archiveFile }
@@ -77,7 +77,8 @@ fun Task.setupTestStartJavaExecutable(launcher: Provider<JavaLauncher>? = null)
   }
 }
 
-val testStartJavaExecutable by tasks.registering { setupTestStartJavaExecutable() }
+val testStartJavaExecutable =
+  tasks.register("testStartJavaExecutable") { setupTestStartJavaExecutable() }
 
 // Setup `testStartJavaExecutable` tasks for multi-JDK testing.
 val testStartJavaExecutableOnOtherJdks =
diff --git a/build-logic/src/main/kotlin/pklNativeExecutable.gradle.kts b/build-logic/src/main/kotlin/pklNativeExecutable.gradle.kts
index 563c8964..6229a7b0 100644
--- a/build-logic/src/main/kotlin/pklNativeExecutable.gradle.kts
+++ b/build-logic/src/main/kotlin/pklNativeExecutable.gradle.kts
@@ -30,22 +30,26 @@ plugins {
 val executableSpec = project.extensions.getByType<ExecutableSpec>()
 val buildInfo = project.extensions.getByType<BuildInfo>()
 
-val stagedMacAmd64Executable: Configuration by configurations.creating
-val stagedMacAarch64Executable: Configuration by configurations.creating
-val stagedLinuxAmd64Executable: Configuration by configurations.creating
-val stagedLinuxAarch64Executable: Configuration by configurations.creating
-val stagedAlpineLinuxAmd64Executable: Configuration by configurations.creating
-val stagedWindowsAmd64Executable: Configuration by configurations.creating
+val stagedMacAmd64Executable: Configuration = configurations.create("stagedMacAmd64Executable")
+val stagedMacAarch64Executable: Configuration = configurations.create("stagedMacAarch64Executable")
+val stagedLinuxAmd64Executable: Configuration = configurations.create("stagedLinuxAmd64Executable")
+val stagedLinuxAarch64Executable: Configuration =
+  configurations.create("stagedLinuxAarch64Executable")
+val stagedAlpineLinuxAmd64Executable: Configuration =
+  configurations.create("stagedAlpineLinuxAmd64Executable")
+val stagedWindowsAmd64Executable: Configuration =
+  configurations.create("stagedWindowsAmd64Executable")
 
-val nativeImageClasspath by configurations.creating {
-  extendsFrom(configurations.runtimeClasspath.get())
-  // Ensure native-image version uses GraalVM C SDKs instead of Java FFI or JNA
-  // (comes from artifact `mordant-jvm-graal-ffi`).
-  exclude("com.github.ajalt.mordant", "mordant-jvm-ffm")
-  exclude("com.github.ajalt.mordant", "mordant-jvm-ffm-jvm")
-  exclude("com.github.ajalt.mordant", "mordant-jvm-jna")
-  exclude("com.github.ajalt.mordant", "mordant-jvm-jna-jvm")
-}
+val nativeImageClasspath =
+  configurations.create("nativeImageClasspath") {
+    extendsFrom(configurations.runtimeClasspath.get())
+    // Ensure native-image version uses GraalVM C SDKs instead of Java FFI or JNA
+    // (comes from artifact `mordant-jvm-graal-ffi`).
+    exclude("com.github.ajalt.mordant", "mordant-jvm-ffm")
+    exclude("com.github.ajalt.mordant", "mordant-jvm-ffm-jvm")
+    exclude("com.github.ajalt.mordant", "mordant-jvm-jna")
+    exclude("com.github.ajalt.mordant", "mordant-jvm-jna-jvm")
+  }
 
 val libs = the<LibrariesForLibs>()
 
@@ -85,32 +89,32 @@ private fun NativeImageBuild.setClasspath() {
   classpath.from(nativeImageClasspath)
 }
 
-val macExecutableAmd64 by
-  tasks.registering(NativeImageBuild::class) {
+val macExecutableAmd64 =
+  tasks.register<NativeImageBuild>("macExecutableAmd64") {
     imageName = executableSpec.name.map { "$it-macos-amd64" }
     mainClass = executableSpec.mainClass
     amd64()
     setClasspath()
   }
 
-val macExecutableAarch64 by
-  tasks.registering(NativeImageBuild::class) {
+val macExecutableAarch64 =
+  tasks.register<NativeImageBuild>("macExecutableAarch64") {
     imageName = executableSpec.name.map { "$it-macos-aarch64" }
     mainClass = executableSpec.mainClass
     aarch64()
     setClasspath()
   }
 
-val linuxExecutableAmd64 by
-  tasks.registering(NativeImageBuild::class) {
+val linuxExecutableAmd64 =
+  tasks.register<NativeImageBuild>("linuxExecutableAmd64") {
     imageName = executableSpec.name.map { "$it-linux-amd64" }
     mainClass = executableSpec.mainClass
     amd64()
     setClasspath()
   }
 
-val linuxExecutableAarch64 by
-  tasks.registering(NativeImageBuild::class) {
+val linuxExecutableAarch64 =
+  tasks.register<NativeImageBuild>("linuxExecutableAarch64") {
     imageName = executableSpec.name.map { "$it-linux-aarch64" }
     mainClass = executableSpec.mainClass
     aarch64()
@@ -120,8 +124,8 @@ val linuxExecutableAarch64 by
     extraNativeImageArgs.add("-H:PageSize=65536")
   }
 
-val alpineExecutableAmd64 by
-  tasks.registering(NativeImageBuild::class) {
+val alpineExecutableAmd64 =
+  tasks.register<NativeImageBuild>("alpineExecutableAmd64") {
     imageName = executableSpec.name.map { "$it-alpine-linux-amd64" }
     mainClass = executableSpec.mainClass
     amd64()
@@ -129,73 +133,75 @@ val alpineExecutableAmd64 by
     extraNativeImageArgs.addAll(listOf("--static", "--libc=musl"))
   }
 
-val windowsExecutableAmd64 by
-  tasks.registering(NativeImageBuild::class) {
+val windowsExecutableAmd64 =
+  tasks.register<NativeImageBuild>("windowsExecutableAmd64") {
     imageName = executableSpec.name.map { "$it-windows-amd64" }
     mainClass = executableSpec.mainClass
     amd64()
     setClasspath()
   }
 
-val assembleNative by tasks.existing
+val assembleNative = tasks.named("assembleNative")
 
-val testStartNativeExecutable by tasks.registering {
-  dependsOn(assembleNative)
+val testStartNativeExecutable =
+  tasks.register("testStartNativeExecutable") {
+    dependsOn(assembleNative)
 
-  // dummy file for up-to-date checking
-  val outputFile = project.layout.buildDirectory.file("testStartNativeExecutable/output.txt")
-  outputs.file(outputFile)
+    // dummy file for up-to-date checking
+    val outputFile = project.layout.buildDirectory.file("testStartNativeExecutable/output.txt")
+    outputs.file(outputFile)
 
-  val execOutput = providers.exec {
-    commandLine(assembleNative.get().outputs.files.singleFile, "--version")
-  }
-
-  doLast {
-    val outputText = execOutput.standardOutput.asText.get()
-    if (!outputText.contains(buildInfo.pklVersionNonUnique)) {
-      throw GradleException(
-        "Expected version output to contain current version (${buildInfo.pklVersionNonUnique}), but got '$outputText'"
-      )
+    val execOutput = providers.exec {
+      commandLine(assembleNative.get().outputs.files.singleFile, "--version")
     }
-    outputFile.get().asFile.toPath().apply {
-      try {
-        parent.createDirectories()
-      } catch (_: java.nio.file.FileAlreadyExistsException) {}
-      writeText("OK")
+
+    doLast {
+      val outputText = execOutput.standardOutput.asText.get()
+      if (!outputText.contains(buildInfo.pklVersionNonUnique)) {
+        throw GradleException(
+          "Expected version output to contain current version (${buildInfo.pklVersionNonUnique}), but got '$outputText'"
+        )
+      }
+      outputFile.get().asFile.toPath().apply {
+        try {
+          parent.createDirectories()
+        } catch (_: java.nio.file.FileAlreadyExistsException) {}
+        writeText("OK")
+      }
     }
   }
-}
 
 val requiredGlibcVersion: Version = Version.parse("2.17")
 
-val checkGlibc by tasks.registering {
-  enabled = buildInfo.os.isLinux && !buildInfo.musl
-  dependsOn(assembleNative)
-  doLast {
-    val exec = providers.exec {
-      commandLine("objdump", "-T", assembleNative.get().outputs.files.singleFile)
-    }
-    val output = exec.standardOutput.asText.get()
-    val minimumGlibcVersion =
-      output
-        .split("\n")
-        .mapNotNull { line ->
-          val match = Regex("GLIBC_([.0-9]*)").find(line)
-          match?.groups[1]?.let { Version.parse(it.value) }
-        }
-        .maxOrNull()
-    if (minimumGlibcVersion == null) {
-      throw GradleException(
-        "Could not determine glibc version from executable. objdump output: $output"
-      )
-    }
-    if (minimumGlibcVersion > requiredGlibcVersion) {
-      throw GradleException(
-        "Incorrect glibc version. Found: $minimumGlibcVersion, required: $requiredGlibcVersion"
-      )
+val checkGlibc =
+  tasks.register("checkGlibc") {
+    enabled = buildInfo.os.isLinux && !buildInfo.musl
+    dependsOn(assembleNative)
+    doLast {
+      val exec = providers.exec {
+        commandLine("objdump", "-T", assembleNative.get().outputs.files.singleFile)
+      }
+      val output = exec.standardOutput.asText.get()
+      val minimumGlibcVersion =
+        output
+          .split("\n")
+          .mapNotNull { line ->
+            val match = Regex("GLIBC_([.0-9]*)").find(line)
+            match?.groups[1]?.let { Version.parse(it.value) }
+          }
+          .maxOrNull()
+      if (minimumGlibcVersion == null) {
+        throw GradleException(
+          "Could not determine glibc version from executable. objdump output: $output"
+        )
+      }
+      if (minimumGlibcVersion > requiredGlibcVersion) {
+        throw GradleException(
+          "Incorrect glibc version. Found: $minimumGlibcVersion, required: $requiredGlibcVersion"
+        )
+      }
     }
   }
-}
 
 // Expose underlying task's outputs
 private fun <T : Task> Task.wraps(other: TaskProvider<T>) {
@@ -203,19 +209,24 @@ private fun <T : Task> Task.wraps(other: TaskProvider<T>) {
   outputs.files(other)
 }
 
-val testNative by tasks.existing { dependsOn(testStartNativeExecutable, checkGlibc) }
+val testNative = tasks.named("testNative") { dependsOn(testStartNativeExecutable, checkGlibc) }
 
-val assembleNativeMacOsAarch64 by tasks.existing { wraps(macExecutableAarch64) }
+val assembleNativeMacOsAarch64 =
+  tasks.named("assembleNativeMacOsAarch64") { wraps(macExecutableAarch64) }
 
-val assembleNativeMacOsAmd64 by tasks.existing { wraps(macExecutableAmd64) }
+val assembleNativeMacOsAmd64 = tasks.named("assembleNativeMacOsAmd64") { wraps(macExecutableAmd64) }
 
-val assembleNativeLinuxAarch64 by tasks.existing { wraps(linuxExecutableAarch64) }
+val assembleNativeLinuxAarch64 =
+  tasks.named("assembleNativeLinuxAarch64") { wraps(linuxExecutableAarch64) }
 
-val assembleNativeLinuxAmd64 by tasks.existing { wraps(linuxExecutableAmd64) }
+val assembleNativeLinuxAmd64 =
+  tasks.named("assembleNativeLinuxAmd64") { wraps(linuxExecutableAmd64) }
 
-val assembleNativeAlpineLinuxAmd64 by tasks.existing { wraps(alpineExecutableAmd64) }
+val assembleNativeAlpineLinuxAmd64 =
+  tasks.named("assembleNativeAlpineLinuxAmd64") { wraps(alpineExecutableAmd64) }
 
-val assembleNativeWindowsAmd64 by tasks.existing { wraps(windowsExecutableAmd64) }
+val assembleNativeWindowsAmd64 =
+  tasks.named("assembleNativeWindowsAmd64") { wraps(windowsExecutableAmd64) }
 
 publishing {
   publications {
diff --git a/build-logic/src/main/kotlin/pklNativeLifecycle.gradle.kts b/build-logic/src/main/kotlin/pklNativeLifecycle.gradle.kts
index 2ad2de5c..5aa10dac 100644
--- a/build-logic/src/main/kotlin/pklNativeLifecycle.gradle.kts
+++ b/build-logic/src/main/kotlin/pklNativeLifecycle.gradle.kts
@@ -13,29 +13,31 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-val assembleNativeMacOsAarch64 by tasks.registering { group = "build" }
+val assembleNativeMacOsAarch64 = tasks.register("assembleNativeMacOsAarch64") { group = "build" }
 
-val assembleNativeMacOsAmd64 by tasks.registering { group = "build" }
+val assembleNativeMacOsAmd64 = tasks.register("assembleNativeMacOsAmd64") { group = "build" }
 
-val assembleNativeLinuxAarch64 by tasks.registering { group = "build" }
+val assembleNativeLinuxAarch64 = tasks.register("assembleNativeLinuxAarch64") { group = "build" }
 
-val assembleNativeLinuxAmd64 by tasks.registering { group = "build" }
+val assembleNativeLinuxAmd64 = tasks.register("assembleNativeLinuxAmd64") { group = "build" }
 
-val assembleNativeAlpineLinuxAmd64 by tasks.registering { group = "build" }
+val assembleNativeAlpineLinuxAmd64 =
+  tasks.register("assembleNativeAlpineLinuxAmd64") { group = "build" }
 
-val assembleNativeWindowsAmd64 by tasks.registering { group = "build" }
+val assembleNativeWindowsAmd64 = tasks.register("assembleNativeWindowsAmd64") { group = "build" }
 
-val testNativeMacOsAarch64 by tasks.registering { group = "verification" }
+val testNativeMacOsAarch64 = tasks.register("testNativeMacOsAarch64") { group = "verification" }
 
-val testNativeMacOsAmd64 by tasks.registering { group = "verification" }
+val testNativeMacOsAmd64 = tasks.register("testNativeMacOsAmd64") { group = "verification" }
 
-val testNativeLinuxAarch64 by tasks.registering { group = "verification" }
+val testNativeLinuxAarch64 = tasks.register("testNativeLinuxAarch64") { group = "verification" }
 
-val testNativeLinuxAmd64 by tasks.registering { group = "verification" }
+val testNativeLinuxAmd64 = tasks.register("testNativeLinuxAmd64") { group = "verification" }
 
-val testNativeAlpineLinuxAmd64 by tasks.registering { group = "verification" }
+val testNativeAlpineLinuxAmd64 =
+  tasks.register("testNativeAlpineLinuxAmd64") { group = "verification" }
 
-val testNativeWindowsAmd64 by tasks.registering { group = "verification" }
+val testNativeWindowsAmd64 = tasks.register("testNativeWindowsAmd64") { group = "verification" }
 
 val buildInfo = project.extensions.getByType<BuildInfo>()
 
@@ -44,79 +46,85 @@ private fun <T : Task> Task.wraps(other: TaskProvider<T>) {
   outputs.files(other)
 }
 
-val assembleNative by tasks.registering {
-  group = "build"
+val assembleNative =
+  tasks.register("assembleNative") {
+    group = "build"
 
-  if (!buildInfo.isCrossArchSupported && buildInfo.isCrossArch) {
-    throw GradleException("Cross-arch builds are not supported on ${buildInfo.os.name}")
-  }
+    if (!buildInfo.isCrossArchSupported && buildInfo.isCrossArch) {
+      throw GradleException("Cross-arch builds are not supported on ${buildInfo.os.name}")
+    }
 
-  when {
-    buildInfo.os.isMacOsX && buildInfo.targetArch == "aarch64" -> {
-      wraps(assembleNativeMacOsAarch64)
-    }
-    buildInfo.os.isMacOsX && buildInfo.targetArch == "amd64" -> {
-      wraps(assembleNativeMacOsAmd64)
-    }
-    buildInfo.os.isLinux && buildInfo.targetArch == "aarch64" -> {
-      wraps(assembleNativeLinuxAarch64)
-    }
-    buildInfo.os.isLinux && buildInfo.targetArch == "amd64" -> {
-      if (buildInfo.musl) wraps(assembleNativeAlpineLinuxAmd64) else wraps(assembleNativeLinuxAmd64)
-    }
-    buildInfo.os.isWindows && buildInfo.targetArch == "amd64" -> {
-      wraps(assembleNativeWindowsAmd64)
-    }
-    else -> {
-      doLast {
-        throw GradleException(
-          "Cannot build targeting ${buildInfo.os.name}/${buildInfo.targetArch} with musl=${buildInfo.musl}"
-        )
+    when {
+      buildInfo.os.isMacOsX && buildInfo.targetArch == "aarch64" -> {
+        wraps(assembleNativeMacOsAarch64)
+      }
+      buildInfo.os.isMacOsX && buildInfo.targetArch == "amd64" -> {
+        wraps(assembleNativeMacOsAmd64)
+      }
+      buildInfo.os.isLinux && buildInfo.targetArch == "aarch64" -> {
+        wraps(assembleNativeLinuxAarch64)
+      }
+      buildInfo.os.isLinux && buildInfo.targetArch == "amd64" -> {
+        if (buildInfo.musl) wraps(assembleNativeAlpineLinuxAmd64)
+        else wraps(assembleNativeLinuxAmd64)
+      }
+      buildInfo.os.isWindows && buildInfo.targetArch == "amd64" -> {
+        wraps(assembleNativeWindowsAmd64)
+      }
+      else -> {
+        doLast {
+          throw GradleException(
+            "Cannot build targeting ${buildInfo.os.name}/${buildInfo.targetArch} with musl=${buildInfo.musl}"
+          )
+        }
       }
     }
   }
-}
 
-val testNative by tasks.registering {
-  group = "verification"
-  dependsOn(assembleNative)
+val testNative =
+  tasks.register("testNative") {
+    group = "verification"
+    dependsOn(assembleNative)
 
-  if (!buildInfo.isCrossArchSupported && buildInfo.isCrossArch) {
-    throw GradleException("Cross-arch builds are not supported on ${buildInfo.os.name}")
-  }
+    if (!buildInfo.isCrossArchSupported && buildInfo.isCrossArch) {
+      throw GradleException("Cross-arch builds are not supported on ${buildInfo.os.name}")
+    }
 
-  when {
-    buildInfo.os.isMacOsX && buildInfo.targetArch == "aarch64" -> {
-      dependsOn(testNativeMacOsAarch64)
-    }
-    buildInfo.os.isMacOsX && buildInfo.targetArch == "amd64" -> {
-      dependsOn(testNativeMacOsAmd64)
-    }
-    buildInfo.os.isLinux && buildInfo.targetArch == "aarch64" -> {
-      dependsOn(testNativeLinuxAarch64)
-    }
-    buildInfo.os.isLinux && buildInfo.targetArch == "amd64" -> {
-      if (buildInfo.musl) dependsOn(testNativeAlpineLinuxAmd64) else dependsOn(testNativeLinuxAmd64)
-    }
-    buildInfo.os.isWindows && buildInfo.targetArch == "amd64" -> {
-      dependsOn(testNativeWindowsAmd64)
-    }
-    else -> {
-      doLast {
-        throw GradleException(
-          "Cannot build targeting ${buildInfo.os.name}/${buildInfo.targetArch} with musl=${buildInfo.musl}"
-        )
+    when {
+      buildInfo.os.isMacOsX && buildInfo.targetArch == "aarch64" -> {
+        dependsOn(testNativeMacOsAarch64)
+      }
+      buildInfo.os.isMacOsX && buildInfo.targetArch == "amd64" -> {
+        dependsOn(testNativeMacOsAmd64)
+      }
+      buildInfo.os.isLinux && buildInfo.targetArch == "aarch64" -> {
+        dependsOn(testNativeLinuxAarch64)
+      }
+      buildInfo.os.isLinux && buildInfo.targetArch == "amd64" -> {
+        if (buildInfo.musl) dependsOn(testNativeAlpineLinuxAmd64)
+        else dependsOn(testNativeLinuxAmd64)
+      }
+      buildInfo.os.isWindows && buildInfo.targetArch == "amd64" -> {
+        dependsOn(testNativeWindowsAmd64)
+      }
+      else -> {
+        doLast {
+          throw GradleException(
+            "Cannot build targeting ${buildInfo.os.name}/${buildInfo.targetArch} with musl=${buildInfo.musl}"
+          )
+        }
       }
     }
   }
-}
 
-val checkNative by tasks.registering {
-  group = "verification"
-  dependsOn(testNative)
-}
+val checkNative =
+  tasks.register("checkNative") {
+    group = "verification"
+    dependsOn(testNative)
+  }
 
-val buildNative by tasks.registering {
-  group = "build"
-  dependsOn(checkNative)
-}
+val buildNative =
+  tasks.register("buildNative") {
+    group = "build"
+    dependsOn(checkNative)
+  }
diff --git a/build-logic/src/main/kotlin/pklSpotlessFormat.gradle.kts b/build-logic/src/main/kotlin/pklSpotlessFormat.gradle.kts
index c418a8b3..d406a570 100644
--- a/build-logic/src/main/kotlin/pklSpotlessFormat.gradle.kts
+++ b/build-logic/src/main/kotlin/pklSpotlessFormat.gradle.kts
@@ -15,7 +15,7 @@
  */
 plugins { id("com.diffplug.spotless") }
 
-val pklFormatter by configurations.creating
+val pklFormatter = configurations.create("pklFormatter")
 
 dependencies { pklFormatter(rootProject.project("pkl-formatter")) }
 
diff --git a/build.gradle.kts b/build.gradle.kts
index 1270141a..c6a7b40c 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -37,7 +37,8 @@ nexusPublishing {
   }
 }
 
-val configureLateInitAnnotation by tasks.registering(ConfigureLateInitAnnotation::class)
+val configureLateInitAnnotation =
+  tasks.register<ConfigureLateInitAnnotation>("configureLateInitAnnotation")
 
 idea {
   project {
@@ -53,9 +54,9 @@ idea {
   }
 }
 
-val clean by tasks.existing { delete(layout.buildDirectory) }
+val clean = tasks.named("clean") { delete(layout.buildDirectory) }
 
-val printVersion by tasks.registering { doFirst { println(buildInfo.pklVersion) } }
+val printVersion = tasks.register("printVersion") { doFirst { println(buildInfo.pklVersion) } }
 
 val message =
   """
diff --git a/pkl-cli/pkl-cli.gradle.kts b/pkl-cli/pkl-cli.gradle.kts
index f25a54f8..c461bd81 100644
--- a/pkl-cli/pkl-cli.gradle.kts
+++ b/pkl-cli/pkl-cli.gradle.kts
@@ -83,8 +83,8 @@ tasks.shadowJar {
   exclude("module-info.*")
 }
 
-val testJavaExecutable by
-  tasks.registering(Test::class) {
+val testJavaExecutable =
+  tasks.register<Test>("testJavaExecutable") {
     testClassesDirs = tasks.test.get().testClassesDirs
     classpath =
       // compiled test classes
@@ -138,7 +138,7 @@ fun Exec.useRootDirAndSuppressOutput() {
 
 // 0.28 Preparing for JDK21 toolchains revealed that `testStartJavaExecutable` may pass, even though
 // the evaluator fails. To catch this, we eval a simple expression using the fat jar.
-val testEvalJavaExecutable by
+val testEvalJavaExecutable =
   setupJavaExecutableRun("testEvalJavaExecutable", evalTestFlags) { useRootDirAndSuppressOutput() }
 
 // Run the same evaluator tests on all configured JDK test versions.
diff --git a/pkl-commons-cli/pkl-commons-cli.gradle.kts b/pkl-commons-cli/pkl-commons-cli.gradle.kts
index c3a9f19a..78171068 100644
--- a/pkl-commons-cli/pkl-commons-cli.gradle.kts
+++ b/pkl-commons-cli/pkl-commons-cli.gradle.kts
@@ -19,10 +19,11 @@ plugins {
   id("pklPublishLibrary")
 }
 
-val svmClasspath: Configuration by configurations.creating
+val svmClasspath: Configuration = configurations.create("svmClasspath")
 
 // used by pklNativeExecutable.gradle.kts
-@Suppress("unused") val svm: SourceSet by sourceSets.creating { compileClasspath = svmClasspath }
+@Suppress("unused")
+val svm: SourceSet = sourceSets.create("svm") { compileClasspath = svmClasspath }
 
 dependencies {
   api(projects.pklCore)
diff --git a/pkl-commons-test/pkl-commons-test.gradle.kts b/pkl-commons-test/pkl-commons-test.gradle.kts
index f6f1dda9..052a0fbe 100644
--- a/pkl-commons-test/pkl-commons-test.gradle.kts
+++ b/pkl-commons-test/pkl-commons-test.gradle.kts
@@ -37,7 +37,7 @@ dependencies {
  * These packages are used by PackageServer to serve assets when running LanguageSnippetTests and
  * PackageResolversTest.
  */
-val createTestPackages by tasks.registering
+val createTestPackages = tasks.register("createTestPackages")
 
 // make sure that declaring a dependency on this project suffices to have test fixtures generated
 tasks.processResources {
@@ -92,8 +92,8 @@ val keystoreName = "localhost.p12"
 val keystoreFile = keystoreDir.map { it.file(keystoreName) }
 val certsFileName = "localhost.pem"
 
-val generateKeys by
-  tasks.registering(JavaExec::class) {
+val generateKeys =
+  tasks.register<JavaExec>("generateKeys") {
     outputs.file(keystoreFile)
     mainClass.set("sun.security.tools.keytool.Main")
     args =
@@ -117,8 +117,8 @@ val generateKeys by
     }
   }
 
-val exportCerts by
-  tasks.registering(JavaExec::class) {
+val exportCerts =
+  tasks.register<JavaExec>("exportCerts") {
     val outputFile = keystoreDir.map { it.file(certsFileName) }
     dependsOn(generateKeys)
     inputs.file(keystoreFile)
diff --git a/pkl-config-kotlin/pkl-config-kotlin.gradle.kts b/pkl-config-kotlin/pkl-config-kotlin.gradle.kts
index b9c4c876..91f791da 100644
--- a/pkl-config-kotlin/pkl-config-kotlin.gradle.kts
+++ b/pkl-config-kotlin/pkl-config-kotlin.gradle.kts
@@ -19,11 +19,11 @@ plugins {
   id("pklPublishLibrary")
 }
 
-val pklConfigJava: Configuration by configurations.creating
+val pklConfigJava: Configuration = configurations.create("pklConfigJava")
 
-val pklConfigJavaAll: Configuration by configurations.creating
+val pklConfigJavaAll: Configuration = configurations.create("pklConfigJavaAll")
 
-val pklCodegenKotlin: Configuration by configurations.creating
+val pklCodegenKotlin: Configuration = configurations.create("pklCodegenKotlin")
 
 val buildInfo = project.extensions.getByType<BuildInfo>()
 
@@ -49,8 +49,8 @@ dependencies {
   testImplementation(libs.geantyref)
 }
 
-val generateTestConfigClasses by
-  tasks.registering(JavaExec::class) {
+val generateTestConfigClasses =
+  tasks.register<JavaExec>("generateTestConfigClasses") {
     val outputDir = layout.buildDirectory.dir("testConfigClasses")
     outputs.dir(outputDir)
     inputs.dir("src/test/resources/codegenPkl")
diff --git a/pkl-core/pkl-core.gradle.kts b/pkl-core/pkl-core.gradle.kts
index dc7d90c5..50aabe4a 100644
--- a/pkl-core/pkl-core.gradle.kts
+++ b/pkl-core/pkl-core.gradle.kts
@@ -35,9 +35,10 @@ val externalReaderFixtureSourceSet: NamedDomainObjectProvider<SourceSet> =
     runtimeClasspath += sourceSets.test.get().output + sourceSets.test.get().runtimeClasspath
   }
 
-val externalReaderFixtureImplementation: Configuration by configurations.getting {
-  extendsFrom(configurations.testImplementation.get())
-}
+val externalReaderFixtureImplementation: Configuration =
+  configurations.getByName("externalReaderFixtureImplementation") {
+    extendsFrom(configurations.testImplementation.get())
+  }
 
 idea {
   module {
diff --git a/pkl-doc/pkl-doc.gradle.kts b/pkl-doc/pkl-doc.gradle.kts
index 75e5028f..6ac1381b 100644
--- a/pkl-doc/pkl-doc.gradle.kts
+++ b/pkl-doc/pkl-doc.gradle.kts
@@ -78,8 +78,8 @@ tasks.test {
   inputs.dir("src/test/files/SinglePackageTest/output")
 }
 
-val testNativeExecutable by
-  tasks.registering(Test::class) {
+val testNativeExecutable =
+  tasks.register<Test>("testNativeExecutable") {
     dependsOn(tasks.assembleNative)
     testClassesDirs = sourceSets.test.get().output.classesDirs
     classpath = sourceSets.test.get().runtimeClasspath
@@ -91,8 +91,8 @@ val testNativeExecutable by
     filter { includeTestsMatching("org.pkl.doc.NativeExecutableTest") }
   }
 
-val testJavaExecutable by
-  tasks.registering(Test::class) {
+val testJavaExecutable =
+  tasks.register<Test>("testJavaExecutable") {
     testClassesDirs = sourceSets.test.get().output.classesDirs
     classpath = sourceSets.test.get().runtimeClasspath
 
diff --git a/pkl-executor/pkl-executor.gradle.kts b/pkl-executor/pkl-executor.gradle.kts
index 57311269..1d499f19 100644
--- a/pkl-executor/pkl-executor.gradle.kts
+++ b/pkl-executor/pkl-executor.gradle.kts
@@ -23,8 +23,8 @@ plugins {
   id("pklJSpecify")
 }
 
-val pklDistributionCurrent: Configuration by configurations.creating
-val pklHistoricalDistributions: Configuration by configurations.creating
+val pklDistributionCurrent: Configuration = configurations.create("pklDistributionCurrent")
+val pklHistoricalDistributions: Configuration = configurations.create("pklHistoricalDistributions")
 
 // Because pkl-executor doesn't depend on other Pkl modules
 // (nor has overlapping dependencies that could cause a version conflict),
@@ -66,37 +66,39 @@ publishing {
 
 sourceSets { main { java { srcDir("src/main/java") } } }
 
-val prepareHistoricalDistributions by tasks.registering {
-  val outputDir = layout.buildDirectory.dir("pklHistoricalDistributions")
-  inputs.files(pklHistoricalDistributions.files)
-  outputs.dir(outputDir)
-  doLast {
-    val distributionDir = outputDir.get().asFile.toPath().also(Files::createDirectories)
-    for (file in pklHistoricalDistributions.files) {
-      val target = distributionDir.resolve(file.name)
-      // Create normal files on Windows, symlink on macOS/linux (need admin privileges to create
-      // symlinks on Windows)
-      if (buildInfo.os.isWindows) {
-        if (!Files.isRegularFile(target, LinkOption.NOFOLLOW_LINKS)) {
-          if (Files.exists(target)) {
-            Files.delete(target)
+val prepareHistoricalDistributions =
+  tasks.register("prepareHistoricalDistributions") {
+    val outputDir = layout.buildDirectory.dir("pklHistoricalDistributions")
+    inputs.files(pklHistoricalDistributions.files)
+    outputs.dir(outputDir)
+    doLast {
+      val distributionDir = outputDir.get().asFile.toPath().also(Files::createDirectories)
+      for (file in pklHistoricalDistributions.files) {
+        val target = distributionDir.resolve(file.name)
+        // Create normal files on Windows, symlink on macOS/linux (need admin privileges to create
+        // symlinks on Windows)
+        if (buildInfo.os.isWindows) {
+          if (!Files.isRegularFile(target, LinkOption.NOFOLLOW_LINKS)) {
+            if (Files.exists(target)) {
+              Files.delete(target)
+            }
+            Files.copy(file.toPath(), target)
           }
-          Files.copy(file.toPath(), target)
-        }
-      } else {
-        if (!Files.isSymbolicLink(target)) {
-          if (Files.exists(target)) {
-            Files.delete(target)
+        } else {
+          if (!Files.isSymbolicLink(target)) {
+            if (Files.exists(target)) {
+              Files.delete(target)
+            }
+            Files.createSymbolicLink(target, file.toPath())
           }
-          Files.createSymbolicLink(target, file.toPath())
         }
       }
     }
   }
-}
 
-val prepareTest by tasks.registering {
-  dependsOn(pklDistributionCurrent, prepareHistoricalDistributions)
-}
+val prepareTest =
+  tasks.register("prepareTest") {
+    dependsOn(pklDistributionCurrent, prepareHistoricalDistributions)
+  }
 
 tasks.test { dependsOn(prepareTest) }
diff --git a/pkl-gradle/pkl-gradle.gradle.kts b/pkl-gradle/pkl-gradle.gradle.kts
index 449d85a7..ac6a53b9 100644
--- a/pkl-gradle/pkl-gradle.gradle.kts
+++ b/pkl-gradle/pkl-gradle.gradle.kts
@@ -69,12 +69,12 @@ sourceSets {
 // Then the path to the jar file and the toolchain's `java` binary
 // are injected into tests as properties.
 
-val externalReader by sourceSets.creating {}
+val externalReader = sourceSets.create("externalReader") {}
 
 dependencies { "externalReaderImplementation"(libs.msgpack) }
 
-val externalReaderJar by
-  tasks.registering(Jar::class) {
+val externalReaderJar =
+  tasks.register<Jar>("externalReaderJar") {
     description = "Builds an external reader executable jar file"
     archiveBaseName = "external-reader"
     archiveVersion = ""
diff --git a/pkl-server/pkl-server.gradle.kts b/pkl-server/pkl-server.gradle.kts
index 0cbf1319..0ff82248 100644
--- a/pkl-server/pkl-server.gradle.kts
+++ b/pkl-server/pkl-server.gradle.kts
@@ -36,38 +36,38 @@ private fun Test.configureNativeTest() {
   include("**/NativeServerTest.*")
 }
 
-val testMacExecutableAarch64 by
-  tasks.registering(Test::class) {
+val testMacExecutableAarch64 =
+  tasks.register<Test>("testMacExecutableAarch64") {
     dependsOn(":pkl-cli:macExecutableAarch64")
     configureNativeTest()
   }
 
-val testMacExecutableAmd64 by
-  tasks.registering(Test::class) {
+val testMacExecutableAmd64 =
+  tasks.register<Test>("testMacExecutableAmd64") {
     dependsOn(":pkl-cli:macExecutableAmd64")
     configureNativeTest()
   }
 
-val testLinuxExecutableAmd64 by
-  tasks.registering(Test::class) {
+val testLinuxExecutableAmd64 =
+  tasks.register<Test>("testLinuxExecutableAmd64") {
     dependsOn(":pkl-cli:linuxExecutableAmd64")
     configureNativeTest()
   }
 
-val testLinuxExecutableAarch64 by
-  tasks.registering(Test::class) {
+val testLinuxExecutableAarch64 =
+  tasks.register<Test>("testLinuxExecutableAarch64") {
     dependsOn(":pkl-cli:linuxExecutableAarch64")
     configureNativeTest()
   }
 
-val testAlpineExecutableAmd64 by
-  tasks.registering(Test::class) {
+val testAlpineExecutableAmd64 =
+  tasks.register<Test>("testAlpineExecutableAmd64") {
     dependsOn(":pkl-cli:alpineExecutableAmd64")
     configureNativeTest()
   }
 
-val testWindowsExecutableAmd64 by
-  tasks.registering(Test::class) {
+val testWindowsExecutableAmd64 =
+  tasks.register<Test>("testWindowsExecutableAmd64") {
     dependsOn(":pkl-cli:windowsExecutableAmd64")
     configureNativeTest()
   }
diff --git a/pkl-tools/pkl-tools.gradle.kts b/pkl-tools/pkl-tools.gradle.kts
index 61fd0c0b..f912a7f1 100644
--- a/pkl-tools/pkl-tools.gradle.kts
+++ b/pkl-tools/pkl-tools.gradle.kts
@@ -25,9 +25,9 @@ plugins {
   signing
 }
 
-val placeholder: SourceSet by sourceSets.creating
+val placeholder = sourceSets.create("placeholder")
 
-val firstPartySourcesJars by configurations.existing
+val firstPartySourcesJars = configurations.named("firstPartySourcesJars")
 
 // Note: pkl-tools cannot (easily) contain pkl-config-kotlin
 // because pkl-tools ships with a shaded Kotlin stdlib.
@@ -55,12 +55,13 @@ dependencies {
 
 // TODO: need to figure out how to properly generate javadoc here.
 // For now, we'll include a placeholder javadoc jar.
-val javadocPlaceholder by tasks.registering(Javadoc::class) { source = placeholder.allJava }
+val javadocPlaceholder =
+  tasks.register<Javadoc>("javadocPlaceholder") { source = placeholder.allJava }
 
 java { withJavadocJar() }
 
-val javadocJar by
-  tasks.existing(Jar::class) {
+val javadocJar =
+  tasks.named<Jar>("javadocJar") {
     from(javadocPlaceholder)
     archiveBaseName.set("pkl-tools-all")
     archiveClassifier.set("javadoc")
@@ -105,8 +106,8 @@ private fun Exec.configureTestStartFatJar(launcher: Provider<JavaLauncher>) {
   }
 }
 
-val testStartFatJar by
-  tasks.registering(Exec::class) { configureTestStartFatJar(buildInfo.javaTestLauncher) }
+val testStartFatJar =
+  tasks.register<Exec>("testStartFatJar") { configureTestStartFatJar(buildInfo.javaTestLauncher) }
 
 tasks.validateFatJar { dependsOn(testStartFatJar) }
 
diff --git a/stdlib/stdlib.gradle.kts b/stdlib/stdlib.gradle.kts
index d7cf6139..40088d63 100644
--- a/stdlib/stdlib.gradle.kts
+++ b/stdlib/stdlib.gradle.kts
@@ -24,8 +24,8 @@ plugins {
 
 // create and publish a self-contained stdlib archive
 // purpose is to provide non-jvm tools/projects with a versioned stdlib
-val stdlibZip by
-  tasks.registering(Zip::class) {
+val stdlibZip =
+  tasks.register<Zip>("stdlibZip") {
     destinationDirectory.set(layout.buildDirectory.dir("libs"))
     archiveBaseName.set("pkl-stdlib")
     archiveVersion.set(project.version as String)