Better Launcher (Aerie)

Interactive Visual Tour: Inside the Aerie Desktop App

Click through the 7 tabs below to inspect real screenshots of Aerie across both Player Mode and Dev Studio Mode. Click any screenshot to zoom in at full 2160x1350 retina resolution.

01 Next Fest Catalog & Beacons 02 Game Store & Playtest Hub 03 Greenlight Voting Arena 04 Dev Hub & Source Control 05 Bidirectional Kanban 06 F8 Telemetry & AI Triage 07 Guided Spotlight Tours

Aerie — Player Mode • Browse Catalog ("Never-Ending Next Fest")

🔍 Click to Zoom

1. The "Never-Ending Next Fest" Catalog: Features the Next Fest Scout Callout hero banner (+31 Scout Bonus BB), Scout Fresh Build roulette button, What Should I Play? AI Concierge, Needs Testers (<8 plays) filter, and a live Match Callout Available (+50 BB) toast in the bottom-right corner.

Scout Queue Taste Match +50 BB Match Beacon

Aerie — Player Mode • Game Store & Playtest Hub (Hookball)

🔍 Click to Zoom

2. Game Store & Playtest Hub: Players switch between release and playtest build channels, cast verified Would Play / Needs Work votes, broadcast Matchmaking Beacons, and review the developer's Active Testing Objectives and Keybindings (including F8 In-Game Bug Reporter).

Delta Patching 94% Would Play Playtest Objectives

Aerie — Player Mode • Greenlight Concept Voting Arena

🔍 Click to Zoom

3. Greenlight Voting Arena: Studios pitch unreleased concepts or major reworks (e.g., Disc of the Dead Pitch v2) with trailers, screenshots, and core gameplay pillars. Players earn +10 Better Bucks per pitch vote while giving structured qualitative feedback.

+10 BB / Vote Versioned Pitches Pre-Production Validation

Aerie — Dev Studio Mode • Developer Hub, BSC & Engine Launcher

🔍 Click to Zoom

4. Developer Hub & Source Control: Switching to Dev Studio mode replaces the consumer banner with a compact context bar and unlocks 1-click Sync & Launch (Godot, Unreal, or Custom CLI), Copy AI SDK Prompt, Error Diagnostics, and Depot Changelists with clickable ticket badges ([HOOK-1]).

BSC & Perforce 1-Click Sync & Launch Copy AI SDK Prompt

Aerie — Dev Studio Mode • Integrated Tasks & Bidirectional Kanban

🔍 Click to Zoom

5. Integrated Tasks & Kanban Board: Organize tasks across To Do, In Progress, Review & Test, and Done. Notice the purple 2 commit badge on HOOK-1—mentioning [HOOK-1] in a Perforce or BSC commit automatically links that revision to the card!

Bidirectional VCS Links AI Sprint Planner Multi-Discipline Tags

Aerie — Dev Studio Mode • F8 In-Game Bug Telemetry & 1-Click AI Triage

🔍 Click to Zoom

6. Playtester Feedback & 1-Click AI Bug Triage: When a player presses F8 in-game, their report arrives with structured Client Diagnostics & Game Telemetry (Godot 4.5.1, 144 fps, 2560x1440, NVIDIA RTX 4070). Clicking AI Triage to Kanban turns the report into ticket HOOK-2 in one click.

Source: IN_GAME_F8 AI Triage to Kanban Hardware Telemetry

Aerie — Built-In Interactive Spotlight Tours (Playtester & Developer Tracks)

🔍 Click to Zoom

7. Built-In Interactive Spotlight Tours: Clicking 🎓 Tours in the top-left header launches a 7-step interactive spotlight walkthrough for either Playtesters or Developers, automatically navigating tabs and highlighting controls in real time.

Playtester Track (7 Steps) Developer Track (7 Steps) Auto-Navigation

How to Use Aerie: Step-by-Step Practical Guide

Aerie is designed around two distinct workflows—one for Players & Playtesters discovering and testing games, and one for Game Developers & Studios building and shipping games. Here is exactly how to use both:

1. The Problem: The 10,000-Game/Week AI Flood & The Post-Engine Shift

