What's new in Red Hat build of Apache Camel 4.18

June 17, 2026
Ivo Bek
Related topics:
Artificial intelligenceData integrationDeveloper productivityIntegration
Related products:
Red Hat build of Apache CamelRed Hat Fuse

Red Hat build of Apache Camel 4.18 helps your integration teams bridge enterprise architectures with AI-driven semantic processing. This release accelerates developer productivity with major upgrades to the Kaoto integration design suite and the introduction of the self-contained Camel CLI Launcher. Upgrading to 4.18 establishes a stable foundation for your integration environments, serving as the final release on Spring Boot 3 before our planned transition to Spring Boot 4 later this year.

Apache Camel enhancements

Red Hat build of Apache Camel 4.18 introduces several enhancements and updates to the framework, running on Spring Boot 3.5 and Quarkus 3.33 with compatibility for HawtIO 4.4 and Kaoto 2.11 and later.

Red Hat refined and added support for the following components:

  • camel-file-watch: A consumer that listens for file creation, modification, and deletion events in a folder.
  • camel-openai: Provides integration with OpenAI and OpenAI-compatible APIs for chat completion and text embeddings using the official openai-java SDK.
  • camel-milvus: For interacting with the Milvus vector database.
  • camel-qdrant: For interacting with the Qdrant vector database.
  • camel-docling: Allows you to convert and process documents from formats like PDF, Word, and PowerPoint into structured formats such as Markdown, HTML, JSON, or plain text using IBM's Docling AI document parser.
  • camel-mina: Provides access to remote file systems over the SFTP protocol using the Apache MINA SSHD library.
  • camel-opentelemetry2: Features a more consistent design and provides an expanded implementation of the latest OpenTelemetry specifications and instrumentation. We recommend migrating your applications from camel-opentelemetry to the new camel-opentelemetry2 to make your projects ready for the future. The camel-opentelemetry component, which is based on an older tracing specification, is now deprecated and will be removed in a future release.

For the complete list of supported components, check the reference guides in the product documentation.

Several improvements were also made to already supported components, such as:

  • camel-kafka: A new saslAuthType option automatically derives the correct protocol and mechanism for PLAIN, SCRAM, SSL, OAUTH, and others, replacing verbose JAAS configurations.
  • camel-aws-s3: Added more bucket operations to the producer and enabled direct streaming from file sources during uploads.
  • camel-sql: Producers can now dynamically select the DataSource, and stored procedures now support named parameters.
  • camel-file: The clustered file lock (FileLockClusterView) is now resilient to split-brain scenarios, and file checksums are now stored as message headers.
  • camel-ftp: Now supports producer-based health checks, which you must explicitly enable.
  • camel-smb: Uses faster atomic move I/O operations instead of copy and delete.
  • camel-zipfile: Avoids loading entire archive contents into memory when paired with the Split EIP.
  • camel-mock: Can now assert JSON payloads while ignoring the ordering of elements.

The Simple expression language received a significant update, adding 50 new functions (bringing the total to 114) for string manipulation, math operations, and safe JSON quoting. You can also add custom first-class functions to simple expressions and use three new operators:

  • Elvis operator (?:): Returns the current value or a fallback default.
  • Ternary operator (? :): Standard conditional logic.
  • Chain operator (~>): Allows piping the result of one function directly into another for cleaner syntax, such as substring ~> trim ~> uppercase.

YAML DSL validation

A new validate plug-in checks YAML DSL files against the schema specification without needing to run Camel. Run the validation using the following command: mvn camel-yaml-dsl-validator:validate

Camel Core and REST updates

To strengthen your security posture, you can add custom keys to camel.main.additionalSensitiveKeywords for log masking.

The REST DSL supports camel-jacksonxml for XML binding, while JAXB remains the default. When using a contract-first approach, Camel captures JMX performance metrics and registers endpoints individually with the underlying HTTP server.

Camel CLI and JBang improvements

The camel debug command automatically detects and attaches to Camel Quarkus applications. Additionally, the camel-cli-debug dependency simplifies remote debugging for Spring Boot and Quarkus applications.

