camunda-bpm-platform
Flexible framework for workflow and decision automation with BPMN and DMN. Integration with Quarkus, Spring, Spring Boot, CDI.
Top Related Projects
A compact and highly efficient workflow and Business Process Management (BPM) platform for developers, system admins and business users.
Activiti is a light-weight workflow and Business Process Management (BPM) Platform targeted at business people, developers and system admins. Its core is a super-fast and rock-solid BPMN 2 process engine for Java. It's open-source and distributed under the Apache license. Activiti runs in any Java application, on a server, on a cluster or in the cloud. It integrates perfectly with Spring, it is extremely lightweight and based on simple concepts.
Apache Airflow - A platform to programmatically author, schedule, and monitor workflows
Quick Overview
Camunda BPM Platform is an open-source workflow and decision automation platform. It provides a robust engine for executing business processes defined in BPMN 2.0, along with tools for process design, deployment, and monitoring. The platform supports both embedded Java and standalone server deployments, making it versatile for various enterprise applications.
Pros
- Comprehensive workflow automation solution with support for BPMN 2.0, DMN, and CMMN standards
- Flexible deployment options (embedded or standalone) to suit different architectural needs
- Extensive API and integration capabilities for seamless incorporation into existing systems
- Active community and regular updates, ensuring ongoing support and improvements
Cons
- Steep learning curve for newcomers, especially those unfamiliar with BPMN concepts
- Can be resource-intensive for complex processes or high-volume scenarios
- Limited out-of-the-box reporting capabilities compared to some commercial alternatives
- Configuration and setup can be complex, particularly for advanced features
Code Examples
- Starting a process instance:
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
RuntimeService runtimeService = processEngine.getRuntimeService();
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("myProcess");
- Completing a user task:
TaskService taskService = processEngine.getTaskService();
Task task = taskService.createTaskQuery().taskDefinitionKey("userTask").singleResult();
taskService.complete(task.getId());
- Deploying a BPMN process:
RepositoryService repositoryService = processEngine.getRepositoryService();
repositoryService.createDeployment()
.addClasspathResource("myProcess.bpmn")
.deploy();
- Querying process instances:
RuntimeService runtimeService = processEngine.getRuntimeService();
List<ProcessInstance> instances = runtimeService.createProcessInstanceQuery()
.processDefinitionKey("myProcess")
.active()
.list();
Getting Started
To get started with Camunda BPM Platform:
- Add the Camunda BPM dependency to your project (Maven example):
<dependency>
<groupId>org.camunda.bpm</groupId>
<artifactId>camunda-engine</artifactId>
<version>7.17.0</version>
</dependency>
- Create a
camunda.cfg.xml
file in your classpath:
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="processEngineConfiguration" class="org.camunda.bpm.engine.impl.cfg.StandaloneProcessEngineConfiguration">
<property name="jdbcUrl" value="jdbc:h2:mem:camunda;DB_CLOSE_DELAY=-1" />
<property name="jdbcDriver" value="org.h2.Driver" />
<property name="jdbcUsername" value="sa" />
<property name="jdbcPassword" value="" />
<property name="databaseSchemaUpdate" value="true" />
</bean>
</beans>
- Initialize the process engine in your application:
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
Competitor Comparisons
A compact and highly efficient workflow and Business Process Management (BPM) platform for developers, system admins and business users.
Pros of Flowable Engine
- Lighter weight and more modular architecture
- Better support for cloud-native deployments
- More flexible and extensible API design
Cons of Flowable Engine
- Smaller community and ecosystem compared to Camunda
- Less comprehensive documentation and learning resources
- Fewer out-of-the-box integrations with third-party tools
Code Comparison
Flowable Engine:
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
RuntimeService runtimeService = processEngine.getRuntimeService();
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("myProcess");
Camunda BPM Platform:
ProcessEngine processEngine = ProcessEngineConfiguration.createStandaloneInMemProcessEngineConfiguration().buildProcessEngine();
RuntimeService runtimeService = processEngine.getRuntimeService();
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("myProcess");
Both examples demonstrate starting a process instance, but Flowable's API is slightly more concise. However, the overall structure and approach are similar, making it relatively easy for developers to switch between the two platforms if needed.
Activiti is a light-weight workflow and Business Process Management (BPM) Platform targeted at business people, developers and system admins. Its core is a super-fast and rock-solid BPMN 2 process engine for Java. It's open-source and distributed under the Apache license. Activiti runs in any Java application, on a server, on a cluster or in the cloud. It integrates perfectly with Spring, it is extremely lightweight and based on simple concepts.
Pros of Activiti
- Lightweight and more flexible architecture
- Easier integration with Spring Boot applications
- More active community and frequent updates
Cons of Activiti
- Less comprehensive documentation compared to Camunda
- Fewer out-of-the-box features and tools
- Limited enterprise support options
Code Comparison
Activiti process definition:
<process id="myProcess" name="My Process">
<startEvent id="start" />
<userTask id="userTask" name="User Task" />
<endEvent id="end" />
<sequenceFlow sourceRef="start" targetRef="userTask" />
<sequenceFlow sourceRef="userTask" targetRef="end" />
</process>
Camunda process definition:
<bpmn:process id="myProcess" name="My Process" isExecutable="true">
<bpmn:startEvent id="start" />
<bpmn:userTask id="userTask" name="User Task" />
<bpmn:endEvent id="end" />
<bpmn:sequenceFlow sourceRef="start" targetRef="userTask" />
<bpmn:sequenceFlow sourceRef="userTask" targetRef="end" />
</bpmn:process>
Both Activiti and Camunda use similar BPMN 2.0 XML syntax for process definitions. The main difference is the namespace prefix, with Camunda using bpmn:
for BPMN elements. Camunda also includes the isExecutable="true"
attribute by default, which is optional in Activiti.
Apache Airflow - A platform to programmatically author, schedule, and monitor workflows
Pros of Airflow
- More extensive ecosystem with a wide range of integrators and operators
- Better suited for data pipeline orchestration and ETL workflows
- Stronger support for Python-based workflows and data science tasks
Cons of Airflow
- Steeper learning curve, especially for non-technical users
- Less focus on business process modeling and human task management
- May require more infrastructure setup and maintenance
Code Comparison
Airflow DAG definition:
from airflow import DAG
from airflow.operators.python_operator import PythonOperator
from datetime import datetime
def my_task():
print("Hello from Airflow!")
dag = DAG('simple_dag', start_date=datetime(2023, 1, 1))
task = PythonOperator(task_id='my_task', python_callable=my_task, dag=dag)
Camunda BPMN process definition:
<bpmn:process id="Process_1" isExecutable="true">
<bpmn:startEvent id="StartEvent_1" />
<bpmn:task id="Task_1" name="My Task">
<bpmn:script>print("Hello from Camunda!");</bpmn:script>
</bpmn:task>
<bpmn:endEvent id="EndEvent_1" />
<bpmn:sequenceFlow id="Flow_1" sourceRef="StartEvent_1" targetRef="Task_1" />
<bpmn:sequenceFlow id="Flow_2" sourceRef="Task_1" targetRef="EndEvent_1" />
</bpmn:process>
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
Camunda Platform 7 - The open source BPMN platform
Camunda Platform 7 is a flexible framework for workflow and process automation. Its core is a native BPMN 2.0 process engine that runs inside the Java Virtual Machine. It can be embedded inside any Java application and any Runtime Container. It integrates with Java EE 6 and is a perfect match for the Spring Framework. On top of the process engine, you can choose from a stack of tools for human workflow management, operations and monitoring.
- Web Site: https://www.camunda.org/
- Getting Started: https://docs.camunda.org/get-started/
- User Forum: https://forum.camunda.org/
- Issue Tracker: https://github.com/camunda/camunda-bpm-platform/issues
- Contribution Guidelines: https://camunda.org/contribute/
Components
Camunda Platform 7 provides a rich set of components centered around the BPM lifecycle.
Process Implementation and Execution
- Camunda Engine - The core component responsible for executing BPMN 2.0 processes.
- REST API - The REST API provides remote access to running processes.
- Spring, CDI Integration - Programming model integration that allows developers to write Java Applications that interact with running processes.
Process Design
- Camunda Modeler - A standalone desktop application that allows business users and developers to design & configure processes.
Process Operations
- Camunda Engine - JMX and advanced Runtime Container Integration for process engine monitoring.
- Camunda Cockpit - Web application tool for process operations.
- Camunda Admin - Web application for managing users, groups, and their access permissions.
Human Task Management
- Camunda Tasklist - Web application for managing and completing user tasks in the context of processes.
And there's more...
- bpmn.io - Toolkits for BPMN, CMMN, and DMN in JavaScript (rendering, modeling)
- Community Extensions - Extensions on top of Camunda Platform 7 provided and maintained by our great open source community
A Framework
In contrast to other vendor BPM platforms, Camunda Platform 7 strives to be highly integrable and embeddable. We seek to deliver a great experience to developers that want to use BPM technology in their projects.
Highly Integrable
Out of the box, Camunda Platform 7 provides infrastructure-level integration with Java EE Application Servers and Servlet Containers.
Embeddable
Most of the components that make up the platform can even be completely embedded inside an application. For instance, you can add the process engine and the REST API as a library to your application and assemble your custom BPM platform configuration.
Contributing
Please see our contribution guidelines for how to raise issues and how to contribute code to our project.
Tests
To run the tests in this repository, please see our testing tips and tricks.
License
The source files in this repository are made available under the Apache License Version 2.0.
Camunda Platform 7 uses and includes third-party dependencies published under various licenses. By downloading and using Camunda Platform 7 artifacts, you agree to their terms and conditions. Refer to https://docs.camunda.org/manual/latest/introduction/third-party-libraries/ for an overview of third-party libraries and particularly important third-party licenses we want to make you aware of.
Top Related Projects
A compact and highly efficient workflow and Business Process Management (BPM) platform for developers, system admins and business users.
Activiti is a light-weight workflow and Business Process Management (BPM) Platform targeted at business people, developers and system admins. Its core is a super-fast and rock-solid BPMN 2 process engine for Java. It's open-source and distributed under the Apache license. Activiti runs in any Java application, on a server, on a cluster or in the cloud. It integrates perfectly with Spring, it is extremely lightweight and based on simple concepts.
Apache Airflow - A platform to programmatically author, schedule, and monitor workflows
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot