Tell the native image platform without palantir's library

The Gradle plugin used com.palantir.gradle.utils:platform, at run time
in the builds it is applied to, to decide whether a native image exists
for the machine and which classifier to resolve. NativePlatform now does
that itself: os.name, os.arch and, on Linux, ldd --version to tell glibc
from musl, read through Gradle's ProviderFactory as before, with the
names open-java-format-native publishes its images under and buildSrc's
open-java-format.native-platform gives the ones the build produces.

The published platforms are listed exactly: the five classifiers on
Maven Central. Before, any glibc Linux and any macOS counted, so a
32-bit x86 JVM went on to look for an image that does not exist.

NativePlatformTest pins those classifiers and extensions, the spellings
of os.arch, glibc against musl, ldd running only on Linux, and the
refusal of platforms it cannot name. One test asks Gradle for the
platform of the JVM running it, which on CI's Linux jobs runs the real
ldd. The plugin no longer depends on platform, exec, providers and
safe-exec-commandline.

Author: abashev

gradle-open-java-format/build.gradle

@@ -23,7 +23,6 @@ dependencies {
     implementation libs.guava
     implementation project(':open-java-format-spi')
     implementation project(':open-java-format-jdk-bootstrap')
-    implementation libs.palantir.platform
     implementation libs.ideaConfiguration.gradlePlugin
 
     testImplementation project(':open-java-format')

gradle-open-java-format/src/main/java/com/palantir/javaformat/gradle/NativeImageFormatProviderPlugin.java

@@ -17,20 +17,18 @@
 package com.palantir.javaformat.gradle;
 
 import com.google.common.base.Preconditions;
-import com.palantir.platform.Architecture;
-import com.palantir.platform.GradleOperatingSystem;
-import com.palantir.platform.OperatingSystem;
 import java.util.Collections;
+import javax.inject.Inject;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.type.ArtifactTypeDefinition;
 import org.gradle.api.provider.Provider;
-import org.gradle.api.tasks.Nested;
+import org.gradle.api.provider.ProviderFactory;
 
 public abstract class NativeImageFormatProviderPlugin implements Plugin<Project> {
 
-    @Nested
-    protected abstract GradleOperatingSystem getOs();
+    @Inject
+    protected abstract ProviderFactory getProviderFactory();
 
     static final String NATIVE_CONFIGURATION_NAME = "palantirJavaFormatNative";
 
@@ -40,38 +38,27 @@ public void apply(Project rootProject) {
                 rootProject == rootProject.getRootProject(),
                 "May only apply dev.openjavaformat.java-format-provider to the root project");
 
-        Provider<OperatingSystem> operatingSystem = getOs().getOperatingSystem();
+        Provider<NativePlatform> platform = NativePlatform.current(getProviderFactory());
         String implementationVersion = JavaFormatExtension.class.getPackage().getImplementationVersion();
         rootProject.getConfigurations().register(NATIVE_CONFIGURATION_NAME, conf -> {
             conf.setDescription("Internal configuration for resolving the open-java-format native image");
             conf.setCanBeConsumed(false);
             conf.setCanBeResolved(true);
             conf.defaultDependencies(deps -> {
-                deps.addAllLater(operatingSystem.map(os -> Collections.singletonList(rootProject
+                deps.addAllLater(platform.map(p -> Collections.singletonList(rootProject
                         .getDependencies()
                         .create(String.format(
-                                "dev.openjavaformat:open-java-format-native:%s:nativeImage-%s_%s@%s",
-                                implementationVersion,
-                                os.uiName(),
-                                Architecture.get().uiName(),
-                                getExtension(os))))));
+                                "dev.openjavaformat:open-java-format-native:%s:%s@%s",
+                                implementationVersion, p.classifier(), p.extension())))));
             });
             conf.getAttributes().attribute(ArtifactTypeDefinition.ARTIFACT_TYPE_ATTRIBUTE, "executable-nativeImage");
         });
         rootProject.getDependencies().registerTransform(ExecutableTransform.class, transformSpec -> {
             transformSpec
                     .getFrom()
                     .attributeProvider(
-                            ArtifactTypeDefinition.ARTIFACT_TYPE_ATTRIBUTE,
-                            operatingSystem.map(NativeImageFormatProviderPlugin::getExtension));
+                            ArtifactTypeDefinition.ARTIFACT_TYPE_ATTRIBUTE, platform.map(NativePlatform::extension));
             transformSpec.getTo().attribute(ArtifactTypeDefinition.ARTIFACT_TYPE_ATTRIBUTE, "executable-nativeImage");
         });
     }