For route history and infrastructure management, camel get history --it provides a detailed step-by-step route execution history. The camel infra run command supports custom ports using the --port option, and camel cmd send can target infrastructure services directly.

Supported environments and certifications

Red Hat Enterprise Linux (RHEL) 8 and JDK 17 are now deprecated but remain supported for at least one year.

New certifications include RHEL 10, Windows Server 2025, and IBM Semeru Runtime CE for Power, IBM Z, and x86 architectures.

Camel on Spring Boot support transition from version 3 to 4

Red Hat build of Apache Camel 4.18 is the last version with support for Spring Boot 3. The next Camel 4.x release in Q4 will be based on Spring Boot 4.

With the community end-of-life (EOL) for open source Spring Boot 3 scheduled for June 2026, Red Hat is announcing a planned transition path for Red Hat build of Apache Camel 4 on Spring Boot 4 support so our customers can maintain a stable, supported integration environment. For more details on the support lifecycle, view the Red Hat Knowledgebase article.

Support for AI-driven semantic processing

Integrating AI into enterprise architectures doesn't require handing over control to unpredictable autonomous agents. Instead, the camel-openai component allows developers to treat large language models (LLMs) as reliable semantic processors, bridging the gap between AI models and enterprise data while strengthening your data governance. By using any OpenAI-compatible provider, working with open small language models, and enforcing structured outputs, the component turns text generation and embeddings into predictable, manageable steps within your standard integration routes.

Explore how to safely connect AI to enterprise systems like databases and message queues. The Camel OpenAI Patterns repository highlights three architectural patterns for building testable integrations: generative parsing for strictly structuring data, semantic routing for directing flow based on intent, and grounded pipelines to maintain contextual integrity without giving models direct access to sensitive systems. Read more at Making LLMs boring: From chatbots to semantic processors.

Implement retrieval-augmented generation (RAG) by combining camel-openai text embeddings with newly supported vector databases such as Qdrant, Milvus, or PostgreSQL with pgvector, where semantic similarity becomes a straightforward SQL query. This approach indexes documents and generates grounded answers while isolating AI from core databases. This also enables pipelines for use cases like semantic product searches or automated ticket deduplication. Read more in the article "Boring RAG" with PostgreSQL and check out our new quick starts:

Camel CLI Launcher replaces Camel JBang

The Camel CLI Launcher is a self-contained, executable JAR file that includes all the dependencies required to run the Camel CLI without needing a separate JBang installation.

The Camel CLI Launcher provides several key operational benefits:

  • It runs with a focus on security by using the productized 4.18-redhat version out of the box.
  • It delivers faster startup times by eliminating the dependency resolution step and using on-demand class loading.
  • It optimizes memory usage by loading only the classes that your integration actually uses.
  • It avoids classpath conflicts by keeping dependencies in separate JAR files.
  • It simplifies version configuration because each self-executing JAR is distributed as its own release.

Camel CLI Launcher is distributed as:

  • A self-executing JAR: camel-launcher-4.18.x-redhat.jar.
  • A distribution archive available in the Red Hat Customer Portal: camel-launcher-4.18.x-redhat-bin.zip.

You can then launch Camel using the java -jar command, or you can extract the distribution archive, add it to your system PATH, and run the camel script.

# In CI automation
java -jar camel-launcher-<version>.jar [command] [options]
# On Unix/Linux
ln -sf "$PWD/bin/camel.sh" "$HOME/.local/bin/camel"
camel [command] [options]
# On Windows
bin\camel.bat [command] [options]

Kaoto integration design suite

Kaoto tools have received a significant update in this release, focusing on complex data transformations, API-first design workflows, visual integration test flows, and extensive quality-of-life improvements across the integration designer in VS Code.

Note

This Kaoto release defaults to Camel JBang for backward compatibility. Camel CLI Launcher is compatible only with Camel 4.18+ and can be enabled in the Kaoto Settings menu in VS Code.

Visual editor canvas and configuration

