Почему AAA-игры, созданные ИИ, работают в браузере? Разбор 1,4 МБ Saltline и 3 путей веб-игр

Почему AAA-игры, созданные ИИ, работают в браузере? Разбор 1,4 МБ Saltline и 3 путей веб-игр

Примечание автора: Saltline выполняет код игры прямо в браузере и вызывает локальный GPU игрока для рендеринга. Процедурные ассеты плюс WebGL — вот и объяснение, почему веб-файл размером около 1,4 МБ способен показать полноценную 3D-сцену шутера.

У «AAA-игры», сделанной AI, есть три причины работать в браузере. Первая: современный браузер сам по себе — это полноценная среда для запуска 3D-приложений. JavaScript выполняет игровую логику, Three.js собирает сцену, а WebGL передаёт всю отрисовку GPU на компьютере игрока. Вторая: на этапе разработки AI выдаёт программу игры, а после её завершения всё выполнение ложится на браузер — во время игры модель AI больше не вызывается. Третья: модели, текстуры и звуки в Saltline генерируются кодом, весь HTML-файл весит около 1,4 МБ, и достаточно открыть страницу, чтобы сразу оказаться в игре.

Здешняя «AAA» — это визуальный ориентир, который разработчик задал AI, своего рода сравнение со стилем картинки. Сам Saltline — небольшой играбельный прототип с одним уровнем.

Дальше начнём с кейса Saltline и разберёмся, где именно работает игра. Потом распутаем техническую цепочку рендеринга 3D-сцен в браузере, объясним, почему процедурная генерация позволяет ужать файл до 1,4 МБ, и сравним три пути: локальный запуск веб-страницы, облачный гейминг и мировые модели AI. В конце дадим код, который можно запустить сразу: с его помощью вы сгенерируете с AI и измерите 3D-сцену на веб-странице, а заодно обсудим реальную дистанцию между браузерными играми и коммерческими AAA-играми.

why-ai-made-3a-game-runs-in-browser-ru-image-0

Table of Contents

To Know: разбираемся в терминах AI-игры уровня AAA в вебе

Термин Объяснение
JavaScript Язык программирования, который исполняет браузер; игровая логика Saltline написана именно на нём
Three.js JavaScript-библиотека для 3D-графики — с её помощью собирают сцену, камеру, освещение и объекты
WebGL Графический интерфейс, который предоставляет браузер: он позволяет веб-странице обращаться к GPU устройства и рисовать 3D-картинку
WebGPU Новое поколение графического и вычислительного интерфейса браузера, возможности у него современнее; Saltline на него не опирается
WebAssembly (Wasm) Низкоуровневый байткод, который умеет исполнять браузер, — благодаря ему программы на C++, Rust и других языках работают в вебе на высокой скорости
GPU Графический процессор, который хорошо справляется с параллельными вычислениями: множеством пикселей и вершин одновременно
Shader Небольшая программа, работающая на GPU: она вычисляет положение каждой вершины или цвет каждого пикселя
Процедурная генерация Построение игрового контента по правилам и математическим функциям вместо заранее подготовленных картинок и файлов моделей
Instancing (инстансинг-рендеринг) Отрисовка множества объектов одинаковой формы за один вызов отрисовки — например, целых рядов контейнеров
Время кадра Время, которое нужно на отрисовку одного кадра; при 60FPS это примерно 16.67 миллисекунды на кадр
Облачный гейминг Игра выполняется на удалённом сервере и передаёт картинку игроку в виде видеопотока
WebRTC Технология браузера для передачи аудио и видео в реальном времени; в облачном гейминге её часто используют для передачи картинки и ввода
Мировая модель AI-модель, которая учится закономерностям изменения окружения и по вводу игрока предсказывает и генерирует последующие сцены

1 Почему 3A-игру, сделанную ИИ, достаточно открыть в браузере: история Saltline

1.1 Что такое Saltline — AI-игра в браузере

9 ноября 2026 года инженер Anthropic Феликс Ризеберг (Felix Rieseberg) опубликовал эксперимент по программированию с Claude Fable 5.2. Он дал модели всего один промпт — сделать компактный шутер от первого лица, визуально максимально близкий к AAA-игре, — и на протяжении всего процесса не давал никакой ручной обратной связи. Результатом стал Saltline.

Действие происходит в контейнерном порту дождливой ночью: склады, причалы, штабеля контейнеров. Игрок должен отключить три сигнальных ретранслятора и эвакуироваться; враги — патрульные дроны в воздухе и механические гончие на земле. Есть движение от первого лица, управление камерой, стрельба, взаимодействие с объектами и задачи миссии, а также дождь, освещение, эмбиент-звук и эффекты оружия. На странице доступны настройки качества графики, включая режим низкой графики.

По словам самого разработчика в X, эксперимент занял около 8 часов, а по оценке на основе цен API стоил примерно 550 долларов: около 445 миллионов входных токенов (значительная часть — из кэша) и около 2,7 миллиона выходных токенов. Это оценочные цифры, которые приводит разработчик, а не счёт, проверенный третьей стороной.

