Mengapa game AAA buatan AI dapat berjalan di web? Membongkar Saltline 1,4 MB dan 3 jalur game web

Mengapa game AAA buatan AI dapat berjalan di web? Membongkar Saltline 1,4 MB dan 3 jalur game web

Catatan penulis: Saltline menjalankan kode game di browser dan memanggil GPU lokal pemain untuk melakukan rendering. Aset prosedural ditambah WebGL menjelaskan mengapa file web berukuran sekitar 1.4MB bisa menampilkan adegan tembak-menembak 3D lengkap.

“Game 3A” buatan AI bisa berjalan di browser karena tiga alasan. Pertama, browser modern sendiri merupakan lingkungan lengkap untuk menjalankan program 3D: JavaScript menjalankan logika game, Three.js menyusun adegan, dan WebGL menyerahkan pekerjaan menggambar ke GPU di komputer pemain. Kedua, keluaran AI pada tahap pengembangan adalah sebuah program game; setelah selesai dikembangkan, seluruh proses berjalannya diserahkan ke browser, dan saat pemain bermain, model AI tidak lagi dipanggil. Ketiga, model, tekstur, dan suara Saltline semuanya dihasilkan dengan kode; satu file HTML berukuran sekitar 1.4MB, buka halaman webnya dan game langsung bisa dimainkan.

“3A” di sini adalah target visual yang ditetapkan pengembang untuk AI, dipakai sebagai analogi gaya visual. Saltline sendiri adalah prototipe kecil yang bisa dimainkan dan hanya punya satu level.

Berikut ini kita mulai dari kasus Saltline untuk memahami di mana game sebenarnya berjalan. Setelah itu, kita bongkar rantai teknis rendering adegan 3D di browser, menjelaskan mengapa pembuatan prosedural bisa menekan ukuran file jadi 1.4MB, lalu membandingkan tiga jalur: menjalankan game di halaman web lokal, cloud gaming, dan model dunia AI. Terakhir, ada sepotong kode yang bisa langsung dijalankan untuk memandu Anda membuat dan mengukur adegan 3D web dengan AI, sekaligus membahas jarak sebenarnya antara game browser dan game 3A komersial.

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

Table of Contents

To Know: Memahami istilah game AAA berbasis web AI

Istilah Penjelasan
JavaScript Bahasa pemrograman yang dijalankan oleh browser; logika game Saltline ditulis dengan bahasa ini
Three.js Pustaka grafis 3D JavaScript yang dipakai untuk membangun scene, kamera, pencahayaan, dan objek
WebGL Antarmuka grafis yang disediakan browser, memungkinkan halaman web memanggil GPU perangkat untuk menggambar tampilan 3D
WebGPU Antarmuka grafis dan komputasi generasi baru di browser dengan kemampuan lebih modern; Saltline tidak bergantung padanya
WebAssembly (Wasm) Bytecode tingkat rendah yang bisa dieksekusi browser, memungkinkan program C++, Rust, dan sejenisnya berjalan cepat di halaman web
GPU Prosesor grafis, unggul dalam menangani komputasi paralel dalam jumlah besar seperti piksel dan vertex secara bersamaan
Shader Program kecil yang berjalan di GPU, menghitung posisi tiap vertex atau warna tiap piksel
Pembuatan prosedural Membangun konten game dengan aturan dan fungsi matematika, menggantikan gambar dan file model yang sudah dibuat sebelumnya
Instancing (rendering instans) Menggambar banyak objek berbentuk sama hanya dengan satu draw call, misalnya deretan kontainer
Waktu frame Waktu yang dibutuhkan untuk merender satu frame; 60FPS setara sekitar 16,67 milidetik per frame
Cloud gaming Game berjalan di server jarak jauh, lalu tampilannya dikirim ke pemain dalam bentuk streaming video
WebRTC Teknologi transmisi audio-video real-time di browser; sering dipakai cloud gaming untuk mengirim tampilan dan input
Model dunia Model AI yang mempelajari pola perubahan lingkungan, lalu memprediksi dan menghasilkan scene berikutnya berdasarkan input pemain

1 Mengapa game AAA buatan AI cukup dibuka lewat halaman web: berawal dari Saltline

1.1 Seperti apa game web AI bernama Saltline

Pada 9 November 2026, engineer Anthropic Felix Rieseberg mempublikasikan eksperimen pemrograman Claude Fable 5.2. Ia hanya memberikan satu petunjuk kepada model: buat game first-person shooter berskala kecil dengan tampilan visual sedekat mungkin dengan game AAA, tanpa umpan balik manusia selama proses berlangsung. Hasil akhirnya adalah Saltline.

Latar game berada di pelabuhan peti kemas pada malam hujan, dengan gudang, dermaga, dan tumpukan kontainer. Pemain harus mematikan tiga stasiun relai sinyal lalu mengevakuasi diri; musuhnya meliputi drone patroli udara dan anjing mekanis darat. Game ini mendukung pergerakan orang pertama, kontrol sudut pandang, menembak, interaksi, dan target misi, plus hujan, pencahayaan, efek suara lingkungan, dan efek senjata. Halamannya menyediakan pengaturan kualitas grafis, termasuk opsi kualitas rendah.

