What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
Helidon 27, released on 22 September 2026, is a feature release that requires Java 27 and changes several core development paths. It introduces preview declarative programming, replaces the previous SE messaging topology with a graph API, and adds incubating Data JDBC modules. MicroProfile support is not available in Helidon 27 at publication, so existing MicroProfile applications generally need to remain on Helidon 4.5.x or be redesigned around Helidon Core APIs.
What Helidon 27 changes
Helidon 27 is the first Helidon release to fully adopt the JDK Tip & Tail software-development model. Feature releases align with JDK releases and raise the minimum Java version, while long-term-support releases are spaced farther apart. Helidon 4 remains the LTS line, and Helidon 29 is planned as the next LTS release.
| Release | Role | Runtime requirement or status |
|---|---|---|
| Helidon 27.0.0 | Feature release | Java 27 required |
| Helidon 4 | LTS line | Use for applications that depend on the existing MicroProfile programming model |
| Helidon 29 | Planned next LTS release | Future release |
The version change is therefore more than a routine dependency update. It affects the programming model, messaging source code and configuration, connector compatibility, and the way JDBC access can be declared.
The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Declarative programming is introduced as a preview
Helidon Declarative adds an inversion-of-control style while allowing application logic to remain imperative. Annotations describe components and operations, and Helidon Injection generates the required code during the build. This moves validation and wiring into compilation rather than relying on runtime reflection or bytecode manipulation.
What build-time generation means
- Annotation processing and code generation become part of the compilation pipeline.
- Many wiring errors can be identified before the application starts.
- Runtime reflection and bytecode enhancement are avoided for the generated paths.
- Declarative features live in the same Helidon feature modules instead of requiring a separate programming-model dependency.
Declarative APIs are preview APIs. In a new major version, they may change without the usual deprecation process, so teams should isolate preview usage and expect source changes when upgrading.
Declarative versus imperative code
| Decision factor | Declarative approach | Imperative approach |
|---|---|---|
| Operation set | Best when operations are known and stable | Best when operations are assembled or selected at runtime |
| Validation | Contracts can be checked during compilation | Checks occur as the application builds and executes operations |
| Runtime behavior | Generated wiring reduces runtime discovery work | Application code controls construction directly |
| API status | Declarative Helidon features are preview functionality | Existing imperative Core APIs remain the fallback when preview stability is unacceptable |
MicroProfile applications cannot make a direct Helidon 27 upgrade
MicroProfile support was decoupled from the core repository and is not available for Helidon 27 at the time of the upgrade guidance. Applications built around Helidon MP, CDI, JAX-RS or other MicroProfile specification APIs should stay on Helidon 4.5.x unless their programming model is replaced with Helidon Core APIs.
A safer migration sequence
- Move the existing application to the latest Helidon 4.5.x release.
- Build and test that application with the JDK required by the target environment.
- Remove deprecation warnings and record every MicroProfile, CDI, JAX-RS, Jersey, LRA and integration dependency.
- For each dependency, identify a replacement in Helidon Core or the Helidon Extensions repository.
- Only after the replacement design is complete, create a Helidon 27 branch and migrate the affected programming model.
This boundary is architectural rather than merely Maven-based: changing the version while leaving MP annotations and runtime assumptions in place does not produce a supported Helidon 27 application.
Rank #2
Messaging moves to a graph API
Helidon 27 replaces the previous SE messaging implementation while retaining the io.helidon.messaging:helidon-messaging coordinates. Existing applications must change both source code and configuration.
Source-level changes
| Earlier messaging code | Helidon 27 direction |
|---|---|
Messaging.builder() |
MessagingGraph.builder() |
| Reactive-streams topology built from channels | Named channels connected through a messaging graph |
MicroProfile Message |
Helidon io.helidon.messaging.Message |
Message.of(...) |
Message.create(...) |
getPayload() |
entity() |
| Acknowledgement callbacks | Handlers complete delivery work before returning and throw when processing fails |
| Asynchronous-style emission patterns | emit(...), which completes synchronously after required outputs finish |
Configuration changes
The old mp.messaging.* configuration tree is replaced by a messaging model. Connector instances are defined under messaging.connector; incoming and outgoing named channels refer to those instances. Connector artifacts built for the previous implementation are not automatically binary-compatible. Use a connector release built for the Helidon 27 API, or remain on Helidon 4.5.x until one is available.
Declarative messaging annotations
The new API exposes annotations including @Messaging.ReceiveFrom, @Messaging.SendTo, @Messaging.Entity, @Messaging.HeaderParam and @Messaging.OnFailure. These annotations let a build-time generated component describe channel input, output, entity mapping, headers and failure handling.
Failure and retry semantics
Each emission enters the runtime as a message batch. Output processing is sequential, and the first failure propagates to the caller. Outputs that already completed are not rolled back. Retrying a failed delivery can therefore repeat side effects, so handlers that write to external systems should be idempotent or use an explicit deduplication strategy.
Data JDBC adds two ways to execute SQL
Helidon Data JDBC executes application-defined SQL through JDBC and offers two models that can coexist in one application. The feature is incubating and is not production ready; APIs and behavior may change incompatibly or be removed in a future release.
Declarative repositories
A declarative repository is an annotated interface. Helidon validates the contract and generates its implementation during compilation. The model is suited to a fixed set of SQL operations that benefit from compile-time checking.
Rank #4
Relevant annotations include @Data.Repository, @Data.Provider("jdbc"), @Jdbc.Client, @Jdbc.Statement, @Jdbc.Execution, @Jdbc.GeneratedKeys and @Jdbc.RowMapper. Compilation uses the Helidon annotation-processor bundle together with helidon-data-jdbc-codegen.
Imperative JdbcClient operations
The imperative model uses JdbcClient to construct operations at runtime. It is the better fit when SQL, filters or statements are selected dynamically and cannot be known completely at compile time.
Recommended Free Tools
Common execution behavior
- The application supplies a JDBC driver and a configured JDBC client or data source.
- Operations use prepared SQL and bind parameters.
- Repository methods execute one prepared SQL statement.
- Complete results are mapped before a method returns.
- Operations can participate in Helidon local JDBC transactions.
- Resource management and result mapping are consistent across the declarative and imperative models.
| Model | Primary strength | Build requirements | Best fit |
|---|---|---|---|
| Declarative repository | Compile-time contract validation and generated implementation | Annotation-processor bundle and helidon-data-jdbc-codegen |
Stable, known SQL operations |
Imperative JdbcClient |
Runtime flexibility | Configured JDBC client or data source and driver | Dynamic SQL and runtime-selected operations |
New and expanded modules
The Helidon 27 API index lists these relevant modules:
Best Value
io.helidon.data.jdbcio.helidon.data.jdbc.codegenio.helidon.data.jdbc.lexicalio.helidon.data.sql.datasourceio.helidon.data.sql.datasource.hikariio.helidon.data.sql.datasource.jdbcio.helidon.data.sql.datasource.ucpio.helidon.messagingio.helidon.declarative.codegen.messaging
Maven metadata for version 27.0.0 records additions including helidon-data-jdbc, helidon-data-jdbc-codegen, helidon-data-jdbc-lexical and helidon-messaging; that artifact listing is dated 19 September 2026, shortly before the 22 September feature-release announcement.
How to choose an upgrade path
- Stay on Helidon 4.5.x: choose this when the application depends on MicroProfile, CDI, JAX-RS or connectors that have not yet been rebuilt for the new messaging API.
- Adopt Helidon 27 declarative features selectively: use this when compile-time wiring and generated repositories are valuable and preview API changes are acceptable.
- Use imperative APIs: choose Core APIs,
JdbcClientor explicit graph construction when runtime flexibility or maximum API control matters. - Plan messaging retries carefully: because completed outputs are not rolled back, make downstream effects idempotent before enabling automatic retries.
Helidon 27 is consequently best treated as a deliberate platform migration: first identify programming-model and connector dependencies, then move messaging and data access one bounded area at a time.
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.
