Cunning3D: A Modern AI-Native Procedural DCC IDE

Cunning3D is an rust native ai 3DIDE software reimagines procedural modeling with Rust + ECS, deep Google Gemini integration, and Game Engine FFI.

Comment

Pin: The Code is Freeze At 26.2.10 on github.

Project Name: Cunning3D

Tagline: A Modern, Cross-Platform Procedural DCC IDE built on Rust + ECS, Async Architecture, Deep Gemini Integration. **Directly open the core geometry data structure and operators to the game engine without requiring any license. Artists can use it just like Blender's procedural graph, and they can customize the powerful overlay system. They can encapsulate CDA (Cunning Digital Assembly) into independent node assets and combine it with OVERLAY. Even a CDA becomes a DCC (the Voxel Edit node has already achieved this). The universal parameter design and FFI enable it to be used universally across web, game engines, desktops, and mobile devices. Programmers, technical artists, and art creators can all find their own positions within it.

What GEMINI and AI Do Here:

  • Full Knowledge Access: AI possesses comprehensive knowledge of all nodes, enabling it to teach users how to use Cunning3D effectively.
  • Code Generation: Assists users in writing compilable and usable Rust node code via Rhai and C APIs (continuous optimization in progress).
  • Voice & Text Control: Helps users operate the Node Editor through voice recognition and text input, enabling "modeling via chat."
  • Smart Autocomplete: In the Node Editor Tab, AI infers user intent from context to assist in node completion via the Tab key.

Nano Series Nodes:

  • NANO TEXTURE: Generates PBR textures for users.
  • NANO DISPLACEMENT: Generates high-poly models from displacement maps.
  • NANO VOXEL HEIGHTMAP: Assists users in generating voxel terrains.

Local LLM Assistance:

  • Provides faster response times and quicker completion speeds.

Future Roadmap:

  • Local fine-tuned models.
  • Code simplification.
  • Compute shader and operator optimization.
  • True algorithmic routing encapsulation nodes and more interactive overlays.

1. Deep AI Integration: Powered by Gemini

Cunning3D goes beyond a simple chatbot; I have deeply embedded Google Gemini into the very core of our node graph and asset generation pipeline:

  • Gemini Graph Autocomplete:

    • Context-Aware: The AI reads the current graph topology, parameter states, and port connections in fast apply / deep thinking modes.
    • Tab-to-Complete: Users simply select a node or describe an intent (e.g., "Scatter vegetation on surface"), press Tab, and Gemini automatically generates the full node chain, sets parameters, and wires ports—drastically lowering the barrier to procedural modeling.
    • Traceable Operations: All AI modifications are converted into explicit Editor Commands, ensuring full undo/redo support and project safety.

  • AI Workspace:

    • A dedicated desktop window supporting multi-turn chat and Function Calling.
    • Full Control: Gemini can invoke engine APIs to search assets, modify scene hierarchy, or even write and compile native Rust code on the fly to extend the node system.

  • Nano Banana Generative Nodes:

    • Nano Voxel Painter: Leveraging Gemini Vision, this node converts reference images or text prompts directly into voxel textures. The AI generates color/material atlases, which the engine quantizes and maps onto 3D voxel grids.
    • Nano Heightmap & Hexplanar Baker: AI-assisted terrain generation and seamless texture baking for complex 3D models.

2. CDA & Coverlay: Redefining "Assets"

Artist is the Dev self — One Asset is One DCC Our core innovation is the CDA (Cunning Digital Assembly) format. It is not just a simple procedural model file with parameters; it is a mini-application with embedded editing logic.

  • One Asset, Full Editor: Every CDA encapsulates its full procedural logic (node graph) and interaction interface. Opening a CDA means gaining a suite of custom editing tools tailored specifically for that asset—even a full DCC software (not only in the future; the voxel edit node is already done).
  • Coverlay (Custom Overlay): Creators can bind flexible interaction layers (Overlay UI/HUD Gizmos) to a CDA. For example, a "Procedural Bridge" can have handles to "drag pier spacing" or buttons to "toggle railings." A Voxel Node can have a full overlay panel for the voxel creator. This gives CDAs the precision of a DCC with the intuitive interaction of a game.
  • Sandboxed & Stable: Thanks to Rust's memory safety and our architecture, a CDA will never crash the host. Even if asset logic fails, it is contained within the asset, ensuring the stability of the editor or game engine.
  • Host-Agnostic: CDAs are self-contained and do not require the massive Cunning3D main software to run. I emphasize "Create Once, Run Anywhere"—whether on Web, Unity, or future platforms, a lightweight Runtime is all that's needed.

