Open-source alternatives to Json Rules Engine

This project is a comprehensive guide to architectural standards and coding patterns for developing maintainable applications within the Laravel framework. It focuses on clean code standards, applying the single responsibility and DRY principles to ensure codebase predictability and consistency. The guide emphasizes decoupling components by moving business logic into service layers and shifting input validation into dedicated request classes to keep controllers lean. It advocates for the use of a service container and dependency injection to reduce class coupling and improve testability. The

Power-Fx is a declarative logic framework and low-code formula language based on Excel formulas. It functions as an expression parser and evaluator that transforms formula strings into an abstract syntax tree to execute logical operations and resolve values. The project provides a standardized integration layer to connect formula-based logic to external data sources for querying and pushing records. This allows for the definition of business rules and calculations that can be shared as consistent logic across different applications and platforms.

Easy-rules is a Java business rules engine designed for defining and evaluating conditional logic and actions. It serves as a framework for organizing simple logic units into complex hierarchies of composite rules and acting as an iterative rule processor. The system functions as an expression language rules engine, allowing rule conditions and actions to be defined via dynamic expressions rather than static compiled code. This enables the configuration of business logic that can change application behavior without requiring source code recompilation. The engine supports fact-based matching

This project is a static analysis tool and linter for Ruby on Rails designed to identify architectural smells and violations of best practices. It serves as a code quality linter, architectural auditor, security scanner, and performance analyzer for Rails applications. The tool evaluates the separation of concerns between controllers, models, and view templates to reduce technical debt. It identifies suboptimal coding patterns and enforces stylistic consistency, while specifically scanning for security vulnerabilities such as unprotected mass assignment in models. The analysis surface covers

eShopOnWeb is a reference application for ASP.NET Core that demonstrates a sample e-commerce site. It serves as a template for building scalable services using domain-driven design to separate business logic from infrastructure and data access. The project implements a decoupled messaging pattern through a request pipeline to separate web controllers from application logic. It utilizes a repository pattern to abstract data persistence and isolate the core application logic from the specific database storage mechanism. The application covers a broad surface of web capabilities, including user

This project is a reference implementation of Domain-Driven Design, Clean Architecture, and Command Query Responsibility Segregation (CQRS) patterns using the Go programming language. It serves as a sample application to demonstrate how to decouple core domain rules from infrastructure and delivery mechanisms. The system is built as a gRPC microservices architecture, utilizing type-safe communication and service contracts. It implements an event-driven architecture to manage eventual consistency and asynchronous processing, specifically employing the Outbox pattern to ensure reliable messagin

This project provides a structured boilerplate for building Go web applications based on clean architecture principles. It serves as a template for organizing codebases to ensure that core business logic remains isolated from external frameworks, database layers, and delivery mechanisms. The implementation prioritizes domain-driven design by centering the application around pure business entities that contain no references to infrastructure concerns. It utilizes layered dependency inversion and interface-based port adaptation to decouple the internal logic from external dependencies, allowing

This is a Swift state management framework and application logic library designed for building applications with a single source of truth and unidirectional data flow. It provides a Redux-inspired architecture that separates business logic from side effects and user interfaces to ensure predictable application behavior across multiple screens. The framework focuses on modularity by allowing complex features to be decomposed into smaller, isolated components. This enables the development of UI-independent business logic that can be extracted into separate modules to improve compilation speed a

This project is a cross-platform development framework and application boilerplate designed to build mobile, desktop, and web applications from a single shared codebase. It functions as a React Native development tool, utilizing declarative components to render platform-specific user interfaces while maintaining consistent business logic across all supported environments. The framework distinguishes itself by centralizing core application rules and data management, ensuring identical functional results regardless of the target device. It employs a build-time file resolution system that allows

This project is an open-source Flutter GitHub client and cross-platform mobile application. It serves as a GitHub GraphQL client and OAuth mobile app, providing a mobile interface for browsing repositories, issues, and user profiles. It is also designed as an open-source architecture reference to demonstrate Flutter best practices, state management, and multi-language localization. The application distinguishes itself by using GraphQL queries to retrieve nested repository and user information, reducing network requests and over-fetching. It utilizes a shared Dart codebase to provide a consist

Effector is a reactive state management library and data flow orchestrator designed for building complex, event-driven applications. It models application logic as a directed acyclic graph, where state updates and asynchronous side effects propagate automatically through declarative pipelines. By decoupling business logic from user interface layers, it allows developers to maintain state in independent containers that communicate via standard interfaces, ensuring the system remains framework-agnostic. The library distinguishes itself through its robust support for isolated execution scopes, w

Zeebe is a cloud-native workflow engine and distributed state machine designed for business process orchestration using BPMN and DMN standards. It operates as a high-performance gRPC workflow runtime that executes complex business processes through a partitioned event-streaming architecture. The system also functions as an orchestrator for large language model agents, coordinating AI reasoning and tool use within deterministic business processes. The engine is distinguished by its peer-to-peer broker networking and a consensus-based data replication model that ensures high availability and fa

This project is a collection of software engineering principles and architectural design patterns designed to minimize the mental effort required to understand and maintain source code. It serves as a guide for implementing clean code methodologies and architectural simplification to reduce the overall cognitive load on developers. The framework emphasizes aligning module boundaries and ubiquitous language with business stakeholders to prevent architectural ripple effects. It advocates for balancing service granularity to avoid the overhead of distributed monoliths and suggests favoring objec

