Game Engine Integration

Unity

C# P/Invoke bindings. Drop-in integration. Async support. Drop the native library into your project, call Atelico.Init(), and start chatting. Works on Windows, macOS, and Linux standalone builds.

Unreal Engine 5

UE5 subsystem integration. FFI bindings. Blueprint compatible, so designers can wire AI calls into gameplay logic without touching C++. Async nodes keep the game thread free.

The subsystem registers automatically. Call it from C++ or Blueprints with the same API surface.

Godot 4

Native GDExtension. Call from GDScript. Ships as an addon. Every capability is available with full async support. No subprocess, no HTTP overhead. Direct function calls.

Custom Engines (C API)

Built your own engine, or working in a language we don't ship bindings for? The core exposes a stable C API: a plain C ABI header that any language with an FFI can call, from C and C++ to Rust, Swift, Zig, and Python.

// Any language with a C FFI: custom engine, C++, Rust, Swift, Zig...
#include "atelico.h"

int main(void) {
    atelico_init();

    char* reply = atelico_chat(
        "What should I do next?",
        "You are a helpful NPC in a fantasy village."
    );
    printf("%s\n", reply);

    atelico_string_free(reply);
    return 0;
}

Chat

Ask an NPC a question or prompt an AI companion. Each engine uses its native async pattern, keeping the game thread responsive. Learn more about LLM inference →

// Unity: C# async/await
Atelico.Init();

// Chat with an NPC
string response = await Atelico.Chat(
    "What should I do next?",
    "You are a helpful NPC in a fantasy village."
);

Structured Output

Request JSON that conforms to a schema. Useful for inventory systems, quest generators, or any feature that needs machine-readable responses. Learn more about structured output →

// Unity: Structured output
Atelico.Init();

string json = await Atelico.ChatStructured(
    "Describe this item",
    "You are an inventory system.",
    itemSchema
);

Image Generation

Generate textures, portraits, or concept art at runtime. The result is returned as raw bytes you can load into a sprite or texture. Learn more about image generation →

// Unity: Image generation
Atelico.Init();

byte[] image = await Atelico.GenerateImage(
    "a crystal sword with blue glow"
);

Frame Budget API

Set how much GPU time AI gets per frame. The engine uses hardware scheduling (Compute Graphics Scheduler on Windows, Metal command queues on macOS/iOS) to enforce the budget without stalling your renderer. Learn more about GPU sharing →

Atelico.SetGpuPriority(GpuPriority.Balance);

Three built-in CGS scheduling modes: PrioritizeGraphics (AI yields to the renderer), Balance (equal priority), and PrioritizeCompute (AI gets priority during loading screens or cutscenes).

More Capabilities

Every capability below is available through the same native API in Unity, Unreal, and Godot.

Embeddings & Vector Search

Text embeddings, semantic similarity, and a facet-filtered KV store for authored content.

Character Behavior System

Autonomous NPCs with emotions, needs, memory, relationships, and planning.

Guardrails & Content Safety

Layered safety: keyword blocklists, ML classifiers, LLM judges, and content rewriters.

Model Adapters

Hot-swap adapters at runtime. Fine-tune style, voice, or task behavior without reloading.

Creative Control

Semantic retrieval, state machines, structured generation, and guardrails keep the AI under your creative control.

Benchmarks

Frame-time impact, tok/s, image generation speed, and memory usage.

OpenAI-Compatible Server

For any language or tool that speaks OpenAI's API, install the standalone server and point your client at it. Python, JavaScript, cURL, LangChain, anything that can call /v1/chat/completions works out of the box.

cargo install atelico-server --features metal
atelico-server

# From any language, use the standard OpenAI API:
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "bonsai-1.7b",
       "messages": [{"role": "user", "content": "Hello!"}]}'

Native Unity, Unreal, and Godot integration