Convert Figma logo to code with AI

camunda logocamunda

Process Orchestration Framework

3,532
644
3,532
1,865

Top Related Projects

A compact and highly efficient workflow and Business Process Management (BPM) platform for developers, system admins and business users.

10,275

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.

3,529

Process Orchestration Framework

39,846

Apache Airflow - A platform to programmatically author, schedule, and monitor workflows

Quick Overview

Camunda is an open-source workflow and decision automation platform. It provides a powerful engine for executing business processes and workflows, along with tools for modeling, monitoring, and optimizing these processes. Camunda supports the BPMN 2.0 standard for process modeling and execution.

Pros

  • Flexible and scalable architecture suitable for both small projects and enterprise-level applications
  • Strong support for BPMN 2.0 standard, allowing for visual process modeling
  • Extensive API and integration capabilities with various programming languages and frameworks
  • Active community and regular updates, ensuring ongoing development and support

Cons

  • Steep learning curve for beginners, especially those new to BPMN concepts
  • Complex setup and configuration for advanced use cases
  • Limited out-of-the-box reporting and analytics capabilities
  • Some features are only available in the enterprise edition, which requires a paid license

Code Examples

  1. Creating a simple process instance:
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
RuntimeService runtimeService = processEngine.getRuntimeService();

ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("myProcess");
  1. Completing a user task:
TaskService taskService = processEngine.getTaskService();
Task task = taskService.createTaskQuery().taskDefinitionKey("userTask").singleResult();

taskService.complete(task.getId());
  1. Querying process instances:
RuntimeService runtimeService = processEngine.getRuntimeService();
List<ProcessInstance> instances = runtimeService.createProcessInstanceQuery()
    .processDefinitionKey("myProcess")
    .active()
    .list();

Getting Started

To get started with Camunda:

  1. Add the Camunda BPM dependency to your project:
<dependency>
  <groupId>org.camunda.bpm</groupId>
  <artifactId>camunda-engine</artifactId>
  <version>7.17.0</version>
</dependency>
  1. Create a camunda.cfg.xml file in your resources folder:
<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>
  1. Initialize the process engine in your application:
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

You can now start using Camunda to model and execute business processes in your application.

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 performance for high-volume scenarios
  • More flexible and extensible API

Cons of Flowable Engine

  • Smaller community and ecosystem compared to Camunda
  • Less comprehensive documentation and tutorials
  • Fewer out-of-the-box integrations with third-party tools

Code Comparison

Flowable Engine process definition:

<process id="myProcess">
  <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" isExecutable="true">
  <bpmn:startEvent id="StartEvent_1" />
  <bpmn:task id="Task_1" name="User Task" />
  <bpmn:endEvent id="EndEvent_1" />
  <bpmn:sequenceFlow id="SequenceFlow_1" sourceRef="StartEvent_1" targetRef="Task_1" />
  <bpmn:sequenceFlow id="SequenceFlow_2" sourceRef="Task_1" targetRef="EndEvent_1" />
</bpmn:process>

Both engines use similar BPMN-based XML for process definitions, with minor differences in namespace and element naming conventions. Flowable tends to have slightly more concise syntax, while Camunda follows BPMN 2.0 specifications more strictly.

10,275

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

  • Lighter weight and more flexible for embedding in Java applications
  • Stronger focus on core BPMN execution engine
  • More active community contributions and frequent releases

Cons of Activiti

  • Less comprehensive enterprise features out-of-the-box
  • Smaller ecosystem of tools and integrations
  • Less extensive documentation and learning resources

Code Comparison

Activiti process definition:

<process id="myProcess">
  <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" 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 that Camunda uses the bpmn: namespace prefix, while Activiti doesn't. Camunda also includes the isExecutable="true" attribute on the process element by default.

3,529

Process Orchestration Framework

Pros of camunda

  • More comprehensive and feature-rich workflow engine
  • Supports both BPMN and DMN standards
  • Offers a wider range of deployment options (on-premise, cloud, hybrid)