Lightning is a PyTorch training framework and distributed AI training orchestrator designed to decouple core research logic from the engineering boilerplate required for model training. It functions as a deep learning workflow manager that automates the process of pretraining and finetuning models across diverse compute environments. The project distinguishes itself by providing a hardware-agnostic training wrapper, allowing the same model code to execute on CPUs, GPUs, or TPUs without modification. It further manages the scaling of workloads from single devices to multi-node clusters and ser

This project is a clean architecture reference implementation and modular project template for Android development. It provides a structural blueprint designed to isolate business logic from external frameworks and user interfaces. The template emphasizes a modular approach to organize code into independent modules, which is intended to improve build times and long-term project scalability. It demonstrates the application of domain-driven design to keep core business rules and entities independent from the underlying platform. The implementation covers several key architectural patterns, inc

This is a Dart state management library and architectural framework that decouples business logic from the user interface by transforming a stream of events into a stream of states. It implements a business logic component pattern to ensure that state transitions are predictable and testable. The project distinguishes itself through advanced event stream processing, providing concurrency strategies to drop, restart, or queue incoming events. It includes a dedicated state persistence layer for saving and restoring application state to maintain session continuity, as well as tools for state his

Space Station 14 is a C# multiplayer game and roleplay simulation framework. It is built upon an Entity-Component-System (ECS) game engine that separates logic into systems and data into components to manage complex entity interactions. The project functions as a grid-based physics simulator with a YAML data-driven prototype system for defining game objects. The project features a specialized 2D sprite rendering engine that maps server-side appearance data to client-side shaders. It implements a networking model with client-side prediction and dirty-flagged state synchronization to reduce inp

Effector is a reactive state management library designed for building complex, event-driven applications. It functions as a data flow engine that models application logic as a directed acyclic graph, ensuring that state updates propagate automatically through interconnected nodes. By utilizing atomic state updates and declarative unit composition, the library maintains data consistency and provides a predictable execution model for managing application state. The project distinguishes itself through its framework-agnostic architecture, which decouples business logic from user interface implem

yii2_fecshop is a comprehensive B2C e-commerce platform and CMS built on the Yii2 PHP framework. It functions as a headless commerce API and an international storefront solution, supporting both single-vendor stores and multi-vendor marketplaces where independent merchants can manage their own products and orders. The system is distinguished by a multi-entry point architecture that separates administrative, web, mobile, and API interfaces while sharing a common service layer. It provides high extensibility through configuration-driven service replacement, event-driven functional extensions, a

This is a reference implementation of Uncle Bob's clean architecture for Android, structured into distinct domain, data, and presentation layers. The project demonstrates how to organize an Android application around business use cases, keeping domain logic and entities free from framework dependencies. The architecture enforces dependency inversion through layered separation, where inner domain layers define interfaces that outer layers implement. This approach enables repository abstractions for data source switching, presenter-view separation for testable UI logic, and use-case composition

This project is a technical resource and pattern library for building enterprise applications with Python. It serves as a guide for implementing clean architecture, providing a framework for separating core business logic from infrastructure and external frameworks. The material focuses on Domain-Driven Design and the application of architectural patterns to maintain complex business requirements. It provides specific guidance on the Repository pattern for data abstraction, Command-Query Responsibility Segregation for optimizing read and write paths, and the use of dependency inversion to dec

This project is a full-stack forum platform built with TypeScript that serves as a reference architecture for implementing domain-driven design and clean architecture patterns. It provides a structured environment for community discussion, enabling users to register, authenticate, and engage in moderated conversations across organized topic categories. The platform distinguishes itself by strictly separating core business logic from infrastructure concerns. By utilizing a layered hexagonal architecture and the repository pattern, the codebase isolates business rules from external frameworks a

This project is a comprehensive template for building enterprise-grade applications using clean architecture principles. It provides a structured foundation that decouples core business logic from infrastructure concerns, ensuring that domain entities remain independent of specific frameworks or database implementations. By utilizing a mediator-based request dispatching pattern, the system separates state-mutating commands from read-only queries, promoting a clean separation of concerns across the entire codebase. The architecture is organized into vertical slices, grouping related logic and

This project is an educational platform and tutorial series designed to teach the Go programming language through the practice of test-driven development. It provides a structured path for developers to master language fundamentals, concurrency, and standard library usage by building functional applications in small, verifiable increments. The core methodology centers on the test-driven development cycle, where failing tests are written before implementation to define requirements and ensure code correctness. This approach is applied across a wide range of practical scenarios, including the c

Eleventy is a JavaScript-based static site generator designed to transform templates, data files, and markdown into optimized HTML. It functions as a versatile template rendering engine and content management framework, allowing developers to aggregate data from diverse sources—including local files, databases, and external APIs—to populate structured web content. The project is distinguished by its template-engine-agnostic pipeline, which decouples the build process from specific rendering languages. This allows users to integrate multiple template formats, such as Liquid, Nunjucks, Handleba

Chartbrew is a self-hosted business intelligence platform and data visualization engine designed to transform raw data from SQL databases and external API endpoints into interactive charts and dashboards. It serves as a tool for building analytics dashboards that monitor business metrics and KPIs through a privately hosted environment. The platform distinguishes itself with an embedded analytics workflow, allowing users to generate secure, time-limited shared links and iframes to display private charts on external websites. It also provides programmatic chart generation via API and integrates

This project is a comprehensive technical guide to advanced Go programming. It serves as a programming guide, technical reference, and textbook covering low-level optimization and distributed systems architecture. The resource provides detailed instructions on writing assembly instructions to optimize performance-critical code and managing C-Go interoperability to bridge C libraries with Go. It also functions as a manual for implementing remote procedure call mechanisms and creating custom plugins for the Protocol Buffers compiler. The material covers high-level capabilities including the de