# Camunda 8's Orchestration Cluster: What the Monorepo Actually Ships

> The camunda/camunda repository holds the Zeebe engine plus Tasklist, Operate, Identity and Optimize. It is a BPMN and DMN execution stack for teams that need long-running, stateful processes, and its licence splits the engine from the client libraries.

**camunda/camunda** — Process Orchestration Framework

- Repository: https://github.com/camunda/camunda
- Website: https://camunda.com/platform/
- Stars: 4,303 · Forks: 828
- Language: Java
- License: not declared
- Published: 2026-09-23 · Updated: 2026-09-23 · Language: en
- Canonical page: https://hysenlabs.com/projects/camunda-camunda

## What the Orchestration Cluster Solves, and for Whom

Most workflow code starts as a chain of service calls and ends as a state machine nobody wants to own. Camunda 8 targets that problem directly: processes are defined in BPMN 2.0, so the control flow is a diagram rather than a function, and the engine holds the state between steps. The README describes the repository as containing the Orchestration cluster components of Camunda 8 and Optimize, listing Zeebe as the cloud-native process engine, Tasklist for tasks that require human input, Operate for managing and troubleshooting processes, Identity for authentication and authorization, and Optimize for identifying constraints in a system.

The audience is narrower than the marketing suggests. If your work is a short request-response API, a BPMN engine is overhead: you pay for a broker, a gateway and a deployment model to express something an if-statement already handles. The fit is long-running processes that span people, systems and devices, where a step may wait hours or days for a human decision or an inbound message. That is the case the README opens with, and it is the case where the engine earns its footprint. Teams already running Camunda 7 are a separate audience again, because the architecture changed between major versions.

## Zeebe, the Gateway and the gRPC Protocol

The architectural break from Camunda 7 is that Zeebe does not use a relational database. The README lists fault tolerance with no relational database required as a property of the stack. Instead, state is distributed across brokers and replicated through a consensus protocol, with an event log as the source of truth. That choice is what allows horizontal scaling and what makes the operational model unfamiliar to anyone coming from a shared SQL instance.

Clients do not talk to brokers directly. They talk to the gateway over gRPC, defined in gateway-protocol/src/main/proto/gateway.proto. The repository's licence section is unusually explicit about this file: the protocol is licensed under the Camunda License 1.0, but using gRPC tooling to generate stubs does not constitute creating a derivative work, and no licensing restrictions are imposed on the resulting stub code by that licence. That clarification exists because code generation sits in a grey zone, and it is worth reading in full rather than skimming.

The gateway protocol implementation, the exporter API, the protocol definitions and the BPMN model API are among the parts published under Apache 2.0. The engine itself is not. That split shapes what you can build on top of Camunda without touching the Camunda License 1.0, and it is the first thing a legal review will ask about.

## Installing Camunda 8 with c8run and Running a First Process

The README does not give a single install command. It points to the Installation and Configuration documentation and to pre-built images on Docker Hub under camunda/camunda. The repository does contain a c8run directory, which is the local distribution used for trying the stack without a cluster, and a camunda.Dockerfile plus an optimize.Dockerfile for container builds. The Makefile in the repository is aimed at contributors and AI-assistant configuration sync, not at operators; its targets include vscode-mcp-sync and claude-settings-sync, which tells you the maintainers use it for development setup rather than deployment guidance.

If you want to read the documentation locally rather than online, the README gives these steps. The site is served on port 3000 under the /camunda/ path.

```bash
cd monorepo-docs-site
npm install
npm start
```

For the Java side, the README links the Java client and the Camunda Spring Boot Starter as the recommended entry points. The Maven coordinates for the engine artifacts sit under the io.camunda group, as the Maven Central badge in the README indicates for camunda-zeebe. Before adding a dependency, confirm the exact artifact and version against the release you intend to run; the repository publishes 8.10.0-rc1 as a release candidate alongside 8.9.21 and 8.8.39, and a release candidate is not the version to put in production.

Adding a documentation page, if you are contributing rather than consuming, means dropping a markdown file into docs/ and registering its ID in the sidebar array in monorepo-docs-site/sidebars.js. The README shows the shape of that array with entries such as 'introduction' and 'getting-started'.

## Where Camunda 8 Is the Wrong Tool

The licence is the sharpest limitation, and it is not a footnote. Zeebe, Operate and Tasklist source files are made available under the Camunda License Version 1.0, with only the listed components under Apache 2.0. If your requirement is a fully permissive process engine you can fork and redistribute without conditions, this repository does not meet it, and no amount of reading the client libraries changes that. The gateway protocol clarification softens one specific case, generated stubs, and nothing more.

