작성자 주석: Saltline은 브라우저에서 게임 코드를 실행하고, 플레이어의 로컬 GPU를 호출해 렌더링을 마무리해요. 절차적 생성 자산에 WebGL을 더한 조합은 약 1.4MB짜리 웹 페이지 파일 하나가 어떻게 완전한 3D 슈팅 장면을 보여줄 수 있는지를 설명해 줍니다.
AI가 만든 “3A 게임”이 웹 페이지에서 돌아갈 수 있는 이유는 세 가지예요. 첫째, 현대 브라우저 자체가 완전한 3D 프로그램 실행 환경이에요. JavaScript가 게임 로직을 실행하고, Three.js가 장면을 구성하며, WebGL이 그리기 작업을 플레이어 컴퓨터의 GPU에 넘겨요. 둘째, AI가 개발 단계에서 내놓는 산출물은 하나의 게임 프로그램이고, 개발이 끝난 뒤의 실행은 전부 브라우저에 맡겨지므로 플레이어가 게임을 즐길 때는 더 이상 AI 모델을 호출하지 않아요. 셋째, Saltline의 모델, 텍스처, 사운드는 모두 코드로 생성되며, 단일 HTML 파일이 약 1.4MB에 불과해서 웹 페이지를 열면 바로 게임에 들어갈 수 있어요.
여기서 말하는 “3A”는 개발자가 AI에게 설정한 시각적 목표로, 화면 스타일을 비유하기 위해 쓴 표현이에요. Saltline 자체는 레벨이 하나뿐인 소규모 플레이 가능 프로토타입이에요.
이제 Saltline 사례부터 시작해 게임이 대체 어디에서 실행되는지 알아볼게요. 이어서 브라우저가 3D 장면을 렌더링하는 기술 체인을 뜯어보고, 절차적 생성이 왜 파일 크기를 1.4MB까지 줄일 수 있는지 설명할게요. 그다음 로컬 웹 페이지 실행, 클라우드 게임, AI 월드 모델이라는 세 가지 경로를 나란히 놓고 비교해 볼게요. 마지막으로 바로 실행할 수 있는 코드 한 조각을 준비해서, AI로 웹 3D 장면을 생성하고 측정하는 방법을 안내하고, 브라우저 게임과 상업용 3A 게임 사이의 실제 거리를 논의할게요.

