Low-code platform and Wasm high-performance computing integration system and method

Abstract

The invention discloses a low-code platform and Wasm high-performance computing integration system and method, and relates to the technical field of front-end development. In order to solve the problems that an existing low-code platform is limited in calculation performance and poor in security isolation performance, the scheme adopted by the invention comprises five modules: a description and registration module establishes a metadata structure for a Wasm module; the dynamic loading and asynchronous compiling module realizes loading as required and compiling during operation, and supports caching, version verification and hot replacement; the authority sandbox and resource isolation module constructs a security environment based on authority configuration to prevent illegal operation; the parameter binding and safety bridging module encapsulates a uniform interface to realize standardized interaction; the packaging and life cycle management module packages the module into a visual component, and supports full life cycle management. According to the method, high-performance, high-safety and visual integration of the Wasm module in a low-code platform is realized.

Description

Technical Field

[0001] The present invention relates to the technical field of front-end development, and specifically, it is a low-code platform and Wasm high-performance computing integration system and method. Background Art

[0002] With the development of low-code platforms, more and more enterprises rely on low-code methods to build front-end applications. However, the modules of traditional low-code platforms are usually implemented using JavaScript, which is difficult to support complex logic or high-computation-density tasks, such as scenarios like large file compression, AI model inference, and image processing. These tasks have high requirements for performance, and JavaScript has obvious bottlenecks in execution efficiency and memory control.

[0003] Wasm (short for WebAssembly) is a bytecode format that can run with near-native performance in browsers, supports multi-language compilation, and has the characteristics of high efficiency, portability, and secure operation. However, existing low-code platforms generally lack native support for Wasm modules and cannot dynamically integrate, configure, and use Wasm modules.

[0004] Therefore, there is an urgent need for a method to embed Wasm modules into low-code platforms in a high-performance, configurable, and visual way to enhance the system capabilities. Summary of the Invention

[0005] Aiming at the core problems of existing low-code platforms, such as limited computing performance, poor security isolation, and high module access costs, the present invention provides a low-code platform and Wasm high-performance computing integration system and method. By systematically integrating the Wasm technology system into the low-code platform, it realizes the standardized access, visual configuration, and secure execution of high-performance modules, significantly improving the operation efficiency and scalability of the low-code platform.

[0006] In the first aspect, the present invention provides a low-code platform and Wasm high-performance computing integration system. The technical solutions adopted to solve the above technical problems are as follows: A low-code platform and Wasm high-performance computing integration system, whose structure includes: A Wasm description and registration module, which is used to establish a metadata structure for each Wasm module that can be recognized, audited, and visually edited by the low-code platform; A dynamic loading and asynchronous compilation module, which is used to realize the on-demand loading and runtime compilation of Wasm modules, support caching, version verification, and hot replacement of Wasm modules, and asynchronously execute through a front-end Wasm compiler to improve the resource utilization efficiency and response performance of the low-code platform; The permission sandbox and resource isolation module is used to build a secure operating environment for Wasm modules, implement fine-grained resource access control based on the permission configuration in the description file, and prevent illegal operations, memory leaks, and mutual interference between different Wasm modules through an independent sandbox isolation mechanism, ensuring the security and stability of the low-code platform during operation; The parameter binding and security bridging module is used to encapsulate a unified execution interface for Wasm modules, support variable binding, automatic type conversion, and call scheduling of the visual interface, and achieve standardized interaction between the low-code platform and Wasm modules; The encapsulation and lifecycle management module is used to encapsulate the registered Wasm modules into visual drag-and-drop components, support full lifecycle management, status tracking, exception handling, and debugging enhancement, and achieve visual configuration and observability of high-performance logic components in the low-code environment.

[0007] Optionally, the Wasm description and registration module involved specifically includes: The compilation and export unit is used to support developers to implement the business logic of Wasm modules using compiled languages and export the function names and parameter structures that need to be exposed externally; The description file generation unit is used to automatically generate a standardized description file in JSON or YAML format based on the exported Wasm module information, and achieve structured definitions of Wasm module metadata, input parameters, return structures, permission configurations, and low-code platform UI adaptation; among them, the metadata includes fields such as moduleName, moduleId, and version, the input parameters include type, default value, and binding method, and the permission configuration includes fields such as memoryLimit, threading, and network; The legality verification unit is used to automatically verify the legality of the standardized description file through the description file schema verification rules predefined by the low-code platform, and ensure that it meets the constraints of no parameter conflicts and complete fields; The component template generation unit is used to automatically extract the description file meta-information and store it in the module management center of the low-code platform after the Wasm module is registered, and generate a visual drag-and-drop component template to support plug-and-play in the low-code development environment.

[0008] Further optionally, the dynamic loading and asynchronous compilation module involved specifically includes: The parsing trigger unit is used to listen for the designer component drag-and-drop event, automatically parse the metadata of the Wasm module description file and extract the moduleId, trigger the Wasm module loading process, and achieve seamless connection between user operations and system responses; The verification and judgment unit is used to verify the validity of the locally cached Wasm module, determine whether it needs to be reloaded based on the moduleId and version, trigger the loading process if the cache fails, and ensure the version consistency and loading efficiency of the Wasm module; The loading and compilation unit is used to realize the non-blocking loading and compilation of the Wasm module in the WebWorker through the fetch API combined with WebAssembly.compileStreaming(), support resource sharding and parallel processing, and avoid blocking the main thread; The instance storage unit is used to store the compiled Wasm module instances and compiled modules, mark the status, support fast retrieval and reuse, avoid repeated compilation overhead, and optimize memory resource management; The listening and update unit is used to listen for Wasm module version change notifications, support the one-key hot update function, ensure the real-time update of the Wasm module code through the preloading mechanism, be compatible with the gray release and rollback strategies, and guarantee the system's dynamic update ability.

