GRUNG ENGINE

Powering the Production Pipeline

About the Toolchain

GrunG is our proprietary, high-performance visual programming language. Engineered from scratch to bypass the typical visual scripting clutter and execution overhead, GrunG allows our studio to wire complex gameplay frameworks that transpile ahead-of-time (AOT) directly into perfectly optimized, compilable standard ISO C++ module classes.

The Core Architecture: Three-Tier Functional Isolation

  • Tier 1 Flowcharts: Strictly isolates macro system behavioral structures, state contexts, and top-level AI transition tables.
  • Tier 2 Execution Rails: Focuses on sequential, vertical imperative code blocks containing timelines, conditions, and visual coroutines.
  • Tier 3 Data Graphs: Handles expression math workflows side-effect-free using clean horizontal dependency pins that evaluate lazily.
Proprietary Tech C++ Transpiler Python Backend Git Native
[State: PlayerTick] ● IMPURE
► Exec Pulse Input
Condition Output Link ──────┐
│
🧩 MathExpression [<=]
CurrentAmmo Int: 0
⚡

AOT Transpilation

Bypasses standard scripting interpreters completely. Compiles source arrays into clean, optimized native standard ISO C++.

🌿

Git Merge Optimization

Splits layouts into a dual-file structure (`.grung` for logic, `.grung.view` for geometry caches) to protect team assets from version conflicts.

🛠️

Auto-Healing Assets

Integrates a centralized project migration map ledger to dynamically re-index asset connection tracks when underlying code rules refactor.

Toolchain Pipeline Milestones

Visual Coroutines

Serializes execution stack scopes into callback hooks to yield loops across frames instantly.

GUID Error Hooks

Injects tracking metadata directly into code lines, passing compiler build warning highlights to the visual grid.

Lazy Evaluation

Saves calculation bandwidth by checking Pure mathematical branches exclusively upon state evaluation requests.

Telemetry Stripping

Optimizes memory spaces by tracking interface layouts in a completely separate metadata layer.

Harness Suite: Syntactic Strain Matrix • Compilation Quality Filter • Bit-Level Behavioral Oracle

Development Roadmap

Phase 1: Architecture Blueprint (Completed)

Established the three-tier layer separations, asset schema paradigms, and hex wire coloring matrix configurations.

Phase 2: Compiler Backend Brain (Active Development)

Constructing the AOT Python parsing script engine to transpile metadata manifests straight into `.h` and `.cpp` code structures.

Phase 3: Infinite Viewport Mesh

Integrating a responsive ImGui canvas layer framework to render interactive workspace wire networks directly inside our tool engine.

Pipeline FAQ

Is there a performance penalty when utilizing GrunG graphs?

No. Because graphs compile down into pure ahead-of-time standard C++ binaries before build cycles run, visual scripting executions occur at identical raw processor clock speeds as manual source coding.

How are file conflicts managed within team versioning control?

By splitting the schema records from coordinate UI data caches, engineers can adjust visual positioning variables freely across screens without introducing merge lock blocks inside the codebase manifest branches.