-
AI-Agnostic Platform
The Rule Editor adapts in real time based on the current rule context, using Adaptive Source to dynamically control available fields, operators, and options. Through a client-defined callback, it can incorporate any LLM of your choice to guide authoring and tailor the experience to your domain. This true bring-your-own-AI (BYOAI) approach makes Code Effects the first AI-agnostic rules engine in the decision automation industry, creating a context-aware, AI-assisted environment that reduces errors and streamlines rule creation.
-
AI-Aware UI
The Rule Editor adapts in real time based on the current rule context, using Adaptive Source to dynamically control available fields, operators, and options. Through a client-defined callback, it can incorporate any LLM of your choice to guide authoring and tailor the experience to your domain. This creates a context-aware, AI-assisted environment that reduces errors and streamlines rule creation.
-
Compile for Any Platform
Built on .NET Standard 2.0, the engine runs on any modern .NET runtime. With an available Full Source perpetual license, teams can compile it for their target environments, enabling consistent deployment across Windows, Linux, macOS, iOS, and Android without changes to rule logic.
-
Native Visual Studio Debugging
Debug business rules directly within Visual Studio using a tracing delegate passed to the Evaluate method. Set breakpoints, step through execution, and inspect condition-level results alongside your source data in real time. This provides full transparency into rule behavior, bringing native debugging to business rules for the first time.
-
Self-Contained Data Processing
All rule evaluation runs locally with no required outbound calls or access to external systems. Rules, data, and user context remain within your environment by default, with any integrations fully controlled by your implementation. This architecture supports secure, compliant deployments, including isolated or air-gapped systems. This unique capability consistently drives adoption of Code Effects in mission-critical, high-visibility projects more than all other features on this page combined.
-
Enforced Rule Execution Security
The engine supports a whitelist of trusted namespaces allowed to declare in-rule methods and rule actions. When defined, this list is enforced during rule evaluation, and an exception is thrown if a rule attempts to invoke methods outside of the approved namespaces. This prevents unauthorized or potentially malicious code from being executed during rule evaluation.
-
Stateless and Thread-Safe Runtime
The engine is built as a thread-safe library, enabling safe and efficient execution in multithreaded and concurrent environments. Rules can be evaluated across multiple threads without contention or shared-state issues. This makes it suitable for mission-critical systems that require reliability, scalability, and predictable behavior under load.
-
Built-In Guidance and Validation
The Rule Editor provides real-time guidance as users build rules, surfacing valid next actions, available options, and immediate feedback on errors. This reduces trial-and-error and helps prevent invalid rule configurations before they are saved. The result is a more efficient authoring experience with fewer mistakes and higher-quality rules.
-
Multi-Source Data Architecture
Supports multiple source types to fit different integration scenarios, including direct use of .NET classes via reflection, XML-based schemas for data description, FlexSource for dynamic data modeling, and Adaptive Source for context-aware, AI-assisted authoring. This flexibility allows rules to be built and evaluated against real, abstracted, or dynamically defined data structures. The result is a consistent rule model across diverse systems without requiring changes to underlying data implementations.
-
Evaluation and Execution Rule Types
Supports two complementary rule types to cover different decision scenarios. Evaluation rules return a deterministic Boolean result and are used for validation, filtering, and conditional logic. Execution rules can invoke .NET methods (rule actions) and set data values based on evaluation results, enabling workflows, state changes, and other side-effect-driven operations within your application.
-
Reusable Rules
Evaluation rules can be defined once and reused across multiple contexts, enabling consistent decision logic throughout your application. Reusable rules can be referenced by rules of any type to build more complex decision structures. This approach reduces duplication, simplifies maintenance, and ensures consistent behavior across systems.
-
Logical Grouping with Parentheses
Rules support explicit grouping of conditions using parentheses, allowing complex logic to be structured into clear, well-defined segments. This enables precise control over evaluation order and improves readability of advanced rule expressions.
-
Configurable Multilingual Support
The Rule Editor supports multilingual UI through an XML-based configuration that defines all labels and messages. Default English terminology can be easily customized or fully translated into any language. Localized configurations can be loaded per user, enabling the editor UI to adapt dynamically to each user’s preferred culture.
-
High-Performance IL-Compiled Evaluation
Rules are compiled into IL, becoming part of your application’s execution path rather than being interpreted at runtime. This eliminates interpretation overhead and enables low-latency, high-throughput evaluation. In benchmark scenarios, the engine has demonstrated the ability to evaluate ONE MILLION object instances against a simple rule in less than 10 milliseconds.
-
Rule-Based Data Filtering and Query Generation
A single evaluation rule can be used to filter large data sets in-memory or translated into LINQ expressions for database queries, allowing rules to be executed either in-memory or at the data source. This enables the same rule definition to drive both object filtering and LINQ-to-SQL or Entity Framework queries. By reusing business rules as query logic, applications can implement dynamic search, segmentation, and data selection without duplicating logic across layers.
-
Human-Readable Rule Logic
Business rules are presented in a clean, human-readable UI, allowing both technical and non-technical users to understand decision logic instantly by simply reading it, without dealing with cryptic formats or programming terminology. Rule conditions are built using fields from your domain model, displayed and described in the user’s preferred language rather than in code syntax.
-
Flexible Rule Storage
Rules are stored as simple XML strings, allowing them to be persisted in any database, file system, or storage solution of your choice. This removes the need for vendor-specific storage mechanisms or retrieval procedures. The result is a flexible, portable rule model that integrates easily with existing data architectures.