[0009] Further optionally, the involved permission sandbox and resource isolation module specifically includes: The permission declaration verification unit is used to verify the legality of the permission declarations in the Wasm module description file, ensure that the permission fields are declared according to the specifications, and avoid security risks caused by undeclared permissions; The WASI permission control unit is used to perform fine-grained control over the system resource access of the Wasm module based on the WebAssembly System Interface or a custom runner, and implement the principle of minimizing permissions; The thread data isolation unit is used to use the browser-native WebAssembly.Memory, SharedArrayBuffer, and postMessage technologies to achieve thread isolation and controlled data exchange between different Wasm modules, and prevent out-of-bounds memory access and thread resource contention; The sandbox environment creation unit is used to create an independent sandbox context before the Wasm module runs, and ensure that the operations of the Wasm module are restricted in an isolated environment; The runtime monitoring unit is used to set the Wasm module runtime timeout mechanism and exception capture callback, monitor the dead loop and memory leak behaviors in real time, and trigger automatic resource recovery and error isolation.

[0010] Further optionally, the involved parameter binding and security bridging module specifically includes: The configuration UI generation unit is used to automatically generate a visual configuration interface according to the Wasm module description file, and realize the graphical configuration of the Wasm module parameters; A variable mapping unit, which is used to support users to map low-code platform variables to Wasm module input parameters through dragging or binding operations, and establish an association relationship between front-end variables and module interfaces; A type conversion unit, which is used to automatically convert JavaScript values into the memory structure required by the Wasm module through the pre-processor of the low-code platform before the Wasm module runs, ensuring parameter format compatibility; A unified call interface unit, which is used to provide a standardized call interface, encapsulate the Wasm module instantiation, parameter passing and exception handling logic, and realize the one-key trigger operation of the Wasm module; A result parsing unit, which is used to parse the memory pointer value returned by the Wasm module and convert the linear memory data into JavaScript primitive data for easy front-end processing.

[0011] Further optionally, the involved encapsulation and lifecycle management module specifically includes: A visualization generation unit, which is used to encapsulate the registered Wasm module into a visualization component, automatically generate independent icons, color identifiers and data binding interfaces, and realize the graphical abstraction of the Wasm module; A lifecycle hook configuration unit, which is used to support the lifecycle hook configuration of the visualization component, allow users to customize the response logic of each stage, and enhance the controllability of the visualization component behavior; A connection interaction unit, which is used to implement connection interaction between visualization components in a flowchart or page construction, support receiving upstream outputs and passing them to downstream, and build a visualization data flow link; A visualization display unit, which is used to provide a visualization debugging window, and display the running logs, output data structures and execution time consumption of the visualization component in real time, improving the observability of the running state of the visualization component; An update notification unit, which is used to trigger a visualization component replacement notification when the Wasm module is updated or an exception occurs, support the call of the hot update interface and UI refresh, and ensure that the visualization component state is synchronized with the Wasm module version.

[0012] In a second aspect, the present invention provides a low-code platform and Wasm high-performance computing integration method. The technical solutions adopted to solve the above technical problems are as follows: A low-code platform and Wasm high-performance computing integration method, which includes the following steps: S1. Build a metadata structure for each Wasm module, including identification information recognizable by the low-code platform, function descriptions, and attribute configurations required for visual editing, and form a standardized description file to support the review and parsing of the low-code platform; S2. Implement the on-demand dynamic loading of Wasm modules, optimize the loading efficiency by combining the caching mechanism and version verification strategy; perform asynchronous compilation through the front-end Wasm compiler, support runtime module hot replacement, and improve the resource utilization and response performance of the low-code platform; S3. Based on the permission configuration in the description file, construct a permission sandbox for Wasm modules to implement fine-grained resource access control; prevent illegal operations, memory leaks, and mutual interference between different Wasm modules through an independent sandbox isolation mechanism, and ensure the safe and stable operation at runtime; S4. Package a unified execution interface for Wasm modules to support variable binding, automatic type conversion, and call scheduling in the visual interface; realize the standardized parameter interaction and data transmission between the low-code platform and Wasm modules through a secure bridging mechanism; S5. Package the registered Wasm modules into draggable visual components, integrate status tracking, exception handling, and debugging functions; provide full life-cycle management capabilities to achieve visual configuration and runtime observability of visual components in the low-code environment.

[0013] Optionally, the specific steps involved in step S1 include: S1.1. Developers use a compiled language to implement the business logic of the Wasm module and export the function names and parameter structures that need to be exposed externally; S1.2. Based on the exported Wasm module information, automatically generate a standardized description file in JSON or YAML format to achieve a structured definition of Wasm module metadata, input parameters, return structures, permission configurations, and low-code platform UI adaptation; among them, the metadata includes fields such as moduleName, moduleId, and version, the input parameters include type, default value, and binding method, and the permission configuration includes fields such as memoryLimit, threading, and network; S1.3. Automatically verify the legality of the standardized description file through the description file schema verification rules predefined by the low-code platform to ensure that it meets the constraints of no parameter conflicts and complete fields; S1.4. After the Wasm module is registered, automatically extract the description file meta-information and store it in the module management center of the low-code platform to generate a visual drag-and-drop component template to support plug-and-play in the low-code development environment.

