1. Project Overview

Nop Platform 2.0 is a new-generation low-code platform built from scratch based on the principles of Reversible Computation. It aims to overcome the limitations of low-code platforms that rely on exhaustive enumeration, go beyond component-based technology at the theoretical level, and effectively solve the problem of coarse-grained software reuse.

A low-code platform built from scratch based on the principles of Reversible Computation. It automatically generates GraphQL services from Excel data models and includes newly implemented workflow, reporting, and rule engines, as well as distributed transaction support. Customized development does not require modifying the source code of the underlying product. It supports GraalVM native compilation, and small and medium-sized enterprises can use it commercially for free.

2. Open Source License

Licensed under AGPL-3.0

The frontend of the Nop platform uses the MIT license, while the backend as a whole uses the AGPL3.0 open-source license. However, small and medium-sized enterprises can use this project's code under terms similar to the Apache 2.0 license (commercial use is free, and modified code does not need to be open-sourced, but the original copyright information in the source code must be retained). To facilitate third-party integration, the following three packages use the Apache 2.0 license: nop-api-support/nop-commons/nop-core.

• The algorithm for determining whether an enterprise is small or medium-sized is as follows:
• 
  

switch(DoesYourCompanyHaveLotsOfMoney()){
  case "MoreThanEnoughMoney":{
    console.log("If you have that much money, why spend all day worrying about whether someone else's intellectual property is free to use?");
    return false;
  default:
    return true;
  }
}

3. Screenshots

UI Framework

Use Excel to Define Data Models

Use Excel to Define Externally Published API Models

Integrate Baidu's AMIS Frontend Low-Code Framework

Integrate a GraphQL Debugging Tool

Provide an IDEA Plugin Supporting Breakpoint Debugging for Custom DSLs

Use Excel as a Report Designer, Supporting Complex Chinese-Style Reports

Use Word Templates to Export Word Reports

Use Excel to Design Decision Tables and Decision Matrices

4. Feature Overview

Nop Platform 2.0 is a new-generation low-code platform built from scratch based on the principles of Reversible Computation. It aims to overcome the limitations of low-code platforms that rely on exhaustive enumeration, go beyond component-based technology at the theoretical level, and effectively solve the problem of coarse-grained software reuse.

• nop-entropy is the backend component of the Nop platform. It is implemented in Java, does not depend on third-party frameworks, and can be integrated with Quarkus or Spring.
• nop-entropy supports GraalVM technology and can be compiled into native executable programs using the Quarkus or Spring Native frameworks. No JDK installation is required at runtime, and startup speed can be improved by dozens of times.
• The design goal of nop-entropy is to become an easy-to-use Domain Language Workbench.. By adding simple metadata definitions, corresponding parsers, validators, IDE plugins, debugging tools, and other components can be generated automatically. General language features such as module decomposition, delta customization, and metaprogramming can also be automatically added to DSL domain-specific languages. In this respect, it is similar to JetBrains' MPS product, although its design principles and technical implementation approach are fundamentally different from those of MPS.
• nop-entropy adopts a cloud-native design with built-in distributed transaction and multi-tenancy support. It can run as a standalone instance or as a distributed cluster. It can provide online API services and automatically package online services for individual business objects into batch processing tasks for batch files. It provides corresponding model support for most business application scenarios. Major functionality can be implemented with only a small amount of configuration, significantly reducing the need for manual coding.
• During development, nop-entropy can serve as aLow-Code Platform Supporting Incremental Development, automatically generating various types of code and related documentation. At runtime, it can serve as theUnderlying Technology for No-Code Platforms Targeting End Users, allowing customers to adjust business module functionality online and iterate products using a what-you-see-is-what-you-get approach.

The currently open-sourced components mainly include the implementation of the XLang language, as well as foundational frameworks such as ORM, the Dependency Injection Container (IoC), Distributed Configuration (Config), GraphQLEngine, Report Engine, Job Scheduler, and Batch Prcessing Engine. Future plans include commonly used components for business development, such as the Rule Engine, Workflow Engine, and Business Intelligence (BI).

WARNING: The code for Nop Platform 2.0 was refactored from Entropy Platform 1.0. The refactoring work is not yet complete, and the platform has not yet been used in actual projects.

5. Tech Stack

Software Architecture

