Neural Network Astra Built a Path of Exile Clone Almost Without Humans — the Whole Game Weighs 2 MB
Game designers may want to start worrying: the neural network GPT-6 Astra single-handedly assembled a working clone of Path of Exile — with practically no human help. That's the claim of a video on Rutube: according to its authors, Astra wrote the game on Three.js, moved the models and recreated the scenes in Blender by itself, generated the interface via GPT-Image 2 and even produced a finished trailer. The most impressive part — trees, rocks and monuments are generated procedurally right in the code, so the whole game weighs about 2 MB.
What exactly did Astra do
Per the video's description, the run looked like this:
- Game code. The engine is Three.js: 3D scenes rendered in the browser via JavaScript and WebGL. The model wrote action-RPG gameplay logic — movement, skills, enemies, loot — in the style of Path of Exile.
- 3D content. Astra moved the models and recreated scenes in Blender itself — the popular free 3D editor used by professional studios.
- Procedural assets. Instead of storing finished models of trees, rocks and monuments as files, the network described them with algorithms: geometry "grows" from code at launch.
- Interface. UI elements were drawn by the GPT-Image 2 image generator.
- Marketing. At the end, Astra edited and delivered a finished game trailer.
It's not an isolated case: since Astra's release in early September 2026, users have shown Minecraft and SimCity clones assembled from a single prompt, and developers at CodeRabbit described how the model built the action-RPG NIGHTSHIFT with a 988-node passive skill tree — a direct nod to Path of Exile's famous passive tree.
What is "procedural code for trees" — a detailed breakdown
This is the key trick that squeezes the game into 2 MB. To grasp its scale, let's compare two approaches to 3D graphics.
The usual way: a model is a file
A classic 3D tree model is a file with the coordinates of thousands of vertices, polygons, normals and textures. One "real" artist-made tree easily takes up hundreds of kilobytes to several megabytes. A forest of a thousand such trees is gigabytes of data. That's why ordinary games weigh tens or hundreds of gigabytes: assets eat almost all of that space.
The procedural way: a model is a recipe
Procedural generation flips the logic: instead of storing ready-made geometry, you store an algorithm that builds it on the fly. A tree in code is described by logic roughly like this:
- Start at a point on the ground with an "up" direction.
- Draw a trunk segment of a given length and thickness.
- From the end of the segment, grow 2–4 branches: each shorter and thinner than its parent, turned by a random (but bounded) angle.
- Repeat recursively for 3–5 levels of branching.
- At the branch tips, place "foliage" — a cloud of simple shapes (spheres, planes, particles).
Such a "recipe" takes up tens of lines of code — kilobytes, not megabytes. One algorithm with different parameters grows an oak, a birch and a dry pine: change branching depth, angles, thickness, color and canopy density.
The seed of randomness: why the forest is the same for everyone
The word "random" is misleading here. The generator uses a deterministic pseudo-random number generator with a fixed seed — a starting number. The same seed always grows the same tree on any computer. So the world is "random" but identical for every player: you only need to pass one number instead of gigabytes of models.
L-systems: the genre classic
The mathematical foundation of procedural plants is L-systems (Lindenmayer systems) — a formalism created by biologist Aristid Lindenmayer in 1968 to describe plant growth. The idea: a string of symbols is rewritten by rules ("A → AB", "B → A"), and the result is interpreted as a drawing: symbols mean "draw a segment", "turn", "start a branch", "end a branch". A few rewriting iterations — and a short rule grows a branching structure of any complexity. This principle powers vegetation generators in many engines and tools like CityEngine.
How it renders in Three.js
In the browser engine Three.js, tree segments are usually cylinders between points, and all vegetation is drawn via InstancedMesh: the GPU gets one geometry and a list of offsets, rotations and scales, drawing thousands of trees in a single draw call. Rocks and monuments in this scheme are parametric shapes (distorted cubes, prisms, "wells" of cylinders) whose surfaces are roughened by noise functions — Perlin or simplex noise adds irregularities, chips and weathering. The result reads as a "hand-made" sculpture, but is stored as a formula.
Why the game weighs 2 MB
Code is text, and text compresses tens of times better than finished models and textures. The entire "world" here is compressed into algorithms: launch it — and geometry is built in memory. The principle isn't new: the shooter .kkrieger (2004) fit into 96 KB, and No Man's Sky generates an entire galaxy from seeds. The novelty is different: the recipe for the world is now written by a neural network, not a team of technical artists.
The flip side of procedural generation
The method has weaknesses. "Procedural" worlds often suffer from sameness — trees differ but look noticeably "related". Artistic control is weaker: making exactly what the art director envisioned is harder than editing a finished model. And generation on the fly costs CPU resources at load time. That's why big games combine procedural generation with hand-made assets — while for a prototype assembled by AI, pure code turned out to be the perfect solution.
Has GPT-6 killed game design as a profession?
The video's headline is provocative, and the numbers command respect: code, models, scenes, interface and trailer — all made by one model. But look at the experience of the same NIGHTSHIFT developers: there, people spent months giving Astra feedback and steering the balancing of seven classes, skills, runes and 40 zones. Balance — "making it fun to play" — turned out to be the hardest creative task, and the model doesn't fully hand it over yet.
The human role seems to be changing: from "the one who writes code and places objects" to "the one who sets the task, checks the result and is responsible for the player's experience". Game design as a handcraft trade is indeed under attack. Game design as task-setting and taste — not yet. And the 2 MB Path of Exile clone is a perfect illustration of the shift: content creation speed has grown by orders of magnitude, and the most expensive resource in gamedev becomes the idea again.
Video
The author's video about assembling the Path of Exile clone with Astra:
FAQ
What is GPT-6 Astra? OpenAI's agentic model, unveiled in September 2026: it works with the computer and browser, writes and debugs code, and completes long multi-step tasks with high autonomy.
Why Three.js for the game? It's a popular library for 3D in the browser: no installer or game engine needed — the game runs on any page, and the network writes JavaScript extremely well.
What does procedural generation give you? Content from formulas instead of files: tiny size, endless variety from one algorithm, and reproducibility by seed. The downsides are sameness and weaker artistic control.
Does this mean games will now be made without people? More likely, people will make them differently: task-setting, result verification, balance and the final "polish pass" remain human work for now.
This material was prepared based on the Rutube video and public developer reports about working with GPT-6 Astra (September 2026).