3. Core Architecture: Procedural & GPU-First

Cunning3D is a procedural platform re-engineered on a modern Rust + ECS (Entity Component System) data-driven architecture.

  • Extreme Performance: I leverage Rust's concurrency and ECS memory management, combined with GPU Compute Pipelines (Compute Shaders) for heavy geometry and voxel math, ensuring real-time interactivity for millions of primitives.
  • Flexible Layering: From artists using Graphs to engineers using DLLs and C APIs, the system is designed to accommodate every role in the production pipeline.

4. Async-First Architecture

To eliminate UI freezes, I built a fully asynchronous foundation:

  • Async Compute Pipeline: Node graph "cooking" runs in background thread pools or Web Workers, completely decoupled from the foreground UI/Render thread.
  • Streaming Results: Compute results are streamed back via channels. The ECS world updates only when data is ready, guaranteeing a zero-blocking viewport experience.
  • Interaction Throttling: During parameter drags, the engine intelligently throttles compute frequency (e.g., 15Hz) to maintain silky-smooth UX, finalizing high-precision results instantly upon release.

5. Cross-Platform Engine: Cunning Engine

  • Cunning CDA Runtime (Core): A pure Rust, UI-agnostic library responsible for parsing and executing .cda assets.
  • Web (WASM) Support: Via cunning_player, I compile the runtime to WebAssembly. Using web-sys and wasm-bindgen, compute logic runs in a Web Worker, while rendering utilizes WebGPU/WebGL. This allows users to run a flexible DCC directly in a browser without installation!
  • Unity/Unreal Integration: The Cunning Engine embeds as a Native Plugin into Unity (with a flexible Runtime/Editor/DCC DLL layering system). Unreal integration is also in planning. Game developers can author assets in Cunning3D and tweak them dynamically inside the game engine, bridging the final gap between DCC and Runtime.

6. Core Technical Features

It utilizes direct FFI DLLs for Unity and Unreal, requiring no sessions or pipes.

  • **There is no data conversion overhead. (You don't need to worry about Rust crashing the host; thanks to compile-time checks and safe unwrapping, Rust is far safer than C++ and practically accident-free.)

  • **It can directly share pointers to N-gon and half-edge structures, as well as core algorithms, with game engines like Unity. This means you can use the core algorithms and geometry structures directly, without the DCC software itself or any graph wrappers.

  • **For Bevy and the Web, it is native and does not even require a glue layer like the Houdini Engine.

  • **In addition to allowing graphics programmers to directly use the core, it supports packaging assembly assets in a way similar to Houdini and Blender's Geometry Nodes, which can be used in game engines like Unity and web players.

  • **Unlike standard HDAs, it includes not only parameters but also comprehensive overlays and HUDs, enabling users to interact with it just like a fully-featured asset.

  • **For technical artists, it offers a non-black-box mode to access internal node operators, reducing additional overhead. It can also be encapsulated by artists as independent DCC software for use in game engines and on the web.

  • **Why expose the low-level layer directly? Six months ago, node graphs and script wrappers were convenient for programmers. However, with the rapid development of AI, direct use of low-level APIs is now the most convenient approach for the future of programmer-AI collaboration, and it also saves significant performance by eliminating glue layers.

Summary: Cunning3D is not just an efficiency tool for programmers and technical artists; it is an accessible DCC modeling software for artists and a comprehensive platform for asset creation.

Built With

Share this project:

Updates

Submission history