Setup Guide

You're in. Let's get
Aura connected.

Follow the steps below to install the Hub, connect to your engine, and start generating code that actually fits your project.

Go to Dashboard → Read the Docs
Installation
Get up and running in minutes
Follow each step in order. Most users are connected and generating code within 5 minutes.
1
Run the Aura Hub installer
Open the AuraHub_Setup.exe (Windows) or .dmg (macOS) file you just downloaded and follow the installer prompts. The Hub installs as a lightweight background service — once installed, you'll see the Aura icon appear in your system tray. It runs silently and starts automatically on login.
The Hub handles all AI communication, authentication, and plugin injection. It must be running for your engine plugin to work.
2
Your engine plugin is already installed
During installation, Aura automatically scanned your drives and injected the plugin into any Unity, Godot, or Unreal projects it found. No manual plugin installation is needed. If you create a new project after installing Aura, the plugin will be injected automatically the next time you open that project.
Don't see the plugin? Open your project once with the Hub running — it will detect and inject on first launch.
3
Open your project and sign in
Launch your engine and open your project. Find the Aura AI panel using the path for your engine, then click Sign In and use the same account you created here.
Unity Window → Aura AI → Open Panel → Sign In
Godot Project → Tools → Aura AI → Sign In
Unreal Toolbar → Aura AI button → Sign In
4
Build your project's context map
After signing in, click Load Context in the Aura panel. Aura reads your scripts, scenes, prefabs, and project structure to build a local map of your codebase. This takes 1–3 minutes depending on project size. Everything runs entirely on your machine — your code is never uploaded or used for training.
The context map is what separates Aura from generic AI tools. Without it, suggestions are generic. With it, every generation is aware of your existing systems, naming conventions, and architecture.
5
Set your project rules (recommended)
In the Aura panel, open the Rules tab. Add constraints you want Aura to always follow — coding conventions, patterns to avoid, systems that should never be modified directly, naming standards, or architectural decisions. Rules are applied to every single generation, so setting them once saves you from correcting the same pattern repeatedly.
Example rules: "Always use the EventBus for cross-system communication" · "Never modify PlayerController directly — extend it" · "All UI code must use the MVVM pattern"
6
Load your Game Design Document (optional but powerful)
If you have a GDD, upload it in the GDD tab of the Aura panel. Aura references it for every suggestion — generated systems, scripts, and mechanics will be aware of your game's design intent. Supported formats: PDF, Word (.docx), plain text, and Markdown. You can update or replace your GDD at any time as your design evolves.
No GDD yet? Even a rough outline helps. A single paragraph describing your game's core loop gives Aura enough context to make significantly more relevant suggestions.
7
Start prompting
You're ready. Type your first request in the Aura chat panel. Be specific — describe what you need, how it should interact with existing systems, and any constraints it should respect. The more context you give, the less cleanup you'll need. Use Ask Mode to ask questions or analyze existing code without making changes, and Build Mode when you want Aura to generate or modify code.
First prompt tip: "Create a [SystemName] that [what it does], using the existing [dependency]. It should follow the [Pattern] pattern already used in [existing script]."
Tutorials
Learn Aura for your engine
Engine-specific guides covering everything from your first generation to advanced context and rule management.
🪟
The Aura AI Panel in Unity
A full walkthrough of the Aura panel — where to find it, what each section does, how to switch between Ask and Build mode, and how to configure it for your workflow. Start here if you're new to Aura.
UnitySetupBeginner
📝
Generating MonoBehaviours and ScriptableObjects
Learn how to ask Aura 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.
UnityC#Generation
🔍
Explaining and Refactoring Existing Code
Select any script and ask Aura 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.
UnityC#Ask Mode
⚡
Ask Mode vs Build Mode
Ask Mode answers questions and analyzes your code without making any changes. Build Mode generates and proposes modifications. Learn when to use each, how to frame prompts for each mode, and how to switch mid-conversation.
UnityWorkflow
📄
Connecting Your GDD to Unity
Upload your Game Design Document and watch Aura generate systems that actually match your game's design. Covers supported formats, what Aura reads and prioritizes, and how to update your GDD as your design evolves.
UnityGDDContext
📏
Setting Project Rules in Unity
Teach Aura your codebase's architecture. Set rules like naming conventions, required design patterns, and systems that should never be touched directly. Rules apply to every generation — set them once, enforce them always.
UnityRulesArchitecture
🟣
The Aura AI 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.
GodotSetupBeginner
📝
Generating GDScript Nodes and Autoloads
Describe a node's behavior and Aura 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.
GodotGDScriptGeneration
🌿
Extending Existing Scenes with AI
Ask Aura 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.
GodotGDScriptWorkflow
🔍
Using Ask Mode in Godot
Debug runtime errors, understand unfamiliar node structures, trace signal chains, or get plain-English explanations of existing GDScript. Ask Mode never modifies your project — it's a read-only conversation about your code.
GodotAsk ModeDebug
📄
GDD-Aware Generation in Godot
How Aura 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 Aura creates.
GodotGDDContext
📏
Project Rules in Godot
Define your scene conventions, signal naming patterns, and architectural decisions as Aura rules. Once set, every generation respects them — no more correcting the same structural patterns in every response.
GodotRulesArchitecture
🔵
The Aura AI Toolbar in Unreal
Panel overview, toolbar button location, and initial configuration for Unreal Engine 5. Covers how the Unreal plugin connects to the running Hub service and what to check if the connection isn't showing as active.
UnrealSetupBeginner
📐
Generating Blueprint Logic
Describe a mechanic and Aura generates Blueprint node graphs you can paste directly into your project. Covers Actor Blueprints, UMG widgets, Animation Blueprints, and how to specify input/output pins and function connections in your prompts.
UnrealBlueprintGeneration
📝
Generating and Extending C++ Components
Ask Aura 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.
UnrealC++Generation
🔍
Using Ask Mode in Unreal
Understand complex Blueprint graphs, get plain-English explanations of C++ hierarchies, trace execution flow through event graphs, or identify where to safely make changes in an unfamiliar project. Ask Mode never modifies anything.
UnrealAsk ModeDebug
📄
GDD-Aware Generation in Unreal
How Aura 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.
UnrealGDDContext
📏
Project Rules in Unreal
Define Unreal-specific conventions as Aura rules — which subsystems to use, naming patterns for assets and classes, modules that should never be modified, and architectural constraints Aura must always respect.
UnrealRulesArchitecture
Prompting Guide
You don't need to know the code — just describe your game
Aura 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 mode
🔍
Ask Mode
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. Aura 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?"
⚡
Build Mode
Creates & edits code
Aura generates or modifies code and shows you each proposed change before doing anything. You approve, edit, or reject every action. Nothing touches your project until you say so.
"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"
🗺️
Plan Mode
Step-by-step build
For bigger features, Aura breaks the work into stages, shows you the full plan upfront, then pauses between steps so you can review progress and approve each piece before moving on.
"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 — Aura 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"
→ Aura 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"
→ Aura 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"
→ Aura 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"
→ Aura 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 — Aura 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 Aura 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
Aura 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.
🔍
Use Ask Mode to explore before building
Before generating a new system, use Ask Mode to have Aura map what's 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.
🧱
Build one system at a time
Generate one system, review it, and integrate it before asking for the next. Aura's output is better when it has your reviewed, integrated code as context. Chaining unreviewed generations leads to compounding inconsistencies.
🔑
BYOK uses your own API key
On Power and Studio plans, you can connect your own OpenAI, Anthropic, or Google API key in the Dashboard under API Keys. When BYOK is active, your monthly credits are not deducted — you pay your provider directly at their rates.
Resources
Everything else you need
📚 Documentation ↗ 🙋 Help Center ↗ 📋 Changelog ↗ 💳 Pricing & Plans ↗

Ready to build?

Your engine is connected and your context is loaded. Open the Aura panel in your engine and start with your first prompt.

Go to Dashboard →