Frameworks built from your repository
The builder reads your pom.xml, recognises the framework and runs the right native build in a container that holds GraalVM 25 and Maven. You do not have to say which framework you use.
| Framework | Native build (Maven) | Port variable | Health path | Required dependency | Verified with |
|---|---|---|---|---|---|
| Quarkus | mvn package -Dnative -Dquarkus.native.container-build=true | QUARKUS_HTTP_PORT | /q/health/ready | quarkus-smallrye-health | Quarkus 4 |
| Spring Boot | mvn -Pnative native:compile | SERVER_PORT | /actuator/health | spring-boot-starter-actuator | Spring Boot 4.0.8 |
| Micronaut | mvn package -Dpackaging=native-image | MICRONAUT_SERVER_PORT | /health | micronaut-management | Micronaut 5.2.1 |
| Helidon | mvn package -Pnative-image | SERVER_PORT | /observe/health/ready | helidon-webserver-observe-health | Helidon 4.5.5 |
| Python (FastAPI) | pip install --require-hashes | PORT | /health/ready | gluonify[fastapi] | CPython 3.13.5 · FastAPI 0.115.12 |
Quarkus is the framework of the platform itself. Spring Boot needs version 3 or later (ahead-of-time processing). Helidon 4.2.0 fails under GraalVM 25: use 4.5.5 or later. The health path of Helidon 3 is /health/ready.
Bringing your application: from Git
From Git: the builder clones the repository, compiles the native executable, publishes it with its SHA-256 and deploys it, then checks the health path (and the wake time when sleep mode is on).
What your application must do
- Be a native executable for Linux: glibc 2.34 or later by default, or static musl for the smallest images. One executable per architecture (arm64 and x86_64).
- Listen on the port the platform gives it (the variable above is set for you) and answer 200 on the health path when ready: an instance that does not answer receives no traffic.
- Need neither a JVM nor writable executable memory: applications run in a sandbox with their own account, folder and network, no capability and a seccomp filter.
Detection and gluonify.json
The framework is read from the pom.xml of the module and of its parents. The order of precedence is the request, then an optional gluonify.json at the root of the module, then detection. If several frameworks are found, the build stops and asks you to choose.
{"framework": "spring-boot", "port": 8080, "health": "/actuator/health", "portEnv": "SERVER_PORT"}Libraries for your application: the Maven repository
The platform publishes the Java libraries its services offer to applications in a Maven repository served by Sea: https://images.gluonify.io/maven. Reading is public and needs no account; only the platform publisher can publish, and a published version never changes. The builder adds this repository to the Maven and Gradle builds it runs, next to Maven Central, so nothing is to be configured on the platform; declare it yourself on your own machine and in your continuous integration. The libraries are the Java client of Crystallon (produce a PDF from a stored template, called by its name, with generated code for the data it expects) and, since 0.6.1, the SDK with no configuration: for a Quarkus application, gluonify-plasma-quarkus brings everything, and gluonify-plasma-testing gives fake services to the tests.
Maven
<repositories>
<repository>
<id>gluonify</id>
<url>https://images.gluonify.io/maven</url>
</repository>
</repositories>
<dependency>
<groupId>io.gluonify.plasma</groupId>
<artifactId>gluonify-plasma-quarkus</artifactId>
<version>0.7.2</version>
</dependency>
<dependency>
<groupId>io.gluonify.plasma</groupId>
<artifactId>gluonify-plasma-testing</artifactId>
<version>0.7.2</version>
<scope>test</scope>
</dependency>Gradle (Kotlin DSL)
repositories {
mavenCentral()
maven("https://images.gluonify.io/maven")
}
dependencies {
implementation("io.gluonify.plasma:gluonify-plasma-quarkus:0.7.2")
testImplementation("io.gluonify.plasma:gluonify-plasma-testing:0.7.2")
}The groupId is io.gluonify.plasma. The version is the platform version (0.7.2 at the time of writing). Only the dependencies of your application are resolved from this repository, not Maven or Gradle plugins. An application with crystallon in "uses" (inferred by Bup from the SDK module, or declared) receives from the platform the address of Crystallon and a short-lived Charm token with the render role: the node agent drops it in a read-only file, renews it before it expires without restarting the application, and the SDK reads it by itself at every call (CrystallonTokens.platform() is the strict form, for a client built by hand); an application acting for a signed-in person forwards that person's token instead. The application token carries the default organisation of Crystallon.
No configuration
Reaching a service of the platform takes 0 lines of configuration: no URL, no token, no property. The application injects the client (gluonify-plasma-quarkus) and the SDK (gluonify-plasma-services) finds the address and the token according to where the application runs. It covers Crystallon and Fermion today. The order is the same for every service:
- An explicit override, for tests: GLUONIFY_SERVICE_<APP>_URL and GLUONIFY_<APP>_TOKEN as system properties.
- On the platform: the address and the application token that the platform provides for each service in "uses". Since SDK 0.7.1 Bup infers "uses" at build time: each client module of the SDK carries a marker (META-INF/gluonify/services/<service>) and Bup adds the service as optional (?crystallon). Nothing to write; gluonify.json only adds what the SDK cannot detect, such as a direct HTTP call to another application or Charm for OIDC. If the service is missing, the message says why.
- On your machine: after gluonify login <zone> (gluonify.lan for the development cluster), the public addresses of the document https://<zone>/.well-known/gluonify and your developer token, renewed by itself. This document is off in production by default.
- Otherwise, a clear error that says what to do: gluonify login, or fake services in tests.
On your machine (development), once
gluonify login gluonify.lan # once, in your browser (PKCE): the SDK then finds the services of the zone
On the platform (production): nothing to declare
# nothing to declare: Bup detects the SDK modules at build time # gluonify-plasma-crystallon-client -> "uses": ["?crystallon"] (optional service)
Only for additions: gluonify.json
{"uses": ["charm", "orders"]}In the code (Quarkus)
@Inject CrystallonClient crystallon; // no URL, no token, no property: 0 lines of configuration
RenderedPdf pdf = crystallon.byName("Gluonify invoice").render(payload);gluonify is the command line of the SDK (jar gluonify-plasma-cli: login, logout, status, token). You sign in in the browser, at Charm, with PKCE: no password goes through the command line. In tests, GluonifyTestServices.start() (gluonify-plasma-testing) starts a fake Crystallon in memory, with nothing to configure. The starter application gluonify-source does exactly this.
Limits
Maven and Gradle projects (Groovy or Kotlin DSL) are both built, framework by framework as the support matrix of the builder lists. Libraries with native code (AWT, RocksDB, GSSAPI, PKCS#11) do not suit the static musl mode. Another language that produces a native Linux executable meeting the contract can be deployed from a binary address, but the builder does not compile it and we have not tested it.