Choosing the Right Open‑Source BPM Engine: Flowable vs Camunda vs Others

Popular open‑source workflow engines on the market include Osworkflow, JBPM, Activiti, Flowable and Camunda. JBPM4, Activiti, Flowable and Camunda share a common ancestry from JBPM4, so experience with one generally translates to the others.

Low‑code platforms, office automation (OA), BPM platforms and workflow systems all require a workflow engine; with so many options, choosing the right one based on functionality and performance is essential.

1. Main Open‑Source Workflow Engines

1. Osworkflow

Osworkflow is a lightweight engine based on a state‑machine mechanism with very few database tables. It provides steps, conditions, loops, splits and joins, but does not support countersign, jump, rollback or add‑sign operations, requiring custom extensions. It is suitable for simple processes, yet the project is outdated and no longer maintained.

Official website: http://www.opensymphony.com/osworkflow/

2. JBPM

JBPM is developed by JBoss. The latest version is JBPM7, but since JBPM5 the code base diverged from JBPM4 and is based on Drools Flow, which is rarely used in China. Therefore, versions after JBPM5 are not recommended. JBPM4’s creator left JBoss and created Activiti; JBPM’s Hibernate‑based persistence is also no longer mainstream, making JBPM a sub‑optimal choice today.

Official website: https://www.jbpm.org/

3. Activiti

Activiti, developed by Alfresco, currently has Activiti 7 as the latest release. It has multiple major versions (5, 6, 7) that can be confusing. Activiti 5 and 6 were led by Tijs Rademakers, who left in 2017 to create Flowable. Activiti 5/6 are no longer maintained; the Salaboy team is developing Activiti 7, which reuses the Activiti 6 core without adding many new features. Caution is advised when selecting Activiti.

Official website: https://www.activiti.org/

4. Flowable

Flowable originated from Activiti 6 and is currently at version 6.6.0. It fixes many Activiti 6 bugs and adds DMN, BPEL support, among others. The commercial edition offers more features, while the open‑source version is less actively maintained after version 6.4.1, with some functions (e.g., form engine, historical data sync, Elasticsearch) no longer open‑sourced.

Flowable is a lightweight Java BPM engine released under the Apache V2 license. It includes BPMN, CMMN, DMN and Form engines.

Official website: https://flowable.com/open-source/

5. Camunda

Camunda is based on Activiti 5 and retains the PVM. The latest version is Camunda 7.15, with two minor releases per year. It offers both open‑source and commercial editions; the open‑source version is sufficient for most enterprise applications. Camunda is strongly recommended for its stable functionality and performance.

Reasons to choose Camunda:

Stress‑tested BPMN engine shows superior performance and stability.

Comprehensive feature set: BPMN, CMMN, DMN, powerful modeling, task management, monitoring and user management tools.

Official website: https://docs.camunda.org/manual/7.15/introduction/

2. Flowable vs Camunda Comparison

1. Feature Comparison

Both engines share many capabilities, but the following differences are notable:

Camunda supports process‑instance migration across versions, while Flowable lacks this feature.

Camunda’s PVM‑based migration from Activiti 5 is seamless; Flowable requires more effort.

Camunda provides permission checks for every CMD command; Flowable does not.

Camunda offers batch APIs (e.g., bulk suspend/activate); Flowable lacks batch support.

Camunda allows starting instances from arbitrary nodes; Flowable starts only from the initial node.

Camunda supports arbitrary node jumps with optional listener triggering; Flowable requires custom extensions.

Camunda provides dual‑asynchronous execution (node and outgoing sequence); Flowable supports only the first asynchronous mode.

Camunda includes built‑in support for multiple scripting languages (Python, Ruby, Groovy, JUEL); Flowable supports only JUEL and Groovy.

Camunda offers external tasks with lock‑and‑complete semantics; Flowable’s httpTask executes immediately without waiting.

Camunda enables user‑specific query preference persistence; Flowable lacks this capability.

Camunda supports bulk deletion or migration of historical data (e.g., to Elasticsearch); Flowable does not.

Camunda provides optional locking for high‑concurrency deployments; Flowable lacks this mechanism.

Camunda allows multi‑engine, multi‑database configurations; Flowable supports only single‑engine multi‑combination.

Camunda permits cross‑process‑definition instance jumps; Flowable does not.

Camunda includes distributed timers; Flowable does not.

Flowable supports NoSQL; Camunda only offers a NoSQL solution.

Camunda offers process‑bottleneck analysis and optimization tools; Flowable does not.

Camunda’s XML parsing is more efficient than Flowable’s.

Camunda allows adding arbitrary attributes to any node; Flowable requires custom extensions.

Camunda does not provide an API for generating process diagram images; Activiti 5/6 and Flowable 5/6 do.

Camunda supports priority settings for tasks and global workflow priority; Flowable lacks this feature.

Camunda enables tagging of processes; Flowable does not.

Both Camunda/Activiti/Flowable do not support Chinese domestic databases such as Kingbase or Dameng.

Flowable 6 supports LDAP/OpenLDAP; Camunda and Activiti 5 do not.

2. Performance Comparison

Benchmark tests conducted by the author show Camunda’s performance surpasses Flowable by 10%–39%, with Camunda exhibiting no errors and better stability under high concurrency, whereas Flowable encountered errors.

Performance test details: https://lowcode.blog.csdn.net/article/details/109030329

3. Recommendation

It is recommended to use Camunda together with bpmn‑js as the workflow engine and designer combination. The author’s real‑world project experience confirms Camunda’s superior functionality, performance and stability compared with Flowable and Activiti.