Setup guide
Set up Avori and
start building.
Install Avori, connect the engine you use, and learn how to describe what you want. Building inside Avori does not need an engine.
Installation
Get up and running in minutes
Install Avori first, then choose the starting path that fits you. Building inside Avori does not require an external engine.
1
Run the Avori installer
Open the Avori_Setup.exe file you just downloaded and follow the installer prompts. The Windows installer is available now; the macOS installer is coming soon. Avori installs as a lightweight background service — once installed, you'll see the Avori icon appear in your system tray. It runs silently and starts automatically on login.
Reinstalling on a new PC is fine: download the Windows installer again, sign in with the same Avori account, then use Avori Settings - Transfer Avori Data if you want to move local chats, GDDs, rules, and project context from the old computer.
2
Open Avori and choose how to begin
Open Avori from the Start menu or system tray and sign in with the same account you used here. Choose Build inside Avori for an engine-free first playable, Start a new game in an engine for a new Unity, Godot, or Unreal project, or Connect an existing project for work already in progress.
You do not need to install or open a game engine to use Build inside Avori. For an engine path, install Unity, Godot, or Unreal separately before asking Avori to start there.
3
Follow only the path you chose
For Build inside Avori, describe the game in the same chat and review Avori's game plan before it builds. For Start a new game in an engine, choose an editor already installed on your computer and the new project location. For Connect an existing project, choose that project's root folder; Avori detects the engine from the project and connects the matching integration.
Avori
Describe → Review game plan → Approve → Play and verify
New
Choose installed editor → Review location and plan → Approve
Existing
Choose project folder → Confirm the detected engine → Connect
4
Wait for the right ready state
An Avori-built playable is ready only after its behavior checks pass and you can play the result. An engine project shows Context live when Avori can read the current scripts, scenes, assets, and structure; Actions ready separately means the connected editor can apply changes you approve. Avori does not call an engine project ready merely because its folder exists.
Core project context stays local. Pro cloud continuity and Cloud Loops use cloud storage or processing only when you explicitly enable them, and your content is not used for training.
5
Tell Avori what should stay true (recommended)
Say lasting game and project decisions in ordinary language, then keep them in the GDD or project rules so Avori can reuse them. Put one-request instructions directly in chat. Experienced developers can still name exact files, systems, or architecture when that precision is useful.
Examples: "Keep movement quick and responsive" · "Ask before changing saved games" · "Reuse the inventory screen that is already here"
6
Load your Game Design Document (optional but powerful)
If you have a GDD, choose your project and click GDD in Avori's top bar. Follow the prompt to attach an existing document or create one with Avori. Avori references it for future suggestions so generated systems, scripts, and mechanics can stay aligned with your game's design intent. Supported formats: PDF, Word (.docx), plain text, and Markdown.
No GDD yet? Even a rough outline helps. A single paragraph describing your game's core loop gives Avori enough context to make significantly more relevant suggestions.
7
Start prompting
You're ready. Type questions and requests in the same Avori chat box. Avori answers normal questions in chat; when work would change your project, it shows the proposed actions for review before anything is applied. For a bounded, multi-step goal, Avori can suggest a Loop, or you can start one yourself with /loop.
First prompt examples: "Make a small space platformer with a fox hero and a blaster" · "Add a dash that feels quick, but do not change the jump" · "Explain why the enemy keeps getting stuck without changing anything yet"
Tutorials
Learn Avori for your engine
Engine-specific guides covering everything from your first generation to advanced context and rule management.
Read the Unity reference in the docs →
The Avori Panel in Unity
A full walkthrough of the Avori panel — where to find it, how project context and approvals work, and how to configure it for your workflow. Start here if you're new to Avori.
Generating MonoBehaviours and ScriptableObjects
Learn how to ask Avori to write fully-formed C# scripts that follow your project's architecture. Covers how to describe dependencies, inheritance, and Unity lifecycle methods so generated code plugs in without rewrites.
Explaining and Refactoring Existing Code
Select any script and ask Avori to explain what it does, identify performance issues, or refactor it to match a pattern. Essential for working with inherited codebases or returning to old projects.
Chat, Reviewed Changes, and Loops
Ask questions or request work in one chat. Avori answers directly when no project change is needed, shows proposed actions before edits, and can suggest a Loop for a bounded multi-step goal.
Connecting Your GDD to Unity
Upload your Game Design Document and watch Avori generate systems that actually match your game's design. Covers supported formats, what Avori reads and prioritizes, and how to update your GDD as your design evolves.
Keeping Unity Work Aligned
Use live project context, your GDD, and explicit prompt constraints to keep generated scripts aligned with existing naming conventions, architecture, and systems that should not be modified directly.
Read the Godot reference in the docs →
The Avori Plugin in Godot
Where to find the plugin, a full panel walkthrough, and initial configuration. Covers Godot 4 compatibility, the Tools menu integration, and how to verify the plugin is connected to the running Hub.
Generating GDScript Nodes and Autoloads
Describe a node's behavior and Avori writes GDScript that fits your scene structure. Covers Node, Resource, and Autoload patterns, and how to specify signals, exports, and lifecycle methods in your prompts.
Extending Existing Scenes with AI
Ask Avori to add logic to existing scenes without overwriting what you've built — new signals, child node logic, extended behavior, or additional exports. Learn how to describe what should change vs. what should stay.
Debugging and Analysis in Godot
Use ordinary chat to debug runtime errors, understand unfamiliar node structures, trace signal chains, or get plain-English explanations of existing GDScript. Avori asks for approval before applying proposed project changes.
GDD-Aware Generation in Godot
How Avori uses your Game Design Document to generate Godot-specific code that respects your game's intended systems. Learn how GDD context influences node naming, scene structure, and the signals Avori creates.
Keeping Godot Work Aligned
Use live project context, your GDD, and explicit prompt constraints to keep generated scenes and scripts aligned with your signal naming, node structure, and architectural decisions.
Read the Unreal reference in the docs →
The Avori Toolbar in Unreal
Setup and troubleshooting for Unreal Engine 5.7 on Windows. Covers how the Unreal plugin connects to the running Hub service and what to check if the connection isn't showing as active.
Generating Blueprint Logic
Describe a mechanic and Avori builds it in the Unreal editor after your approval: Actor Blueprints with variables, functions, and connected nodes, UMG widgets, and Animation Blueprint state machines. Covers how to specify pins and function connections in your prompts.
Generating and Extending C++ Components
Ask Avori to write UObject-based C++ actors, components, and subsystems that follow Unreal's module structure. Learn how to describe parent classes, module dependencies, and UPROPERTY/UFUNCTION requirements so generated code compiles cleanly.
Debugging and Analysis in Unreal
Use ordinary chat to understand Blueprint graphs, explain C++ hierarchies, trace event flow, or identify where a change belongs. Avori asks for approval before applying proposed project changes.
GDD-Aware Generation in Unreal
How Avori connects your Game Design Document to Unreal's systems — influencing class naming, Blueprint graph structure, component hierarchies, and the GameplayAbility or GameMode setup it generates.
Project Rules in Unreal
Define Unreal-specific conventions as Avori rules — which subsystems to use, naming patterns for assets and classes, modules that should never be modified, and architectural constraints Avori must always respect.
Prompting Guide
You don't need to know the code — just describe your game
Avori understands plain English. Whether you're building your first game or your tenth, these tips will help you get the right results from every prompt.
Choose the right workflow
Chat
No code changes
Questions and analysis — nothing in your project is modified. Use it to understand existing code, debug an error, or plan what to build before you build it. Avori reads your project and answers in plain English.
"Why is my player falling through the floor?"
"What does this script actually do?"
"What's the best way to add a jump to what I have?"
Reviewed changes
You approve changes
Request the work in the same chat. Avori generates or modifies code and shows each proposed project action before applying it. You approve or reject the action; there is no separate mode switch.
"Create a cube that falls when I press Play"
"Add a spacebar jump to my player"
"Write a health system with a UI health bar"
Loop
Bounded multi-step goal
For bigger goals, Avori can suggest a Loop and show its goal, limits, validation, and execution location before it starts. You can also type /loop yourself. Local Loops run on this computer; continuing while it is off requires Avori Pro.
"Build me a complete inventory system"
"Create an enemy with patrol, chase, and attack states"
"Set up a main menu, pause menu, and game over screen"
Starter prompts — try these to see what's possible
You don't need technical vocabulary. Plain descriptions work — Avori figures out the implementation. As you get more comfortable, adding system names and patterns gives you tighter control.
Beginner
"I want to make something I can see on screen that falls down when I press Play, and doesn't fall through the floor"
→ Avori creates a visible object with physics, adds a ground plane beneath it, and positions both so the physics are immediately visible when you press Play.
Beginner
"I want to press spacebar to make my character jump and then come back down"
→ Avori finds your existing player script and adds jump logic with a ground check so the player can only jump when they're on the ground.
Beginner
"Make something that follows the player around but stops when it gets close enough"
→ Avori creates a simple enemy that moves toward the player and stops within a configurable range — with a speed variable you can tune in the Inspector.
Beginner
"I want the player to lose health when they touch an enemy and show a red bar on screen"
→ Avori creates a health system, wires up damage on collision, and adds a UI health bar — all connected to your existing player object.
Experienced
"Create a PlayerController MonoBehaviour with a speed float, Rigidbody-based WASD movement, and a grounded jump on Space using a sphere cast. Use the existing InputManager and follow the pattern in CharacterBase."
→ Precise control — Avori follows your existing architecture, class hierarchy, and naming conventions exactly.
Both styles work. Beginners get working results from plain descriptions. Experienced developers get precise output by naming existing systems and patterns. Start with whatever feels natural — you can always follow up with more detail in the next message.
Best Practices
Get more out of every prompt
Tips from working with Avori across hundreds of projects.
Be specific — name the systems
Instead of "make an enemy AI", say "make a patrol AI that uses the existing NavMesh, pulls from EnemyPool, and broadcasts OnDetectPlayer on the EventBus when the player is within 15 units." The more specific you are, the less cleanup you'll need.
Load your GDD before your first prompt
Avori references the GDD for every generation. Loading it before you start means your very first prompt already has design context — generated systems won't contradict mechanics you've already defined.
Set rules before generating big systems
Add your architecture decisions and coding conventions to Rules before building anything significant. It's faster to set a rule once than to correct the same pattern in every generation for the rest of the project.
Explore in chat before building
Before generating a new system, ask Avori what is already there — which scripts handle similar logic, what patterns are already in use, and where a new system should plug in. This prevents duplication and conflicts.
Queued actions wait for your editor
If Avori creates scene or file actions while your engine is busy, those actions wait until the editor connection is ready. Keep the Hub running, return to your editor, and Avori will continue from the queued work instead of losing the request.
Trial credits, Avori Balance, and personal keys
Trial credits and prepaid Avori Balance pay for Avori-hosted models. Using your own AI provider key is part of Avori Pro: connect your own provider key in Avori Settings → Keys, and your provider bills that usage directly without touching Avori Balance.
Resources