Video game development and distribution are undergoing two simultaneous structural disruptions:

2. High-Level System Architecture

Aerie utilizes a hybrid local-first desktop core (Tauri v2 + Rust) connected to a zero-cold-start serverless backend on Cloudflare:

┌─────────────────────────────────────────────────────────────────────────────┐
│                       AERIE DESKTOP RUNTIME (Tauri v2)                      │
│                                                                             │
│  ┌─────────────────────────┐  ┌─────────────────┐  ┌─────────────────────┐  │
│  │    React 19 Frontend    │  │ Aerie AI Engine │  │ WebRTC VoiceManager │  │
│  │ (Player & Studio Modes) │  │  (10 Tools/BYOK)│  │ (Calls SFU + Mesh)  │  │
│  └────────────▲────────────┘  └────────▲────────┘  └──────────▲──────────┘  │
│               │                        │                      │             │
│  ┌────────────▼────────────────────────▼──────────────────────▼──────────┐  │
│  │                Rust Native Core (apps/desktop/src-tauri)               │  │
│  │   • Single-Instance Guard      • Streaming Delta Downloader (packages)│  │
│  │   • Perforce CLI Reader (p4)   • BetterSourceControl CLI Driver (bsc) │  │
│  │   • Engine Scanner (Unreal/Godot/Custom) • PE Binary Self-Updater     │  │
│  └─────────────────────────────────────▲─────────────────────────────────┘  │
│                                        │                                    │
│                 ┌──────────────────────▼──────────────────────┐             │
│                 │   Local Loopback HTTP Server (127.0.0.1)    │             │
│                 │              PORT: 27088                    │             │
│                 └──────────────────────▲──────────────────────┘             │
└────────────────────────────────────────┼────────────────────────────────────┘
                                         │
               ┌─────────────────────────┴────────────────────────┐
               │                                                  │
┌──────────────▼────────────────┐              ┌──────────────────▼───────────┐
│     Running Game Process      │              │ Cloudflare Serverless Cloud  │
│   (Godot, Rust, C++, Zig, TS) │              │                              │
│ • GET /api/user (Identity)    │              │ • Worker API (packages/backend)
│ • POST /api/match-beacon      │              │ • D1 SQLite Database         │
│ • POST /api/feedback (F8 Bug) │              │ • R2 Zero-Egress Storage     │
│ • GET /api/session/pending-join              │ • Cloudflare Calls SFU Voice │
└───────────────────────────────┘              └──────────────────────────────┘

Monorepo Layout

3. Personas, RBAC & Adaptive UI

Aerie eliminates visual clutter through Adaptive Progressive Disclosure:

4. The "Never-Ending Next Fest" & Anti-Snowball Discovery

Steam's algorithm uses cumulative volume (gross revenue, total wishlists), which creates an inescapable rich-get-richer snowball where the top 1% monopolize front-page visibility. Aerie replaces this with the Anti-Snowball Proof-of-Play Mathematical Curve:

Browse Catalog — Never-Ending Next Fest & Live Match Callout Beacon

🔍 Click to Zoom

Catalog Discovery & Match Beacons: Fresh builds waiting for their first 8 human playtesters appear in the Next Fest Scout Callout banner with automatic Scout Bonus Better Bucks.

Scout Roulette AI Concierge Live Match Beacon

Game Store & Playtest Hub — Channels, Proof-of-Play & Objectives

🔍 Click to Zoom

Store & Playtest Hub: Dedicated channel switcher (Release vs Playtest), Proof-of-Play voting, Matchmaking Callout broadcaster, and structured Active Testing Objectives.

Playtest Channels Active Objectives F8 Keybinding

Interactive Proof-of-Play Discovery Simulator

Test how Aerie calculates discovery ranking and rewards playtesters using the live simulator below:

The Better Bucks Virtual Economy

Better Bucks (BB) incentivize human players to playtest early builds, answer matchmaking callout beacons, and file high-quality bug reports:

Cloudflare Calls SFU WebRTC Voice & Team Chat

