NRules

Quick Summary

NRules is a production .NET rules engine built on the Rete network algorithm — the same approach used by enterprise BRMS systems like Drools, but scoped entirely to the .NET ecosystem. Unlike most open-source rule engines that use simple sequential evaluation, NRules implements real forward chaining with incremental matching: facts are asserted into working memory, and the Rete network fires rules as conditions are satisfied, including chains where the output of one rule is the input for another. It supports modern .NET 6+ and .NET Framework, is actively maintained by Sergiy Nikolayev (v1.0.4 released February 2026), and has a runtime rule builder that lets code construct and load rule sets dynamically at application startup.

An AI-assisted authoring tool — NRules Rule Writer GPT — exists specifically for C# developers defining NRules rules with natural language assistance.

The constraint is that NRules is deeply .NET-specific. Rules are written as C# fluent DSL — a syntax that is expressive and type-safe, but inaccessible to anyone who is not a C# developer. There is no visual editor, no decision table, no hosted service, and no concept of governance. Business users cannot change rules; every rule change is a code change, a build, and a deployment. More critically, NRules is maintained by a single developer. Sergiy Nikolayev has maintained the project consistently and the February 2026 release shows active development — but the project's long-term continuity depends on one person remaining engaged. For organizations with supply-chain risk policies, single-maintainer dependencies require scrutiny independent of the current project health.

NRules also offers no cross-stack portability. Teams running Python, Java, JavaScript, or Go microservices alongside .NET cannot use NRules outside the C# boundary. The rules engine is not a service — it is a library that lives inside .NET processes.

What Is NRules?

NRules is a .NET library implementing the Rete network algorithm for forward-chaining rule evaluation. Core components:

• Fluent C# DSL — rules are C# classes inheriting from Rule, with When() (conditions matching against typed fact objects) and Then() (action methods fired when conditions are met)
• Rete network — incremental matching using alpha memory (single-fact pattern evaluation) and beta memory (multi-fact join evaluation); patterns are evaluated against changes to the fact network rather than re-evaluating everything on every fire
• Forward chaining — the engine fires rules as conditions become satisfied; rules whose actions assert new facts can trigger other rules in sequence
• Working memory — facts are inserted, updated, and retracted; the Rete network maintains match state between firings
• Runtime rule builder — a fluent API for constructing and loading rule definitions programmatically at runtime without pre-compilation
• Agenda and rule ordering — rules are scheduled for firing on an agenda; priority and conflict resolution control which rule fires when multiple rules are triggered simultaneously

There is no authoring UI, no decision table, no hosted cloud option, no governance layer, no REST API, and no cross-language support. NRules is a C# library that evaluates rules against a .NET fact model.

How We Analyzed NRules' Abilities

For this review, we focused on what determines whether a team can responsibly build production decisioning on NRules in 2026 — not whether the Rete implementation passes unit tests, but whether the operational and organizational model can support the team's actual requirements.

Our analysis draws from the NRules GitHub repository (v1.0.4 release notes, commit history, issue tracker), the NRules documentation, and real-world engineering estimates modeled at production scale.

How NRules Works

NRules uses Rete-based forward-chaining evaluation — fundamentally different from sequential evaluation:

1. Rule Definition: Developers write C# classes inheriting from Rule, implementing When() with pattern conditions and Then() with action logic. The fluent DSL uses LINQ-style expressions for fact matching — type-safe, IntelliSense-supported, and readable to C# engineers.

2. Compilation: At startup, a RuleRepository compiles rule classes into a Rete network — an internal graph of alpha nodes (single-fact pattern matching), beta nodes (multi-fact joins), and terminal nodes (agenda items). Compilation happens once; the network is then reused per-session.

3. Session Creation: An ISession is created for each evaluation context. Sessions can be kept open for stateful, multi-step evaluation or created fresh per request for stateless processing.

4. Fact Assertion: The application inserts facts using session.Insert(), updates them with session.Update(), and retracts them with session.Retract(). The Rete network incrementally evaluates pattern matches as facts change — only affected parts of the network re-evaluate.

5. Agenda Firing: session.Fire() executes all rules on the agenda in priority order. Rules whose Then() actions assert or modify facts can trigger additional rules; forward chaining continues until the agenda is empty.

6. Change Management: A rule change means modifying the C# rule class, rebuilding the application, and redeploying. There is no built-in test harness beyond standard .NET unit tests, no simulation mode, and no staging environment concept at the rules layer.

Who Uses NRules?

NRules is used by:

Experienced .NET engineering teams: Teams that evaluated enterprise BRMS options (IBM ODM, Progress Corticon) and found them disproportionately expensive or complex for their use case, choosing NRules for a production-grade Rete engine at $0 license cost.

Teams with complex rule interdependencies: Use cases where rule chaining is essential — one rule's output triggers another — are where NRules' Rete architecture provides genuine value over sequential engines.

Financial services and insurance .NET shops: Domain-specific evaluation logic in risk scoring, eligibility determination, or pricing rules that needs production performance within a .NET architecture.

Teams building C# applications that can't justify a full BRMS: Organizations where Drools or Corticon would require Java expertise or disproportionate licensing spend for the use case they're solving.

Reviews

Pros:

• .NET-native production Rete engine — a real Rete network implementation, not sequential evaluation; handles large rule sets and forward chaining with proper algorithmic efficiency
• Actively maintained — v1.0.4 released February 2026; Sergiy Nikolayev continues to address issues and ship improvements, unlike many open-source rule engines that have gone dark
• Runtime rule builder — rules can be constructed and loaded programmatically at runtime via the fluent builder API without requiring pre-compiled rule classes
• Supports modern .NET 6+ and .NET Framework — no legacy compatibility issues; runs on the current .NET stack without framework constraints
• AI-assisted authoring for C# developers — NRules Rule Writer GPT helps C# developers define NRules rules with natural language assistance, reducing the learning curve for the DSL

---

.NET Developer on GitHub Discussions

NRules is the best Rete engine available for .NET, full stop. If your problem requires real forward chaining — rules that chain into other rules, not just evaluate once — this is your only serious open-source option on the .NET stack. Sergiy is responsive on GitHub and the documentation is solid. For developer-owned rule logic in a .NET service, I'd choose this over any sequential engine.

Solutions Architect on Stack Overflow

We run NRules in a financial services application for eligibility rules that chain across several steps. The Rete performance is solid at our volume — significantly better than what we had before with a hand-rolled sequential evaluator. The limitation is what it's always been with library-based engines: our compliance team cannot touch the rules. Everything goes through engineering, which is a bottleneck. But for purely technical teams, NRules is excellent.

Verified Community Reviews

Cons:

• No business-user authoring — rules are C# code with a fluent DSL; non-developers cannot write, modify, or review rules without developer assistance
• .NET only, no cross-stack — if your organization runs Python, Java, Go, or JavaScript services, none of them can use NRules without a C# process boundary
• No UI, no hosted option, no governance — no visual editor, no decision table, no cloud deployment, no approval workflow, no audit trail; all governance is a custom build
• Single-maintainer risk — the entire project depends on Sergiy Nikolayev; supply-chain risk policies at many organizations require scrutiny of single-maintainer dependencies regardless of current project health
• No workflow or Human-in-the-Loop — NRules evaluates rules but has no concept of multi-step decision workflows or human approval gates
• No AI or MCP integration at the platform level — the NRules Rule Writer GPT helps C# developers write rules, but there is no AI decision layer, no MCP connector, and no natural language decisioning at the platform level

---

Engineering Manager on LinkedIn

We had to write our own approval workflow, audit logger, versioning system, and admin UI on top of NRules. By the time we finished, we'd spent more than we would have on a platform license. The library is technically strong but the TCO of building enterprise-grade infrastructure on top of a library is always higher than it looks. Also: one maintainer. If Sergiy moves on, we have a problem.

Developer on GitHub Issues

NRules is great if you're a .NET shop and you need forward chaining. The problem is everything around it. Our product team cannot touch rules — every business change is a code deployment. We're looking at migrating to a platform where we can give them a UI. The library did its job; we outgrew what a library can do.

Verified Community Reviews

In-Depth NRules Features Analysis

1. Execution & Scale

NRules' Rete implementation provides genuine algorithmic advantages over sequential engines for large, complex rule sets. Alpha memory avoids redundant single-fact pattern testing; beta memory tracks multi-fact join states incrementally. For rule sets with many conditions sharing common patterns, Rete's performance advantage over linear scan compounds as rule count grows. Stateful sessions allow incremental fact assertion — the Rete network only re-evaluates changes, not the full rule set on every fire.

For production .NET services with complex rule sets, NRules performs well in-process. The scaling story is the same as any embedded library: scaling the decisioning layer means scaling the .NET application process. There are no NRules-specific scaling primitives, session clustering, or distributed evaluation mechanisms.

Strengths:

• Rete network provides algorithmic scaling for large rule sets — incremental matching avoids linear performance degradation as rule counts grow, unlike sequential engines.
• Stateful sessions enable incremental fact evaluation — facts can be asserted, updated, and retracted across multiple calls; the Rete network re-evaluates only affected matches.
• Forward chaining supports complex rule interdependencies — rules that assert facts consumed by other rules chain naturally within a session.
• In-process .NET execution avoids external service latency — no network hop for rule evaluation; the engine runs inside the hosting .NET application.

Drawbacks:

• No auto-scaling — scaling means scaling the .NET application; there is no decisioning-layer-specific scaling mechanism.
• Rete compilation overhead at startup — the initial compilation of rule classes into the Rete network adds startup time; session creation is fast, but cold start costs are real.
• No horizontal session sharing — stateful sessions are per-process; distributing session state across instances requires custom synchronization.
• .NET-only — no cross-stack rule sharing; Python, Go, or Java services cannot call into NRules without introducing a .NET process boundary.

2. Build & Author

NRules rules are C# classes. The fluent DSL — When() with typed pattern matching and Then() with action methods — is readable and type-safe for C# engineers; Visual Studio and Rider provide full IntelliSense and refactoring support. The NRules Rule Writer GPT gives C# developers natural language assistance for constructing rules, reducing the learning curve for the DSL's pattern syntax.

None of this helps non-developers. A compliance analyst, product manager, or pricing actuary looking at a C# Rule class cannot safely modify it — even with the GPT assistance, which is aimed at helping C# developers, not replacing the need for them. Every business rule change routes through a developer, requiring code review and application deployment.

Strengths:

