Примечание автора: 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-играми.

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, который вызывает игровой код перед каждым обновлением экрана, формируя игровой цикл:
- Считывает ввод с клавиатуры, мыши или сенсорного экрана (в Saltline нужно кликнуть по игровой области, чтобы захватить управление мышью).
- Обновляет состояние игры: позицию игрока, поведение врагов, траектории пуль.
- Вызывает рендерер Three.js — через WebGL GPU рисует новый кадр.
- Браузер показывает кадр и ждёт следующего обновления.

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.

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 Сопоставление трёх подходов

| Критерий сравнения | Локальный запуск в браузере | Облачный гейминг | 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, плюс процедурной генерации. Главных выводов три:
- Браузер — это среда выполнения игрового движка: связка JavaScript, Three.js и WebGL позволяет веб-странице напрямую использовать локальный GPU для рендеринга 3D-сцен.
- Затраты на AI сосредоточены на этапе разработки: после генерации Saltline работает независимо от Claude; по словам разработчика, около 550 долларов — это разовая оценочная стоимость.
- 1.4MB решают проблему распространения: память и нагрузка на GPU во время работы по-прежнему ложатся на устройство игрока; Saltline позиционируется как быстро собранный играбельный 3D-прототип.
Если хотите сами пройти путь «AI пишет игру, браузер её запускает», советуем на APIYI apiyi.com через один и тот же OpenAI-совместимый интерфейс сравнить, как разные модели генерируют код Three.js, а затем измерить результат с помощью скрипта для замера времени кадра из этой статьи.
📚 Справочные материалы
- Отдельная демо-страница Saltline: вход в игру, а также загрузка, качество графики и описание управления
- Ссылка:
saltline.games -
Пояснение: официальные рекомендации по времени инициализации, WebGL 2 и аппаратному ускорению
-
Зеркало кода Saltline и README: версия в виде одного HTML-файла
- Ссылка:
github.com/realcodebear/saltline-fable-5.2 -
Пояснение: описан процесс переноса Artifact, структура файлов и внешняя зависимость от Google Fonts
-
Репозиторий GitHub китайской версии «几猫»: китайская обёртка Saltline
- Ссылка:
github.com/Megasu/jimao-3a-game -
Пояснение: указаны размеры файлов, работа офлайн и требования к браузеру
-
Спецификация и цены модели Claude Fable 5.2: официальная документация Anthropic
- Ссылка:
platform.claude.com/docs/en/models/fable-5-2/overview -
Пояснение: цены на вход, выход, кэширование и размер контекстного окна
-
MDN WebGL API: документация по интерфейсу GPU-рендеринга в браузере
- Ссылка:
developer.mozilla.org/en-US/docs/Web/API/WebGL_API -
Пояснение: авторитетный источник для понимания принципов работы WebGL
-
Официальная документация Three.js: библиотека 3D-графики для веба
- Ссылка:
threejs.org/docs -
Пояснение: описание API Scene, Mesh, ShaderMaterial, InstancedMesh и других
-
Технические ограничения Unity WebGL: ограничения платформы браузерных игр
- Ссылка:
docs.unity.cn/6000.0/Documentation/Manual/webgl-technical-overview.html -
Пояснение: описание ограничений файловой системы, потоков, памяти и поддержки мобильных устройств
-
Системные требования NVIDIA GeForce NOW: сетевые требования облачного гейминга
- Ссылка:
nvidia.com/en-us/geforce-now/system-reqs -
Пояснение: рекомендации по пропускной способности и задержке для разного качества графики и частоты кадров
-
Epic Games Pixel Streaming: потоковая передача рендеринга из облака
- Ссылка:
dev.epicgames.com/documentation/unreal-engine/pixel-streaming-in-unreal-engine -
Пояснение: официальная документация Unreal Engine о передаче изображения в браузер через WebRTC
-
Анонс технологии Genie 3: мировая модель Google DeepMind
- Ссылка:
deepmind.google/blog/genie-3-a-new-frontier-for-world-models - Пояснение: возможности и ограничения генерации интерактивных сред в реальном времени
- Ссылка:
Автор: техническая команда APIYI
Связь по техническим вопросам: пишите нам на главной странице официального сайта APIYI, а больше материалов о подключении моделей ищите в документации docs.apiyi.com