[0014] Further optionally, the specific steps involved in step S2 include: S2.1. Listen for the designer component drag event, automatically parse the metadata of the Wasm module description file and extract the moduleId, trigger the Wasm module loading process, and achieve seamless connection between user operations and system responses; S2.2. Verify the validity of the locally cached Wasm module. Based on the moduleId and version, determine whether it needs to be reloaded. If the cache is invalid, trigger the loading process to ensure the version consistency and loading efficiency of the Wasm module; S2.3. In the Web Worker, implement the non-blocking loading and compilation of the Wasm module through the fetch API combined with WebAssembly.compileStreaming(), support resource sharding and parallel processing, and avoid blocking the main thread; S2.4. Store the compiled Wasm module instances and compiled modules, mark the status, support fast retrieval and reuse, avoid repeated compilation overhead, and optimize memory resource management; S2.5. Listen for Wasm module version change notifications, support the one-key hot update function, ensure the real-time update of the Wasm module code through the preloading mechanism, be compatible with the gray release and rollback strategies, and guarantee the system's dynamic update ability; The specific steps of step S3 include: S3.1. Verify the legality of the permission declarations in the Wasm module description file to ensure that the permission fields are declared according to the specifications and avoid security risks caused by undeclared permissions; S3.2. Based on the WebAssembly System Interface or a custom runner, perform fine-grained control over the system resource access of the Wasm module to implement the principle of minimizing permissions; S3.3. Use the browser-native WebAssembly.Memory, SharedArrayBuffer, and postMessage technologies to achieve thread isolation and controlled data exchange between different Wasm modules, preventing out-of-bounds memory access and thread resource contention; S3.4. Create an independent sandbox context before the Wasm module runs to ensure that the operations of the Wasm module are restricted in an isolated environment; S3.5. Set a running timeout mechanism and an exception capture callback for the Wasm module, monitor infinite loop and memory leak behaviors in real time, and trigger automatic resource recovery and error isolation.

[0015] Further optionally, the specific steps of step S4 include: S4.1. Automatically generate a visual configuration interface according to the Wasm module description file to achieve graphical configuration of the Wasm module parameters; S4.2. Through drag-and-drop or binding operations, the user maps the low-code platform variables to the input parameters of the Wasm module to establish the association relationship between the front-end variables and the module interfaces; S4.3. Before the Wasm module runs, the preprocessor of the low-code platform automatically converts JavaScript values into the memory structure required by the Wasm module to ensure parameter format compatibility; S4.4. Provide a standardized call interface to encapsulate the Wasm module instantiation, parameter passing, and exception handling logic to achieve one-key triggering and running of the Wasm module; S4.5. Parse the memory pointer value returned by the Wasm module and convert the linear memory data into JavaScript raw data for easy front-end processing; The specific steps of step S5 include: S5.1. Package the registered Wasm module as a visual component, automatically generate independent icons, color identifiers, and data binding interfaces to achieve graphical abstraction of the Wasm module; S5.2. The visual component supports lifecycle hook configuration, allowing users to customize the response logic for each stage to enhance the controllability of the visual component behavior; S5.3. Implement connection interaction between visual components in the flowchart or page construction, receive upstream outputs and pass them to the downstream to build a visual data flow link; S5.4. Provide a visual debugging window to display the running logs, output data structures, and execution time consumption of the visual components in real time to improve the observability of the running status of the visual components; S5.5. Trigger a visual component replacement notification when the Wasm module is updated or an exception occurs, and call the hot update interface and refresh the UI to ensure that the status of the visual component is synchronized with the Wasm module version.

[0016] A low-code platform and Wasm high-performance computing integration system and method of the present invention has the following beneficial effects compared with the prior art: 1. The present invention supports on-demand dynamic loading and asynchronous compilation of Wasm modules, effectively reducing the initialization resource consumption of the low-code platform; introducing a permission sandbox and a running isolation mechanism to ensure the running safety of low-code modules and prevent unauthorized operations; through a standardized call bridging and parameter binding process, users can efficiently use Wasm modules without understanding the underlying details, significantly reducing the usage threshold; the low-code modules are encapsulated as visual components within the platform, with lifecycle management capabilities, supporting hot updates, log tracking, and debugging information output, enhancing the controllability and usability of high-performance logic for developers and non-technical users; overall, it not only improves the low-code platform's ability to carry complex business logic but also promotes the low-cost integration and high-frequency use of Wasm modules, with good technical promotion value and industrial application prospects; 2. By systematically integrating the Wasm technology system into the low-code platform, the present invention realizes the standardized access, visual configuration, and secure execution of high-performance modules, significantly improving the operation efficiency and scalability of the low-code platform; it is applicable to scenarios for enhancing the modular capabilities and operation efficiency in the low-code platform. 3. The present invention realizes the high-performance, high-security, and visual integration of Wasm modules in the low-code platform. By standardizing the Wasm module registration process, it reduces the development threshold, improves the execution efficiency using the Wasm runtime, and combines double-layer sandbox isolation to ensure system security, ultimately endowing the low-code platform with business expansion capabilities featuring high scalability, high-performance computing capabilities, and production-level security standards. BRIEF DESCRIPTION OF THE DRAWINGS