• C# fluent DSL is type-safe and IntelliSense-enabled — rule conditions and actions are first-class C# code; the IDE catches type errors, supports refactoring, and provides full tooling support.
• Real forward chaining via Rete — rule chaining (where a rule's output triggers other rules) is a native capability, not a bolt-on; complex interdependent rule sets work correctly.
• Runtime rule builder for dynamic rule construction — rule sets can be assembled and loaded programmatically at runtime without requiring pre-compiled C# classes; useful for rule sets driven by configuration.
• NRules Rule Writer GPT reduces C# developer learning curve — AI assistance for defining NRules-style rules in natural language lowers onboarding time for developers unfamiliar with the DSL.

Drawbacks:

• Zero authoring path for non-C# developers — every rule is C# code; business teams cannot self-serve any rule changes, regardless of the Rule Writer GPT tool (which targets C# developers, not business users).
• No decision tables — tabular policy logic must be expressed as individual C# rule classes; there is no built-in table-style authoring.
• .NET-only rule authoring — other stacks cannot use NRules rules; the C# DSL is not portable to other languages or platforms.
• No AI at the platform level — AI-assisted authoring is limited to C# developer tooling; there is no AI decision layer, no natural language rule execution, and no copilot for business-level rule management.

3. Operate & Govern

NRules ships zero governance. The library has no concept of users, roles, approvals, versions, environments, or change history. Governance must be built from scratch — Git history as version record, code review as approval proxy, custom action-method logging as execution trace. These proxies are workable for small developer-owned systems. They do not satisfy compliance programs requiring formal change approval evidence, and they do not enable rapid rollback without a full application redeployment.

Strengths:

• Git provides a version record — rule classes in source control give commit history showing who changed what and when.
• Code review provides a lightweight approval mechanism — PRs enforce a review step before changes go live.

Drawbacks:

• No native approval workflows — rules go live at deployment; no built-in pre-deployment approval step exists.
• No RBAC — anyone with repository and deployment access can change any rule.
• No execution audit trail — the library produces no record of what rules fired, against what facts, for what decisions; audit evidence requires a custom logging project.
• No one-click rollback — reverting a bad change means reverting a git commit, rebuilding, and redeploying the application.
• No environment promotion workflow — dev-to-staging-to-production follows whatever the team's CI/CD pipeline does; no rule-specific promotion concept exists.

4. Integrations & API

NRules has no integration layer. Facts are .NET objects asserted into working memory by application code. Any data the rules need — from a database, external API, message queue, or event stream — must be fetched by the application before being inserted as facts. Every integration is custom C# written, deployed, and maintained by the team.

Strengths:

• Integrates with any .NET-accessible data source — the hosting application can use any .NET data access library (EF Core, Dapper, HttpClient) to fetch facts before insertion.
• No external process dependencies — the engine runs entirely in-process; no separate database, message broker, or runtime service to provision for the engine itself.

Drawbacks:

• No connector catalog — every data source integration is a custom development project with no acceleration from pre-built connectors.
• No REST API — NRules is a library; exposing rule evaluation as an HTTP endpoint requires the team to build a controller layer in ASP.NET or similar.
• No webhooks or scheduler — evaluation is triggered by application code; event-driven and scheduled triggering require custom orchestration.
• No import/export format — migrating rule sets to another platform requires reading C# source files and manually reconstructing logic.
• Multi-source data requires sequential custom fetches — the application must retrieve each data source before the session; there is no declarative multi-source support.

5. Support / SLA

NRules has no formal support structure. Sergiy Nikolayev maintains the project and is generally responsive on GitHub — the issue tracker and discussions show active engagement. This is better than most open-source rule engines. But it is not a commercial support channel with SLAs, escalation paths, or guaranteed response times. No enterprise tier, no support contract, no migration assistance.

Strengths:

• Sergiy Nikolayev is genuinely responsive on GitHub — issue resolution and discussion response times are better than most single-maintainer open-source projects.
• v1.0.4 released February 2026 shows active development — the project is not stagnant; recent releases include real improvements.
• Documentation is solid for a library of this scope — the wiki and XML doc comments provide enough coverage for experienced .NET developers to self-serve most questions.

Drawbacks:

• No SLA of any kind — uptime and reliability are entirely the team's infrastructure responsibility.
• Single-maintainer support — all maintainer support depends on one person's availability; vacation, illness, or changed priorities can halt response times.
• No migration assistance — moving to another platform is a self-owned engineering project.
• No training programs — no structured onboarding, certification, or learning paths beyond the documentation and GitHub discussions.
• Vulnerability response depends on one person — a security issue requires Sergiy to address it; there is no security team or formal response process.

6. Security & Compliance

NRules carries no compliance certification. All compliance posture is the implementing team's responsibility — SOC 2, ISO 27001, and GDPR controls must be built and maintained at the application and infrastructure layer. For vendor risk management programs, "single maintainer" is an emerging flag in supply-chain security policies independent of known vulnerabilities, as it represents undiversified risk in the maintenance and patch response model.

Strengths:

• Deployment flexibility — runs anywhere .NET runs; on-premises, Azure, AWS, containerized; no platform constraints from the library.
• No external network calls — NRules makes no outbound connections at runtime; all data stays within the hosting .NET process.
• MIT license permits auditing and forking — teams can read the full source, audit it, and maintain their own patched fork if required.

Drawbacks:

• No SOC 2, ISO 27001, or GDPR certification — all compliance is the team's responsibility.
• Single-maintainer supply-chain risk — no organizational redundancy in the maintenance model; security patches depend entirely on one person's availability and engagement.
• No multi-tenancy — the library has no tenant isolation concept; multi-tenancy must be built at the application level.
• Security controls are entirely the team's responsibility — no encryption, access control, or data handling ships with the library.

7. Logs / History / Reports

NRules exposes an IEventProvider interface that fires events for rule activation, firing, and fact insertion/update/retraction. This event system provides a hook for custom execution tracing — teams implement listeners that pipe to their logging infrastructure. The library stores nothing. There is no built-in audit trail, analytics dashboard, reason-code generation, or log retention.

Strengths:

• IEventProvider exposes granular execution events — activation, firing, and fact lifecycle events give a complete picture of what the Rete network is doing for custom logging implementations.
• .NET structured logging integration — events can be piped to Microsoft.Extensions.Logging, Serilog, or any .NET logging framework the application already uses.
• Rich rule activation context — event payloads include matched fact objects, making it possible to build detailed execution records with full fact context.

Drawbacks:

• No built-in audit trail — event emission plus storage plus querying is entirely a custom build project; the library provides only the event hooks.
• No analytics dashboard — rule execution patterns, latency distributions, and outcome analytics require external tooling built by the team.
• No explainability or reason codes — structured natural-language explanations must be coded into event handlers or action methods.
• No log retention — the library stores nothing; retention is whatever the hosting application and its logging infrastructure provide.
• No organization tools — rule sets are C# classes in a project; there is no native search, tagging, or taxonomy support.

Pricing

NRules is free — MIT license, available on NuGet, zero cost to adopt. The real cost is implementation time, infrastructure, the permanent developer-time tax on every rule change, and the ongoing cost of building and maintaining governance infrastructure that the library doesn't ship. Year 1 TCO at 100 TPS reflects those real costs for a team that builds everything enterprise-grade from scratch.

Total Cost of Ownership Comparison

What the Numbers Actually Mean

NRules' ≥$80K Year 1 is higher than Easy Rules (also ≥$80K) because the Rete implementation is more complex to implement correctly, and the single-maintainer risk premium reflects the contingency cost organizations should plan for around supply-chain continuity. GoRules at ≥$250K is far higher because, despite a $0 license, the full-stack self-hosting, operations, and governance build costs compound significantly.

Nected at ≥$20K Year 1 costs less in total because governance, connectors, business-user authoring, and managed infrastructure are included in the platform. The permanent developer-time tax on every rule change is eliminated. The single-maintainer supply-chain risk is also eliminated — Nected is a commercial platform with an engineering team. At ≥$60K over three years versus ≥$240K for NRules, the case for Nected is straightforward for any organization where business-team participation in rules, compliance requirements, or organizational risk management matter.

Top 3 NRules Alternatives

The three most commonly evaluated alternatives when NRules doesn't fit — or when teams outgrow the constraints of a .NET-only, developer-only library model. Nected is the complete platform play: business users author rules in a visual editor without writing C#, governance ships on day one, the API works from any language or stack, and Year 1 TCO starts at ≥$20K versus NRules' ≥$80K when implementation and ops are counted. GoRules is the most realistic swap for engineering teams who want to stay open-source but need cross-language reach — it is actively maintained by an organization rather than a single person, works across stacks, and has a modern interface, though governance and connectors still require a custom build. Easy Rules is a Java library in the same open-source library category as NRules — simpler sequential evaluation rather than Rete, Java-only, and explicitly in maintenance mode since 2020; it is worth comparing if a Java team is evaluating both, but NRules is the clearly stronger maintained option.

Looking for the full list of NRules alternatives? See our deep-dive → Top 10 NRules Alternatives for 2026

Why Teams Compare Nected Against NRules

When teams evaluate NRules — or run it in production and hit the limits of a developer-only, library-only model — four things consistently drive the comparison with Nected:

Every rule change is a C# PR, a build, and a deploy: NRules rules are C# code. Changing a rule means a developer writes C#, the team reviews a pull request, CI builds the application, and it deploys. Business teams — product managers, ops analysts, compliance officers — have no interface to touch rule logic. That engineering bottleneck is permanent unless you replace the engine. Nected gives product and ops teams a visual editor — they update rules in minutes, no C# required.

.NET only — every other stack in your organization is cut off: NRules is a C# library. If your organization runs Python, Java, Go, or JavaScript services alongside .NET, none of those services can use NRules without introducing a .NET process boundary just to evaluate rules. Nected is API-first — any language, any service, any cloud integrates via REST. No .NET constraint, no cross-process overhead.

No governance, no workflow, no hosted option: NRules ships Rete evaluation and nothing else. No audit trail. No RBAC. No approval flows. No versioning. No hosted cloud option. Every governance control your compliance team needs is a custom engineering project built on top of a library. Nected ships maker/checker approval flows, audit logs, RBAC, and one-click rollback on every plan — no custom build, no separate infrastructure.

Single-maintainer risk: NRules is maintained by one person — Sergiy Nikolayev. He has done consistent, high-quality work and v1.0.4 shipped in February 2026. But the project's security response, feature roadmap, and long-term continuity depend entirely on one individual's continued involvement. For organizations with supply-chain risk management requirements, that dependency requires scrutiny. Nected is a backed, actively developed product with a full engineering team, contractual SLAs, and a shipping roadmap.

Final Verdict

NRules is the best open-source Rete rules engine available for the .NET ecosystem. For C# development teams that need genuine forward chaining, work in a .NET-only architecture, and can accept a developer-owned library model with no business-user participation, it is technically strong. Sergiy Nikolayev's active maintenance — v1.0.4 in February 2026 — puts NRules ahead of most open-source alternatives that have gone dark.

The fundamental constraints are architectural, not execution quality. NRules requires C# — business users are permanently gated out. It is .NET-only — cross-stack organizations cannot use it outside the C# boundary. It ships zero governance — audit trails, RBAC, approval flows, and versioning are all custom build projects. And it carries single-maintainer supply-chain risk that vendor risk management programs increasingly flag.

Nected at ≥$20K Year 1 is a better total cost despite the license — because governance, connectors, cross-stack API access, business-team authoring, and managed infrastructure are included. The ≥$80K Year 1 and ≥$240K three-year NRules TCO reflects what teams actually pay when they build everything enterprise-grade from scratch on a library. For .NET teams where the constraints above are acceptable and the rule sets are complex enough to benefit from Rete — NRules is a solid choice. For everyone else, Nected removes the constraints without the TCO penalty.