Menurut penuturan pengembang sendiri di X, eksperimen ini memakan waktu sekitar 8 jam, dengan perkiraan biaya sekitar 550 dolar AS berdasarkan tarif API, serta menghabiskan sekitar 445 juta token input (sebagian besar berupa cache) dan sekitar 2,7 juta token output. Angka-angka ini adalah estimasi yang dilaporkan pengembang, bukan tagihan yang telah diaudit pihak ketiga.

“几猫·国产3A大作” (Karya AAA Domestik) yang kemudian beredar di platform sosial Tiongkok adalah versi bahasa Mandarin atau versi kemasan ulang dari Saltline; “国产3A大作” adalah nama yang muncul saat penyebaran.

1.2 Satu file 1,4 MB berisi seluruh game bergaya AAA

Versi HTML mandiri Saltline hanya berupa satu index.html; repositori GitHub mencatat ukurannya 1.425.707 byte, sekitar 1,43 MB (1,36 MiB). File ini memuat kode inti yang dibutuhkan game untuk berjalan; kode runtime Three.js juga ikut dibundel. Game ini tidak punya file model 3D, tekstur, dan efek suara terpisah.

Sebagai pembanding, paket instalasi game 3D konvensional biasanya berisi banyak model, tekstur resolusi tinggi, animasi, efek suara, dan data scene. Saltline mengganti seluruh aset itu dengan “kode yang menghasilkan aset”; inilah alasan utama ukurannya kecil, yang akan dibahas di Bagian 3.

1.3 Game Saltline sebenarnya berjalan di perangkat pemain sendiri

AI hanya terlibat di tahap pengembangan. Mirror GitHub Saltline menunjukkan hal ini: versi aslinya adalah Claude Artifact; saat diporting, skrip runtime framework Artifact dihapus, kode game dipertahankan, deklarasi DOCTYPE, charset, dan Viewport ditambahkan, lalu game bisa dijalankan dengan server HTTP lokal.

Ini menunjukkan bahwa logika game dan antarmuka percakapan Claude sudah sepenuhnya terpisah. Saat pemain membuka halaman web, browser membaca HTML, menjalankan JavaScript, menginisialisasi WebGL, lalu GPU lokal menggambar setiap frame; sepanjang proses itu tidak ada model AI yang melakukan inferensi.

Ada satu detail tambahan: keterangan mirror menyebut bahwa font masih dimuat dari Google Fonts. Deskripsi yang lebih akurat: program inti game Saltline berjalan secara lokal, scene, tekstur, dan suara dihasilkan oleh kode lokal, sedangkan font memiliki dependensi pemuatan eksternal.


2 Bagaimana Browser Menjadi Lingkungan Runtime 3D untuk Game 3A AI

Browser modern dapat mem-parsing HTML, sekaligus memanggil antarmuka grafis, menjalankan kode berperforma tinggi, mengelola memori, serta memproses audio dan video. Dari sekian banyak kemungkinan, Saltline memakai salah satu kombinasi yang paling umum: JavaScript + Three.js + WebGL.

2.1 JavaScript Menangani Logika Game Web

JavaScript adalah “otak” dari game. Di mana musuh berpatroli, apakah peluru mengenai sasaran, apakah stasiun relai sudah ditutup, apakah pemain bisa dievakuasi—semua aturan ini ditulis dalam kode JavaScript, lalu dieksekusi oleh mesin JavaScript browser di CPU.

Untuk tugas komputasi yang lebih berat, browser juga menyediakan WebAssembly. Ketika engine seperti Unity mengekspor versi web, sebagian program dikompilasi menjadi WebAssembly untuk mempercepat eksekusi. WebAssembly menangani eksekusi program, sementara rendering gambar tetap dikerjakan oleh WebGL—keduanya bisa bekerja sama. Saltline sendiri lebih banyak mengandalkan JavaScript untuk menjalankan logika.

2.2 Three.js mengorganisasi scene 3D

Menulis scene 3D langsung dengan WebGL berarti harus menangani banyak detail tingkat rendah. Three.js membungkus detail-detail itu menjadi objek yang intuitif:

  • Scene: wadah scene, menampung semua objek dan cahaya
  • Camera: kamera, dalam game first-person ia adalah mata pemain
  • Geometry: struktur geometris, mendefinisikan bentuk kontainer dan gudang
  • Material: material, menentukan apakah permukaan tampak seperti logam atau beton
  • Mesh: objek terlihat hasil gabungan geometri dan material
  • Light: cahaya, lampu jalan dan lampu peringatan di pelabuhan pada malam hujan
  • Renderer: renderer, menyerahkan semua konten di atas ke GPU untuk digambar