The second limitation is operational weight. A distributed engine without a relational database trades one set of problems for another: you need to run and monitor brokers, understand replication, and reason about the event log when something goes wrong. For a process with three steps and no waiting, that is a poor trade. The README's own framing, processes that span people, systems and devices, is a reasonable filter. If your process completes inside a single request, you are outside the intended case.

The third is versioning. Three release lines appear in the recent releases, 8.10.0-rc1, 8.9.21 and 8.8.39, which means a maintenance window and an upgrade path to plan. The README defers cadence and maintenance periods to the Camunda release policy rather than stating them in the repository, so the upgrade cost cannot be assessed from the code alone.

## Camunda 8 Against Temporal and Plain Message Queues

The closest architectural alternative is Temporal, which also persists workflow state outside a relational database and also separates a client SDK from a server. The difference is the modelling surface. Temporal workflows are written as code in a general-purpose language, so the process definition is a program. Camunda 8 puts BPMN 2.0 at the centre, so the process definition is a diagram that business analysts can read and that the engine executes. If your organisation needs a shared artefact between engineering and operations, that is the argument for BPMN. If your team would rather express orchestration as ordinary functions with tests and type checking, code-first is the better fit and BPMN becomes a translation layer you maintain for no reason.

The other alternative is not a workflow engine at all: a message queue plus a database table of pending work. That handles simple fan-out and retry well and costs far less to operate. It stops being adequate when you need visibility into where a specific instance is, human task assignment, and decision tables evaluated by a DMN engine. Those are the features the Orchestration cluster bundles, and bundling them is the reason to accept the deployment complexity.

## Maintenance, Releases and the Licence Split

The repository is not archived and the last push was on 2026-09-23, so it is current. The release cadence is visible in the tags: 8.10.0-rc1 on 2026-09-22, 8.9.21 on 2026-09-17 and 8.8.39 on 2026-09-18. Multiple maintained lines running in parallel is normal for a platform of this size, and it means an upgrade is a project rather than a patch. The README points to the release policy for cadence and maintenance periods but does not restate them in the repository, so plan against that page, not against the tag list.

On licensing, the practical implication is that the split decides how you can reuse code. The Apache 2.0 list covers the Java client, the Camunda Spring Boot Starter, the exporter API, the protocol, the gateway protocol implementation and the BPMN model API. Everything else in Zeebe, Operate and Tasklist is under the Camunda License 1.0. If you build an exporter, you are working against an Apache 2.0 API and can distribute your exporter freely; that is a meaningful boundary for anyone extending the platform. This is a description of what the repository states, not legal advice, and the licence files under licenses/ are the authoritative text.

## Conclusion

Adopt camunda/camunda if you need BPMN 2.0 processes with human tasks, message correlation from Kafka or another queue, and no relational database in the execution path. Do not adopt it if you want a permissively licensed engine: Zeebe, Operate and Tasklist fall under the Camunda License 1.0, and only the Java client, Spring Boot starter, exporter API, protocol, gateway protocol implementation and BPMN model API are Apache 2.0. Before committing, verify three things in your own environment: that the c8run distribution starts on your target OS, that your throughput matches the load-tests directory's assumptions rather than a vendor figure, and that your legal team accepts the Camunda License 1.0 terms for the engine components.

## FAQ

### What is Camunda used for?

Camunda 8 orchestrates business processes that span people, systems and devices. The repository ships Zeebe for BPMN execution, Tasklist for human tasks, Operate for monitoring and troubleshooting, Identity for authentication, and Optimize for process analysis.

### Is Camunda a workflow engine?

The engine is Zeebe, described in the README as the cloud-native process engine of Camunda 8. It executes BPMN 2.0 processes and DMN decisions, and it does not require a relational database.

### How does Camunda work?

Processes are defined in BPMN 2.0 and executed by Zeebe, which keeps state across steps. Clients reach the engine through a gateway over a gRPC protocol defined in gateway.proto, and the repository states that fault tolerance comes from not requiring a relational database.

### How to install Camunda 8?

The README does not give install commands. It links the Installation and Configuration documentation and points to pre-built images on Docker Hub under camunda/camunda, and the repository contains a c8run directory for running the stack locally.

### How to use Camunda in Spring Boot?

The README lists the Camunda Spring Boot Starter under clients/camunda-spring-boot-starter as a recommended entry point, and that component is published under the Apache License 2.0. The README links a getting-started page for it rather than showing code.

## Sources

- [camunda/camunda on GitHub](https://github.com/camunda/camunda)
- [Issues](https://github.com/camunda/camunda/issues)
- [Project website](https://camunda.com/platform/)
- [README](https://github.com/camunda/camunda/blob/main/README.md)
- [Releases](https://github.com/camunda/camunda/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/camunda-camunda