Aerie embeds low-latency voice channels and persistent text/DM chat directly inside the launcher so playtesters and developers never need to alt-tab to external voice servers during a multiplayer test:

• Cloudflare Calls SFU + P2P Mesh Fallback: Voice channels route audio through Cloudflare's global Anycast WebRTC Selective Forwarding Unit (SFU) with automatic peer-to-peer mesh fallback, WebAudio speaking indicators, mute/deafen controls, and per-user volume sliders.
• Game-Scoped Channels & Party Rooms: Every game automatically provisions #general, #playtest-feedback, and #bug-reports text channels alongside dedicated multiplayer party voice rooms.

5. Matchmaking Beacons, Local IPC Server & Game SDK

Whenever a game or editor is launched from Aerie, the launcher spawns a zero-dependency local HTTP server on http://127.0.0.1:27088. Any game engine or custom compiled language can communicate with Aerie using standard HTTP requests.

Environment Variables & CLI Injected on Launch

Local Loopback HTTP API Endpoints (`127.0.0.1:27088`)

6. Universal AI-Native SDK Specification

Whether building with Godot, Unreal, Rust (Bevy), Zig (Mach), C++ (SDL3/Raylib), or WebGPU, integrating Aerie takes under 30 seconds.

You are integrating our game with the Aerie (Better Launcher) desktop runtime.
Aerie runs a zero-dependency local HTTP loopback server on `http://127.0.0.1:27088` (or environment variable `BETTER_LAUNCHER_PORT`) whenever the game or editor is running.

### Environment Variables & CLI Flags Injected by Aerie on Launch:
- `BETTER_LAUNCHER_PORT`: Local IPC port (default 27088)
- `BETTER_LAUNCHER_APP_ID`: Game catalog slug (e.g. "my-game")
- `BETTER_LAUNCHER_USER_ID`: Authenticated player UUID
- `BETTER_LAUNCHER_DISPLAY_NAME`: Authenticated player display name
- `BETTER_LAUNCHER_JOIN_SESSION`: If present (or passed via `--better-join-session=<id>`), immediately connect the player to this multiplayer lobby.

### Local Loopback HTTP Endpoints (http://127.0.0.1:27088):
1. `GET /api/user` -> returns { "userId": "...", "displayName": "...", "email": "..." }
2. `POST /api/session` -> advertise multiplayer lobby: { "appId": "...", "sessionId": "...", "maxPlayers": 4, "currentPlayers": 1, "isJoinable": true }
3. `GET /api/session/pending-join` -> poll every 2s; if `sessionId` is non-null, connect player to that lobby.
4. `POST /api/match-beacon` -> broadcast "Need Players" alert to all online Aerie players for Better Bucks bounties. Call `POST /api/match-joined` with { "sessionId": "..." } when someone connects.
5. `POST /api/feedback` -> in-game bug report: { "appId": "...", "category": "bug", "title": "...", "content": "...", "metadata": { "fps": 120, "map": "..." } }

Please create a clean, non-blocking `aerie_sdk` module in our project's language that implements these 5 endpoints and wires `GET /api/user` and `F8` bug reporting into our game loop.

Multi-Language SDK Implementations

Choose your engine or language below to view production-ready, zero-dependency implementations:

extends Node
# Autoload: BetterLauncher (process_mode = Node.PROCESS_MODE_ALWAYS)

signal join_session_requested(session_id: String)
signal feedback_submitted(success: bool, error_message: String)

var _base_url: String = "http://127.0.0.1:27088"
var _user_id: String = ""
var _display_name: String = "Player"
var _poll_timer: Timer

func _ready() -> void:
    var port = OS.get_environment("BETTER_LAUNCHER_PORT")
    if port != "":
        _base_url = "http://127.0.0.1:" + port
    
    # Check cold join CLI flag: --better-join-session=<id>
    for arg in OS.get_cmdline_args():
        if arg.begins_with("--better-join-session="):
            join_session_requested.emit(arg.split("=")[1])
            
    _fetch_identity()
    _setup_polling()

func _setup_polling() -> void:
    _poll_timer = Timer.new()
    _poll_timer.wait_time = 2.5
    _poll_timer.timeout.connect(_poll_pending_join)
    add_child(_poll_timer)
    _poll_timer.start()

