Developer Joy
Start quickly, keep types in one place, and spend less time wiring things together
The Pipeline FrameworkReactive Pipeline Processing
Build pipeline-style applications on Quarkus, with generated adapters and a shared type-safe core
Skip to content
Visual Pipeline Designer Available
The Pipeline Framework includes a visual canvas designer at https://app.pipelineframework.org that allows you to create and configure your pipelines using an intuitive drag-and-drop interface. Simply design your pipeline visually, click "Download Application", and you'll get a complete ZIP file with all the generated source code - no command-line tools needed!
Latest Releases
View allFresh from GitHub releases for The Pipeline Framework.
Loading releases...
Key Features
The Pipeline Framework is a powerful tool for building reactive pipeline processing systems. It simplifies the development of distributed systems by providing a consistent way to create, configure, and deploy pipeline steps.
Runtime and Processing Model
- Reactive by default: Built on Mutiny for non-blocking throughput and backpressure-aware execution.
- Why it matters: Better CPU utilization and higher compute density typically mean lower runtime cost for the same workload.
- Quarkus runtime foundation: Aligns with Quarkus runtime and build-time patterns for fast, production-grade services.
- Immutable event flow: No in-place updates during execution; append/preserve semantics improve traceability and safety.
- Rich step semantics: Supports OneToOne, OneToMany, ManyToOne, ManyToMany, and SideEffect patterns.
Extensibility with Plugins
- Plugin-friendly model: Pipeline plugins add cross-cutting capabilities without coupling business logic to infrastructure code.
- Why it matters: You can deliver platform concerns (cache, telemetry, orchestration behaviors) with less code churn in core services.
- Clear extension points: Use Using Plugins and Aspect Semantics as primary references.
Integration and Deployment Flexibility
- Transport coverage: Automatic generation for gRPC, REST, and local/in-process clients.
- Quarkus Dev Services workflow: Smooth local development with managed service dependencies (for example, PostgreSQL) in dev/test flows.
- Why it matters: Teams can adapt interfaces to consumers and platform constraints without rewriting core processing logic.
- Deployment layouts: Works across modular, pipeline-runtime, and monolith build layouts.
- Evolution path: Start with a monolith for speed, then break into services as scale and ownership boundaries grow.
Operations
- Built-in observability: Metrics, tracing, and structured logging are first-class.
- Resilience features: Health checks, robust error handling, and dead-letter queue support.
- Container-first packaging: Current delivery flow supports image builds with Jib for predictable CI/CD integration.
- Native compilation path: Quarkus native builds support low cold-start and efficient resource usage where needed.
- Why it matters: Teams get faster incident diagnosis, more predictable deployments, and lower operational overhead at scale.
Developer Experience
- Shared
commonmodule: Central place for entity and DTO definitions used across pipeline components. - Type safety across the pipeline: Compile-time checks catch contract drift early as steps and transports evolve.
- Why it matters: Teams get safer refactors, fewer runtime mapping errors, and faster confidence when changing domain models.
- Testability gains: Functional boundaries and generated transport layers make behavior easier to isolate and test.
- Fast onboarding and testing: Design visually with Canvas and validate behavior via Testing with Testcontainers.