To Know: AI 웹 3A 게임 용어 이해하기
| 용어 | 설명 |
|---|---|
| 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 AI가 만든 3A 게임은 왜 웹페이지만 열면 될까: Saltline부터 살펴보기
1.1 Saltline은 어떤 AI 웹 게임일까요
2026년 11월 9일, Anthropic 엔지니어 Felix Rieseberg가 Claude Fable 5.2의 코딩 실험 하나를 공개했어요. 그는 모델에 프롬프트 하나만 주고, 비주얼이 최대한 AAA 게임에 가까운 소규모 1인칭 슈팅 게임을 만들어 달라고 요청했죠. 전 과정에서 사람의 피드백은 제공하지 않았고, 그 결과물이 바로 Saltline이에요.
게임 배경은 비 오는 밤의 컨테이너 항만이에요. 창고, 부두, 층층이 쌓인 컨테이너가 등장하죠. 플레이어는 세 개의 신호 중계소를 끄고 철수해야 하며, 적으로는 공중 순찰 드론과 지상 기계 사냥견이 나와요. 1인칭 이동, 시점 제어, 사격, 상호작용, 임무 목표를 지원하고, 빗방울, 조명, 환경 음향, 무기 효과도 구현돼 있어요. 페이지에는 낮은 화질 옵션을 포함한 그래픽 품질 설정도 제공해요.
개발자 본인이 X에 남긴 글에 따르면, 이번 실험은 약 8시간이 걸렸고, API 가격을 기준으로 추산한 비용은 약 550달러였어요. 입력 Token은 약 4억 4,500만 개(이 중 상당량은 캐시), 출력 Token은 약 270만 개를 사용했죠. 이 수치는 개발자가 보고한 추정치일 뿐, 제3자가 감사한 청구서는 아니에요.
이후 중국 소셜 플랫폼에서는 ‘几猫·国产3A大作’이라는 이름으로 퍼졌어요. 이는 Saltline의 중국어 버전이나 재포장 버전이고, ‘国产3A大作’은 ‘국산 3A 대작’이라는 뜻으로 확산 과정에서 붙은 이름이에요.
1.2 1.4MB 단일 파일에 3A 스타일 게임 전체가 들어 있어요
Saltline의 독립 HTML 버전에는 index.html 파일 하나만 있어요. GitHub 저장소에 기록된 크기는 1,425,707바이트로, 약 1.43MB(1.36MiB)예요. 이 파일 안에는 게임 실행에 필요한 핵심 코드가 들어 있고, Three.js 런타임 코드도 함께 번들링돼 있어요. 게임에 별도의 3D 모델, 텍스처, 음향 파일은 없어요.
비교해 보면, 전통적인 3D 게임 설치 패키지에는 보통 수많은 모델, 고해상도 텍스처, 애니메이션, 음향, 장면 데이터가 들어 있어요. Saltline은 이런 에셋을 모두 ‘에셋을 생성하는 코드’로 바꿨어요. 이것이 파일 크기가 작은 근본 이유이고, 3절에서 더 자세히 풀어볼게요.
1.3 Saltline 게임은 실제로 플레이어 기기에서 실행돼요
AI는 개발 단계에만 참여해요. Saltline의 GitHub 미러가 이 점을 잘 보여줘요. 원본 버전은 Claude Artifact였어요. 미러로 옮길 때 Artifact 프레임워크 실행 스크립트를 삭제하고 게임 코드는 그대로 유지했으며, DOCTYPE, 문자셋, Viewport 선언을 추가했어요. 그리고 로컬 HTTP 서버로 실행하면 바로 시작할 수 있죠.
이 말은 게임 로직이 Claude 대화 인터페이스와 완전히 분리됐다는 뜻이에요. 플레이어가 웹페이지를 열면 브라우저가 HTML을 읽고 JavaScript를 실행하며 WebGL을 초기화해요. 그다음 로컬 GPU가 매 프레임을 그리죠. 이 전 과정에서 AI 모델은 추론에 관여하지 않아요.
한 가지 디테일을 덧붙이면, 미러 설명에는 폰트가 여전히 Google Fonts에서 로드된다고 나와요. 정확히 말하면, Saltline의 핵심 게임 프로그램은 로컬에서 실행되고, 장면·텍스처·사운드는 로컬 코드가 생성해요. 다만 폰트는 외부 로드 의존성이 있어요.
2 브라우저가 어떻게 AI 3A 게임의 3D 실행 환경이 되는가
현대 브라우저는 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 장면 구성하기
WebGL로 직접 3D 장면을 작성하려면 수많은 저수준 세부 사항을 처리해야 해요. Three.js는 이런 세부 사항을 직관적인 객체로 캡슐화했어요.
- Scene: 장면 컨테이너로, 모든 물체와 조명을 담아요
- Camera: 카메라로, 1인칭 게임에서는 플레이어의 눈이에요
- 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.4MB 파일을 브라우저로 전달하는 역할만 해요. Saltline 공식 페이지에서 로딩 화면에 멈춘 플레이어에게 WebGL 2와 브라우저 하드웨어 가속을 확인해 보라고 권하는 것도 바로 이 때문이에요.
2.4 셰이더, 머티리얼, 조명이 3D 장면의 외형을 구성한다
3D 장면의 외형은 네 가지 요소가 함께 결정해요. 모델이 형태를 제공하고, 머티리얼이 표면 속성을 정하며, 조명이 밝고 어두움을 만들고, 셰이더가 이 요소들을 계산해 최종 픽셀 색상으로 만들어내죠.
셰이더는 GPU에서 실행되며 두 종류로 나뉘어요. 버텍스 셰이더는 각 버텍스가 화면에서 어디에 위치할지 계산하고, 프래그먼트 셰이더는 각 픽셀의 색을 계산하죠. 비 내리는 밤의 컨테이너를 예로 들면, 프래그먼트 셰이더는 수학 함수만으로 골판의 줄무늬, 녹 얼룩, 젖은 표면의 반사를 계산할 수 있어요. 미리 그려 둔 텍스처는 전혀 필요하지 않죠.
2.5 웹 게임 루프: 입력을 처리하고 화면을 계속 갱신한다
게임과 정적 웹페이지의 차이는 1초에 수십 번 화면을 다시 그린다는 점이에요. 브라우저는 requestAnimationFrame 인터페이스를 제공하는데, 화면이 갱신되기 직전마다 게임 코드를 콜백으로 호출해 게임 루프를 만들어요:
- 키보드, 마우스, 터치 입력을 읽어요(Saltline은 게임 영역을 클릭해야 마우스 제어권을 얻을 수 있어요)
- 게임 상태를 갱신해요: 플레이어 위치, 적의 행동, 총알 궤적
- Three.js 렌더러를 호출해 WebGL을 거쳐 GPU가 새 프레임을 그리게 해요
- 브라우저가 화면을 표시하고, 다음 갱신을 기다려요