[0017] FIG Figure 1 is a block diagram of module connections in Embodiment 1 of the present invention; FIG Figure 2 is a flowchart of the method in Embodiment 2 of the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0018] To make the technical solutions, technical problems to be solved, and technical effects of the present invention clearer and more understandable, the following describes the technical solutions of the present invention clearly and completely in conjunction with specific embodiments.

[0019] Embodiment 1: Referring to FIG Figure 1 , this embodiment proposes a low-code platform and Wasm high-performance computing integration system, the structure of which includes: A Wasm description and registration module, used to establish a metadata structure for each Wasm module that can be recognized, audited, and visually edited by the low-code platform; A dynamic loading and asynchronous compilation module, used to realize the on-demand loading and runtime compilation of Wasm modules, support caching, version verification, and hot replacement of Wasm modules, and asynchronously execute through the front-end Wasm compiler to improve the resource utilization efficiency and response performance of the low-code platform; A permission sandbox and resource isolation module, used to build a secure operating environment for Wasm modules, implement fine-grained resource access control based on the permission configuration in the description file, and prevent illegal operations, memory leaks, and interference between different Wasm modules through an independent sandbox isolation mechanism to ensure the security and stability of the low-code platform during operation; A parameter binding and security bridging module, used to encapsulate a unified execution interface for Wasm modules, support variable binding, automatic type conversion, and call scheduling on the visual interface, and realize the standardized interaction between the low-code platform and Wasm modules; The encapsulation and lifecycle management module is used to encapsulate the registered Wasm module into a visual drag-and-drop component, supporting full lifecycle management (initialization, running, destruction, etc.), status tracking, exception handling, and debugging enhancement, to achieve visual configuration and observability of high-performance logic components in a low-code environment.

[0020] In this embodiment, the involved Wasm description and registration module specifically includes: The compilation and export unit is used to support developers to implement the business logic of the Wasm module using compiled languages (such as Rust / C++), and export the function names and parameter structures that need to be exposed externally; The description file generation unit is used to automatically generate a standardized description file in JSON or YAML format based on the exported Wasm module information, to achieve a structured definition of the Wasm module metadata, input parameters, return structure, permission configuration, and low-code platform UI adaptation; among them, the metadata includes three fields: module name moduleName, module unique identifier moduleId, and module version number version, the input parameters include three core attributes: type, default value, and binding method, and the permission configuration includes three fields: memory limit memoryLimit, threading support threading, and network access permission network; The legality verification unit is used to automatically verify the legality of the standardized description file through the description file schema verification rules predefined by the low-code platform, to ensure that it meets the constraints of no parameter conflicts and complete fields; The component template generation unit is used to automatically extract the meta-information of the description file and store it in the module management center of the low-code platform after the Wasm module is registered, and generate a visual drag-and-drop component template to support plug-and-play in the low-code development environment.

[0021] In this embodiment, the involved dynamic loading and asynchronous compilation module specifically includes: The parsing trigger unit is used to listen for the designer component drag-and-drop event, automatically parse the metadata of the Wasm module description file and extract the module unique identifier moduleId, trigger the Wasm module loading process, and achieve seamless connection between user operations and system responses; The verification and judgment unit is used to verify the validity of the locally cached Wasm module, and judge whether it needs to be reloaded based on the module unique identifier moduleId and the module version number version. If the cache fails, it triggers the loading process to ensure the version consistency and loading efficiency of the Wasm module; Loading and compiling unit, which is used to realize the non-blocking loading and compilation of Wasm modules in WebWorker through the fetch API combined with WebAssembly.compileStreaming(), support resource sharding and parallel processing, and avoid blocking the main thread; Instance storage unit, which is used to store the compiled Wasm module instances and compilation modules, mark the status as "Ready", support fast retrieval and reuse, avoid repeated compilation overhead, and optimize memory resource management; Listening and updating unit, which is used to listen to the Wasm module version change notification, support the one-key hot update function, ensure the real-time update of the Wasm module code through the preloading mechanism, be compatible with the gray release and rollback strategies, and ensure the dynamic update ability of the system.

[0022] In this embodiment, the involved permission sandbox and resource isolation module specifically includes: Permission declaration verification unit, which is used to verify the legality of the permission declarations in the Wasm module description file, ensure that the permission fields are declared according to the specifications, and avoid security risks caused by undeclared permissions; WASI permission control unit, which is used to perform fine-grained control over the system resource access of Wasm modules based on the WebAssembly System Interface (abbreviated as WASI) or a custom runner, and implement the principle of minimizing permissions; Thread data isolation unit, which is used to utilize the browser-native WebAssembly.Memory (WebAssembly memory object for managing linear memory space), SharedArrayBuffer (shared array buffer, a memory area allowing multi-threaded sharing), and postMessage (sending messages, an API for cross-context communication in the browser) technologies to achieve thread isolation and controlled data exchange between different Wasm modules, and prevent out-of-bounds memory access and thread resource contention; Sandbox environment creation unit, which is used to create an independent sandbox context based on iframes or WebWorkers before the Wasm module runs, ensuring that the operations of the Wasm module are restricted in an isolated environment; Runtime monitoring unit, which is used to set the Wasm module runtime timeout mechanism and exception capture callback, monitor infinite loop and memory leak behaviors in real time, and trigger automatic resource recovery and error isolation.

