Comparison and Selection Guide for Open‑Source Workflow Engines: Flowable vs Camunda and Others

1. Mainstream Open‑Source Workflow Engines Introduction

1) Osworkflow

Osworkflow is a lightweight workflow engine based on a state‑machine mechanism with very few database tables. It supports steps, conditions, loops, splits, joins, etc., but lacks features such as countersign, jump, rollback, and add‑sign, requiring custom extensions. It is suitable for simple processes but the project is outdated and has not been updated for a long time.

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

2) JBPM

JBPM, developed by JBoss, currently has version 7, but since JBPM5 the code base diverged from JBPM4 and is based on Drools Flow, which is rarely used in the domestic market. Therefore, versions after JBPM5 are not recommended. JBPM4, the early version, gave rise to Activiti after its creator left JBoss. JBPM is not the optimal choice for new projects.

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

3) Activiti

Activiti is developed by Alfresco and currently has version 7. It has several major branches (Activiti5, Activiti6, Activiti7) whose histories are complex. Activiti5 and Activiti6 were led by Tijs Rademakers, who left in 2017 to create Flowable. Activiti5/6 are no longer actively maintained; the Salaboy team now maintains Activiti7, which mainly re‑packages Activiti6 without adding major new features. Caution is advised when selecting Activiti.

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

4) Flowable

Flowable originated from Activiti6 and is currently at version 6.6.0. The project fixed many bugs of Activiti6 and added support for DMN, BPEL, and other extensions. Flowable is a lightweight Java BPM engine released under the Apache V2 license. It includes modules for BPMN, CMMN, DMN, and Form Engine.

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

5) Camunda

Camunda is based on Activiti5 and retains the PVM engine. The latest version is 7.15, with two minor releases per year. It offers a comprehensive feature set, including BPMN, CMMN, DMN, strong tooling for modeling, task management, monitoring, and user management. The open‑source edition is sufficient for most enterprise applications, and the author strongly recommends Camunda for its stable performance and rich functionality.

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

2. Flowable vs Camunda Comparison

1) Functional Differences

Camunda supports process‑instance migration across versions; Flowable lacks this capability.

Camunda retains PVM technology, making migration from Activiti5 seamless; Flowable does not have PVM, increasing migration effort.

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

Camunda offers batch APIs for operations such as bulk suspension or activation; Flowable requires manual iteration.

Camunda’s batch APIs support asynchronous execution; Flowable lacks asynchronous batch processing.

Camunda can start a process instance from any node; Flowable can only start from the start node.

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

Camunda implements a double‑asynchronous mechanism (node‑level and transition‑level); Flowable only supports the first.

Camunda supports multiple scripting languages (Python, Ruby, Groovy, JUEL) out‑of‑the‑box; Flowable supports only JUEL and Groovy.

Camunda provides external tasks that can be completed by external systems, solving distributed transaction issues; Flowable’s httpTask is fire‑and‑forget.

Camunda allows user‑specific query preference persistence, enabling personalized filtering.

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

Camunda offers lock mechanisms for high‑concurrency deployments; Flowable does not.

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

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

Camunda provides distributed timers; Flowable does not.

Flowable supports NoSQL; Camunda only offers a NoSQL solution.

Camunda includes tools for process optimization and bottleneck analysis; Flowable lacks such mechanisms.

Camunda’s XML parsing is more efficient than Flowable’s due to removal of the double‑parsing mechanism.

Camunda allows arbitrary attribute addition to any node; Flowable requires custom extensions.

Camunda does not expose an API for generating process diagram images (handled on the front‑end); Activiti/Flowable provide such APIs.

Camunda supports node‑level and global priority settings for timers; Activiti/Flowable do not.

Camunda permits tagging of processes; Activiti/Flowable do not.

None of Camunda/Activiti/Flowable support domestic Chinese databases such as Kingbase or Dameng.

Flowable supports LDAP and OpenLDAP; Camunda and Activiti do not.

2) Performance Comparison

The author conducted multiple benchmark tests and found that Camunda’s performance exceeds Flowable’s by 10%–39%, with Camunda showing higher stability under high‑concurrency loads while Flowable occasionally reported errors.

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

3. Selection Recommendation

The author recommends using Camunda together with the bpmn‑js designer. In the author’s real‑world projects, Camunda demonstrated superior functionality, performance, and stability compared with Flowable and Activiti.

Source: https://blog.csdn.net/wanyu_123

Backend‑focused Technical Community

Build a high‑quality technical exchange community. Developers, technical recruiters, and anyone interested in sharing job referrals are welcome to join and help each other improve.

Maintain civility and focus on technical exchange , job referrals , and industry discussion .

Advertisements are prohibited; do not trust private messages to avoid scams.

Click the ❤ below to support us. Thank you!