func _fetch_identity() -> void:
    var http = HTTPRequest.new()
    add_child(http)
    http.request_completed.connect(func(res, code, hdrs, body):
        if code == 200:
            var json = JSON.parse_string(body.get_string_from_utf8())
            if json and json.has("displayName"):
                _display_name = json.displayName
                _user_id = json.get("id", "")
        http.queue_free()
    )
    http.request(_base_url + "/api/user")

func _poll_pending_join() -> void:
    var http = HTTPRequest.new()
    add_child(http)
    http.request_completed.connect(func(res, code, hdrs, body):
        if code == 200:
            var json = JSON.parse_string(body.get_string_from_utf8())
            if json and json.get("sessionId", "") != "":
                join_session_requested.emit(json.sessionId)
        http.queue_free()
    )
    http.request(_base_url + "/api/session/pending-join")

func submit_feedback(title: String, content: String, category: String = "bug") -> void:
    var http = HTTPRequest.new()
    add_child(http)
    var payload = {
        "appId": OS.get_environment("BETTER_LAUNCHER_APP_ID"),
        "category": category,
        "title": title,
        "content": content,
        "metadata": {
            "engine": "Godot " + Engine.get_version_info().string,
            "os": OS.get_name(),
            "gpu": RenderingServer.get_video_adapter_name()
        }
    }
    http.request_completed.connect(func(res, code, hdrs, body):
        feedback_submitted.emit(code == 200, "" if code == 200 else "HTTP %d" % code)
        http.queue_free()
    )
    http.request(_base_url + "/api/feedback", ["Content-Type: application/json"], HTTPClient.METHOD_POST, JSON.stringify(payload))

use serde::{Deserialize, Serialize};
use std::env;

pub struct AerieClient {
    base_url: String,
    client: reqwest::Client,
    pub app_id: String,
}

#[derive(Deserialize, Debug)]
pub struct AerieUser {
    pub id: String,
    #[serde(rename = "displayName")]
    pub display_name: String,
    pub email: Option<String>,
}

#[derive(Serialize)]
pub struct FeedbackReport<'a> {
    #[serde(rename = "appId")]
    pub app_id: &'a str,
    pub category: &'a str,
    pub title: &'a str,
    pub content: &'a str,
}

impl AerieClient {
    pub fn new() -> Self {
        let port = env::var("BETTER_LAUNCHER_PORT").unwrap_or_else(|_| "27088".to_string());
        let app_id = env::var("BETTER_LAUNCHER_APP_ID").unwrap_or_default();
        Self {
            base_url: format!("http://127.0.0.1:{}", port),
            client: reqwest::Client::new(),
            app_id,
        }
    }

    pub async fn get_user(&self) -> Result<AerieUser, reqwest::Error> {
        self.client
            .get(format!("{}/api/user", self.base_url))
            .send()
            .await?
            .json::<AerieUser>()
            .await
    }

    pub async fn send_feedback(&self, title: &str, content: &str) -> Result<(), reqwest::Error> {
        let payload = FeedbackReport {
            app_id: &self.app_id,
            category: "bug",
            title,
            content,
        };
        self.client
            .post(format!("{}/api/feedback", self.base_url))
            .json(&payload)
            .send()
            .await?;
        Ok(())
    }
}

export class AerieSDK {
  private baseUrl: string;
  public appId: string;

  constructor() {
    const port = (typeof process !== 'undefined' && process.env.BETTER_LAUNCHER_PORT) || '27088';
    this.baseUrl = `http://127.0.0.1:${port}`;
    this.appId = (typeof process !== 'undefined' && process.env.BETTER_LAUNCHER_APP_ID) || '';
  }

  async getUser(): Promise<{ id: string; displayName: string; email?: string }> {
    const res = await fetch(`${this.baseUrl}/api/user`);
    return res.json();
  }