[0023] In this embodiment, the involved parameter binding and security bridging module specifically includes: Configuration UI generation unit, which is used to automatically generate a visual configuration interface (such as input boxes, dropdown boxes, JSON editors, etc.) according to the Wasm module description file, and realize the graphical configuration of the Wasm module parameters; A variable mapping unit, which is used to support users to map low-code platform variables to the input parameters of the Wasm module through dragging or binding operations, and establish the association relationship between the front-end variables and the module interface; A type conversion unit, which is used to automatically convert JavaScript values into the memory structure required by the Wasm module through the pre-processor of the low-code platform before the Wasm module runs, ensuring parameter format compatibility; A unified call interface unit, which is used to provide a standardized call interface executeWasm(moduleId, input), encapsulate the Wasm module instantiation, parameter passing and exception handling logic, and realize the one-key trigger operation of the Wasm module; A result parsing unit, which is used to parse the memory pointer value returned by the Wasm module, and convert the linear memory data into JavaScript primitive data (such as picture buffer, structured JSON) for easy front-end processing.

[0024] In this embodiment, the involved encapsulation and lifecycle management module specifically includes: A visualization generation unit, which is used to encapsulate the registered Wasm module into a visualization component, automatically generate independent icons, color identifiers and data binding interfaces, and realize the graphical abstraction of the Wasm module; A lifecycle hook configuration unit, which is used to support the configuration of lifecycle hooks such as onInit, onExecute, onError, onDestroy of the visualization component, allowing users to customize the response logic of each stage and enhancing the controllability of the visualization component behavior; A connection interaction unit, which is used to implement the connection interaction between visualization components in the flowchart or page construction, support receiving upstream outputs and passing them to the downstream, and build a visualization data flow link; A visualization display unit, which is used to provide a visualization debugging window, and display the running logs, output data structures and execution time consumption of the visualization component in real time, improving the observability of the running state of the visualization component; An update notification unit, which is used to trigger the visualization component replacement notification when the Wasm module is updated or an exception occurs, support the call of the hot update interface and the UI refresh, and ensure that the visualization component state is synchronized with the Wasm module version.

[0025] Embodiment 2: Refer to the appendix Figure 2 , this embodiment proposes a low-code platform and Wasm high-performance computing integration method, which includes the following steps: S1. Build a metadata structure for each Wasm module, including identification information recognizable by the low-code platform, functional descriptions, and attribute configurations required for visual editing, to form a standardized description file to support the review and parsing of the low-code platform. To achieve this, the following specific operations are performed: S1.1. Developers use compiled languages (such as Rust / C++) to implement the business logic of the Wasm module and export the function names and parameter structures that need to be exposed externally; S1.2. Based on the exported Wasm module information, automatically generate a standardized description file in JSON or YAML format to implement the structured definitions of Wasm module metadata, input parameters, return structures, permission configurations, and low-code platform UI adaptation; among them, the metadata includes three fields: module name moduleName, module unique identifier moduleId, and module version number version, the input parameters include three core attributes: type, default value, and binding method, and the permission configuration includes three fields: memory limit memoryLimit, threading support threading, and network access permission network; S1.3. Automatically verify the legality of the standardized description file through the description file schema verification rules predefined by the low-code platform to ensure that it meets the constraints of no parameter conflicts and complete fields; S1.4. After the Wasm module is registered, automatically extract the description file meta-information and store it in the module management center of the low-code platform to generate a visual drag-and-drop component template to support plug-and-play in the low-code development environment.

[0026] S2. Implement the on-demand dynamic loading of the Wasm module, and optimize the loading efficiency by combining the caching mechanism and the version verification strategy; perform asynchronous compilation through the front-end Wasm compiler to support runtime module hot replacement and improve the resource utilization and response performance of the low-code platform. To achieve this, the following specific operations are performed: S2.1. Listen for the drag-and-drop events of designer components, automatically parse the metadata of the Wasm module description file and extract the module unique identifier moduleId, trigger the Wasm module loading process, and achieve seamless connection between user operations and system responses; S2.2. Verify the validity of the Wasm module cached locally, and judge whether it needs to be reloaded based on the module unique identifier moduleId and the module version number version. If the cache fails, trigger the loading process to ensure the version consistency and loading efficiency of the Wasm module; S2.3. Implement non-blocking loading and compilation of Wasm modules in Web Workers through the fetch API combined with WebAssembly.compileStreaming(), support resource sharding and parallel processing, and avoid blocking the main thread. S2.4. Store the compiled Wasm module instances and compilation modules, mark the status as "Ready", support fast retrieval and reuse, avoid repeated compilation overhead, and optimize memory resource management. S2.5. Listen for Wasm module version change notifications, support one-key hot update function, ensure real-time update of Wasm module code through preloading mechanism, be compatible with gray release and rollback strategies, and guarantee the dynamic update ability of the system.

[0027] S3. Based on the permission configuration in the description file, construct a permission sandbox for Wasm modules and implement fine-grained resource access control. Through an independent sandbox isolation mechanism, prevent illegal operations, memory leaks, and mutual interference between different Wasm modules, and ensure safe and stable operation at runtime. To achieve this, the following specific operations are performed: S3.1. Verify the legality of the permission declarations in the Wasm module description file to ensure that the permission fields are declared according to the specifications and avoid security risks caused by undeclared permissions. S3.2. Based on the WebAssembly System Interface (abbreviated as WASI) or a custom runner, perform fine-grained control over the system resource access of Wasm modules to implement the principle of minimizing permissions. S3.3. Utilize the browser-native WebAssembly.Memory (a WebAssembly memory object for managing linear memory space), SharedArrayBuffer (a shared array buffer, a memory area allowing multi-thread sharing), and postMessage (sending messages, an API for cross-context communication in the browser) technologies to achieve thread isolation and controlled data exchange between different Wasm modules, and prevent out-of-bounds memory access and thread resource contention. S3.4. Before the Wasm module runs, create an independent sandbox context based on iframe or WebWorker to ensure that the operations of the Wasm module are restricted in an isolated environment. S3.5. Set a Wasm module running timeout mechanism and an exception capture callback to monitor infinite loop and memory leak behaviors in real time, and trigger automatic resource recovery and error isolation.