nop-entropy does not use the Spring framework. All modules are developed from scratch using a model-driven approach. (Much of the framework's own code is also generated from models and can be customized through declarative configurations.) In principle, nop-entropy can run on any microservice framework that supports the REST service standard. Currently, we primarily support integration with the Quarkus and Spring frameworks.

Quarkus is a new-generation cloud-native microservice framework open-sourced by Red Hat. Its development experience and maturity in compiling to GraalVM Native are significantly better than those of the Spring framework. With Quarkus, applications can be compiled into a single uber jar (executed using the java -jar command) or into standalone executable programs. The latter do not require a JDK installation at runtime and can achieve startup speeds dozens of times faster. Currently, nop-entropy development and debugging are primarily based on Quarkus, so there may be some minor issues with Spring framework support.

The nop-entropy project currently consists of the following main modules:

1. nop-api-support: Support classes for API interfaces
2. nop-commons: Common utility classes and helper functions
3. nop-core: Virtual file system, reflection system, basic tree, graph, and table models, data-driven code generation framework, XML and JSON parsers
4. nop-xlang: XPL template language, TypeScript-like scripting language, XPath-like general-purpose Tree path access language, XSLT-like general-purpose Tree transformation language, XDefinition metamodel definition language, and XDelta delta merging operations.
5. nop-config: Dynamic configuration management
6. nop-ioc: Dependency injection container supporting conditional assembly
7. nop-dao: SQL management, transactions, JDBC access, and database dialects
8. nop-orm: ORM engine supporting the EQL object query language
9. nop-ooxml: Parsing and generation of Excel and Word template files
10. nop-graphql: GraphQL parser and execution engine
11. nop-biz: Business flow engine that integrates with nop-graphql to provide GraphQL and REST services externally
12. nop-ui: View layer models
13. nop-js: Wrapper for graalvm-js, used to execute JS bundling tasks on the Java side, eliminating dependencies on frontend bundling tools such as Vite and Webpack
14. nop-web: Dynamically executes Js packaging tasks and generates the JSON page files required by the frontend at runtime.
15. nop-rpc: Distributed RPC framework supporting canary releases and integrating Nacos and Sentinel.
16. nop-report: A Chinese-style reporting engine that uses Excel as its visual designer.
17. nop-wf: Workflow engine.
18. nop-rule: Rule engine that uses Excel as its visual designer.
19. nop-batch: Batch processing engine.
20. nop-job: Distributed task scheduling engine.
21. nop-tcc: Distributed transaction engine.
22. nop-cluster: Distributed cluster support.
23. nop-auth: User permission management.
24. nop-sys: System configuration management.
25. nop-cli: Packages the code generator as a command-line tool.
26. nop-autotest: Automated testing framework.
27. nop-demo: Integration demo application for the Quarkus and Spring frameworks.
28. nop-idea-plugin: IDEA plugin supporting syntax assistance, link navigation, breakpoint debugging, and other features for custom DSLs.

The frontend code of the Nop platform is located in the nop-chaos project. The build output of nop-chaos is packaged into the following Java modules.

1. nop-web-site: Build output of the main frontend page framework.
2. nop-web-amis-editor: Build output of the AMIS visual editor used by the frontend. In general business development, we only need to write JSON and a small amount of JS code, so there is no need to rebuild the nop-chaos project.

Installation Guide

Environment Requirements: JDK 11+, Maven 3.6+, Git

Visit Yifei Open Source: [https://code.exmay.com/](https://code.exmay.com/) to download.
cd nop-entropy
mvn -T 2C clean install -DskipTests -Dquarkus.package.type=uber-jar

Note: Compilation and execution require JDK 11 or later. JDK 8 is not supported.

The quarkus.package.type parameter is recognized by the Quarkus framework. Setting it to uber-jar packages projects such as nop-quarkus-demo into a single JAR file containing all dependency classes. It can be run directly using java -jar XXX-runner.jar.

• nop-idea-plugin: nop-idea-plugin is an IDEA plugin project and must be compiled using Gradle.
• 
  

cd nop-idea-plugin
gradlew buildPlugin

The compiled plugin is stored in the build/distributions directory. See Plugin Installation and Usage.

Usage instructions

• The platform includes a built-in demo application that uses an H2 in-memory database and can be started directly.
• 
  

cd nop-demo/nop-quarkus-demo/target
java -Dquarkus.profile=dev -jar nop-quarkus-demo-2.0.0-SNAPSHOT-runner.jar

If profile=dev is not specified, the application starts in prod mode. In prod mode, you need to configure the database connection in application.yaml. By default, it uses the local MySQL database.

• Access URL: http://localhost:8080,  Username: nop, Password: 123
• You can debug the QuarksDemoMain class in the nop-quarks-demo project directly in IDEA. The Quarkus framework provides the following debugging tools during development:

http://localhost:8080/q/dev http://localhost:8080/q/graphql-ui

You can view the definitions and parameters of all backend service functions in the graphql-ui tool.

• For complete development examples, see tutorial.

Framework Integration

nop-entropy does not depend on the Spring or Quarkus framework, nor does it depend on any specific database. Therefore, it can be easily integrated into third-party applications.

The core engine does not rely on a database and can run entirely in memory. All storage-related code has been separated into independent DAO modules, such as nop-auth-dao and nop-sys-dao.

1. Use as an incremental code generation tool: During Maven packaging, Excel model files can be loaded and processed using specified template directories to generate code incrementally. See codegen.md.
2. Provide reversible computation support for existing XML/JSON/YAML configuration files and domain model files: Add dynamic decomposition, merging, and product customization mechanisms to model files. This is completely transparent to the application layer. The engine layer only needs a custom model file loader. See delta-loader.md.
3. Provide support for developing domain-specific languages (DSLs): Simply define an xdef metamodel file to obtain IDE features such as syntax assistance, link navigation, and breakpoint debugging. Support for customized visual designers will be provided in the future. See idea-plugin.md.
4. Use as a model-driven GraphQL engine: Automatically generate GraphQL services based on Excel models, supporting CRUD operations for complex parent-child tables. See graphql.md.
5. Use as a reporting engine: Simply add a small number of annotations to Word or Excel files to use them as report templates and dynamically generate complex Chinese-style reports. See report.md.
6. Use as a workflow engine: Combined with the scheduled task engine, it supports both human-operated approval workflows and distributed DAG task flows similar to Airflow. See workflow.md.
7. Use as a batch processing engine: Similar to the SpringBatch+XXLJob framework, it provides support for distributed batch processing tasks. Configuration files can specify how to parse and generate text or binary data files without writing parsing or generation code. See batch.md.
8. Use as a rule engine: Implement complex business rule evaluations through configuration. See rule.md.
9. Use as a data-driven automated testing framework: Implement automated testing through recording and playback. During the first execution, output data is automatically recorded. Subsequent executions compare results against the recorded data snapshots, reducing the amount of code that needs to be written manually. See autotest.md.