3. 1.4MB로 완성도 높은 3A 스타일 장면을 만드는 이유: 절차적 생성
3.1. 모델, 텍스처, 사운드까지 모두 함수로 작성
Felix Rieseberg는 11월 10일 보충 설명을 통해 게임 속 콘텐츠는 전부 코드이고, 텍스처와 모델 모두 함수이며 별도의 이미지나 3D 모델 에셋은 없다고 밝혔어요. Claude가 생성한 것은 이런 콘텐츠를 만드는 코드와 셰이더입니다.
전통적인 방식과 비교하면 차이가 한눈에 드러나요:
- 텍스처: 전통 방식은 컨테이너 텍스처 이미지를 내려받아 붙이지만, 절차적 방식은 노이즈 함수와 색상 변화, 셰이더로 금속 표면을 실시간 계산해요
- 모델: 전통 방식은 모델링 소프트웨어에서 만든 모델 파일을 불러오지만, 절차적 방식은 버텍스와 기하 파라미터로 런타임에 직접 구성해요
- 사운드: 전통 방식은 녹음된 오디오 파일을 로드하지만, 절차적 방식은 브라우저 오디오 인터페이스로 실시간 합성해요
파일 안에 저장되는 것은 ‘생성 규칙’이고, 최종 화면은 런타임에야 계산돼요. 규칙은 보통 결과물보다 훨씬 작아서, 수십 줄짜리 셰이더 하나로 항구 전체의 지면 텍스처를 커버할 수 있어요.
3.2. 파일 크기, 런타임 메모리, 연산 부하를 구분해서 보기
1.4MB를 이해하는 핵심은 세 가지 개념을 분리해서 보는 거예요:
| 개념 | 무엇을 측정하나 | Saltline의 경우 |
|---|---|---|
| 파일 크기 | 내려받아야 하는 코드와 리소스의 양 | 약 1.4MB, 배포가 매우 가벼움 |
| 런타임 메모리 | 실행 중 점유하는 메모리와 VRAM | 장면이 런타임에 생성되며, 공식 데이터는 미공개 |
| 연산 부하 | CPU, GPU가 프레임마다 처리하는 작업량 | 화질 설정과 기기에 따라 달라지며, 공식 데이터는 미공개 |
| 초기화 시간 | 페이지를 열고 조작할 수 있을 때까지 걸리는 시간 | 항구, 창고, 조명, 사운드를 구축해야 한다고 공식 안내하며, 소요 시간은 기기에 따라 다름 |
절차적 생성은 ‘런타임 계산’으로 ‘다운로드 크기’를 맞바꿔요. 1.4MB짜리 프로그램이 런타임에 수많은 지오메트리와 머티리얼, 텍스처를 만들어내지만, GPU는 여전히 매 프레임 많은 셰이더 연산을 수행해야 하죠. Saltline 공식 페이지에서도 START 버튼이 나타나는 시점은 플레이어 기기에 따라 달라지며, 끊길 경우 Low 화질로 전환할 수 있다고 분명히 안내하고 있어요.