[0028] S4. Wrap a unified execution interface for the Wasm module, support variable binding, automatic type conversion, and call scheduling in the visual interface; through a secure bridging mechanism, implement standardized parameter interaction and data transmission between the low-code platform and the Wasm module. To achieve this, the following specific operations are performed: S4.1. Automatically generate a visual configuration interface (such as input boxes, dropdown boxes, JSON editors, etc.) according to the Wasm module description file to achieve graphical configuration of Wasm module parameters; S4.2. The user maps low-code platform variables to Wasm module input parameters through drag-and-drop or binding operations to establish an association between the front-end variables and the module interface; S4.3. Before the Wasm module runs, automatically convert JavaScript values into the memory structure required by the Wasm module through the preprocessor of the low-code platform to ensure parameter format compatibility; S4.4. Provide a standardized call interface executeWasm(moduleId, input), encapsulate the Wasm module instantiation, parameter passing, and exception handling logic to achieve one-key triggering and running of the Wasm module; S4.5. Parse the memory pointer value returned by the Wasm module and convert the linear memory data into JavaScript primitive data (such as image buffer, structured JSON) for easy front-end processing.

[0029] S5. Package the registered Wasm module into a draggable visual component, integrate state tracking, exception handling, and debugging functions; provide full life-cycle management capabilities to achieve visual configuration and runtime observability of visual components in the low-code environment.

[0030] S5.1. Package the registered Wasm module into a visual component, automatically generate independent icons, color identifiers, and data binding interfaces to achieve graphical abstraction of the Wasm module; S5.2. The visual component supports the configuration of life-cycle hooks such as onInit, onExecute, onError, and onDestroy, allowing users to customize the response logic in each stage to enhance the controllability of the visual component behavior; S5.3. Implement connection interaction between visual components in the flowchart or page construction, receive upstream outputs and pass them to the downstream to build a visual data flow link; S5.4. Provide a visual debugging window to display the running logs, output data structures, and execution time-consuming of visual components in real time to improve the observability of the running status of visual components; S5.5. Trigger a visualization component replacement notification when the Wasm module is updated or encounters an exception, and call and refresh the UI through the hot update interface to ensure that the status of the visualization component is synchronized with the Wasm module version.

[0031] In summary, by using the integrated system and method of a low-code platform and Wasm high-performance computing of the present invention, the development threshold is reduced by standardizing the Wasm module registration process, the execution efficiency is improved by using the WASM runtime, and the system security is ensured by combining double-layer sandbox isolation. Finally, the low-code platform is endowed with the business expansion ability of high scalability, high-performance computing ability and production-level security standards, solving the core problems of limited computing performance, poor security isolation and high module access cost existing in the existing low-code platforms.

[0032] The above specific application examples have elaborated in detail the principle and implementation manner of the present invention. These embodiments are only used to help understand the core technical content of the present invention. Based on the above specific embodiments of the present invention, any improvements and modifications made by those skilled in the art of this technology without departing from the principle of the present invention shall fall within the scope of patent protection of the present invention.

Claims

1. A low-code platform and Wasm high-performance computing integration system, characterized in that, Its structure includes: The Wasm description and registration module is used to establish a metadata structure for each Wasm module that can be recognized, audited, and visually edited by the low-code platform; The dynamic loading and asynchronous compilation module is used to implement the on-demand loading and runtime compilation of Wasm modules, support the caching, version verification, and hot replacement of Wasm modules, and is executed asynchronously through the front-end Wasm compiler to improve the resource utilization efficiency and response performance of the low-code platform; The permission sandbox and resource isolation module is used to build a secure operating environment for Wasm modules, implement fine-grained resource access control based on the permission configuration in the description file, and prevent illegal operations, memory leaks, and interference between different Wasm modules through an independent sandbox isolation mechanism to ensure the security and stability of the low-code platform during operation; The parameter binding and security bridging module is used to encapsulate a unified execution interface for Wasm modules, support variable binding, automatic type conversion, and call scheduling on the visual interface, and achieve standardized interaction between the low-code platform and Wasm modules; The encapsulation and lifecycle management module is used to encapsulate the registered Wasm modules into visual drag-and-drop components, support full lifecycle management, state tracking, exception handling, and debugging enhancement, and achieve visual configuration and observability of high-performance logic components in the low-code environment.