Позже в китайских соцсетях распространилась «几猫·国产3A大作» — это китайская версия или переупаковка Saltline, а «国产3A大作» — название, появившееся уже по ходу распространения.

1.2 В одном файле на 1,4 МБ помещается вся игра в стиле AAA

У самостоятельной HTML-версии Saltline есть только один index.html; размер, записанный в репозитории GitHub, — 1 425 707 байт, то есть примерно 1,43 МБ (1,36 МиБ). В этом файле лежит весь основной код, нужный для работы игры, туда же упакован и код Three.js. Отдельных файлов с 3D-моделями, текстурами и звуками у игры нет.

Для сравнения: установочный пакет традиционной 3D-игры обычно набит моделями, текстурами высокого разрешения, анимациями, звуками и данными сцен. Saltline заменил все эти ассеты «кодом, который их генерирует», и это главная причина его компактности; подробнее — в разделе 3.

1.3 Saltline на самом деле работает на устройстве игрока

ИИ участвует только на этапе разработки. Зеркало Saltline на GitHub это подтверждает: исходная версия была Claude Artifact, при переносе из неё удалили рабочий скрипт фреймворка Artifact, оставили код игры, добавили DOCTYPE, объявление кодировки и viewport, и после этого достаточно локального HTTP-сервера, чтобы всё запустить.

Это значит, что игровая логика полностью отделена от интерфейса диалога с Claude. Когда игрок открывает страницу, браузер читает HTML, выполняет JavaScript, инициализирует WebGL, а локальный GPU отрисовывает каждый кадр — ни на одном этапе модель ИИ в выводе не участвует.

Один нюанс: в описании зеркала упоминается, что шрифты по-прежнему загружаются с Google Fonts. Точнее так: основная игровая программа Saltline выполняется локально, сцены, текстуры и звуки генерируются локальным кодом, но есть внешняя зависимость в виде загрузки шрифтов.


2. Как браузер превращается в 3D-среду выполнения для AAA-игр с ИИ

Современный браузер умеет разбирать HTML, а ещё вызывать графические интерфейсы, выполнять высокопроизводительный код, управлять памятью и обрабатывать аудио и видео. Saltline использует одну из самых распространённых комбинаций: JavaScript + Three.js + WebGL.

2.1. JavaScript отвечает за логику веб-игры

JavaScript — это «мозг» игры. Где патрулируют враги, попала ли пуля в цель, выключен ли ретранслятор, сможет ли игрок эвакуироваться — все эти правила написаны на JavaScript и выполняются движком JavaScript в браузере на CPU.

Для более тяжёлых вычислений браузер также предоставляет WebAssembly. Когда такие движки, как Unity, экспортируют веб-версию, часть программы компилируется в WebAssembly, чтобы ускорить выполнение. WebAssembly отвечает за выполнение программы, а рендеринг изображения по-прежнему выполняет WebGL — они могут работать вместе. Saltline в основном опирается на JavaScript для реализации логики.

2.2 Three.js организует 3D-сцену

Если писать 3D-сцену напрямую на WebGL, придётся вручную возиться с кучей низкоуровневых деталей. Three.js упаковывает эти детали в понятные объекты:

  • Scene: контейнер сцены, в котором хранятся все объекты и источники света.
  • Camera: камера; в игре от первого лица это глаза игрока.
  • Geometry: геометрическая структура, задающая форму контейнеров и складов.
  • Material: материал, определяющий, выглядит поверхность как металл или как бетон.
  • Mesh: видимый объект, полученный сочетанием геометрии и материала.
  • Light: свет — фонари и предупреждающие огни в дождливую ночь в порту.
  • Renderer: рендерер, который передаёт всё перечисленное GPU для отрисовки.

Официальная библиотека примеров Three.js также демонстрирует скелетную анимацию, карты теней, эффекты постобработки и инстансированный рендеринг. Особенно полезен в портовой сцене Instancing: сотни и тысячи похожих контейнеров могут использовать одну и ту же геометрию, меняя только параметры положения и цвета, — всё рисуется за один вызов отрисовки, что заметно снижает нагрузку на браузер.

2.3 WebGL передаёт работу по отрисовке локальному GPU

WebGL — это графический интерфейс, который браузер предоставляет JavaScript, построенный на технологиях OpenGL ES. Схема работы у него простая: игровой код через JavaScript вызывает WebGL, WebGL отправляет команды отрисовки на GPU, GPU вычисляет картинку, а браузер выводит её на страницу.

Ключевой момент: этот GPU — видеокарта в компьютере игрока. Каждый кадр Saltline вычисляется на устройстве игрока, а сеть отвечает лишь за первоначальную доставку файла размером 1,4 МБ в браузер. Именно поэтому официальная страница Saltline советует игрокам, застрявшим на экране загрузки, проверить WebGL 2 и аппаратное ускорение в браузере.

2.4 Шейдеры, материалы и освещение формируют внешний вид 3D-сцены