Pustaka contoh resmi Three.js juga memamerkan kemampuan seperti animasi tulang (skeletal animation), pemetaan bayangan (shadow mapping), efek pascapemrosesan, dan rendering instansiasi. Di antaranya, Instancing sangat berguna untuk scene pelabuhan: ratusan hingga ribuan kontainer serupa bisa berbagi satu set geometri, hanya mengubah parameter posisi dan warna, lalu diselesaikan dengan satu draw call—yang secara signifikan meringankan beban browser.

2.3 WebGL menyerahkan pekerjaan menggambar ke GPU lokal

WebGL adalah antarmuka grafis yang disediakan browser untuk JavaScript, dibangun di atas teknologi terkait OpenGL ES. Alur kerjanya lugas: kode game memanggil WebGL lewat JavaScript, WebGL mengirim instruksi menggambar ke GPU, GPU menghitung gambar, lalu browser menampilkannya di halaman.

Yang menjadi kunci, GPU ini adalah kartu grafis di komputer pemain. Setiap frame Saltline dihitung di perangkat pemain, sementara jaringan hanya bertugas mengirimkan file 1.4MB ke browser pada awal mula. Inilah alasan halaman resmi Saltline menyarankan pemain yang macet di layar loading untuk memeriksa WebGL 2 dan akselerasi perangkat keras browser.

2.4 Shader, material, dan pencahayaan membentuk tampilan adegan 3D

Tampilan sebuah adegan 3D ditentukan oleh empat bagian: model memberikan bentuk, material memberikan properti permukaan, pencahayaan memberikan terang-gelap, dan shader menghitung semua faktor tersebut menjadi warna piksel akhir.

Shader berjalan di GPU dan terbagi menjadi dua jenis. Vertex shader menghitung posisi setiap vertex di layar, sedangkan fragment shader menghitung warna setiap piksel. Contohnya pada kontainer di malam hujan, fragment shader dapat memakai fungsi matematika untuk menghasilkan garis-garis panel bergelombang, bintik karat, dan pantulan pada permukaan basah, sepenuhnya tanpa perlu tekstur yang sudah digambar sebelumnya.

2.5 Siklus game web: menangani input dan terus memperbarui layar

Perbedaan game dengan halaman web statis adalah game harus menggambar ulang puluhan kali setiap detik. Browser menyediakan antarmuka requestAnimationFrame, yang memanggil callback kode game sebelum setiap penyegaran layar, sehingga membentuk siklus game:

  1. Membaca input keyboard, mouse, atau layar sentuh (Saltline perlu mengklik area game untuk mendapatkan kontrol mouse)
  2. Memperbarui status game: posisi pemain, perilaku musuh, lintasan peluru
  3. Memanggil renderer Three.js, lalu melalui WebGL membiarkan GPU menggambar frame baru
  4. Browser menampilkan gambar, lalu menunggu penyegaran berikutnya

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

3 Mengapa 1.4MB dapat menghasilkan adegan bergaya 3A yang lengkap: pembuatan prosedural

3.1 Model, tekstur, dan suara semuanya ditulis sebagai fungsi

Pada 10 November, Felix Rieseberg menambahkan penjelasan bahwa seluruh konten dalam game adalah kode; tekstur dan model semuanya berupa fungsi, tanpa file gambar atau aset model 3D terpisah. Yang dihasilkan Claude adalah kode dan Shader untuk membangun konten tersebut.

Dibandingkan dengan cara tradisional, perbedaannya langsung terlihat:

  • Tekstur: cara tradisional mengunduh gambar tekstur kontainer lalu menempelkannya; cara prosedural menghitung permukaan logam secara real-time menggunakan fungsi noise, variasi warna, dan Shader
  • Model: cara tradisional mengimpor file model yang sudah jadi dari perangkat lunak pemodelan; cara prosedural membangunnya saat runtime menggunakan vertex dan parameter geometri
  • Suara: cara tradisional memuat file audio yang sudah direkam; cara prosedural menyintesisnya secara real-time dengan API audio browser

Yang disimpan dalam file adalah “aturan pembuatan”; tampilan akhir baru dihitung saat runtime. Aturan biasanya jauh lebih kecil daripada hasilnya. Shader beberapa puluh baris saja sudah bisa menutupi tekstur permukaan seluruh area pelabuhan.

3.2 Membedakan ukuran file, memori runtime, dan beban komputasi

Kunci untuk memahami 1.4MB adalah memisahkan tiga konsep ini:

Konsep Apa yang diukur Kondisi Saltline
Ukuran file Berapa banyak kode dan aset yang perlu diunduh Sekitar 1.4MB, distribusinya sangat ringan
Memori runtime Berapa banyak memori dan VRAM yang dipakai saat berjalan Adegan dihasilkan saat runtime, data resmi belum dipublikasikan
Beban komputasi Berapa banyak kerja CPU dan GPU per frame Tergantung pengaturan kualitas dan perangkat, data resmi belum dipublikasikan
Waktu inisialisasi Waktu dari membuka halaman sampai bisa berinteraksi Dokumentasi resmi menyebutkan bahwa pelabuhan, gudang, pencahayaan, dan suara perlu dibangun; durasinya tergantung perangkat