  async advertiseSession(sessionId: string, currentPlayers: number, maxPlayers: number) {
    return fetch(`${this.baseUrl}/api/session`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ appId: this.appId, sessionId, currentPlayers, maxPlayers, isJoinable: true })
    });
  }

  async pollPendingJoin(): Promise<string | null> {
    const res = await fetch(`${this.baseUrl}/api/session/pending-join`);
    const data = await res.json();
    return data.sessionId || null;
  }

  async sendFeedback(title: string, content: string, category: 'bug' | 'feature' = 'bug') {
    return fetch(`${this.baseUrl}/api/feedback`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ appId: this.appId, title, content, category })
    });
  }
}

import os
import json
import urllib.request

class AerieClient:
    def __init__(self):
        port = os.environ.get("BETTER_LAUNCHER_PORT", "27088")
        self.base_url = f"http://127.0.0.1:{port}"
        self.app_id = os.environ.get("BETTER_LAUNCHER_APP_ID", "")

    def get_user(self):
        req = urllib.request.Request(f"{self.base_url}/api/user")
        with urllib.request.urlopen(req) as response:
            return json.loads(response.read().decode())

    def send_feedback(self, title: str, content: str, category: str = "bug"):
        payload = json.dumps({
            "appId": self.app_id,
            "title": title,
            "content": content,
            "category": category
        }).encode("utf-8")
        req = urllib.request.Request(f"{self.base_url}/api/feedback", data=payload, headers={"Content-Type": "application/json"})
        with urllib.request.urlopen(req) as response:
            return response.status == 200

#pragma once
#include <string>
#include <curl/curl.h>

class AerieClient {
private:
    std::string baseUrl;
    std::string appId;

    static size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp) {
        ((std::string*)userp)->append((char*)contents, size * nmemb);
        return size * nmemb;
    }

public:
    AerieClient() {
        const char* port = std::getenv("BETTER_LAUNCHER_PORT");
        baseUrl = std::string("http://127.0.0.1:") + (port ? port : "27088");
        const char* app = std::getenv("BETTER_LAUNCHER_APP_ID");
        appId = app ? app : "";
    }

    std::string GetUser() {
        CURL* curl = curl_easy_init();
        std::string readBuffer;
        if (curl) {
            std::string url = baseUrl + "/api/user";
            curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
            curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
            curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
            curl_easy_perform(curl);
            curl_easy_cleanup(curl);
        }
        return readBuffer;
    }
};

Optional `aerie.project.json` Workspace Manifest

For custom code-first games without a .uproject or project.godot file, dropping an aerie.project.json in your repository root enables 1-click "Sync & Run Project" for all team members:

{
  "name": "My Custom Engine Game",
  "engine": "custom",
  "framework": "Rust + Bevy 0.15",
  "buildCommand": "cargo build --release",
  "launchCommand": "cargo run --release -- --windowed",
  "sourceControl": "bsc",
  "targetExecutable": "target/release/game.exe"
}

7. Developer Hub & Studio Workstation

Switching to Dev Studio Mode unifies source control, game engines, Kanban, and bug triage:

Developer Hub — 1-Click BSC / Perforce Sync, Engine Launcher & Changelists

🔍 Click to Zoom

Workspace & Engine Hub: Compact studio context bar, 1-click Sync & Launch Godot / Unreal / Custom, Copy AI SDK Prompt, and live changelist history with linked ticket badges.

BetterSourceControl Perforce Helix Core Engine Auto-Detect

Tasks & Kanban — Multi-Discipline Board with Bidirectional Commit Links

🔍 Click to Zoom

Bidirectional Kanban & VCS: Every ticket has a 1-click copyable tag (e.g., [HOOK-1]) that automatically links matching Perforce and BSC changelist revisions directly onto the card.

Auto-Linked Commits AI Sprint Planner

Playtester Feedback & Bugs — In-Game F8 Telemetry & 1-Click AI Triage

🔍 Click to Zoom

In-Game F8 Telemetry & AI Triage: Inspect player reports alongside automatically captured engine, build, FPS, resolution, map, and GPU telemetry, then convert to a Kanban ticket in one click.

F8 Telemetry AI Triage to Kanban Sentiment Digest

8. Aerie Copilot & 10 Specialized AI Workflows