Внешний вид 3D-сцены определяют четыре составляющие: модель задаёт форму, материал — свойства поверхности, освещение — светотень, а шейдер сводит все эти факторы в итоговый цвет пикселя.

Шейдер выполняется на GPU и бывает двух типов. Вершинный шейдер вычисляет положение каждой вершины на экране, фрагментный шейдер вычисляет цвет каждого пикселя. На примере контейнера в дождливую ночь: фрагментный шейдер может с помощью математических функций рассчитать полосы на гофрированных панелях, пятна ржавчины, блики на влажной поверхности — и для этого совсем не нужна заранее нарисованная текстура.

2.5 Игровой цикл браузерной игры: обработка ввода и постоянное обновление экрана

Игра отличается от статичной веб-страницы тем, что ей нужно перерисовываться десятки раз в секунду. Браузер предоставляет интерфейс requestAnimationFrame, который вызывает игровой код перед каждым обновлением экрана, формируя игровой цикл:

  1. Считывает ввод с клавиатуры, мыши или сенсорного экрана (в Saltline нужно кликнуть по игровой области, чтобы захватить управление мышью).
  2. Обновляет состояние игры: позицию игрока, поведение врагов, траектории пуль.
  3. Вызывает рендерер Three.js — через WebGL GPU рисует новый кадр.
  4. Браузер показывает кадр и ждёт следующего обновления.

why-ai-made-3a-game-runs-in-browser-ru-image-1

3 Почему 1.4MB хватает на полноценную сцену уровня AAA: процедурная генерация

3.1 Модели, текстуры и звук записаны как функции

10 ноября Felix Rieseberg добавил пояснение: всё содержимое игры — это код, а текстуры и модели — функции; отдельных файлов изображений или 3D-моделей нет. Claude генерирует код и шейдеры, которые строят это содержимое.

В сравнении с традиционным подходом разница видна сразу:

  • Текстуры: обычно скачивают картинку с текстурой контейнера и натягивают её; при процедурном подходе металлическая поверхность вычисляется в реальном времени с помощью шумовых функций, изменения цвета и шейдеров
  • Модели: обычно импортируют готовый файл из программы для моделирования; при процедурном подходе их собирают во время работы из вершин и геометрических параметров
  • Звук: обычно загружают записанный аудиофайл; при процедурном подходе звук синтезируется в реальном времени через аудиоинтерфейс браузера

В файле хранятся «правила генерации», а итоговая картинка вычисляется только во время работы. Правила обычно намного меньше результата: шейдер из нескольких десятков строк может покрыть текстуру земли на всей территории порта.

3.2 Разделяем размер файла, память во время работы и вычислительную нагрузку

Ключ к пониманию 1.4MB — разделить три понятия:

Понятие Что измеряет Ситуация с Saltline
Размер файла Сколько кода и ресурсов нужно скачать Около 1.4MB, распространяется очень легко
Память во время работы Сколько памяти и видеопамяти занимает работа Сцена генерируется на лету, официальных данных нет
Вычислительная нагрузка Какой объём работы CPU и GPU выполняют за кадр Зависит от настроек качества графики и устройства, официальных данных нет
Время инициализации Время от открытия страницы до момента, когда можно начать управлять В официальном описании указано, что нужно построить порт, склады, освещение и звук; время зависит от устройства

Процедурная генерация платит вычислениями во время работы за маленький объём загрузки. Программа размером 1.4MB может на лету создавать массу геометрии, материалов и текстур, но GPU каждый кадр всё равно выполняет большой объём шейдерных вычислений. На официальной странице Saltline также прямо предупреждают: время появления кнопки START зависит от устройства игрока, а при подтормаживаниях можно переключиться на качество Low.

why-ai-made-3a-game-runs-in-browser-ru-image-2

3.3 Однофайловая архитектура делает распространение очень лёгким

Ценность однофайлового HTML — в распространении. Его можно положить на любой сервис статического хостинга или скачать локально и открыть через HTTP-сервер; чтобы поделиться, достаточно одной ссылки. В GitHub-репозитории китайской версии «几猫» сразу доступны онлайн-демо и скачивание, а также указано, что игра работает офлайн (кроме загрузки шрифтов).

Такой формат особенно удобен для прототипов, созданных ИИ. Модель за один раз выдаёт готовый файл, разработчику не нужно возиться с конвейером ассетов, инструментами сборки и настройкой сервера — после генерации можно сразу отправить файл другим, чтобы они попробовали.


4. Три разных подхода к запуску AAA-игр в браузере

За выражением «играть в игры прямо в браузере» стоят три технических подхода с совершенно разной вычислительной моделью. Чтобы точно понять, что такое Saltline, нужно сначала разобраться в них.

4.1 Локальный запуск в браузере: подход Saltline

ИИ генерирует код, код отправляется игроку, а браузер выполняет логику на месте и рендерит картинку на локальном GPU. Основная вычислительная нагрузка ложится на устройство игрока: во время игры подключаться к ИИ-модели не нужно, а после скачивания файлов игра может работать офлайн. Плата за это — производительность целиком зависит от устройства и браузера игрока.