Pembuatan prosedural menukar “komputasi saat runtime” dengan “ukuran unduhan” yang kecil. Program 1.4MB dapat membuat banyak geometri, material, dan tekstur saat runtime, tetapi GPU tetap harus menyelesaikan banyak perhitungan Shader setiap frame. Halaman resmi Saltline juga secara jelas mengingatkan bahwa waktu munculnya tombol START bergantung pada perangkat pemain; jika terjadi lag, pemain dapat beralih ke kualitas Low.

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

3.3 Arsitektur satu file membuat distribusi sangat ringan

Nilai HTML satu file terletak pada distribusinya. File ini bisa diletakkan di layanan hosting statis mana pun, atau diunduh ke lokal dan dibuka dengan server HTTP; untuk berbagi hanya perlu satu tautan. Repositori GitHub versi bahasa Mandarin “几猫” langsung menyediakan tautan untuk mencoba online dan mengunduh, serta menjelaskan bahwa game dapat berjalan offline (kecuali pemuatan font).

Bentuk ini sangat cocok untuk prototipe yang dihasilkan AI. Model menghasilkan satu file lengkap dalam sekali output; developer tidak perlu menangani pipeline aset, alat bundling, dan konfigurasi server. Setelah dihasilkan, file bisa langsung dikirim ke orang lain untuk dicoba.


4 Tiga jalur berbeda untuk menjalankan game 3A di browser

Di balik “bermain game di browser” ada tiga jalur teknologi dengan cara komputasi yang sepenuhnya berbeda. Memahami ketiganya adalah kunci untuk memahami Saltline dengan tepat.

4.1 Berjalan secara lokal di browser: Jalur Saltline

AI menghasilkan kode, kode dikirim ke pemain, lalu browser menjalankan logika secara lokal dan merender gambar dengan GPU lokal. Perangkat pemain menanggung komputasi utama, saat game berjalan tidak perlu terhubung ke model AI, dan setelah file diunduh ada peluang untuk berjalan secara offline. Harganya adalah performa sepenuhnya bergantung pada perangkat dan browser pemain.

4.2 Cloud gaming: jalur GeForce NOW dan Pixel Streaming

Game berjalan di server jarak jauh, GPU di cloud merender gambar, lalu mengalirkannya ke browser sebagai streaming video. Browser hanya bertanggung jawab menampilkan video, memutar suara, dan mengirim input pemain kembali ke server.

Pixel Streaming dari Epic Games memungkinkan aplikasi Unreal Engine berjalan di cloud atau komputer jarak jauh, dengan mengirimkan gambar dan audio ke browser melalui WebRTC. NVIDIA GeForce NOW adalah layanan cloud gaming yang ditujukan untuk pemain, dengan persyaratan jaringan browser yang diumumkan resmi: minimal 15Mbps untuk 720p/60FPS, minimal 25Mbps untuk 1080p/60FPS, minimal 35Mbps untuk 1440p/120FPS, dan disarankan latensi di bawah 80ms. Jalur ini menurunkan ambang batas perangkat keras lokal, dengan imbalan ketergantungan berkelanjutan pada jaringan.

4.3 Model dunia AI: jalur Genie 3

Model dunia tidak menulis skenario dan aturan sebelumnya, melainkan memprediksi dan menghasilkan segmen gambar berikutnya berdasarkan keadaan saat ini dan input pemain. Pada Agustus 2025, Google DeepMind merilis Genie 3, yang secara resmi diumumkan dapat menghasilkan lingkungan yang dapat dijelajahi secara real-time pada 720p, hingga 24FPS, dengan konsistensi adegan yang dapat bertahan hingga beberapa menit. Muse/WHAMM dari Microsoft dan Oasis dari Decart juga sedang mengeksplorasi arah ini.

Pada Januari 2026, Project Genie yang berbasis Genie 3 dibuka untuk pengalaman, dengan tahap pertama ditujukan untuk pelanggan berlangganan Google AI Ultra berusia 18 tahun ke atas di wilayah Amerika Serikat, dan batasan 60 detik per pengalaman pembuatan. Jalur ini saat ini berada pada tahap penelitian dan prototipe produk, dan tidak ada hubungannya dengan teknologi yang digunakan Saltline.

4.4 Perbandingan tiga jalur

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