2. The integrated system of a low-code platform and Wasm high-performance computing according to claim 1, characterized in that The Wasm description and registration module specifically includes: The compilation and export unit is used to support developers to implement the business logic of Wasm modules using compiled languages and export the function names and parameter structures that need to be exposed externally; The description file generation unit is used to automatically generate a standardized description file in JSON or YAML format based on the exported Wasm module information, and achieve a structured definition of Wasm module metadata, input parameters, return structures, permission configurations, and low-code platform UI adaptation; among them, the metadata includes fields such as moduleName, moduleId, and version, the input parameters include type, default value, and binding method, and the permission configuration includes fields such as memoryLimit, threading, and network; The legality verification unit is used to automatically verify the legality of the standardized description file through the description file schema verification rules predefined by the low-code platform to ensure that it meets the constraints of no parameter conflicts and complete fields; The component template generation unit is used to automatically extract the metadata of the description file and store it in the module management center of the low-code platform after the Wasm module is registered, and generate a visual drag-and-drop component template to support plug-and-play in the low-code development environment.

3. The integrated system of a low-code platform and Wasm high-performance computing according to claim 2, characterized in that, The dynamic loading and asynchronous compilation module specifically includes: The parsing trigger unit is used to listen for designer component drag events, automatically parse the metadata of the Wasm module description file and extract the moduleId, and trigger the Wasm module loading process to achieve seamless connection between user operations and system responses; The verification and judgment unit is used to verify the validity of the locally cached Wasm module, determine whether it needs to be reloaded based on the moduleId and version, trigger the loading process if the cache fails, and ensure the version consistency and loading efficiency of the Wasm module; The loading and compilation unit is used to achieve non-blocking loading and compilation of the Wasm module in the WebWorker through the fetch API combined with WebAssembly.compileStreaming(), support resource sharding and parallel processing, and avoid blocking the main thread; The instance storage unit is used to store the compiled Wasm module instances and compiled modules, mark the status, support fast retrieval and reuse, avoid repeated compilation overhead, and optimize memory resource management; The listening and update unit is used to listen to the Wasm module version change notification, support the one-key hot update function, ensure the real-time update of the Wasm module code through the preloading mechanism, be compatible with the gray release and rollback strategies, and guarantee the system's dynamic update ability.

4. A low-code platform and Wasm high-performance computing integrated system according to claim 2, wherein The permission sandbox and resource isolation module specifically includes: The permission declaration verification unit is used to verify the legality of the permission declarations in the Wasm module description file, ensure that the permission fields are declared according to the specifications, and avoid security risks caused by undeclared permissions; The WASI permission control unit is used to perform fine-grained control over the system resource access of the Wasm module based on the WebAssembly System Interface or a custom runner, and implement the principle of minimizing permissions; The thread data isolation unit is used to utilize the browser's native WebAssembly.Memory, SharedArrayBuffer, and postMessage technologies to achieve thread isolation and controlled data exchange between different Wasm modules, preventing out-of-bounds memory access and thread resource contention; The sandbox environment creation unit is used to create an independent sandbox context before the Wasm module runs, ensuring that the operations of the Wasm module are restricted in an isolated environment; The runtime monitoring unit is used to set the Wasm module runtime timeout mechanism and exception capture callback, monitor the dead loop and memory leak behaviors in real time, and trigger automatic resource recovery and error isolation.

5. A low-code platform and Wasm high-performance computing integration system according to claim 4, characterized in that The parameter binding and security bridging module specifically includes: The configuration UI generation unit is used to automatically generate a visual configuration interface according to the Wasm module description file, and achieve graphical configuration of the Wasm module parameters; The variable mapping unit is used to support the user to map the low-code platform variables to the Wasm module input parameters through drag-and-drop or binding operations, and establish the association relationship between the front-end variables and the module interfaces; The type conversion unit is used to automatically convert the JavaScript values into the memory structure required by the Wasm module through the preprocessor of the low-code platform before the Wasm module runs, ensuring parameter format compatibility; The unified call interface unit is used to provide a standardized call interface, encapsulate the Wasm module instantiation, parameter passing, and exception handling logic, and achieve one-key trigger operation of the Wasm module. A result parsing unit for parsing the memory pointer value returned by the Wasm module and converting the linear memory data into JavaScript primitive data for easy front-end processing.

6. The low-code platform and Wasm high-performance computing integrated system according to claim 5, wherein The encapsulation and lifecycle management module specifically includes: A visualization generation unit for encapsulating the registered Wasm module into a visualization component, automatically generating independent icons, color identifiers, and data binding interfaces to achieve graphical abstraction of the Wasm module; A lifecycle hook configuration unit for supporting the lifecycle hook configuration of the visualization component, allowing users to customize the response logic for each stage and enhancing the controllability of the visualization component behavior; A connection interaction unit for implementing connection interaction between visualization components in a flowchart or page construction, supporting receiving upstream outputs and passing them to downstream to build a visualization data flow link; A visualization display unit for providing a visualization debugging window to display the running logs, output data structures, and execution time consumption of the visualization component in real time, improving the observability of the running state of the visualization component; An update notification unit for triggering a visualization component replacement notification when the Wasm module is updated or an exception occurs, supporting the call of the hot update interface and UI refresh to ensure that the state of the visualization component is synchronized with the Wasm module version.

