1. Project Overview

OneCode Low-Code Engine

With the growing popularity of the low-code concept, related technologies and products have emerged rapidly. From established industry software vendors to open platform providers, and from new developments in SaaS software among Internet companies to emerging low-code innovative products and services, everyone has quickly embraced low-code. Although each platform has its own advantages, most operate within their own ecosystems. As a result, choosing the right platform for enterprise use can be difficult. Evaluating low-code platform capabilities and enabling interoperability between components across different platforms have therefore become urgent market needs.

In 2022, regarding platform interoperability, Alibaba released its open-source engine "LowCodeEngin" in the second quarter. In the fourth quarter, the China Academy of Information and Communications Technology (CAICT), responding to market demand, released the General Technical Requirements for Low-Code Development Platforms, further standardizing and organizing concepts and functional requirements related to low-code.

Against the backdrop of comprehensive openness, the CodeBee team has released a low-code engine (LowCodeEngine) based on the open-source LGPL license.

2. Open Source License

Licensed under GPL-3.0

3. Screenshots

Product Components

The low-code engine consists of three mutually supporting components: the visual designer, the OneCode unified coding framework, and the DSM domain modeling tool. These components support each other through an open, standardized component protocol to enable interoperability.

(1) Visual Designer Engine

The designer adopts a drag-and-drop engine combined with a plugin-based architecture. Users can develop plugins using an open low-code protocol. It supports two extension languages: JS and JAVA. Style development provides a standard CSS3 editor and supports event actions and dynamic function extensions. It also supports custom function library extensions and resource libraries such as Alibaba Fonts and Images.

(2) OneCode Unified Code Editor:

OneCode is a unified syntax system designed specifically for low-code languages. It uses Java as its native language and runs in the JVM environment. Users can interact with low-code applications through Java, develop engine plugins using Java, and invoke the code engine to compile, deploy, and run applications.

(3) DSMEngine Domain Modeling

4. Feature Overview

The DSM model supports three modeling modes:

(1) CodeFrist Code-First Mode

Write natively using the Java language and OneCode mode.

(2) ViewFrist View-First Mode

Create the initial interaction model through drag-and-drop operations in the visual engine, then reverse-generate the DSM model.

(3) ModuleFrist Model-First Mode

Build the underlying model using databases, microservice interfaces, and other approaches.

DSM Reverse Conversion

DSM models created through different approaches can be freely converted between View, Code, and Module modes through OneCode. Related tools can then be used for simulation, debugging, deployment, and execution.

DSM Third-Party Language Conversion

The DSM code generation module adopts an independent template architecture. In addition to supporting OneCode output, it also supports customized code generation modules that independently generate models in third-party languages.

5. Tech Stack

Working Principles

OneCode itself is based on the JAVA language ecosystem. It is an extended subset built on Java Spring annotations. The hybrid compilation engine uses extended annotations to construct complete Domain models. By reading standard Spring annotations, it handles ordinary Web data delivery and scheduling processes. It dynamically renders JS files through the Domain model and outputs them as JSON for the frontend engine to build pages.

OneCode Modeling Process

Users build page models through drag-and-drop operations, which are serialized into JSON files according to standard protocols. The backend OneCode service system parses these JSON files, integrates DSM modeling information and backend service logic, and then performs hybrid compilation. The code factory selects the specified code generation templates to produce integrated frontend and backend compilation files.

Drag-and-Drop Modeling

The frontend low-code engine provides drag-and-drop functionality, allowing users to translate requirements into corresponding component combinations. After modeling is completed, the components are serialized into JSON files according to the standard low-code component format.

Backend Integration

        The backend integration system reads standard JSON components and converts them into backend models. Users can use the DSM modeling tool or the modeling communication SDK provided by OneCode to intervene in the modeling process for frontend-required service invocation logic and business data logic.

Hybrid Compilation and Code Generation

       After backend modeling integration is completed, the code factory uses code generation configurations to output OneCode source code.

(1) Standardization Capabilities

The OneCode platform adopts an open design model and standardized storage and communication protocols for frontend component design. This greatly facilitates interoperability between components from different low-code platforms and enables universal compatibility by design. It helps prevent isolated application ecosystems and addresses users' concerns about being locked into a specific platform.

(2) Hybrid Compilation Empowerment

In addition to implementing standardized component definitions on the frontend, OneCode also provides DSM, a backend modeling tool, to connect the two through domain models. This allows backend service models to be called directly during frontend component modeling to build data-related APIs. The DSM modeling tool can also directly read frontend component properties during backend modeling, enabling communication between frontend actions and backend services.

Connecting the two models significantly reduces the workload involved in low-code platform development. At the same time, through model-specific modeling intervention APIs, it enables business models to be constructed at a deeper level in terms of model creation and refactoring.

(3) Hybrid Compilation Validation (Precompilation)

Traditional low-code platforms are generally built entirely on JS-based models. Their structures are relatively clear during initial modeling, but even slightly complex logic can cause code redundancy and structural disorder during compilation, especially when handling cross-page operations or frontend-backend data interactions. Due to the characteristics of scripting languages, real-time validation is not possible, and problems can only be discovered through runtime testing. Pages built using low-code platforms often produce unpredictable results simply because of minor changes, such as adding or removing components or modifying component properties and styles. This significantly reduces code maintainability. The domain models built by OneCode effectively solve this problem. Whenever any frontend or backend model changes, hybrid compilation can be triggered to validate and notify users of page-to-page relationships and frontend-backend data relationships. This improves overall compilation capabilities through precompilation.

(4) Empowering Traditional Low-Code Services

Several domains have achieved excellent implementation results in low-code platforms. Let's explore how OneCode provides value using the most common form-and-workflow model as an example.

Detailed content, please refer to README.md document.