4.2 Облачный гейминг: GeForce NOW и подход Pixel Streaming

Игра запускается на удалённом сервере, облачный GPU рендерит картинку, а затем она уходит в браузер видеопотоком. Браузер только показывает видео, воспроизводит звук и отправляет ввод игрока обратно на сервер.

Pixel Streaming от Epic Games позволяет приложениям Unreal Engine работать в облаке или на удалённом компьютере и передавать изображение и звук в браузер через WebRTC. NVIDIA GeForce NOW — это облачный игровой сервис для игроков. Официальные требования к сети для браузера такие: для 720p/60FPS нужно не меньше 15 Мбит/с, для 1080p/60FPS — не меньше 25 Мбит/с, для 1440p/120FPS — не меньше 35 Мбит/с, а задержку желательно держать ниже 80 мс. Такой подход снижает планку по локальному железу, но взамен требует постоянного подключения к сети.

4.3 Модели мира в ИИ: подход Genie 3

Модель мира не задаёт сцены и правила заранее, а предсказывает и генерирует следующий фрагмент картинки по текущему состоянию и вводу игрока. В августе 2025 года Google DeepMind выпустила Genie 3; по официальным данным, она умеет в реальном времени генерировать исследуемые среды в 720p и с частотой до 24 FPS, а согласованность сцены сохраняется в течение нескольких минут. Microsoft с Muse/WHAMM и Decart с Oasis тоже исследуют это направление.

В январе 2026 года открылся доступ к Project Genie на базе Genie 3 — сначала для пользователей Google AI Ultra из США старше 18 лет, с ограничением в 60 секунд на каждую генерацию. Это направление пока находится на стадии исследований и прототипов продукта и не связано с технологиями, которые использует Saltline.

4.4 Сопоставление трёх подходов

why-ai-made-3a-game-runs-in-browser-ru-image-3

Критерий сравнения Локальный запуск в браузере Облачный гейминг AI-модель мира
Примеры Saltline GeForce NOW, Pixel Streaming Genie 3
Игровая логика Выполнение заранее написанного кода локально Выполнение заранее написанного кода в облаке Модель учится динамике среды на данных
Генерация изображения Рендеринг на локальном GPU Рендеринг на облачном GPU Генерация AI в реальном времени
Роль браузера Среда запуска игры Терминал для видео и взаимодействия Точка входа для взаимодействия
Зависимость от сети После первой загрузки можно в основном работать офлайн Постоянное подключение, нужны высокая пропускная способность и низкая задержка Обычно требуется постоянное подключение
Требования к локальному железу Относительно высокие Относительно низкие Зависят от способа развёртывания модели
Когда возникают затраты на AI Сосредоточены на этапе разработки AI-инференса нет, но облачные GPU расходуются постоянно Инференс выполняется постоянно при каждом запуске игры

Разница в структуре затрат — самое практичное из отличий. В Saltline расходы на AI сосредоточены в одной разработке, а дальше рендеринг ложится на устройство игрока: оценка в 550 долларов не растёт вместе с числом игроков. Облачный гейминг и модели мира, наоборот, постоянно расходуют серверные вычисления при каждом запуске игры.


5 Практика: генерируем и запускаем 3D-сцену в браузере с помощью ИИ

Самый быстрый способ понять принцип — прогнать всё самому. В этом разделе три шага: сначала запускаем написанную вручную процедурную сцену, потом просим большую языковую модель через API сгенерировать однофайловую игру, и в конце измеряем её время кадра.

5.1 Минимальная рабочая процедурная сцена на Three.js

Этот файл через Instancing рисует 400 контейнеров: гофрированные полосы и пятна ржавчины на каждом контейнере вычисляются шейдером в реальном времени — никаких файлов с картинками вообще не нужно. Сохраните его как index.html, в том же каталоге запустите python3 -m http.server 8000, а затем откройте в браузере http://localhost:8000.