Cons of camunda

  • Steeper learning curve due to more complex architecture
  • Requires more resources to run and maintain
  • May be overkill for simpler workflow needs

Code comparison

camunda:

@Deployment(resources = "process.bpmn")
public void testProcess() {
  runtimeService.startProcessInstanceByKey("myProcess");
  Task task = taskService.createTaskQuery().singleResult();
  assertEquals("My Task", task.getName());
}

camunda:

@Test
public void testProcess() {
  ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("myProcess");
  assertThat(processInstance).isNotNull();
  assertThat(taskService.createTaskQuery().processInstanceId(processInstance.getId()).count()).isEqualTo(1);
}

Summary

Both repositories are related to the Camunda workflow engine, but they serve different purposes. The camunda repository is the main project, offering a full-featured workflow and decision automation platform. It provides a robust set of tools for modeling, executing, and managing business processes. On the other hand, the camunda repository's purpose is not clear from the given information, as it appears to be a duplicate or potentially a different project with the same name. Without more context, it's difficult to make a meaningful comparison between the two repositories.

39,846

Apache Airflow - A platform to programmatically author, schedule, and monitor workflows

Pros of Airflow

  • More extensive ecosystem with a larger community and wider range of integrations
  • Better suited for data pipeline orchestration and ETL workflows
  • Offers a more flexible and pythonic approach to workflow definition

Cons of Airflow

  • Steeper learning curve, especially for non-Python users
  • Can be more resource-intensive and complex to set up and maintain
  • Less focus on business process modeling compared to Camunda

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 Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Camunda 8 orchestrates complex business processes that span people, systems, and devices

Maven Central

Camunda 8 delivers scalable, on-demand process automation as a service. Camunda 8 is combined with powerful execution engines for BPMN processes and DMN decisions, and paired with tools for collaborative modeling, operations, and analytics.

This repository contains the core execution cluster components of Camunda 8:

  • Zeebe - The cloud-native process engine of Camunda 8.
  • Tasklist - Complete tasks that require human input.
  • Operate - Manage, monitor, and troubleshoot your processes.
  • Optimize - Improve your processes by identifying constraints in your system.

In addition to the core execution cluster components, the Camunda 8 stack also includes:

  • Console - Configure and deploy clusters with Console.
  • Web Modeler - Web Application to model BPMN, DMN, & Forms and deploy or start new instances.
  • Desktop Modeler - Use Desktop Modeler as a desktop application for modeling BPMN, DMN, and Forms with your local process application project.
  • Connectors - Integrate with an external system by using a Connector.

Using Camunda 8, you can:

  • Define processes visually in BPMN 2.0
  • Choose your programming language
  • Deploy with Docker and Kubernetes
  • Build processes that react to messages from Kafka and other message queues
  • Scale horizontally to handle very high throughput
  • Fault tolerance (no relational database required)
  • Export process data for monitoring and analysis
  • Engage with an active community

Learn more at camunda.com.

Status

To learn more about what we're currently working on, check the GitHub issues and the latest commits.

Helpful Links

Recommended Docs Entries for New Users

Contributing

Read the Contributions Guide.

Code of Conduct

This project adheres to the Camunda Code of Conduct. By participating, you are expected to uphold this code. Please report unacceptable behavior as soon as possible.

Release Lifecycle

Please refer to our Release Policy to learn about our release cadence, maintenance periods, etc.

License

Zeebe, Operate, and Tasklist source files are made available under the Camunda License Version 1.0 except for the parts listed below, which are made available under the Apache License, Version 2.0. See individual source files for details.

Available under the Apache License, Version 2.0:

Clarification on gRPC Code Generation

The Zeebe Gateway Protocol (API) as published in the gateway-protocol is licensed under the Camunda License 1.0. Using gRPC tooling to generate stubs for the protocol does not constitute creating a derivative work under the Camunda License 1.0 and no licensing restrictions are imposed on the resulting stub code by the Camunda License 1.0.