Acron

Acron for AI & ML

Your Model.
In The Game.

Acron is the only production engine where PyTorch just works in-process — no subprocess, no FFI layer, no ONNX export pipeline. ML inference runs in your game loop at native Python speed.

Status Private Beta — invite only
Request Beta Access AI Integration Docs

Why Acron

ML Libraries
Are First-Class

In Unity or Unreal, running a PyTorch model requires an external server, ONNX export, or a plugin. In Acron, your game logic and your model are in the same Python process. import torch and call it directly.

  • ▪Zero overhead — no inter-process communication, no serialization round-trips
  • ▪Any Python ML library — PyTorch, TensorFlow, JAX, scikit-learn, HuggingFace
  • ▪Python 3.14 no-GIL — true multicore; run inference on a background thread without locking the game
  • ▪C++ where you need it — drop to C++ for performance-critical non-ML code
ai_npc.py
import torch
from transformers import AutoModelForCausalLM
from acron import Entity, NavAgent

# Load model once — stays in GPU memory
npc_brain = AutoModelForCausalLM.from_pretrained(
    'mistral-7b-instruct',
    device_map='auto',
)

class AIGuard(Entity):
    def on_player_near(self, player):
        context = self.get_world_state()
        # Call model directly — no subprocess
        response = npc_brain.generate(
            context, max_new_tokens=40
        )
        self.speak(decode(response))

Use Cases

What You Can Build

LLM-Driven NPCs

Run local LLMs (Mistral, LLaMA, Phi) directly in the game process. NPCs that reason about the world state, remember conversations, and respond dynamically — without an external server.

Reinforcement Learning Environments

Acron's game loop is a first-class RL environment. Connect Gym/Gymnasium agents, run training loops, and visualise learned policies — all in the same process as the renderer and physics.

Procedural Content with Diffusion

Generate textures, terrain, or character assets at runtime using diffusion models. No export/import pipeline — write the texture directly to the GPU buffer.

Behaviour Cloning from Demonstrations

Record player sessions as Python data, train a behaviour cloning model with PyTorch, and deploy the policy as an NPC in the same session. Iteration loop: minutes, not days.

Computer Vision in VR/Simulation

Render segmentation masks, depth maps, and optical flow directly from the engine's render pipeline. Feed to a CV model for perception research or sim-to-real transfer.

Navigation with Learned Policies

Combine Acron's nav mesh with a trained policy network. The nav mesh handles geometry; the policy decides high-level behaviour. NumPy arrays pass between them at zero cost.

Build the
Intelligent Game

Your model and your game in one Python process. Request beta access and start building.

Request Beta Access All Features