<!DOCTYPE html>
<html lang="zh">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Процедурный контейнерный порт</title>
  <style>body{margin:0;overflow:hidden;background:#05070a}</style>
  <script type="importmap">
    { "imports": { "three": "https://unpkg.com/[email protected]/build/three.module.js" } }
  </script>
</head>
<body>
<script type="module">
import * as THREE from 'three';

const renderer = new THREE.WebGLRenderer({ antialias: true });
renderer.setSize(innerWidth, innerHeight);
document.body.appendChild(renderer.domElement);

const scene = new THREE.Scene();
scene.fog = new THREE.Fog(0x05070a, 20, 90);
const camera = new THREE.PerspectiveCamera(60, innerWidth / innerHeight, 0.1, 200);

// Процедурный материал: гофрированные полосы + шумовые пятна ржавчины + простой направленный свет
const material = new THREE.ShaderMaterial({
  uniforms: { uTime: { value: 0 } },
  vertexShader: `
    varying vec2 vUv; varying vec3 vNormal; varying vec3 vColor;
    void main() {
      vUv = uv;
      vNormal = normalize(mat3(modelMatrix * instanceMatrix) * normal);
      vColor = vec3(1.0);
      #ifdef USE_INSTANCING_COLOR
        vColor = instanceColor;
      #endif
      gl_Position = projectionMatrix * viewMatrix * modelMatrix * instanceMatrix * vec4(position, 1.0);
    }`,
  fragmentShader: `
    varying vec2 vUv; varying vec3 vNormal; varying vec3 vColor;
    float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
    void main() {
      float ribs = 0.75 + 0.25 * step(0.5, fract(vUv.x * 14.0));   // гофрированные полосы
      float rust = smoothstep(0.82, 1.0, hash(floor(vUv * 40.0)));  // пятна ржавчины
      vec3 base = mix(vColor * ribs, vec3(0.35, 0.18, 0.08), rust);
      float light = max(dot(vNormal, normalize(vec3(0.4, 1.0, 0.3))), 0.15);
      gl_FragColor = vec4(base * light, 1.0);
    }`
});

// Instancing: 400 контейнеров за один вызов отрисовки
const count = 400;
const mesh = new THREE.InstancedMesh(new THREE.BoxGeometry(6, 2.6, 2.4), material, count);
const m = new THREE.Matrix4(), c = new THREE.Color();
const palette = [0x8a2b1e, 0x1f4e79, 0x2f6b3a, 0x9a7b1c];
for (let i = 0; i < count; i++) {
  const x = (i % 20) * 7 - 70, z = Math.floor(i / 20) * 4 - 40;
  const y = 1.3 + Math.floor(Math.random() * 3) * 2.6;
  m.makeTranslation(x, y, z);
  mesh.setMatrixAt(i, m);
  mesh.setColorAt(i, c.set(palette[i % palette.length]));
}
scene.add(mesh);

// Игровой цикл: обновляем камеру и рендерим каждый кадр
renderer.setAnimationLoop((t) => {
  const s = t * 0.0001;
  camera.position.set(Math.sin(s) * 50, 18, Math.cos(s) * 50);
  camera.lookAt(0, 0, 0);
  renderer.render(scene, camera);
});

addEventListener('resize', () => {
  camera.aspect = innerWidth / innerHeight;
  camera.updateProjectionMatrix();
  renderer.setSize(innerWidth, innerHeight);
});
</script>
</body>
</html>

Этот код в сжатом виде передаёт ключевую идею Saltline: геометрия строится через BoxGeometry, внешний вид вычисляется шейдером, а множество повторяющихся объектов рисуется с помощью инстансинга. Весь файл весит всего несколько KB, Three.js загружается с CDN; Saltline же упаковывает Three.js прямо в HTML.

5.2 Генерация одностраничной 3D-игры большой языковой моделью через API

Процесс генерации Saltline — это долгая, многораундовая агентная разработка, на которую ушли сотни миллионов токенов. Индивидуальному разработчику стоит начать с одного вызова: попросить модель выдать рабочую одностраничную мини-игру на Three.js и на практике почувствовать разделение труда «ИИ пишет программу — браузер её запускает». В коде ниже используется OpenAI-совместимый интерфейс; имя модели замените на то, что в списке моделей платформы поддерживает длинный вывод кода.

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # OpenAI-совместимый интерфейс APIYI
)

resp = client.chat.completions.create(
    model="YOUR_MODEL_NAME",  # ориентируйтесь на список моделей платформы
    messages=[{"role": "user", "content": "用 Three.js 写一个单文件 HTML 第一人称小游戏,所有模型和纹理用代码与 Shader 生成,只输出完整 HTML。"}],
)
open("game.html", "w", encoding="utf-8").write(resp.choices[0].message.content)
Посмотреть полный код реализации (с очисткой блоков кода и ограничениями в промпте)
import re
import openai
from pathlib import Path

SYSTEM_PROMPT = """你是一名资深 Web 3D 游戏工程师。
要求:
1. 只输出一个完整的 HTML 文件,不要任何解释文字。
2. 使用 Three.js(通过 importmap 从 CDN 引入 [email protected])。
3. 不引用任何外部图片、模型或音频文件;几何体用代码构造,纹理用 ShaderMaterial 计算,音效用 Web Audio API 合成。
4. 使用 requestAnimationFrame 或 renderer.setAnimationLoop 实现游戏循环。
5. 提供 Low / High 两档画质切换,Low 档降低像素比和物体数量。
6. 点击画面后使用 Pointer Lock 获取鼠标控制,WASD 移动。
"""

def extract_html(text: str) -> str:
    """Убирает обёртку в виде блока кода ```html, которую модель может добавить"""
    match = re.search(r"```(?:html)?\s*(.*?)```", text, re.S)
    return (match.group(1) if match else text).strip()

def generate_game(idea: str, model: str, out_file: str = "game.html") -> Path:
    client = openai.OpenAI(
        api_key="YOUR_API_KEY",
        base_url="https://api.apiyi.com/v1"
    )
    resp = client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": idea},
        ],
        max_tokens=16000,
    )
    html = extract_html(resp.choices[0].message.content)
    path = Path(out_file)
    path.write_text(html, encoding="utf-8")
    print(f"已生成 {path},大小 {path.stat().st_size / 1024:.1f} KB")
    print("运行:python3 -m http.server 8000,然后打开 http://localhost:8000/" + out_file)
    return path

