DecisionLang
Declarative modeling and multi-runtime execution language for decisions.
Built for everyone.
What is DecisionLang?
DecisionLang is a decision modeling and multi-runtime execution language. A fifth-generation language (5GL), purposefully built to unify AI, data, rules, processes, and math into a declarative form easy to understand for technical and non-technical teams.
The Origin of DecisionLang
At FlexRule, we saw a gap; decisions were mixed with logic, code, config, SQL, rules, workflows, and UI. They were everywhere but never unified.
We explored the usual options: existing modeling languages were too niche and limiting, visual builders too rigid.
So we built DecisionLang. Our patented innovation as a fifth-generation modeling and multi-runtime execution language that brings AI, data, rules, processes, and math together in one declarative form.
DecisionLang’s mission is to make teams say, “Finally, someone solved it. We can see the decisions.”
10x Your Decision Cycle Productivity with DecisionLang
Traditional No-Code or Low-Code
- Rules are buried in flows
- Flows are buried in UIs
- Business Logic are buried into complex and convoluted orchestration
- Data Semantics (e.g. filters and joins) are buried in SQL
- Context is buried in ETL, pipelines and Workflows
- AI is bolted on afterward
- Optimization is left behind entirely
- Same decision logic doesn’t translate across SQL, rules, and calculations. Scattered. Duplicated.
- Decision and decision logic are treated the same, blurring the line between what to decide and how it’s decided. Business intent vs. Implementation.
Technical debt is still technical debt, whether it comes from no-code, low-code, or pro-code.
With DecisionLang
- Decisions come first, and are modeled explicitly. Not rules, code, data, ML, or dashboards.
- Logic lives in the declarative language, not buried in scripts or hidden behind UIs.
- Data semantics (filters, joins, relationships) are part of the model, not trapped in SQL.
- Context is declared, not stitched together from ETL pipelines.
- Rules, AI, optimization, and process are unified, not patched in later.
- Execution is portable across database, .NET, JS, server, and client with no rewrites.
- Everything is governed: transparent, clear, versioned, readable, and traceable.
Unified decision language brings consistency, eliminates duplication, and increases agility.
Business Value of DecisionLang
Accelerates Time-to-Value
Provides a clean and structured language purpose-built for decisions. Multiple teams can use DecisionLang simultaneously. So, it shortens the time from business requirement to deployment of automated and augmented decisions.
Eliminates Lose in Translation
Its layered design supports both technical and non-technical users. It establishes a dynamic common language on top of the Decision Model and Notation (DMN) standard. This reduces miscommunication, avoids translation errors, and enables direct participation of all team members.
Enables Agility in Change
The dynamic nature of DecisionLang enables quick changes. The deep separation of concerns in its design makes DecisionLang modular and composable. Therefore, applying changes becomes isolated, local, safe, and fast.
Reduces Operational Costs
Composability and reusability are built into the core of DecisionLang. Clarity and ease of applying changes in isolation, along with the participatory nature across teams, reduce development and change efforts and long-term maintenance costs.
Ensures Governance and Compliance
What you model is what gets executed. No layers upon layers of transformation or compilation to avoid loss-in-translation effects. So, DecisionLang guarantees traceability, explainability, and auditability.
Maximizes Project Growth and Scalability
Simplicity and familiarity of syntax, and the participatory approach based on multi-layer targeting of multiple roles, enable the delivery of complex scenarios with minimum technical skills and no need for an army to scale.
Guarantees Quality and Reliability
DecisionLang makes decision logic predictable, testable, and trustworthy. Every rule, condition, and data element is explicitly defined, with nothing hidden or left to chance. Quality is built-in, visible, and verifiable.
Future-Proofs Architecture
DecisionLang unifies data, AI, rules, constraints, and reasoning under a consistent declarative and modern paradigm, which ensures seamless integration and ease of extensibility. Its extensible nature (by custom code, or by itself) allows new concepts and behaviors to be introduced without sacrificing clarity, structure, or governance over time.
Meet DecisionLang
Your future-proof purposefully built declarative language for decisions.
DecisionLang Architecture
The architecture of DecisionLang consists of three core layers
Expression Layer
This is where detailed runtime expressions live. It enables users to define dynamic expressions for various tasks such as creating objects, defining values and parameters, invoking functions, specifying calculations, conditions and control logic. This layer powers the granular atomic logic behind decisions and feeds into the Composition layer.
Composition Layer
This is a set of XML documents, collectively known as a Logic Document, that defines the semantics, coordinates behaviors, declares the inputs and outputs of the decision logic, and manages dependencies to other Logic Documents. It structures logic representation, making it a robust and future-proof foundation for managing decisions and their logic at scale.
Binder Layer
Binder layers are the translation and execution adapters inside DecisionLang. They take the Logic Documents and Expressions in DecisionLang and translate them into the syntax, semantics, and runtime structures required to target a specific execution environment. This allows the same decision model to run seamlessly across different technologies such as SQL, DMN, JavaScript, and .NET without a rewrite.
Composition Layer
Define the intent, i.e. the “What”. Separate it from the “How” i.e. a Decision Logic.
The Composition Layer defines the scope of “what”. What decision or action should be taken and without prescribing how it is done. It is a purely semantic intent model that structures what must be decided or performed.
In an essence it defines a “Logic Document” as a container for a composite structure and semantic of a decision with defining how different elements i.e. decision units such as business knowledge, sub decision, signal and etc. are related and what they require.
With the Composition Layer, you:
- Model intent based on the outcomes and objectives
- Capture the metrics around the success or failure
- Decompose decisions into sub-decisions or required actions
- Define semantic relationships and dependencies between them and their scopes
This upfront and deep separation of intent from implementation enables clear, composable, and scalable decision architecture in DecisionLang. It’s a declarative layer that describes a variety of decision's intents in XML.
Expression Layer
Make the “how”, i.e. Decision Logic, reusable and scalable.
The Expression Layer captures the “how”. The how a decision is made or an action is performed using structured logic, expression evaluations, and computations.
It supports two types of expressions:
Structured expressions: no-code composable logic built from atomic expressions, such as condition sets, activity flows, multi-branch evaluations, decision tables and more.
Atomic expressions: declarative, functional, standalone expressive logic such as comparisons, calculations, inline conditions, filters, function calls, and other constructs of an expression language such as types, flow control, operators, operands and more.
Expressions in this layer operate on the context and outcomes defined in the Composition Layer. They represent the actual decision logic while remaining modular, traceable, and portable.
This separation keeps your decision models clean, explainable, and executable across environments.
Binder Layer
Bridging Design and Execution
Binders eliminate the need to rewrite logic for different layers of your enterprise across various execution environments.
The Binder Layer connects DecisionLang's declarative design to multiple runtimes. It translates expressions such as filters, rules, or calculations into the form that each engine can understand and execute.
While all logic can run natively using the DecisionLang engine, binders improve efficiency when targeting platforms like SQL, JavaScript, .NET, DMN, or Constraint Programming (CP) solvers. Alternatively, you can build your own binder.
For example, a TSQL Binder pushes filtering logic directly into the database to improve performance without changing your model.
From a single DecisionLang model, you can run the same logic across different runtimes without rewriting or duplicating anything.
Integration
DecisionLang is modular and extensible by design. Built to fit your architecture, not force one.
With our Open SDK, you can customize everything. Extend or modify every level from language and runtime behavior to the No-Code modeling experience.
It gives your team full control to integrate DecisionLang into any environment while preserving clarity, structure, and governance.
DecisionLang allows you to:
- Reference ready-to-use extensions including optimization, AI, ML, and reasoning modules
- Integrate existing code and connect your own libraries or services into the runtime
- Define custom functions for reusable, domain-specific logic
- Extend runtime behaviors such as evaluation, storage, or service layers
- Inject custom interfaces and callbacks for event handling and monitoring
- Customize the No-Code experience to match your organization’s language and modeling patterns
- Extend using code, DecisionLang, or No-Code so every role can contribute at the right level of abstraction
DecisionLang and DMN
DecisionLang is DMN Conformance Level 3, but it extends well beyond the limits of DMN.
DecisionLang is the superset of Decision Model and Notation with Conformance Level 3.
What this means:
- You can model DMN decision tables, decision graphs, and boxed expressions directly in DecisionLang
- DMN models can be authored, executed, and extended as part of your decision logic
- DMN is treated as a supported subset within a broader decision modeling language
Why it matters:
- Teams familiar with DMN can adopt DecisionLang without disruption
- As decision complexity grows, DecisionLang provides more power and flexibility
- You can model rules, flows, context, AI, and optimization without stepping outside the language
DecisionLang embraces DMN where it fits, and expands where it doesn't. It gives you a smooth path from standard models to advanced, real-world decisioning.
No-Code and Low-Code
Same Power for Everyone.
Authoring environments (Decision Designer and Decision Studio) provides a diverse range of visual languages for DecisionLang that do not require programming to create executable business logic.
Through intuitive editors, drag-and-drop interfaces, and graphical modeling tools, non-technical users can design, test, and deploy decision logic with the same precision and power as code-based models.
Every visual model is backed by executable DecisionLang logic, ensuring that what you design is exactly what runs.
This consistency allows both technical and non-technical users to collaborate seamlessly while maintaining transparency, traceability, and governance.
Who Should Care and Why?
Future-proof decision modeling and execution language — declarative, extensible, and enterprise-ready
Where DecisionLang is used in our Platform?
