Tencent/puerts
Puerts
Puerts is a TypeScript runtime embedder and game engine scripting framework designed to integrate dynamic languages into low-level host applications. It functions as a high-performance cross-language API bridge, allowing developers to execute gameplay logic and editor scripts using TypeScript and JavaScript within a compiled host environment.
The project distinguishes itself through a unified bridging API that supports pluggable scripting backends, enabling the selection or hot-swapping of different language engines to balance execution speed against binary size. It provides automated type declaration generation to ensure type-safe access and autocomplete for native host APIs.
The framework covers a broad capability surface including reflection-based API bridging for native function invocation, cross-language object mapping, and the integration of third-party packages. It also supports advanced automation through natural language engine control, AI agent integration for dynamic behaviors, and a standardized remote control protocol for connecting external AI coding tools to a running project.
Features
- JavaScript Engine Embedding - Integrates a JavaScript and TypeScript execution engine directly into low-level host applications.
- Cross-Language Bridges - Functions as a high-performance cross-language bridge for invoking native engine functions from a scripting environment.
- Game Logic Scripting - Provides a framework for developing game logic and autonomous agents using a type-safe scripting language.
- Scripted Logic Systems - Uses dynamic languages within a host environment to handle logic development outside of the native compiled code.
- TypeScript - Enables writing gameplay logic and scripts for Unity or Unreal Engine using TypeScript.
- TypeScript Game Engine Integrations - Embeds a TypeScript runtime into game engines to execute gameplay logic and editor scripts.
- Native Game Function Invocations - Invokes native functions and manages objects across different languages using reflection or static wrappers for high execution speed.
- Scripting and Compiled Language Integration - Integrates dynamic languages into applications to develop logic outside of the primary compiled language.
- Host API Bridging - Establishes high-performance communication between script runtimes and host APIs written in low-level languages for efficient data exchange.
- Multi-Language Runtime Embeddings - Integrates various dynamic scripting engines into a host application to handle logic outside of compiled code.
- Reflection-Based API Bridging - Maps native host functions to a scripting environment using reflection and static wrappers for high-performance cross-language calls.
- TypeScript Runtime Embedders - Provides a system for integrating a JavaScript and TypeScript execution engine into low-level host applications.
- Cross-Language Object Mapping - Manages the lifecycle and access of native host objects within a managed scripting environment using a unified bridge.
- Scripting Backend Swapping - Allows swapping different language engine implementations to trade off between execution speed and final binary size.
- Type Definition Generators - Automatically generates TypeScript declaration files to provide type-safe access and autocomplete for native host APIs.
- Automated Type Generation - Automatically produces TypeScript declaration files from native host APIs to provide static type checking and autocomplete.
- External API Tool Exposures - Exposes internal state and functions as callable tools for external AI coding tools via a standardized protocol.
- Gameplay - Integrates autonomous AI agents into game environments to create dynamic behaviors based on real-time state.
- External Tool Integrations - Connects external AI editors and clients to the project via a standardized protocol to access core capabilities.
- Scripting Engine Selection - Allows choosing between different engine implementations to balance execution performance against the final binary code size.
- Scripting Runtime Hot-Swapping - Swaps between different language runtimes to balance execution speed, binary size, and specific functional requirements.
- Natural Language Editor Automation - Allows for automated scene building and object inspection in game editors using natural language and scripts.
- Embedded Gameplay AI Agents - Integrates autonomous agents into the project runtime to create dynamic characters that perceive game state and execute actions.
- Embedded Runtime AI Agents - Inserts autonomous agents into a live project environment to create dynamic behaviors and gameplay logic based on real-time state.
- Natural Language Editor Control - Executes commands and manipulates scene objects using AI-generated scripts that access the editor API via natural language prompts.
- Natural Language Engine Control - Allows the project to execute engine API calls through an AI assistant to automate scene building and object inspection.
- Remote Control Protocols - Exposes internal engine state and APIs to external tools via a communication layer for remote manipulation and verification.
- Multi-Language Script Execution - Executes logic using various scripting languages by embedding a compatible script engine into the host application.
- Unified Bridge APIs - Provides a unified bridging API to embed various dynamic languages into a host engine for logic development.