Dimensi perbandingan Menjalankan di web lokal Cloud gaming Model dunia AI
Contoh perwakilan Saltline GeForce NOW, Pixel Streaming Genie 3
Logika game Eksekusi kode yang sudah ditulis sebelumnya secara lokal Eksekusi kode yang sudah ditulis sebelumnya di cloud Model mempelajari dinamika lingkungan dari data
Pembuatan gambar Rendering GPU lokal Rendering GPU cloud Dihasilkan AI secara real-time
Peran browser Lingkungan menjalankan game Terminal video dan interaksi Pintu masuk interaksi
Ketergantungan jaringan Setelah pemuatan pertama, sebagian besar bisa offline Terus terhubung ke internet, butuh bandwidth tinggi dan latensi rendah Biasanya perlu koneksi internet terus-menerus
Persyaratan perangkat keras lokal Relatif tinggi Relatif rendah Tergantung cara deployment model
Waktu terjadinya biaya AI Terpusat di tahap pengembangan Tanpa inferensi AI, terus mengonsumsi GPU cloud Inferensi terus-menerus setiap kali bermain

Struktur biaya adalah perbedaan paling nyata di antara ketiganya. Saltline memusatkan biaya AI dalam satu kali pengembangan; setelah itu perangkat pemain yang menanggung rendering, sehingga estimasi biaya 550 dolar tidak akan bertambah seiring jumlah pemain. Cloud gaming dan model dunia justru terus mengonsumsi daya komputasi server setiap kali orang bermain.


5 Praktik Langsung: Membuat dan Menjalankan Adegan 3D Web dengan AI

Cara tercepat untuk memahami prinsipnya adalah dengan mencobanya sendiri. Bagian ini terbagi menjadi tiga langkah: pertama menjalankan adegan terprogram yang ditulis manual, lalu menggunakan API agar Model Bahasa Besar menghasilkan game satu file, dan terakhir mengukur waktu frame-nya.

5.1 Program Three.js prosedural minimal yang bisa dijalankan

File berikut menggambar 400 kontainer dengan Instancing, di mana garis gelombang (corrugation) dan bercak karat pada setiap kontainer dihitung secara real-time oleh Shader, tanpa satu pun file gambar. Simpan sebagai index.html, jalankan python3 -m http.server 8000 di direktori yang sama, lalu buka http://localhost:8000 di browser.

<!DOCTYPE html>
<html lang="zh">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Pelabuhan kontainer prosedural</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);

// Material prosedural: garis gelombang + bercak karat ber-noise + pencahayaan arah sederhana
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));   // garis gelombang
      float rust = smoothstep(0.82, 1.0, hash(floor(vUv * 40.0)));  // bercak karat
      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: menggambar 400 kontainer dalam satu panggilan draw
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);

// Loop permainan: perbarui kamera setiap frame lalu render
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>

Kode ini merangkum inti gagasan Saltline: geometri dibentuk oleh BoxGeometry, tampilan luarnya dihitung oleh Shader, dan objek berulang dalam jumlah besar digambar dengan Instancing. Seluruh file hanya beberapa KB, Three.js dimuat dari CDN; Saltline sendiri memaketkan Three.js langsung ke dalam HTML.

5.2 Membuat Model Bahasa Besar Menghasilkan Game 3D Satu File Melalui API

Proses pembuatan Saltline adalah pemrograman bergaya agen yang panjang dan multi-putaran, menghabiskan ratusan juta Token. Pengembang individu dapat memulai dari satu pemanggilan saja, meminta model menghasilkan game kecil Three.js satu file yang bisa langsung dijalankan, dan merasakan pembagian kerja “AI menulis program, browser menjalankan program”. Kode di bawah ini menggunakan antarmuka yang kompatibel dengan OpenAI; ganti nama model dengan model dari daftar model platform yang mendukung output kode panjang.

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # Antarmuka kompatibel OpenAI APIYI
)

resp = client.chat.completions.create(
    model="YOUR_MODEL_NAME",  # Mengacu pada daftar model platform
    messages=[{"role": "user", "content": "用 Three.js 写一个单文件 HTML 第一人称小游戏,所有模型和纹理用代码与 Shader 生成,只输出完整 HTML。"}],
)
open("game.html", "w", encoding="utf-8").write(resp.choices[0].message.content)
Lihat kode implementasi lengkap (termasuk pembersihan blok kode dan batasan petunjuk)
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:
    """Menghapus penanda blok kode ```html yang mungkin dibungkus model"""
    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",
    )

File yang dihasilkan dan Saltline mengikuti logika operasi yang sama: pemanggilan API hanya terjadi sekali saat pembuatan; setelah itu, membuka game.html dan bermain berapa kali pun tidak lagi menimbulkan biaya model.

🚀 Saran memulai cepat: Ingin membandingkan hasil berbagai model dalam menulis game Three.js, Anda bisa memakai APIYI apiyi.com dengan kunci API yang sama untuk beralih antara model Claude, GPT, Gemini, dan sebagainya. Antarmukanya kompatibel dengan OpenAI, jadi kode di atas hanya perlu mengubah parameter model. Pengguna baru mendapat kuota pengujian gratis, cocok untuk memverifikasi kualitas pembuatan dengan petunjuk kecil terlebih dahulu.

5.3 Mengukur performa nyata game 3D di browser

Ukuran 1,4 MB hanya menjawab “seberapa cepat unduhannya”. Untuk menilai apakah sebuah game web bisa berjalan lancar atau tidak, kita perlu mengukur indikator-indikator berikut:

Metrik Tujuan pengukuran Metode pengukuran
Waktu dapat dimainkan pertama Pengalaman saat mulai Dari membuka halaman hingga bisa mengendalikan karakter, bisa menggunakan Performance API untuk mencatat titik waktu
FPS / waktu frame Kelancaran dan stabilitas 60FPS setara sekitar 16,67 ms/frame, perhatikan fluktuasi waktu frame
Penggunaan CPU Beban logika game Amati main thread di panel Performance Chrome DevTools
Penggunaan GPU dan VRAM Beban rendering Task Manager sistem atau alat pemantauan kartu grafis
Memori sistem Sumber daya saat runtime Amati memori proses browser setelah inisialisasi scene selesai
Lalu lintas jaringan setelah pemuatan Dependensi eksternal Panel Network DevTools, bedakan permintaan font, program, dan sejenisnya

Tempelkan kode berikut ke konsol browser untuk menghitung rata-rata waktu frame dan frame paling lambat selama 10 detik:

(() => {
  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);
})();

Saat pengujian, kunci versi browser, sistem operasi, model perangkat, resolusi, dan tingkat kualitas grafis. Pengukuran harus mencakup skenario saat pergerakan pemain, aktivitas musuh, tembakan, dan efek hujan muncul bersamaan; hanya mengukur scene kosong tepat setelah masuk game akan menghasilkan hasil yang terlalu optimistis.


6 Seberapa jauh game 3A berbasis web dari game 3A komersial yang sesungguhnya

6.1 Keterbatasan hardware dan platform yang dihadapi game browser

Dokumentasi resmi Unity menjelaskan batasan platform Web dengan cukup gamblang: akses sistem file terbatas, sebagian fitur cache tidak tersedia, multithreading dibatasi oleh lingkungan browser, sumber daya memori terbatas, dan kompatibilitas antar browser berbeda-beda. Build WebGL Unity terutama ditujukan untuk browser desktop, dengan dukungan perangkat mobile yang terbatas.

Halaman pengalaman Saltline membuktikan keterbatasan tersebut. Halaman itu memberi tahu bahwa inisialisasi mungkin berjalan lambat, kecepatan startup dipengaruhi performa perangkat, perlu memeriksa WebGL 2 dan akselerasi hardware, serta beralih ke kualitas Low saat tersendat. Ambang untuk membuka sebuah halaman web memang sangat rendah, tetapi ambang untuk menjalankannya dengan lancar tetap bergantung pada GPU pemain.

6.2 1.4MB: distribusi ringan, beban runtime lain cerita

Pembuatan prosedural mengubah “aset yang diunduh” menjadi “aset yang dihitung saat runtime”. Tekstur dihitung per piksel secara real-time di GPU, geometri dibangun oleh CPU saat inisialisasi, dan semua pekerjaan ini terjadi di perangkat pemain. Saat ini pengembang belum mempublikasikan waktu boot standar, FPS rata-rata, penggunaan VRAM, maupun memori Saltline, jadi untuk menilai beban runtime-nya Anda perlu mengukurnya sendiri dengan metode di Bagian 5.3.

6.3 Skala rekayasa game AAA komersial

Game AAA komersial umumnya berarti investasi dana, tenaga kerja, dan sumber daya dalam skala besar. Sebutan ini menggambarkan skala produksi, bukan standar sertifikasi teknis yang seragam. Sebuah game AAA komersial membutuhkan konten puluhan jam, animasi karakter dan sistem fisika yang kompleks, sinkronisasi jaringan multipemain, adaptasi lintas platform, serta pembaruan, pemeliharaan, pengujian, dan optimasi yang berlangsung bertahun-tahun. Pembuatan prosedural unggul untuk konten yang polanya kuat seperti kontainer, permukaan tanah, dan air hujan; tetapi untuk karakter dan adegan naratif yang butuh banyak polesan seni, produksi aset tradisional tetap lebih cocok.

6.4 Apa yang sebenarnya dibuktikan Saltline

Yang dibuktikan Saltline adalah bahwa model AI dengan kemampuan pemrograman yang kuat dapat, dalam satu proses generasi yang berkelanjutan, menyatukan desain level, konstruksi scene, shader, mekanisme game, logika kontrol, dan generasi audio, lalu menghasilkan prototipe game 3D dengan gaya yang utuh dan bisa langsung dibagikan. Biaya serah-terima antar alat dan antar peran yang berbeda dalam alur kerja tradisional di sini dipadatkan ke dalam konteks satu model.

Jika kita membandingkan data yang diutarakan pengembang dengan harga model resmi yang dipublikasikan, komposisi biaya eksperimen ini bisa dilihat dengan jelas:

Item Data Sumber
Waktu pengembangan Sekitar 8 jam Keterangan Felix Rieseberg, 2026-11-09
Estimasi biaya Sekitar 550 dolar AS (diperkirakan berdasarkan harga API) Keterangan Felix Rieseberg
Token input Sekitar 445 juta, sebagian besar di-cache Keterangan Felix Rieseberg
Token output Sekitar 2,7 juta Keterangan Felix Rieseberg
Harga input / output Fable 5.2 $8 / $40 per juta token Dokumen model resmi Anthropic
Harga baca cache Fable 5.2 $0.20 per juta token Dokumen model resmi Anthropic
Jendela konteks / output maksimal 1M token / 128K token Dokumen model resmi Anthropic

Harga baca cache jauh lebih rendah daripada harga input biasa, sehingga 445 juta token input tidak bisa langsung dikonversi menjadi total biaya memakai harga satuan input biasa. Pengembang tidak mempublikasikan rincian tagihan yang spesifik, jadi 550 dolar AS sebaiknya dipahami sebagai estimasi biaya satu eksperimen generasi.

💰 Saran biaya: Biaya pembuatan game web dengan AI terpusat di tahap pengembangan, dengan konteks panjang dan iterasi multi-putaran sebagai pengeluaran utama. Sebelum benar-benar menjalankan tugas panjang, Anda bisa memakai APIYI apiyi.com dengan petunjuk yang lebih kecil untuk membandingkan kualitas kode beberapa model terlebih dahulu, lalu memutuskan model mana yang akan dipakai untuk generasi berdurasi panjang. Penagihan berbasis pemakaian memudahkan pengendalian biaya percobaan.


7 Pertanyaan yang Sering Diajukan (FAQ)

Q1: Game 3A buatan AI yang berjalan di browser, apakah gambar game-nya dikirim dari server?

Gambar Saltline dirender oleh GPU lokal pemain. Setelah browser mengunduh file HTML sekitar 1,4MB, JavaScript menjalankan logika game, lalu WebGL memanggil kartu grafis lokal untuk menggambar setiap frame. Yang mengirim gambar dari server adalah layanan cloud gaming seperti GeForce NOW, dan itu jalur teknologi yang berbeda.

Q2: Apakah model Claude dipanggil secara real-time saat bermain Saltline?

Tidak. Claude Fable 5.2 hanya menghasilkan kode game pada tahap pengembangan. Mirror GitHub-nya sudah menghapus skrip framework Claude Artifact, jadi game bisa dijalankan dengan server HTTP biasa, dan proses bermain tidak menimbulkan biaya pemanggilan model.

Q3: Apa perbedaan Saltline dengan model dunia AI seperti Genie 3?

Aturan dan skenario Saltline sudah ditulis lebih dulu menjadi kode oleh AI, lalu saat dijalankan dieksekusi oleh alur rendering konvensional. Genie 3 memprediksi dan menghasilkan gambar per frame berdasarkan input pemain, dengan aturan yang dipelajari dari data. Yang pertama adalah AI menulis program, yang kedua adalah AI langsung menghasilkan gambar — keduanya secara teknis saling independen.

Q4: Game 3A berbentuk halaman web 1,4MB, komputer dengan spesifikasi seperti apa yang bisa menjalankannya dengan lancar?

Pengembang tidak merilis data spesifikasi minimum maupun FPS. Halaman resminya menyarankan untuk memastikan browser mendukung WebGL 2 dan akselerasi hardware aktif, serta beralih ke kualitas Low jika terasa tersendat. Untuk hasil pengukuran yang konkret, sebaiknya ukur sendiri di perangkat Anda memakai skrip waktu frame di bagian 5.3 artikel ini.

Q5: Bagaimana cara membuat sendiri game 3D berbasis web yang serupa dengan API?

Daftar di APIYI apiyi.com dan dapatkan kunci API, lalu atur `base_url` pada kode di bagian 5.2 menjadi `https://api.apiyi.com/v1`, pilih model yang unggul dalam menghasilkan kode panjang, dan tulis di petunjuk secara eksplisit permintaan seperti “HTML satu file, Three.js, semua aset dibuat dengan kode dan shader”. Setelah jadi, buka lewat server HTTP lokal dan game siap dicoba.

Q6: Apa saja keterbatasan membuat game browser dengan AI?

Panjang output satu kali pemanggilan terbatas, sehingga game kompleks butuh beberapa putaran generasi dengan jendela konteks panjang, dan biayanya ikut naik. Kode yang dihasilkan sering masih perlu di-debug untuk masalah performa dan kompatibilitas. Browser sendiri juga punya batasan memori, thread, dan dukungan mobile. Sebaiknya lakukan perbandingan skala kecil dulu memakai beberapa model lewat APIYI apiyi.com, pilih model dengan stabilitas kode terbaik, baru kemudian memperbesar skala proyek.