if __name__ == "__main__":
    generate_game(
        idea="雨夜集装箱港口,玩家需要关闭三个信号塔后撤离,有巡逻无人机。",
        model="YOUR_MODEL_NAME",
    )

Сгенерированный файл работает по той же логике, что и Saltline: вызов API происходит только в момент генерации, а дальше можно открывать game.html и играть сколько угодно — модель больше не будет тратить токены.

🚀 Совет для быстрого старта: если хотите сравнить, как разные модели справляются с написанием игры на Three.js, можно через APIYI (apiyi.com) переключать Claude, GPT, Gemini и другие модели с одним и тем же API-ключом — интерфейс совместим с OpenAI, и в коде выше достаточно поменять параметр model. Новым пользователям дают бесплатную тестовую квоту — удобно сначала проверить качество генерации на коротком промпте.

5.3 Измеряем реальную производительность браузерных 3D-игр

1,4 МБ отвечают только на вопрос «как быстро скачалось». Чтобы понять, потянет ли браузер игру, нужно измерять вот эти показатели:

Метрика Зачем измерять Как измерять
Время до первого управления Впечатление от запуска От открытия страницы до момента, когда можно управлять персонажем — можно расставлять метки через Performance API
FPS / время кадра Плавность и стабильность 60 FPS — это примерно 16,67 мс на кадр, следите за колебаниями времени кадра
Загрузка CPU Нагрузка от игровой логики Панель Performance в Chrome DevTools, наблюдаем за главным потоком
Загрузка GPU и видеопамять Нагрузка рендеринга Системный диспетчер задач или утилиты мониторинга видеокарты
Системная память Ресурсы во время работы После инициализации сцены смотрим память процесса браузера
Сетевой трафик после загрузки Внешние зависимости Панель Network в DevTools, отдельно смотрим запросы шрифтов, программ и прочего

Если вставить приведённый ниже код в консоль браузера, он посчитает среднее время кадра и самый медленный кадр за 10 секунд:

(() => {
  const times = []; let last = performance.now();
  const start = last;
  function tick(now) {
    times.push(now - last); last = now;
    if (now - start < 10000) return requestAnimationFrame(tick);
    const avg = times.reduce((a, b) => a + b, 0) / times.length;
    const worst = Math.max(...times);
    console.log(`平均帧时间 ${avg.toFixed(2)}ms(约 ${(1000 / avg).toFixed(1)} FPS),最慢一帧 ${worst.toFixed(2)}ms`);
  }
  requestAnimationFrame(tick);
})();

При тестировании фиксируйте версию браузера, операционную систему, модель устройства, разрешение и уровень качества графики. Измерения должны покрывать сцену, где одновременно есть движение игрока, активность врагов, стрельба и эффект дождя. Если мерить только пустую сцену сразу после входа в игру, результат получится слишком оптимистичным.

6 Насколько веб-игра класса 3A далека от настоящей коммерческой 3A

6.1 Аппаратные и платформенные ограничения браузерных игр

Официальная документация Unity довольно ясно описывает ограничения веб-платформы: доступ к файловой системе ограничен, часть функций кэширования недоступна, многопоточность зависит от браузерной среды, ресурсы памяти ограничены, а совместимость между разными браузерами неодинакова. Сборки Unity под WebGL в основном рассчитаны на настольные браузеры, поддержка мобильных устройств ограничена.

Страница с демо Saltline подтверждает эти ограничения. На ней предупреждают, что инициализация может быть медленной, скорость запуска зависит от производительности устройства, стоит проверить WebGL 2 и аппаратное ускорение, а при подтормаживаниях переключиться на качество Low. Порог входа — просто открыть веб-страницу — очень низкий, но порог для плавной работы по-прежнему зависит от GPU игрока.

6.2 1.4MB: лёгкая доставка, а нагрузка при работе — отдельный вопрос

Процедурная генерация превращает «скачиваемые ассеты» в «ассеты, вычисляемые во время работы». Текстуры рассчитываются попиксельно в реальном времени на GPU, геометрия строится на CPU при инициализации — всё это происходит на устройстве игрока. Пока разработчики не опубликовали для Saltline стандартное время запуска, средний FPS, потребление видеопамяти или оперативной памяти; чтобы оценить нагрузку во время работы, придётся измерять её самостоятельно по методике из раздела 5.3.

6.3 Инженерный масштаб коммерческой AAA-игры

Коммерческая AAA-игра обычно подразумевает крупные вложения денег, людей и ресурсов. Это название описывает масштаб производства, а не какой-то единый технический стандарт сертификации. Коммерческой AAA-игре нужен контент на несколько десятков часов, сложная анимация персонажей и физические системы, сетевая синхронизация для многопользовательского режима, адаптация под разные платформы, а также годы обновлений, поддержки, тестирования и оптимизации. Процедурная генерация хорошо справляется с сильно упорядоченным контентом — контейнерами, поверхностью земли, дождём. А вот для персонажей и нарративных сцен, которым требуется много художественной доработки, традиционное производство ассетов всё ещё подходит лучше.