3.3. 단일 파일 아키텍처로 배포가 아주 가벼워지다
단일 HTML 파일의 가치는 배포에 있어요. 어떤 정적 호스팅 서비스에든 올릴 수 있고, 로컬에 내려받아 HTTP 서버로 열 수도 있으며, 공유할 때는 링크 하나면 충분해요. ‘几猫’ 중국어 버전의 GitHub 리포지토리는 온라인 체험과 다운로드 링크를 바로 제공하고, 오프라인 실행이 가능하다고(폰트 로딩은 제외) 설명하고 있어요.
이런 형태는 AI가 생성한 프로토타입에 특히 잘 맞아요. 모델이 한 번에 완성된 파일 하나를 출력하면, 개발자는 에셋 파이프라인이나 번들링 도구, 서버 설정을 건드릴 필요 없이 생성 직후 바로 다른 사람에게 보내 체험하게 할 수 있거든요.
4 웹에서 3A 게임을 구동하는 세 가지 다른 경로
“웹에서 게임을 한다”는 말 뒤에는 계산 방식이 완전히 다른 세 가지 기술 경로가 있어요. 이걸 제대로 봐야 Saltline을 정확히 이해할 수 있어요.
4.1 로컬 웹 실행: Saltline의 경로
AI가 코드를 생성하고, 그 코드가 플레이어에게 전달되면 브라우저가 로컬에서 로직을 실행하고 로컬 GPU가 화면을 렌더링해요. 주요 계산은 플레이어의 기기가 담당하고, 게임을 실행할 때 AI 모델에 연결할 필요가 없으며, 파일을 다운로드한 뒤에는 오프라인 실행도 가능해요. 대가는 성능이 전적으로 플레이어의 기기와 브라우저에 달려 있다는 점이에요.
4.2 클라우드 게임: GeForce NOW와 Pixel Streaming의 접근
게임은 원격 서버에서 실행되고, 클라우드 GPU가 화면을 렌더링한 뒤 비디오 스트림으로 브라우저에 전송해요. 브라우저는 비디오 표시, 오디오 재생, 플레이어 입력을 서버로 전송하는 역할만 담당해요.
Epic Games의 Pixel Streaming은 Unreal Engine 애플리케이션이 클라우드나 원격 컴퓨터에서 실행되고, WebRTC를 통해 화면과 오디오를 브라우저로 전송할 수 있게 해줘요. NVIDIA GeForce NOW는 플레이어를 위한 클라우드 게임 서비스로, 공식적으로 공개된 브라우저 네트워크 요구사항은 720p/60FPS에서 최소 15Mbps, 1080p/60FPS에서 최소 25Mbps, 1440p/120FPS에서 최소 35Mbps이며, 지연 시간은 80ms 미만을 권장해요. 이 접근 방식은 로컬 하드웨어의 진입 장벽을 낮춰주는 대신, 네트워크에 대한 지속적인 의존이라는 대가를 치러요.
4.3 AI 월드 모델: Genie 3의 접근
월드 모델은 장면과 규칙을 미리 작성하지 않고, 현재 상태와 플레이어 입력을 기반으로 다음 화면을 예측하고 생성해요. 2025년 8월, Google DeepMind는 Genie 3를 발표했으며, 공식 발표에 따르면 720p, 최대 24FPS로 실시간으로 탐험 가능한 환경을 생성할 수 있고, 장면 일관성은 몇 분간 유지할 수 있다고 해요. 마이크로소프트의 Muse/WHAMM, Decart의 Oasis도 이 방향을 탐색하고 있어요.
2026년 1월, Genie 3 기반의 Project Genie가 체험판으로 공개되었고, 첫 회차는 미국 지역 18세 이상의 Google AI Ultra 구독자를 대상으로 하며, 매 생성 체험에는 60초 제한이 있어요. 이 접근 방식은 현재 연구 및 제품 프로토타입 단계에 있으며, Saltline이 사용하는 기술과는 관련이 없어요.
4.4 세 가지 경로 비교