Aerie features a multi-provider AI engine supporting Google Gemini, Anthropic Claude, and OpenAI via Bring-Your-Own-Key (BYOK) or managed credits with 10 agentic studio workflows:

9. Admin Studio, Cloud Build Pipeline & Self-Updater

Aerie operates entirely on Cloudflare serverless primitives (Workers, D1, R2, Calls):

Zero-Script Windows PE Self-Updater (`updater.rs`)

1. Streams the new binary from /api/releases/download/<version> to better-launcher.exe.new.
2. Validates that downloaded payload is > 1 MB and starts with a valid Windows PE MZ (0x4D 0x5A) header.
3. Exploits Windows NTFS's capability to rename running executables: renames better-launcher.exe -> .old, moves .new -> better-launcher.exe, and spawns the new process with --wait-pid <pid>.
4. New process waits for the old PID to terminate via Win32 OpenProcess / WaitForSingleObject, acquires the single-instance lock, and deletes .old.

10. Investor Thesis & Commercialization Engine

Aerie is engineered from day one as a high-margin, capital-efficient for-profit B2B2C platform—combining recurring SaaS infrastructure revenue from game studios with marketplace and playtesting network effects on the consumer side.

Four Interlocking Revenue Engines

Competitive Teardown: Aerie vs. $500/mo Legacy Game Backends & The Fragmented Dev Stack

Typical B2B game backend platforms charge studios $500/month (plus per-MAU overages) for an API-only backend (auth, basic leaderboards, feedback webhooks, and key lists) that requires heavy engine SDK integration, includes zero binary build hosting, zero source control, and brings zero players to the game. Even worse, assembling a complete indie studio workflow today requires stitching together 5 separate paid services costing $750+/month:

Disruptive SaaS Pricing & Why Aerie Sustains 88%+ Gross Margins

How can Aerie charge $29–$79/month (undercutting $500/month legacy game backends by up to 94%) while delivering 10x the functionality and maintaining software-grade 88%+ gross margins? The secret is Aerie's local-first Rust client + Cloudflare Zero-Egress architecture:

• $0.00 Bandwidth Egress via Cloudflare R2: Traditional platforms and backend hosts get crushed by cloud egress fees ($0.09/GB) every time players download multi-gigabyte game builds or binary depot revisions. Aerie stores all game builds and content-addressed source control blobs on Cloudflare R2, which charges $0.00/GB for egress bandwidth and just $0.015/GB/month at rest.
• Localhost Compute Offloading (Tauri v2 + Rust): Instead of running expensive dedicated cloud containers for every studio workspace, Aerie executes SHA-256 depot hashing, engine workspace syncing, IPC session routing (127.0.0.1:27088), and AI prompt assembly directly on the user's local machine via native Rust threads.
• Serverless Sub-Millisecond State (Cloudflare Workers + D1): API requests, Proof-of-Play telemetry verification, and matchmaking beacons run on Cloudflare Edge Workers backed by D1 SQLite—costing pennies per million requests with zero idle server overhead.

11. Interactive In-App Tours

Aerie features two built-in 7-step guided walkthroughs accessible anytime via the Tours button in the sidebar:

Interactive Spotlight Tours — Live In-App Onboarding

🔍 Click to Zoom

Interactive Spotlight Cutouts: Both 7-step tours automatically switch views and spotlight the exact UI controls so new playtesters and studio collaborators can learn Aerie in under 60 seconds.

Playtester Tour Developer Tour

12. Download Desktop Client & Quick Start Scripts

Download the standalone portable Windows executable directly from Cloudflare R2, or use the developer scripts below to build from source:

# 1. Start local desktop client with hot-reload
npm run dev

# 2. Package standalone Windows distribution ZIP (release-dist/BetterLauncher-v*.zip)
.\package-release.bat

# 3. Publish launcher update to Cloudflare R2 + D1 (bumps version & triggers client auto-update)
.\Publish_Launcher.bat

# 4. Deploy Cloudflare serverless backend
npm run backend:deploy

# 5. Deploy this documentation website to Cloudflare Pages
npm run docs:deploy