• Blog
  • >
  • More FEEL for Camunda

Ready to build a BPMN model?

Build your first business process model instantly with Camunda Platform 8.

Join the Camunda Developer Newsletter

Get the latest events, release notes, and product updates straight to your mailbox.


I’m happy to announce the first release of the new community extension FEEL-Scala. FEEL is a part of the DMN specification of the OMG and stands for “Friendly Enough Expression Language”. It provides a simple data model and a syntax designed for a wide audience. The new community extension implements a large feature set of FEEL and replaces the default FEEL engine of the Camunda DMN engine.

Why Another FEEL Engine?

The Camunda DMN engine includes a built-in FEEL engine which can be used for input entries of a decision table. Currently, this FEEL engine can not be used for other expressions (e.g., output entries, literal expressions) and only supports a limited set of data types and operators.

The new community extension brings a completely new FEEL engine which has the goal to fill the gaps. It supports all data types, all operators, built-in functions and can be used for input entries (i.e., unary tests) and any other expression. So it might be interesting for applications that use DMN intensively to model complex decisions and especially for decision literal expressions.

Why Scala?

Scala is a modern, object-oriented and functional JVM language with a good Java interoperability. The new FEEL engine is written in Scala because it makes it very easy to build a parser for the language (i.e., based on parser combinators). And personally, I really like Scala a lot 😉

How to Use it?

If you use an embedded Camunda BPM engine then you can add the extension as dependency to your project POM:


And register the process engine plugin in your configuration:

<bean id="processEngineConfiguration" class="org.camunda.bpm.engine.impl.cfg.StandaloneProcessEngineConfiguration">
    <property name="processEnginePlugins">
           <bean class="org.camunda.feel.CamundaFeelEnginePlugin" />

Or, if you use a shared Camunda BPM engine (i.e., Camunda distribution) then you can download the extension plugin (feel-engine-plugin-1.0.0-complete.jar) and copy it to the library folder of your application server. Then, add the plugin to your process engine configuration (e.g., conf/bpm-platform.xml):

        <!-- other plugins -->    


Assuming you have two input variables applicant and credit_history:

applicant: {
    maritalStatus: "M",
    monthly: {
        income: 10000,
        repayments: 2500,
        expenses: 3000

credit_history: [ 
        record_date: date("2008-03-12"),
        event: "home mortgage",
        weight: 100  
        record_date: date("2011-04-01"),
        event: "foreclosure warning",
        weight: 150  

Then, you can evaluate the following FEEL expressions using the Camunda DMN engine with the FEEL-Scala extension:

applicant.monthly.income * 12                                            // 120000

if applicant.maritalStatus in ("M","S") then "valid" else "not valid"    // "valid"

sum( [applicant.monthly.repayments, applicant.monthly.expenses] )        // 5500

sum( credit_history[record_date > date("2011-01-01")].weight )           // 150

some ch in credit_history satisfies ch.event = "bankruptcy"              // false

See the complete example on GitHub.

Additional Information

You can find more information about the FEEL engine, the integration in Camunda BPM and examples on GitHub and the Wiki.


Contributions in the form of code, bug reports and feature ideas are very welcome and can be made directly in the feel-scala repository on GitHub.

Related Content

Learn the difference between REST, GraphQL and gRPC. Understand the pros and cons and top use cases of each API to help you choose the right one.
Learn about the path we've taken to support Jakarta EE 10 on Wildfly 27 as smoothly as possible for our customers.
Learn why more and more companies are investing in cloud-native technology, and how it can benefit you today.