| 비교 항목 | 로컬 웹 실행 | 클라우드 게임 | AI 월드 모델 |
|---|---|---|---|
| 대표 사례 | Saltline | GeForce NOW, Pixel Streaming | Genie 3 |
| 게임 로직 | 로컬에서 미리 작성된 코드 실행 | 클라우드에서 미리 작성된 코드 실행 | 모델이 데이터로부터 환경 역학을 학습 |
| 화면 생성 | 로컬 GPU 렌더링 | 클라우드 GPU 렌더링 | AI 실시간 생성 |
| 브라우저 역할 | 게임 실행 환경 | 영상 및 상호작용 단말 | 상호작용 진입점 |
| 네트워크 의존성 | 최초 로딩 후에는 기본적으로 오프라인 가능 | 지속적인 연결 필요, 높은 대역폭과 낮은 지연 요구 | 일반적으로 지속적인 연결 필요 |
| 로컬 하드웨어 요구 사항 | 상대적으로 높음 | 상대적으로 낮음 | 모델 배포 방식에 따라 다름 |
| AI 비용 발생 시점 | 개발 단계에 집중 | AI 추론 없음, 클라우드 GPU를 지속적으로 소모 | 플레이할 때마다 지속적인 추론 |
비용 구조가 이 세 가지 경로에서 가장 실제적인 차이예요. Saltline은 AI 비용을 한 번의 개발 과정에 집중시키고, 이후에는 플레이어 기기가 렌더링을 담당하기 때문에 550달러라는 추정 비용이 플레이어 수에 따라 늘어나지 않아요. 반면 클라우드 게임과 월드 모델은 플레이할 때마다 서버 연산 능력을 계속 소모해요.
5 직접 해보기: AI로 웹 3D 장면 생성하고 실행하기
원리를 이해하는 가장 빠른 방법은 직접 한 번 실행해 보는 거예요. 이번 섹션은 세 단계로 나눠요. 먼저 손으로 작성한 절차적 장면을 실행하고, 다음으로 API를 통해 대규모 언어 모델이 단일 파일 게임을 생성하도록 한 뒤, 마지막으로 프레임 시간을 측정해요.
5.1 최소한으로 실행 가능한 Three.js 절차적 장면
아래 파일은 Instancing을 사용해 400개의 컨테이너를 그립니다. 각 컨테이너의 골판 줄무늬와 녹 반점은 모두 Shader가 실시간으로 계산하며, 전체 과정에 이미지 파일은 전혀 없습니다. index.html로 저장한 뒤 같은 디렉터리에서 python3 -m http.server 8000을 실행하고, 브라우저에서 http://localhost:8000을 열면 됩니다.
<!DOCTYPE html>
<html lang="ko">
<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로 구성하고, 겉모습은 Shader로 계산하며, 대량의 반복 오브젝트는 Instancing으로 그립니다. 전체 파일은 몇 KB에 불과하고 Three.js는 CDN에서 불러옵니다. 반면 Saltline은 Three.js를 HTML 안에 직접 번들링했답니다.
5.2 API로 대규모 언어 모델이 단일 파일 3D 게임을 생성하게 하기
Saltline의 생성 과정은 오랜 시간에 걸친 다중 라운드의 에이전트형 프로그래밍으로, 수억 개의 토큰을 소모했어요. 개인 개발자는 우선 한 번의 호출로 시작해서, 모델이 바로 실행 가능한 단일 파일 Three.js 미니 게임을 출력하도록 해 보고 “AI가 코드를 작성하고, 브라우저가 그 코드를 실행한다”는 역할 분담을 경험해 볼 수 있어요. 아래 코드는 OpenAI 호환 인터페이스를 사용하며, 모델 이름은 플랫폼 모델 목록에서 긴 코드 출력을 지원하는 모델로 바꿔 주세요.
import openai
client = openai.OpenAI(
api_key="YOUR_API_KEY",
base_url="https://api.apiyi.com/v1" # APIYI OpenAI 호환 인터페이스
)
resp = client.chat.completions.create(
model="YOUR_MODEL_NAME", # 플랫폼 모델 목록을 기준으로 함
messages=[{"role": "user", "content": "Three.js로 단일 파일 HTML 1인칭 미니 게임을 만들어 줘. 모든 모델과 텍스처는 코드와 셰이더로 생성하고, 완전한 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에서 동일한 API 키로 Claude, GPT, Gemini 등의 모델을 바꿔 가며 사용할 수 있어요. 인터페이스가 OpenAI와 호환이라 위 코드에서
model파라미터만 바꾸면 돼요. 신규 사용자에게는 무료 테스트 크레딧이 제공되니, 짧은 프롬프트로 생성 품질부터 검증해 보기에 좋아요.
5.3 브라우저 3D 게임의 실제 성능 측정하기
1.4MB는 “얼마나 빨리 다운로드되는지”만 알려줬어요. 웹 게임이 제대로 돌아가는지 아닌지를 판단하려면 다음 지표들을 측정해야 해요.
| 지표 | 측정 목적 | 측정 방법 |
|---|---|---|
| 최초 조작 가능 시간 | 시작 경험 | 페이지를 연 시점부터 캐릭터를 조작할 수 있을 때까지 Performance API로 시점 기록 |
| FPS / 프레임 시간 | 부드러움과 안정성 | 60FPS는 프레임당 약 16.67ms에 해당하며, 프레임 시간의 변동에 주목 |
| CPU 점유율 | 게임 로직 부하 | Chrome DevTools Performance 패널에서 메인 스레드 관찰 |
| GPU 점유율과 VRAM | 렌더링 부하 | 운영체제 작업 관리자 또는 그래픽카드 모니터링 도구 |
| 시스템 메모리 | 런타임 자원 | 씬 초기화가 끝난 뒤 브라우저 프로세스 메모리 관찰 |
| 로딩 후 네트워크 트래픽 | 외부 의존성 | DevTools Network 패널에서 폰트, 프로그램 등 요청 구분 |
아래 코드를 브라우저 콘솔에 붙여 넣으면 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 공식 문서는 Web 플랫폼의 제약을 분명히 설명해요. 파일 시스템 접근이 제한되고, 일부 캐시 기능을 사용할 수 없으며, 멀티스레딩은 브라우저 환경의 제약을 받고, 메모리 리소스도 제한적이며, 브라우저마다 호환성도 달라요. Unity의 WebGL 빌드는 주로 데스크톱 브라우저를 대상으로 하며, 모바일 기기 지원은 제한적이에요.
Saltline의 체험 페이지는 이런 제약을 그대로 보여줘요. 페이지에서는 초기화가 느릴 수 있고 시작 속도는 기기 성능에 영향을 받는다고 안내하며, WebGL 2와 하드웨어 가속을 확인해야 하고, 끊길 때는 Low 화질로 전환해야 한다고 권해요. 웹페이지를 여는 문턱은 아주 낮지만, 부드럽게 실행되는 문턱은 여전히 플레이어의 GPU에 달려 있어요.
6.2 1.4MB는 배포가 가볍다는 뜻일 뿐, 실행 부하는 별개예요
절차적 생성은 “다운로드 에셋”을 “런타임 계산 에셋”으로 바꿔요. 텍스처는 GPU에서 픽셀 단위로 실시간 계산되고, 기하학은 초기화 시점에 CPU가 구성하며, 이 모든 작업은 플레이어 기기에서 일어나요. 현재 개발자는 Saltline의 표준 시작 시간, 평균 FPS, VRAM이나 메모리 점유율을 공개하지 않았어요. 실행 부하를 평가하려면 5.3절의 방법으로 직접 측정해야 해요.
6.3 상용 3A 게임의 엔지니어링 규모
상용 3A 게임은 보통 대규모 자금, 인력, 리소스 투자를 의미해요. 이 호칭은 제작 규모를 묘사할 뿐, 통일된 기술 인증 기준은 없어요. 상용 3A 게임 하나에는 수십 시간 분량의 콘텐츠, 복잡한 캐릭터 애니메이션과 물리 시스템, 멀티플레이 네트워크 동기화, 크로스 플랫폼 대응, 수년에 걸친 지속적인 업데이트 유지보수와 테스트 최적화가 필요해요. 절차적 생성은 컨테이너, 지면, 빗물처럼 규칙성이 강한 콘텐츠에 강하지만, 대량의 아트 다듬기가 필요한 캐릭터와 내러티브 장면을 마주할 때는 전통적인 에셋 제작이 여전히 더 적합해요.
6.4 Saltline이 실제로 증명한 것
Saltline이 증명한 것은, 강력한 프로그래밍 능력을 갖춘 AI 모델이 하나의 연속된 생성 과정 안에서 레벨 디자인, 장면 구성, 셰이더, 게임 메커니즘, 조작 로직, 오디오 생성을 통합해 스타일이 온전히 갖춰지고 바로 공유할 수 있는 3D 게임 프로토타입을 만들어낼 수 있다는 점이에요. 전통적인 워크플로우에서는 서로 다른 도구와 직군 사이의 인수인계 비용이 컸지만, 여기서는 그 비용이 하나의 모델 컨텍스트 안으로 압축됐어요.
개발자가 직접 밝힌 데이터와 공개된 공식 모델 가격을 대조하면 이번 실험의 비용 구성을 명확히 볼 수 있어요.
| 항목 | 데이터 | 출처 |
|---|---|---|
| 개발 시간 | 약 8시간 | Felix Rieseberg 본인 진술, 2026-11-09 |
| 추정 비용 | 약 550달러 (API 가격 기준 추정) | Felix Rieseberg 본인 진술 |
| 입력 토큰 | 약 4억 4,500만, 그중 상당량이 캐시 | Felix Rieseberg 본인 진술 |
| 출력 토큰 | 약 270만 | Felix Rieseberg 본인 진술 |
| Fable 5.2 입력 / 출력 가격 | 100만 토큰당 $8 / $40 | Anthropic 공식 모델 문서 |
| Fable 5.2 캐시 읽기 가격 | 100만 토큰당 $0.20 | Anthropic 공식 모델 문서 |
| 컨텍스트 윈도우 / 최대 출력 | 1M 토큰 / 128K 토큰 | Anthropic 공식 모델 문서 |
캐시 읽기 가격은 일반 입력 가격보다 훨씬 낮기 때문에, 4억 4,500만 입력 토큰을 일반 입력 단가로 그대로 환산해 총비용을 계산할 수는 없어요. 개발자가 구체적인 청구서 내역을 공개하지 않았으니, 550달러는 한 번의 생성 실험에 대한 추정 비용으로 이해해야 해요.
💰 비용 조언: AI로 웹 게임을 생성할 때 비용은 개발 단계에 집중되고, 긴 컨텍스트와 여러 차례의 반복 작업이 주요 지출이에요. 본격적인 장기 작업에 들어가기 전에 APIYI apiyi.com을 통해 더 작은 프롬프트로 몇몇 모델의 코드 품질을 먼저 비교해 본 뒤, 어떤 모델에서 장시간 생성을 할지 결정할 수 있어요. 사용량 기반 과금이라 시행착오 비용을 통제하기 쉬워요.
7 자주 묻는 질문 FAQ
Q1: AI가 만든 3A 게임을 웹에서 실행하면, 게임 화면이 서버에서 전송되는 건가요?
Saltline의 화면은 플레이어의 로컬 GPU에서 렌더링돼요. 브라우저가 약 1.4MB의 HTML 파일을 다운로드한 뒤 JavaScript로 게임 로직을 실행하고, WebGL을 통해 로컬 그래픽 카드로 매 프레임을 그려요. 서버에서 화면을 전송하는 방식은 GeForce NOW 같은 클라우드 게이밍이며, 이는 다른 기술 경로예요.
Q2: Saltline을 플레이할 때 실시간으로 Claude 모델을 호출하나요?
아니요. Claude Fable 5.2는 개발 단계에서 게임 코드를 생성할 때만 사용돼요. GitHub 미러에는 Claude Artifact의 프레임워크 스크립트가 이미 제거되어 있어서, 게임은 일반 HTTP 서버로 실행할 수 있고 플레이 과정에서 모델 호출 비용이 발생하지 않아요.
Q3: Saltline과 Genie 3 같은 AI 세계 모델의 차이는 무엇인가요?
Saltline의 규칙과 장면은 는 AI가 미리 코드로 작성해 두고, 실행 시에는 전통적인 렌더링 파이프라인이 처리해요. Genie 3는 플레이어 입력에 따라 프레임 단위로 예측하며 화면을 생성하고, 규칙은 데이터에서 학습돼요. 전자는 AI가 프로그램을 작성하는 방식, 후자는 AI가 화면을 직접 생성하는 방식이며, 두 기술은 서로 독립적이에요.
Q4: 1.4MB짜리 웹 3A 게임은 어떤 사양의 컴퓨터에서 부드럽게 실행되나요?
개발자는 최소 사양과 FPS 데이터를 공개하지 않았어요. 공식 페이지에서는 브라우저가 WebGL 2를 지원하는지 확인하고 하드웨어 가속을 켜 두며, 끊길 때는 Low 화질로 전환하라고 권장해요. 구체적인 성능은 본문 5.3절의 프레임 시간 스크립트로 자신의 기기에서 직접 측정해 보세요.
Q5: API로 비슷한 웹 3D 게임을 직접 생성하려면 어떻게 하나요?
APIYI apiyi.com에서 가입하고 API 키를 발급받은 뒤, 5.2절 코드의 `base_url`을 `https://api.apiyi.com/v1`로 설정하고, 긴 코드 출력에 능한 모델을 선택하세요. 프롬프트에 “단일 파일 HTML, Three.js, 모든 에셋은 코드와 셰이더로 생성”이라고 명확히 요구하세요. 생성한 뒤 로컬 HTTP 서버로 열면 바로 플레이할 수 있어요.
Q6: AI로 브라우저 게임을 생성할 때 어떤 한계가 있나요?
한 번의 호출로 나오는 출력 길이가 제한적이라, 복잡한 게임은 여러 라운드의 긴 컨텍스트 생성이 필요하고 비용도 그만큼 올라가요. 생성된 코드는 성능과 호환성 문제를 디버깅해야 하는 경우가 많아요. 브라우저 자체에도 메모리, 스레드, 모바일 지원 등의 제약이 있어요. 먼저 APIYI apiyi.com을 통해 여러 모델로 소규모 비교를 진행하고, 코드 안정성이 가장 좋은 모델을 골라 프로젝트 규모를 키우는 걸 권장해요.
8 AI 웹 3A 게임 핵심 요점 Key Takeaways
- 실행 위치: Saltline은 플레이어 브라우저에서 실행되고, 로컬 GPU가 렌더링을 담당해요
- 명확한 역할 분담: AI는 개발 단계에서 코드를 작성하고, 브라우저는 실행 단계에서 코드를 실행해요
- 기술 체인: JavaScript가 로직을 담당하고, Three.js가 장면을 구성하며, WebGL이 GPU를 호출해요
- 용량의 비밀: 모델, 텍스처, 사운드가 모두 함수로 작성되어 단일 파일이 약 1.4MB예요
- 작은 파일이라고 가벼운 실행은 아니에요: 절차적 에셋이 다운로드 비용을 런타임 계산 비용으로 바꿔요
- 세 가지 경로: 로컬 웹 실행, 클라우드 게임, AI 월드 모델은 계산 위치가 각기 달라요
- 직접 검증: APIYI apiyi.com을 통해 여러 모델을 호출해 단일 파일 Three.js 게임을 생성하고 실제로 테스트할 수 있어요
9 정리
AI가 만든 3A 스타일 게임이 웹에서 실행될 수 있는 건 브라우저가 이미 갖추고 있던 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 -
설명: Scene, Mesh, ShaderMaterial, InstancedMesh 등 API 설명
-
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 문서 센터에서 확인할 수 있습니다.