7. A method for integrating a low-code platform with Wasm high-performance computing, characterized in that, Including the following steps: S1. Build a metadata structure for each Wasm module, including identification information recognizable by the low-code platform, function descriptions, and attribute configurations required for visual editing, to form a standardized description file to support the review and parsing of the low-code platform; S2. Implement the on-demand dynamic loading of the Wasm module, and optimize the loading efficiency by combining the caching mechanism and version verification strategy; Execute asynchronous compilation through the front-end Wasm compiler, support runtime module hot replacement, and improve the resource utilization and response performance of the low-code platform; S3. Based on the permission configuration in the description file, build a permission sandbox for the Wasm module to implement fine-grained resource access control; Through an independent sandbox isolation mechanism, prevent illegal operations, memory leaks, and mutual interference between different Wasm modules, and ensure the security and stability of runtime; S4. Encapsulate a unified execution interface for the Wasm module to support variable binding, automatic type conversion, and call scheduling of the visualization interface; through a secure bridging mechanism, achieve standardized parameter interaction and data transmission between the low-code platform and the Wasm module; S5. Encapsulate the registered Wasm module into a draggable visualization component, integrate state tracking, exception handling, and debugging functions; provide full lifecycle management capabilities to achieve visual configuration and runtime observability of the visualization component in a low-code environment.

8. A method for integrating a low-code platform with Wasm high-performance computing according to claim 7, characterized in that, The specific steps of S1 include: S1.

1. Developers use a compiled language to implement the business logic of the Wasm module and export the function names and parameter structures that need to be externally exposed; S1.

2. Automatically generate a standardized description file in JSON or YAML format based on the exported Wasm module information, and implement the structured definitions of Wasm module metadata, input parameters, return structures, permission configurations, and low-code platform UI adaptation; among them, the metadata includes fields such as moduleName, moduleId, and version, the input parameters include type, default value, and binding method, and the permission configuration includes fields such as memoryLimit, threading, and network; S1.

3. Automatically verify the legality of the standardized description file through the description file schema verification rules predefined by the low-code platform to ensure that it meets the constraints of no parameter conflicts and complete fields; S1.

4. After the Wasm module is registered, automatically extract the description file meta-information and store it in the module management center of the low-code platform, and generate a visual drag-and-drop component template to support plug-and-play in the low-code development environment.

9. A method for integrating a low-code platform with Wasm high-performance computing according to claim 7, characterized in that The specific steps of step S2 include: S2.

1. Listen for the designer component drag-and-drop event, automatically parse the metadata of the Wasm module description file and extract the moduleId, trigger the Wasm module loading process, and achieve seamless connection between user operations and system responses; S2.

2. Verify the validity of the Wasm module cached locally, and judge whether it needs to be reloaded based on the moduleId and version. If the cache is invalid, trigger the loading process to ensure the version consistency and loading efficiency of the Wasm module; S2.

3. Implement non-blocking loading and compilation of the Wasm module in the Web Worker through the fetch API combined with WebAssembly.compileStreaming(), support resource sharding and parallel processing, and avoid blocking the main thread; S2.

4. Store the compiled Wasm module instance and the compiled module, mark the status, support fast retrieval and reuse, avoid repeated compilation overhead, and optimize memory resource management; S2.

5. Listen for the Wasm module version change notification, support the one-key hot update function, ensure the real-time update of the Wasm module code through the preloading mechanism, be compatible with the gray release and rollback strategies, and ensure the system's dynamic update ability; The specific steps of step S3 include: S3.

1. Verify the legality of the permission declarations in the Wasm module description file to ensure that the permission fields are declared according to the specifications and avoid security risks caused by undeclared permissions; S3.

2. Based on the WebAssembly System Interface or a custom runner, perform fine-grained control over the system resource access of the Wasm module to implement the principle of minimizing permissions; S3.

3. Use the browser-native WebAssembly.Memory, SharedArrayBuffer, and postMessage technologies to achieve thread isolation and controlled data exchange between different Wasm modules, preventing out-of-bounds memory access and thread resource contention; S3.

4. Create an independent sandbox context before running the Wasm module to ensure that the operations of the Wasm module are restricted to an isolated environment; S3.

5. Set up a running timeout mechanism and exception capture callback for the Wasm module to monitor infinite loop and memory leak behaviors in real time, and trigger automatic resource recovery and error isolation.

10. A method for integrating a low-code platform with Wasm high-performance computing according to claim 9, characterized in that, The specific steps of step S4 include: S4.

1. Automatically generate a visual configuration interface according to the Wasm module description file to achieve graphical configuration of Wasm module parameters; S4.

2. The user maps the low-code platform variables to the Wasm module input parameters through drag-and-drop or binding operations to establish the association between the front-end variables and the module interfaces; S4.

3. Before running the Wasm module, automatically convert the JavaScript values into the memory structure required by the Wasm module through the preprocessor of the low-code platform to ensure parameter format compatibility; S4.

4. Provide a standardized call interface to encapsulate the Wasm module instantiation, parameter passing, and exception handling logic to achieve one-click triggering and running of the Wasm module; S4.

5. Parse the memory pointer value returned by the Wasm module and convert the linear memory data into JavaScript raw data for easy front-end processing; The specific steps of step S5 include: S5.

1. Package the registered Wasm module into a visual component, automatically generate independent icons, color identifiers, and data binding interfaces to achieve graphical abstraction of the Wasm module; S5.

2. The visual component supports lifecycle hook configuration, allowing users to customize the response logic for each stage to enhance the controllability of the visual component behavior; S5.

3. Implement the connection interaction between visual components in the flowchart or page construction, receive the upstream output and pass it to the downstream to build a visual data flow link; S5.

4. Provide a visual debugging window to display the running logs, output data structures, and execution time consumption of the visual components in real time to improve the observability of the running status of the visual components; S5.

5. Trigger a visual component replacement notification when the Wasm module is updated or an exception occurs, and call the hot update interface and refresh the UI to ensure that the state of the visual component is synchronized with the Wasm module version.

Images