Helidon 27 is a feature release for Java 27 that changes several of Helidon’s programming contracts rather than simply adding APIs. It introduces the preview Helidon Declarative model, replaces the previous SE messaging implementation with a synchronous graph API, and adds incubating Data JDBC modules. Helidon 4 remains the long-term-support line, so the upgrade decision depends heavily on whether an application uses MicroProfile, existing messaging connectors, or production-critical database code.
What Helidon 27 changes
The Helidon project released Helidon 27.0.0 on 22 September 2026 as a feature release. It is the first release to fully adopt the JDK Tip & Tail development model: Helidon feature releases track JDK releases, and each feature release raises the minimum Java version. Helidon 4 is the current LTS line, while Helidon 29 is planned as the next LTS release.
As an Amazon Associate I earn from qualifying purchases.
| Area | Helidon 4 | Helidon 27 |
|---|---|---|
| Release role | LTS line | Feature release |
| Minimum Java | Not stated in the release material for this comparison | Java 27 |
| SE messaging | Previous reactive-streams implementation | Messaging graph API with synchronous delivery |
| MicroProfile | Supported in the 4.5.x line | Not available at the time of the v27 upgrade guidance |
| Declarative programming | Not the v27 model | Preview annotations and build-time generation |
| Data JDBC | Not the v27 module set | Incubating declarative and imperative JDBC APIs |
The Java 27 requirement is a runtime and build prerequisite, not an optional optimization. Teams need a JDK 27 toolchain for compilation, tests and deployment before changing Helidon dependencies.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Helidon Declarative moves work to build time
Helidon Declarative is an inversion-of-control style programming model that keeps application logic imperative while generating framework code during compilation. It is based on Helidon Injection, and declarative capabilities are delivered in the same feature modules instead of requiring a separate dependency stack. Annotation processing and generated classes replace much of the runtime reflection and bytecode manipulation normally associated with dependency injection.
What the model changes
- Validation: annotated contracts can be checked while the project is compiled.
- Runtime behavior: generated code avoids relying on runtime discovery for the supported declarative paths.
- Build pipeline: annotation processing and code generation become part of every clean build and must be handled by CI and IDE configurations.
- Stability: Declarative is a preview feature. In a new major version, its APIs may change without the usual deprecation process.
This makes the model a better fit for fixed application structure than for operations whose shape is chosen dynamically at runtime. Projects should evaluate generated-code review, incremental-build behavior and preview-API risk before adopting it broadly.
MicroProfile applications have a hard upgrade boundary
MicroProfile support was decoupled from the core repository and was not available for Helidon 27 when the v27 upgrade guidance was published. Applications built around Helidon MP, CDI, JAX-RS or other MicroProfile specification APIs should remain on Helidon 4.5.x unless the team is prepared to replace that programming model with Helidon Core APIs.
A safer migration sequence
- Move the existing application to the latest Helidon 4.5.x release.
- Build and test that version on JDK 27 so Java-related issues are separated from Helidon API changes.
- Remove deprecation warnings and record every MicroProfile, Jersey, LRA and integration dependency.
- Check the Helidon Extensions repository for a replacement for each dependency before removing the MicroProfile layer.
- Only then prototype the equivalent Helidon Core implementation and run endpoint, security, transaction and integration tests.
There is no direct, drop-in MicroProfile-to-Helidon-27 path documented by the project. Treat a move as an architectural migration rather than a version-only upgrade.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Clear out junk files and repair common Windows errors3Scan for outdated or missing drivers - takes under a minuteRank #2
Messaging changes from reactive topology to a synchronous graph
Helidon 27 keeps the Maven coordinates io.helidon.messaging:helidon-messaging but replaces the previous SE implementation. Source and configuration changes are required even though the artifact coordinates look familiar.
Core API migration
| Earlier SE or MicroProfile usage | Helidon 27 equivalent |
|---|---|
Messaging.builder() |
MessagingGraph.builder() |
| Reactive-streams topology built from channels | Named channels assembled in a messaging graph |
| Reactive emitter behavior | emit(...), completing synchronously after required outputs finish |
MicroProfile Message |
io.helidon.messaging.Message |
Message.of(...) |
Message.create(...) |
getPayload() |
entity() |
| Acknowledgement callbacks | No acknowledgement callback on the new message type; handlers finish delivery work before returning and throw on failure |
The new API also exposes declarative annotations including @Messaging.ReceiveFrom, @Messaging.SendTo, @Messaging.Entity, @Messaging.HeaderParam and @Messaging.OnFailure.
Configuration and connectors
Configuration moves from mp.messaging.* to a messaging tree. Connector instances are declared under messaging.connector, and incoming or outgoing named channels refer to those instances. Existing connector artifacts are not automatically binary-compatible with the replacement implementation. Use a connector release built for the Helidon 27 API, or stay on Helidon 4.5.x until the required connector is available.
Delivery and retry semantics
An emission enters the runtime as a message batch. Output processing is sequential, and the first failure propagates to the caller. Outputs that completed before the failure are not rolled back. Retrying the batch can therefore repeat side effects, so handlers that write to external systems need idempotency keys, deduplication or an equivalent recovery design.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Data JDBC offers two programming models
Helidon Data JDBC executes application-defined SQL through JDBC and supports both a generated repository style and a runtime-selected client style. The two models can coexist in one application and provide consistent result mapping, transaction participation and resource management.
Declarative repositories
An annotated repository interface defines the supported operations. Helidon validates the contract and generates its implementation during compilation. Relevant annotations include @Data.Repository, @Data.Provider("jdbc"), @Jdbc.Client, @Jdbc.Statement, @Jdbc.Execution, @Jdbc.GeneratedKeys and @Jdbc.RowMapper. Compilation requires the Helidon annotation-processor bundle and helidon-data-jdbc-codegen.
Rank #4
This model is suited to a known set of SQL operations because malformed contracts can fail the build instead of waiting for a production request. Each repository method executes one prepared SQL statement, binds its parameters and maps the complete result before returning.
Imperative JdbcClient
The imperative model uses JdbcClient to construct operations at runtime. It is the better choice when SQL, filters or projections are selected dynamically and cannot be represented cleanly by a fixed repository contract. It still uses prepared SQL, configured JDBC clients or data sources, managed resources and local JDBC transaction participation.
| Decision factor | Declarative repository | Imperative JdbcClient |
|---|---|---|
| SQL shape | Fixed operations declared on an interface | Selected or assembled at runtime |
| Validation | Contract and generated implementation checked at compile time | More responsibility remains in application code and runtime tests |
| Build requirements | Annotation processing and Data JDBC code generation | Data JDBC runtime and client configuration |
| Flexibility | Lower, in exchange for a stable contract | Higher for dynamic queries |
| Transactions and resources | Managed by the Data JDBC integration | Managed by the same integration through the client |
| Maturity | Incubating; not production ready | |
Requirements and status
- Helidon Data JDBC runtime modules.
- A JDBC driver for the target database.
- A configured Helidon JDBC client or data source.
- For repositories, the annotation-processor bundle and
helidon-data-jdbc-codegen.
The project explicitly describes Data JDBC as incubating and not production ready. APIs and behavior may change incompatibly or be removed in a future release. Use it for evaluation, internal prototypes or controlled adoption with a rollback plan rather than making it the foundation of a system that requires a stable persistence API today.
Best Value
New modules in the Helidon 27 inventory
The v27 API index lists io.helidon.data.jdbc, io.helidon.data.jdbc.codegen, io.helidon.data.jdbc.lexical, io.helidon.data.sql.datasource, io.helidon.data.sql.datasource.hikari, io.helidon.data.sql.datasource.jdbc, io.helidon.data.sql.datasource.ucp, io.helidon.messaging and io.helidon.declarative.codegen.messaging. Maven metadata for version 27.0.0 records additions including io.helidon.data.jdbc:helidon-data-jdbc, helidon-data-jdbc-codegen, helidon-data-jdbc-lexical and io.helidon.messaging:helidon-messaging.
Who should move to Helidon 27 now?
- Good candidates: new services targeting Java 27, teams wanting the graph-based messaging API, and projects able to isolate preview or incubating modules behind internal interfaces.
- Wait on Helidon 4.5.x: applications dependent on MicroProfile APIs, CDI/JAX-RS integrations without v27 replacements, or connectors that have not published compatible releases.
- Use caution with Data JDBC: its compile-time repository model is attractive for fixed SQL, but the incubating status rules out treating it as a stable, production-ready persistence layer.
Helidon 27 is therefore a deliberate platform transition: Java 27 and the new APIs unlock the declarative, messaging and data work, while MicroProfile compatibility, connector availability and Data JDBC maturity determine whether an existing service can make the move safely.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Free tools Windows power users keep installed
One-click scans. No signup required.