8 Poin Utama Game 3A Berbasis Web dengan AI

  • Lokasi eksekusi: Saltline berjalan di browser pemain, GPU lokal menangani rendering
  • Pembagian tugas jelas: AI menulis kode pada tahap pengembangan, browser mengeksekusi kode pada tahap operasi
  • Rantai teknologi: JavaScript mengelola logika, Three.js menyusun scene, WebGL memanggil GPU
  • Rahasia ukuran file: model, tekstur, dan suara semuanya ditulis sebagai fungsi, satu file sekitar 1.4MB
  • File kecil bukan berarti ringan saat dijalankan: aset prosedural mengubah biaya unduhan menjadi biaya komputasi saat runtime
  • Tiga jalur: lokasi komputasi untuk eksekusi web lokal, cloud gaming, dan world model AI masing-masing berbeda
  • Verifikasi langsung: Anda bisa memanggil berbagai model melalui APIYI apiyi.com untuk menghasilkan game Three.js satu file lalu mengujinya secara langsung

9 Kesimpulan

Game bergaya 3A buatan AI dapat berjalan di web berkat kemampuan 3D yang sudah dimiliki browser ditambah generasi prosedural. Ada tiga poin inti:

  1. Browser adalah lingkungan eksekusi game engine: kombinasi JavaScript, Three.js, dan WebGL memungkinkan halaman web langsung memanggil GPU lokal untuk merender scene 3D.
  2. Biaya AI terkonsentrasi pada tahap pengembangan: setelah selesai dibuat, Saltline berjalan mandiri tanpa Claude; perkiraan biaya sekali pakai sekitar 550 dolar AS menurut pengembangnya sendiri.
  3. 1.4MB menyelesaikan masalah distribusi: beban memori dan GPU saat runtime tetap ditanggung perangkat pemain, dan Saltline diposisikan sebagai prototipe 3D yang dapat dimainkan dan dibangun dengan cepat.

Jika ingin merasakan langsung alur “AI menulis game, browser menjalankan game”, disarankan menggunakan APIYI apiyi.com dengan antarmuka kompatibel OpenAI yang sama untuk membandingkan hasil kode Three.js dari berbagai model, lalu mengukur hasilnya memakai skrip waktu frame di artikel ini.


📚 Referensi

  1. Halaman pengalaman mandiri Saltline: akses demo game serta penjelasan pemuatan, kualitas grafis, dan kontrol
  2. Tautan: saltline.games
  3. Keterangan: Berisi waktu inisialisasi serta petunjuk resmi tentang WebGL 2 dan akselerasi perangkat keras

  4. Mirror kode dan README Saltline: versi HTML satu file

  5. Tautan: github.com/realcodebear/saltline-fable-5.2
  6. Keterangan: Mencatat proses porting Artifact, struktur file, dan dependensi eksternal Google Fonts

  7. Repositori GitHub Jimao versi Tionghoa: versi kemasan berbahasa Tionghoa Saltline

  8. Tautan: github.com/Megasu/jimao-3a-game
  9. Keterangan: Menyediakan penjelasan tentang ukuran file, cara menjalankan secara offline, dan persyaratan browser

  10. Spesifikasi dan harga model Claude Fable 5.2: dokumentasi resmi Anthropic

  11. Tautan: platform.claude.com/docs/en/models/fable-5-2/overview
  12. Keterangan: Harga input, output, dan cache serta jendela konteks

  13. MDN WebGL API: dokumentasi antarmuka rendering GPU browser

  14. Tautan: developer.mozilla.org/en-US/docs/Web/API/WebGL_API
  15. Keterangan: Referensi otoritatif untuk memahami cara kerja WebGL

  16. Dokumentasi resmi Three.js: pustaka grafik 3D Web

  17. Tautan: threejs.org/docs
  18. Keterangan: Penjelasan API untuk Scene, Mesh, ShaderMaterial, InstancedMesh, dan lain-lain

  19. Batasan teknis Unity WebGL: batasan platform game browser

  20. Tautan: docs.unity.cn/6000.0/Documentation/Manual/webgl-technical-overview.html
  21. Keterangan: Penjelasan batasan sistem file, thread, memori, dan dukungan perangkat seluler

  22. Persyaratan sistem NVIDIA GeForce NOW: persyaratan jaringan cloud gaming

  23. Tautan: nvidia.com/en-us/geforce-now/system-reqs
  24. Keterangan: Rekomendasi bandwidth dan latensi untuk berbagai kualitas grafis dan frame rate

  25. Epic Games Pixel Streaming: streaming rendering dari cloud

  26. Tautan: dev.epicgames.com/documentation/unreal-engine/pixel-streaming-in-unreal-engine
  27. Keterangan: Dokumentasi resmi Unreal Engine tentang pengiriman frame ke browser melalui WebRTC

  28. Rilis teknologi Genie 3: model dunia Google DeepMind

    • Tautan: deepmind.google/blog/genie-3-a-new-frontier-for-world-models
    • Keterangan: Kemampuan dan batasan dalam menghasilkan lingkungan interaktif real-time

Penulis: Tim Teknis APIYI
Diskusi teknis: Silakan hubungi kami melalui halaman utama situs resmi APIYI. Untuk materi integrasi model lainnya, kunjungi pusat dokumentasi di docs.apiyi.com.

Artikel terkait

Similar Posts