6.4 Что на самом деле доказал проект Saltline

Saltline доказывает, что ИИ-модель с сильными навыками программирования способна в рамках одного непрерывного процесса генерации объединить дизайн уровней, построение сцен, шейдеры, игровую механику, логику управления и генерацию звука — и выдать целостный по стилю 3D-прототип игры, которым можно сразу поделиться. В традиционном процессе затраты на передачу работы между разными инструментами и специалистами здесь сжимаются до контекста одной модели.

Если сопоставить данные, приведённые разработчиком, с официально опубликованными ценами моделей, можно понять структуру затрат этого эксперимента:

Пункт Данные Источник
Время разработки около 8 часов Со слов Felix Rieseberg, 2026-11-09
Ориентировочная стоимость около 550 долларов США (оценка по ценам API) Со слов Felix Rieseberg
Входные токены около 445 млн, значительная часть — из кэша Со слов Felix Rieseberg
Выходные токены около 2,7 млн Со слов Felix Rieseberg
Цена ввода / вывода Fable 5.2 $8 / $40 за миллион токенов Официальная документация моделей Anthropic
Цена чтения из кэша Fable 5.2 $0.20 за миллион токенов Официальная документация моделей Anthropic
Контекстное окно / максимальный вывод 1M токенов / 128K токенов Официальная документация моделей Anthropic

Цена чтения из кэша значительно ниже обычной цены ввода, поэтому 445 млн входных токенов нельзя напрямую пересчитать в общую стоимость по обычной цене за входной токен. Разработчик не раскрыл точную разбивку счёта, поэтому 550 долларов следует понимать как ориентировочную стоимость одного эксперимента по генерации.

💰 Совет по стоимости: затраты на генерацию веб-игры с помощью ИИ сосредоточены на этапе разработки, а основные расходы — длинный контекст и множество итераций. Прежде чем всерьёз запускать длительные задачи, можно через APIYI apiyi.com сначала сравнить качество кода нескольких моделей на небольших промптах, а затем решить, на какой модели выполнять длительную генерацию. Оплата по мере использования помогает контролировать стоимость проб и ошибок.


7 Часто задаваемые вопросы (FAQ)

Вопрос 1: Если 3A-игра, сделанная ИИ, запускается в браузере, значит, игровая картинка передаётся с сервера?

Картинку Saltline рендерит локальный GPU игрока. Браузер скачивает HTML-файл размером около 1,4 МБ, затем JavaScript выполняет игровую логику, а через WebGL вызывает локальную видеокарту для отрисовки каждого кадра. Передача картинки с сервера — это облачные игры вроде GeForce NOW, совсем другой технологический путь.

Вопрос 2: Во время игры в Saltline модель Claude вызывается в реальном времени?

Нет. Claude Fable 5.2 генерирует код игры только на этапе разработки. В зеркале на GitHub уже удалены каркасные скрипты Claude Artifact, и игру можно запустить на обычном HTTP-сервере — во время игры никаких затрат на вызовы модели не возникает.

Вопрос 3: В чём разница между Saltline и AI-мировыми моделями вроде Genie 3?

Правила и сцены Saltline заранее написаны ИИ в виде кода, а во время работы их исполняет традиционный конвейер рендеринга. Genie 3 предсказывает и генерирует картинку покадрово на основе действий игрока, а правила выучиваются из данных. Первый случай — ИИ пишет программу, второй — ИИ напрямую генерирует картинку; технически эти подходы независимы друг от друга.

Вопрос 4: Какая конфигурация компьютера нужна, чтобы 3A-игра весом 1,4 МБ в браузере работала плавно?

Разработчик не публиковал минимальные требования и данные по FPS. Официальная страница рекомендует проверить поддержку WebGL 2 в браузере и включить аппаратное ускорение, а при подтормаживаниях переключиться на низкое качество графики (Low). Конкретные показатели лучше измерять на своём устройстве с помощью скрипта времени кадра из раздела 5.3 этой статьи.

Вопрос 5: Как с помощью API самому сгенерировать похожую 3D-игру для браузера?

Зарегистрируйтесь на APIYI apiyi.com и получите API Key, установите `base_url` из кода раздела 5.2 в `https://api.apiyi.com/v1`, выберите модель, хорошо справляющуюся с длинным выводом кода, и в промпте явно потребуйте «однофайловый HTML, Three.js, все ассеты генерируются кодом и шейдерами». После генерации откройте файл через локальный HTTP-сервер и можно пробовать играть.

Вопрос 6: Какие ограничения есть у генерации браузерных игр с помощью ИИ?

