quarkusio/quarkus · warning · QuarkusCommandException

Failed to determine a compatible Quarkus version for the req

Error message

Failed to determine a compatible Quarkus version for the requested extensions: ${extensionKeys}

What it means

When computing a recommended project state, ProjectUpdateInfos.getRecommendedOrigins() feeds each extension's candidate origins into OriginSelector to find a set of platform/catalog combinations compatible with ALL extensions. When OriginSelector returns null (no mutually compatible combination exists), a QuarkusCommandException listing all requested extensions is thrown. resolveRecommendedState() catches it, logs a warning, and returns the unchanged current state.

Source

Thrown at independent-projects/tools/devtools-common/src/main/java/io/quarkus/devtools/project/update/ProjectUpdateInfos.java:210

        return stateBuilder.build();
    }

    private static List<ExtensionCatalog> getRecommendedOrigins(List<Extension> extensions)
            throws QuarkusCommandException {
        final List<ExtensionOrigins> extOrigins = new ArrayList<>(extensions.size());
        for (Extension e : extensions) {
            addOrigins(extOrigins, e);
        }

        final OriginCombination recommendedCombination = OriginSelector.of(extOrigins).calculateRecommendedCombination();
        if (recommendedCombination == null) {
            final StringBuilder buf = new StringBuilder();
            buf.append("Failed to determine a compatible Quarkus version for the requested extensions: ");
            buf.append(extensions.get(0).getArtifact().getKey().toGacString());
            for (int i = 1; i < extensions.size(); ++i) {
                buf.append(", ").append(extensions.get(i).getArtifact().getKey().toGacString());
            }
            throw new QuarkusCommandException(buf.toString());
        }
        return recommendedCombination.getUniqueSortedCatalogs();
    }

    private static void addOrigins(final List<ExtensionOrigins> extOrigins, Extension e) {
        ExtensionOrigins.Builder eoBuilder = null;
        for (ExtensionOrigin o : e.getOrigins()) {
            if (o instanceof ExtensionCatalog c) {
                final OriginPreference op = (OriginPreference) c.getMetadata().get(Constants.REGISTRY_CLIENT_ORIGIN_PREFERENCE);
                if (op == null) {
                    continue;
                }
                if (eoBuilder == null) {
                    eoBuilder = ExtensionOrigins.builder(e.getArtifact().getKey());
                }
                eoBuilder.addOrigin(c, op);
            }
        }

View on GitHub (pinned to e1c734241f)

Solutions

Update or remove the outlier extension(s) listed in the message so all extensions belong to one Quarkus platform stream
Refresh the registry cache (delete ~/.quarkus/repository cache or set quarkus.registry client to fetch fresh metadata) so current platform combinations are visible
Check configured registries in ~/.m2/settings.xml / quarkus registry config; ensure the platform catalog containing a compatible version is enabled
Note this is caught and downgraded to a warning by resolveRecommendedState — review the log output; if used via getRecommendedOrigins directly, handle QuarkusCommandException

Example fix

<!-- before: mixing incompatible streams -->
<dependency>io.quarkus:quarkus-rest:2.16-only-ext</dependency>
<dependency>io.quarkus:quarkus-vertx:3.x-only-ext</dependency>
<!-- after: align all extensions to one platform stream -->
<dependencyManagement>import io.quarkus.platform:quarkus-bom:3.15.1</dependencyManagement>
<dependency>io.quarkus:quarkus-vertx</dependency> <!-- version from BOM -->

Defensive patterns

Strategy: fallback

Validate before calling

// pre-check overlap of platform origins across extensions
Set<String> allStreams = recommendedCatalog.getExtensions().stream()
    .flatMap(e -> e.getOrigins().stream())
    .map(ExtensionOrigin::getPlatformKey).collect(Collectors.toSet());
if (allStreams.size() > 1) log.warn("Extensions span multiple platform streams: " + allStreams);

Try / catch

ProjectState recommended;
try {
    recommended = ProjectUpdateInfos.resolveRecommendedState(currentState, catalog, log);
} catch (QuarkusCommandException e) {
    log.warn("No compatible platform combination; keeping current state");
    recommended = currentState;
}

Prevention

Keep all extensions from a single Quarkus platform stream
Refresh the Quarkus registry cache after platform releases/removals
Remove or upgrade orphaned extensions with no metadata in the target catalog
Check the warning list of extensions lacking compatibility info and resolve those first

When it happens

Trigger: Calling ProjectUpdateInfos.resolveRecommendedState(currentState, recommendedCatalog, log) when the current extensions have no common compatible Quarkus platform version in the configured registries — e.g. extensions whose latest origins belong to disjoint platform streams with no overlapping version combination.

Common situations: Projects mixing extensions available only in an older platform stream with extensions only in a newer stream, custom/locally-built extensions registered with origin-preference metadata that no registry platform provides, stale registry cache after a platform removal, pinning extensions across major Quarkus versions.

Related errors

AI-assisted analysis of quarkusio/quarkus@e1c734241f (2026-09-05). Data as JSON: /api/errors/7fa65a2396a0caa5. Report an issue: GitHub.