-
-    static String getExtension(OperatingSystem operatingSystem) {
-        if (operatingSystem.equals(OperatingSystem.WINDOWS)) {
-            return "exe";
-        }
-        return "bin";
-    }
 }

gradle-open-java-format/src/main/java/com/palantir/javaformat/gradle/NativeImageSupport.java

@@ -16,36 +16,22 @@
 
 package com.palantir.javaformat.gradle;
 
-import com.palantir.platform.Architecture;
-import com.palantir.platform.GradleOperatingSystem;
-import com.palantir.platform.OperatingSystem;
 import javax.inject.Inject;
 import org.gradle.api.provider.ProviderFactory;
-import org.gradle.api.tasks.Nested;
 
 public abstract class NativeImageSupport {
 
-    @Nested
-    protected abstract GradleOperatingSystem getOs();
-
     @Inject
     protected abstract ProviderFactory getProviderFactory();
 
     public boolean isNativeImageConfigured() {
         return isNativeFlagEnabled() && isNativeImageSupported();
     }
 
-    /**
-     * The platforms a native image is published for, and therefore the only ones where it can be
-     * resolved. macOS is supported on both architectures: the x86-64 image used to be excluded
-     * because nobody built it, and .github/workflows/ci.yml now does. Windows has an image for
-     * x86-64 only, and musl none: no job produces them.
-     */
+    /** Whether this platform has a published native image; see NativePlatform's PUBLISHED. */
     private boolean isNativeImageSupported() {
-        return getOs().getOperatingSystem()
-                .map(os -> os.equals(OperatingSystem.LINUX_GLIBC)
-                        || os.equals(OperatingSystem.MACOS)
-                        || (os.equals(OperatingSystem.WINDOWS) && Architecture.get() == Architecture.X86_64))
+        return NativePlatform.current(getProviderFactory())
+                .map(NativePlatform::isPublished)
                 .get();
     }
 

gradle-open-java-format/src/main/java/com/palantir/javaformat/gradle/NativePlatform.java

@@ -0,0 +1,125 @@
+/*
+ * (c) Copyright 2026 Palantir Technologies Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.palantir.javaformat.gradle;
+
+import java.util.Locale;
+import java.util.Set;
+import java.util.function.Supplier;
+import org.gradle.api.provider.Provider;
+import org.gradle.api.provider.ProviderFactory;
+import org.gradle.process.ExecOutput;
+
+/**
+ * A platform in the names open-java-format-native publishes its images under: the classifier
+ * {@code nativeImage-<os>_<arch>}. buildSrc's open-java-format.native-platform names the images the build
+ * produces the same way, and NativePlatformTest pins the names of the published ones.
+ */
+record NativePlatform(OperatingSystem operatingSystem, Architecture architecture) {
+
+    enum OperatingSystem {
+        MACOS,
+        LINUX_GLIBC,
+        LINUX_MUSL,
+        WINDOWS
+    }
+
+    enum Architecture {
+        X86,
+        X86_64,
+        AARCH64
+    }
+
+    /**
+     * The platforms a native image is published for, and therefore the only ones where it can be resolved.
+     * macOS has an image for both architectures: the x86-64 one used to be missing because nobody built it,
+     * and .github/workflows/ci.yml now does. Windows has one for x86-64 only, and musl none: no job produces
+     * them.
+     */
+    private static final Set<NativePlatform> PUBLISHED = Set.of(
+            new NativePlatform(OperatingSystem.LINUX_GLIBC, Architecture.X86_64),
+            new NativePlatform(OperatingSystem.LINUX_GLIBC, Architecture.AARCH64),
+            new NativePlatform(OperatingSystem.MACOS, Architecture.X86_64),
+            new NativePlatform(OperatingSystem.MACOS, Architecture.AARCH64),
+            new NativePlatform(OperatingSystem.WINDOWS, Architecture.X86_64));
+
+    /** The platform of the JVM that runs Gradle. */
+    static Provider<NativePlatform> current(ProviderFactory providers) {
+        ExecOutput ldd = providers.exec(spec -> {
+            spec.commandLine("ldd", "--version");
+            // musl's ldd prints its version to stderr and exits with 1.
+            spec.setIgnoreExitValue(true);
+        });
+        Supplier<String> lddVersion = () -> ldd.getStandardOutput().getAsText().get()
+                + ldd.getStandardError().getAsText().get();
+        return providers
+                .systemProperty("os.name")
+                .zip(providers.systemProperty("os.arch"), (osName, osArch) -> of(osName, osArch, lddVersion));
+    }
+
+    /** The platform for the given os.name and os.arch; lddVersion is asked only on Linux. */
+    static NativePlatform of(String osName, String osArch, Supplier<String> lddVersion) {
+        return new NativePlatform(operatingSystem(osName, lddVersion), architecture(osArch));
+    }
+
+    boolean isPublished() {
+        return PUBLISHED.contains(this);
+    }
+
+    String classifier() {
+        return "nativeImage-" + uiName(operatingSystem) + "_" + uiName(architecture);
+    }
+
+    /** native-image names the Windows binary .exe, and the image is published with that extension. */
+    String extension() {
+        return operatingSystem == OperatingSystem.WINDOWS ? "exe" : "bin";
+    }
+
+    private static OperatingSystem operatingSystem(String osName, Supplier<String> lddVersion) {
+        String name = osName.toLowerCase(Locale.ROOT);
+        if (name.startsWith("mac")) {
+            return OperatingSystem.MACOS;
+        }
+        if (name.startsWith("windows")) {
+            return OperatingSystem.WINDOWS;
+        }
+        if (name.startsWith("linux")) {
+            // A glibc binary does not run on musl, and ldd is what tells the two apart.
+            String libc = lddVersion.get().toLowerCase(Locale.ROOT);
+            if (libc.contains("glibc") || libc.contains("gnu libc")) {
+                return OperatingSystem.LINUX_GLIBC;
+            }
+            if (libc.contains("musl")) {
+                return OperatingSystem.LINUX_MUSL;
+            }
+            throw new UnsupportedOperationException("Cannot tell glibc from musl: ldd --version printed " + libc);
+        }
+        throw new UnsupportedOperationException("No native image name for the operating system " + osName);
+    }
+
+    private static Architecture architecture(String osArch) {
+        return switch (osArch.toLowerCase(Locale.ROOT)) {
+            case "x86_64", "x64", "amd64" -> Architecture.X86_64;
+            case "arm", "arm64", "aarch64" -> Architecture.AARCH64;
+            case "x86", "i686" -> Architecture.X86;
+            default -> throw new UnsupportedOperationException("No native image name for the architecture " + osArch);
+        };
+    }
+
+    private static String uiName(Enum<?> value) {
+        return value.name().toLowerCase(Locale.ROOT).replace('_', '-');
+    }
+}

gradle-open-java-format/src/test/java/com/palantir/javaformat/gradle/NativePlatformTest.java

@@ -0,0 +1,154 @@
+/*
+ * (c) Copyright 2026 Palantir Technologies Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.palantir.javaformat.gradle;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import com.palantir.javaformat.gradle.NativePlatform.Architecture;
+import com.palantir.javaformat.gradle.NativePlatform.OperatingSystem;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UncheckedIOException;
+import java.nio.file.Path;
+import java.util.function.Supplier;
+import org.gradle.api.Project;
+import org.gradle.testfixtures.ProjectBuilder;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+final class NativePlatformTest {
+
+    private static final String GLIBC = "ldd (Ubuntu GLIBC 2.39-0ubuntu8) 2.39";
+
+    // The classifiers open-java-format-native has on Maven Central, and the names buildSrc's
+    // open-java-format.native-platform gives the images it builds.
+    @CsvSource(
+            delimiter = '|',
+            value = {
+                "Linux      | aarch64 | ldd (GNU libc) 2.41                   | nativeImage-linux-glibc_aarch64 | bin",
+                "Linux      | amd64   | ldd (Ubuntu GLIBC 2.39-0ubuntu8) 2.39 | nativeImage-linux-glibc_x86-64  | bin",
+                "Mac OS X   | aarch64 |                                       | nativeImage-macos_aarch64       | bin",
+                "Mac OS X   | x86_64  |                                       | nativeImage-macos_x86-64        | bin",
+                "Windows 11 | amd64   |                                       | nativeImage-windows_x86-64      | exe"
+            })
+    @ParameterizedTest
+    void names_each_published_image(
+            String osName, String osArch, String lddVersion, String classifier, String extension) {
+        NativePlatform platform = NativePlatform.of(osName, osArch, lddOnLinuxOnly(lddVersion));
+
+        assertThat(platform.isPublished()).isTrue();
+        assertThat(platform.classifier()).isEqualTo(classifier);
+        assertThat(platform.extension()).isEqualTo(extension);
+    }
+
+    @CsvSource(
+            delimiter = '|',
+            value = {
+                "Linux      | i686    | ldd (Ubuntu GLIBC 2.39-0ubuntu8) 2.39 | nativeImage-linux-glibc_x86",
+                "Linux      | x86_64  | musl libc (x86_64)                    | nativeImage-linux-musl_x86-64",
+                "Windows 11 | aarch64 |                                       | nativeImage-windows_aarch64"
+            })
+    @ParameterizedTest
+    void knows_there_is_no_image_for_other_platforms(
+            String osName, String osArch, String lddVersion, String classifier) {
+        NativePlatform platform = NativePlatform.of(osName, osArch, lddOnLinuxOnly(lddVersion));
+
+        assertThat(platform.isPublished()).isFalse();
+        assertThat(platform.classifier()).isEqualTo(classifier);
+    }
+
+    @Test
+    void tells_glibc_from_musl_with_ldd() {
+        assertThat(NativePlatform.of("Linux", "amd64", () -> GLIBC).operatingSystem())
+                .isEqualTo(OperatingSystem.LINUX_GLIBC);
+        assertThat(NativePlatform.of("Linux", "amd64", () -> "ldd (GNU libc) 2.41")
+                        .operatingSystem())
+                .isEqualTo(OperatingSystem.LINUX_GLIBC);
+        // musl's ldd prints its version to stderr, after an empty stdout.
+        assertThat(NativePlatform.of("Linux", "amd64", () -> "musl libc (x86_64)\nVersion 1.2.5\n")
+                        .operatingSystem())
+                .isEqualTo(OperatingSystem.LINUX_MUSL);
+    }
+
+    @CsvSource({
+        "aarch64, AARCH64",
+        "AMD64,   X86_64",
+        "amd64,   X86_64",
+        "arm,     AARCH64",
+        "arm64,   AARCH64",
+        "i686,    X86",
+        "x64,     X86_64",
+        "x86,     X86",
+        "x86_64,  X86_64"
+    })
+    @ParameterizedTest
+    void reads_every_spelling_of_os_arch(String osArch, Architecture architecture) {
+        assertThat(NativePlatform.of("Mac OS X", osArch, NativePlatformTest::noLdd)
+                        .architecture())
+                .isEqualTo(architecture);
+    }
+
+    @Test
+    void refuses_what_it_cannot_name() {
+        assertThatThrownBy(() -> NativePlatform.of("FreeBSD", "amd64", NativePlatformTest::noLdd))
+                .isInstanceOf(UnsupportedOperationException.class)
+                .hasMessageContaining("FreeBSD");
+        assertThatThrownBy(() -> NativePlatform.of("Linux", "riscv64", () -> GLIBC))
+                .isInstanceOf(UnsupportedOperationException.class)
+                .hasMessageContaining("riscv64");
+        assertThatThrownBy(() -> NativePlatform.of("Linux", "amd64", () -> "ldd: unrecognized option '--version'"))
+                .isInstanceOf(UnsupportedOperationException.class)
+                .hasMessageContaining("Cannot tell glibc from musl");
+    }
+
+    // On Linux this runs the real ldd through Gradle's ProviderFactory, which CI's ubuntu jobs exercise.
+    @Test
+    void reads_the_platform_of_the_jvm_running_gradle(@TempDir Path projectDir) {
+        Project project =
+                ProjectBuilder.builder().withProjectDir(projectDir.toFile()).build();
+
+        assertThat(NativePlatform.current(project.getProviders()).get())
+                .isEqualTo(NativePlatform.of(
+                        System.getProperty("os.name"), System.getProperty("os.arch"), NativePlatformTest::runLdd));
+    }
+
+    /** The table's ldd output, or for an empty cell, an ldd that must not run: the platform is not Linux. */
+    private static Supplier<String> lddOnLinuxOnly(String lddVersion) {
+        return lddVersion == null ? NativePlatformTest::noLdd : () -> lddVersion;
+    }
+
+    private static String noLdd() {
+        throw new AssertionError("ldd must only run on Linux");
+    }
+
+    private static String runLdd() {
+        try {
+            Process process = new ProcessBuilder("ldd", "--version")
+                    .redirectErrorStream(true)
+                    .start();
+            try (InputStream output = process.getInputStream()) {
+                return new String(output.readAllBytes(), UTF_8);
+            }
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+    }
+}