Длина вывода за один вызов ограничена, сложным играм нужна многораундовая генерация с длинным контекстом, и стоимость растёт. Сгенерированный код часто требует отладки производительности и совместимости. У самого браузера есть ограничения по памяти, потокам и поддержке на мобильных устройствах. Рекомендую сначала через APIYI apiyi.com сравнить несколько моделей на небольшом масштабе, выбрать модель с самой стабильным кодом и только потом расширять проект.


8 Ключевые выводы: AI-веб-игра уровня AAA

  • Где запускается: Saltline работает в браузере игрока, рендеринг выполняет локальный GPU.
  • Чёткое разделение задач: AI пишет код на этапе разработки, браузер выполняет код на этапе запуска.
  • Техническая цепочка: JavaScript отвечает за логику, Three.js собирает сцену, WebGL обращается к GPU.
  • Секрет размера: модели, текстуры и звуки записаны как функции; один файл весит около 1.4MB.
  • Маленький файл не означает лёгкий запуск: процедурные ассеты переводят расходы на скачивание в вычислительные затраты во время работы.
  • Три маршрута: локальный запуск в браузере, облачный гейминг и AI-модели мира — вычисления происходят в разных местах.
  • Проверьте на практике: через APIYI apiyi.com можно вызывать разные модели, генерировать Three.js-игру в одном файле и тестировать её.

9 Итог

Игра в стиле AAA, созданная AI, может работать в браузере благодаря тому, что браузеры давно умеют запускать 3D, плюс процедурной генерации. Главных выводов три:

  1. Браузер — это среда выполнения игрового движка: связка JavaScript, Three.js и WebGL позволяет веб-странице напрямую использовать локальный GPU для рендеринга 3D-сцен.
  2. Затраты на AI сосредоточены на этапе разработки: после генерации Saltline работает независимо от Claude; по словам разработчика, около 550 долларов — это разовая оценочная стоимость.
  3. 1.4MB решают проблему распространения: память и нагрузка на GPU во время работы по-прежнему ложатся на устройство игрока; Saltline позиционируется как быстро собранный играбельный 3D-прототип.

Если хотите сами пройти путь «AI пишет игру, браузер её запускает», советуем на APIYI apiyi.com через один и тот же OpenAI-совместимый интерфейс сравнить, как разные модели генерируют код Three.js, а затем измерить результат с помощью скрипта для замера времени кадра из этой статьи.


📚 Справочные материалы

  1. Отдельная демо-страница Saltline: вход в игру, а также загрузка, качество графики и описание управления
  2. Ссылка: saltline.games
  3. Пояснение: официальные рекомендации по времени инициализации, WebGL 2 и аппаратному ускорению

  4. Зеркало кода Saltline и README: версия в виде одного HTML-файла

  5. Ссылка: github.com/realcodebear/saltline-fable-5.2
  6. Пояснение: описан процесс переноса Artifact, структура файлов и внешняя зависимость от Google Fonts

  7. Репозиторий GitHub китайской версии «几猫»: китайская обёртка Saltline

  8. Ссылка: github.com/Megasu/jimao-3a-game
  9. Пояснение: указаны размеры файлов, работа офлайн и требования к браузеру

  10. Спецификация и цены модели Claude Fable 5.2: официальная документация Anthropic

  11. Ссылка: platform.claude.com/docs/en/models/fable-5-2/overview
  12. Пояснение: цены на вход, выход, кэширование и размер контекстного окна

  13. MDN WebGL API: документация по интерфейсу GPU-рендеринга в браузере

  14. Ссылка: developer.mozilla.org/en-US/docs/Web/API/WebGL_API
  15. Пояснение: авторитетный источник для понимания принципов работы WebGL

  16. Официальная документация Three.js: библиотека 3D-графики для веба

  17. Ссылка: threejs.org/docs
  18. Пояснение: описание API Scene, Mesh, ShaderMaterial, InstancedMesh и других

  19. Технические ограничения Unity WebGL: ограничения платформы браузерных игр

  20. Ссылка: docs.unity.cn/6000.0/Documentation/Manual/webgl-technical-overview.html
  21. Пояснение: описание ограничений файловой системы, потоков, памяти и поддержки мобильных устройств

  22. Системные требования NVIDIA GeForce NOW: сетевые требования облачного гейминга

  23. Ссылка: nvidia.com/en-us/geforce-now/system-reqs
  24. Пояснение: рекомендации по пропускной способности и задержке для разного качества графики и частоты кадров

  25. Epic Games Pixel Streaming: потоковая передача рендеринга из облака

  26. Ссылка: dev.epicgames.com/documentation/unreal-engine/pixel-streaming-in-unreal-engine
  27. Пояснение: официальная документация Unreal Engine о передаче изображения в браузер через WebRTC

  28. Анонс технологии Genie 3: мировая модель Google DeepMind

    • Ссылка: deepmind.google/blog/genie-3-a-new-frontier-for-world-models
    • Пояснение: возможности и ограничения генерации интерактивных сред в реальном времени

Автор: техническая команда APIYI
Связь по техническим вопросам: пишите нам на главной странице официального сайта APIYI, а больше материалов о подключении моделей ищите в документации docs.apiyi.com

Читайте также

Похожие записи