The visual editor canvas and configuration forms include the following enhancements:

  • Advanced drag-and-drop capabilities have graduated from experimental to production-ready and are enabled by default.
  • New visual cues instantly show if a route is configured to start up automatically.
  • You can rapidly generate new routes starting from direct: components with a single click.
  • You can import existing specifications from a file, remote URI, or Apicurio Registry to automatically generate Camel REST DSL definitions and skeleton routes. A new form-based editor allows you to visually configure REST endpoints, parameters, security requirements, and content types, linking them directly to your Camel routes.
  • Component forms feature a Show/Hide URI toggle for a cleaner look, alongside a new button to trigger field suggestions.
  • Improved handling of {{ }} placeholders makes sure routes do not fail during XML serialization.
  • Updates address issues with XML bean parsing, consistent YAML entity sorting, and broad support for URI formats both with and without :// separators.

The wizard in Figure 1 shows the process for importing an OpenAPI specification to automatically create routes for REST operations.

Kaoto OpenAPI Import
Figure 1: Kaoto: Import OpenAPI and automatically create routes for REST operations.

DataMapper improvements

The DataMapper continues to be a core focus, making complex data transformations more intuitive and capable of handling enterprise-grade schemas.

  • It improves rendering performance and stability when navigating and mapping large datasets and complex schemas.
  • It adds full support for xs:choice and abstract or complex types. The DataMapper supports advanced XSLT constructs, including xsl:for-each-group, xsl:variable, and xsl:sort, and allows you to inject comments into XSLT.
  • It supports overriding field types directly in the UI, deserializing literal values, and collection choice mapping, where members inherit collection semantics.
  • It provides full support for XML xs:import and xs:include statements and JSON $ref references, allowing you to work with schemas spread across multiple files.
  • You can use a JSON source message body directly as a data source without wrapping it in parameters.
  • You can use the Wrap-with-If action to wrap already mapped fields with conditional logic without rebuilding the transformation.
  • New zoom controls and resizable expansion panels let you view more document fields simultaneously, while upgraded visual icons display field types and minOccurs or maxOccurs cardinality requirements at a glance.

Visual integration test flows backed by Citrus

You can visualize, design, and execute Citrus YAML tests side-by-side with your integration prototypes. Switching the component catalog from Camel to Citrus lets the visual designer expose more than 120 Citrus test actions. This allows you to build messaging tests that validate HTTP REST calls, Kafka events, or Selenium UI steps in a single flow. This brings the Kaoto experience and Camel JBang integration used for route development directly into the testing lifecycle.

Compared to manually authoring Citrus tests, this visual approach reduces the learning curve and helps prevent common configuration errors. Instead of referencing external documentation to hand-code complex YAML syntax, you can use Kaoto's schema-based validation to make sure all mandatory fields and properties are accurately populated as you build out test actions and nested containers. This visual approach accelerates the creation of integration tests across multiple transports and provides an at-a-glance understanding of the complete testing flow, which can be difficult to read in raw code.

The visual editor canvas in Figure 2 demonstrates how to design and run Citrus integration tests side-by-side with your prototypes.

Kaoto Citrus integration tests
Figure 2: Kaoto: Visual integration test flows.

VS Code workspace and testing views

  • The workspace displays nested folders, highlights Maven roots, and preserves integration-specific item types such as routes and Kamelets.
  • New buttons let you quickly select Run or Export for entire folders and workspaces into Maven-based projects.
  • A new kaoto.localKameletDirectories user setting injects the --local-kamelet-dir argument into Camel JBang commands.
  • A new sidebar view provides a workflow for managing and running Citrus integration tests.

HawtIO operator v2

This release upgrades the HawtIO operator. You can install the operator on Red Hat OpenShift as a cluster-wide singleton to manage HawtIO console instances across all requested namespaces, removing the previous single-namespace restriction. The new version is available through the latest and v2 channels. 

The v1 channel is no longer available. Existing installations must switch to the v2 channel to upgrade the operator.

Get started with Red Hat build of Apache Camel

Red Hat build of Apache Camel 4.18 equips your teams with predictable AI integration, enhanced visual design tools in Kaoto, and a streamlined CLI launcher.

To explore these new capabilities, view the Red Hat build of Apache Camel product page to download the latest release and set up your development environment.

Resources