How To Build A Game With GPT-6 Astra in 2026

GPT-6 Astra can take a written game idea and code it into a playable 3D browser game, writing and debugging its systems along the way.

However, the art and sound still need generative models behind them, and fal is the best place to get them, since our plugin puts over 1,000 models inside the same ChatGPT chat where GPT-6 Astra writes the code.

In this guide, I take Velvet Rope, a third-person museum heist, from a written brief to a playable build, using prompts you can paste straight into GPT-6 Astra's chat window.

TL;DR

GPT-6 Astra can build a playable 3D browser game inside ChatGPT, writing and debugging the code from a written brief.

The fal plugin gives GPT-6 Astra over 1,000 generative media models in the same chat, covering characters, props, textures, and sound without extra software.

My checkpoint plays offline from a single 26 MB HTML file, with Nightjar and the drones in final form alongside two of the five artifacts.

Can you actually build a game with GPT-6 Astra?

Yes, you can build a playable game with GPT-6 Astra through any of five routes creators already use, which differ mainly in where the assets come from.

OpenAI makes GPT-6 Astra available in ChatGPT and through the Responses API under the model name gpt-6-astra.

The simplest route keeps everything in code, the way OpenAI's Hollowflux demo draws its caves and characters without a single imported sprite sheet.

OpenAI's Void Explorer build added image generation on top, using generated concepts to settle the game's look before much of the code existed.

The same project had GPT-6 Astra model the player ship in Blender, which is the third route for anyone with Blender installed.

Creators have also linked GPT-6 Astra to Unreal Engine 5 over MCP and pulled engine asset packs into their scenes, while other engine builds have added audio through a separate provider key.

The fifth route, and the one this guide follows, connects the fal plugin so GPT-6 Astra can call GPT Image 2.5 Flare, Meshy 7.1, and the rest of fal's catalog of over 1,000 models from the same chat.

The table below compares the five routes on what each one needs and produces.

Velvet Rope, the game I'm about to show you, combines two of these routes, pairing a code-only foundation with fal for the generated assets.

💡 I'd say that fal is the best fit when a browser game needs finished characters and sound without a 3D app or an engine on your machine, since a single plugin covers every asset type Velvet Rope needs at fal's standard model rates.

What does GPT-6 Astra do in a fal game build?

In a fal game build, GPT-6 Astra writes the game's code and orders its assets from fal, while you approve the art and judge how the game plays.

The table below shows who owns each part of Velvet Rope:

fal plays no part in the game loop or in hosting, and with all generated files shipped inside the project, a round of Velvet Rope makes zero calls to fal.

Why use the fal plugin for GPT-6 Astra game builds?

The fal plugin gives GPT-6 Astra over 1,000 generative media models inside the same ChatGPT chat where the game code gets written, which keeps the whole build in one conversation.

For Velvet Rope, GPT-6 Astra can order Nightjar's concept art, the rigged mesh, the gallery paintings, and the alarm sound without switching accounts or handling API keys.

Meshy 7.1 turns one approved concept into a rigged, animated GLB file that Three.js loads directly.

After a one-time authorization inside ChatGPT, you never paste a fal key into the chat.

The finished game needs no key in its source either, because it makes no calls to fal.

Beyond the model runs themselves, which bill at fal's standard rates, the connection adds no fee of its own on top of your fal usage.

The fal setup is one plugin install from the ChatGPT apps directory, then an authorization step that links your fal account to GPT-6 Astra.

After the authorization step, all you need to do is pick GPT-6 Astra in ChatGPT's model picker before you paste the first prompt.

If you type a request to connect fal straight into ChatGPT, the fal listing comes up without a trip through the directory menus.

Before starting the build, you can ask GPT-6 Astra to list the fal tools it can see, which confirms the connection works.

The fal connection does not grant access to GPT-6 Astra itself, which depends on what your ChatGPT account includes.

New fal accounts start with zero credits, so top up at least $1 before the asset steps.

What is Velvet Rope, the game built in this guide?

Velvet Rope is a third-person stealth game set after closing time in the east wing of the Veradine Museum, a fictional gallery invented for this guide.

You play Nightjar, a clockwork cat burglar who has 90 seconds to lift five artifacts from their plinths and climb out through the rotunda skylight while three security drones sweep the galleries with cones of light.

I picked a heist because one enclosed museum wing keeps the camera indoors, away from open terrain and long draw distances.

GPT-6 Astra programs the stealth from scratch as vision cones and line-of-sight checks, a demanding test for any coding model.

The artifacts and the planned gallery paintings give fal's image and 3D models work the player sees throughout the round.

At those rates, uninterrupted exposure ends the round in about 3.1 seconds, or 6.25 seconds while sneaking.

Drone coverage renders as translucent amber volumes that turn red the moment a drone spots Nightjar.

The art direction called for deep teal gallery walls with brass details under cool moonlight from the rotunda skylight.

Step 1: Brief GPT-6 Astra and write the asset manifest

Before any fal call, the first prompt has GPT-6 Astra build a graybox version of Velvet Rope from the full rules and write an asset manifest.

All the prompts in this guide go into GPT-6 Astra's chat in ChatGPT while fal runs behind the plugin.

Art direction can wait until the character step, since GPT-6 Astra needs exact numbers such as cone angles and the 90 second timer to test the rules first.

GPT-6 Astra writes the asset manifest in this step as a short JSON file, giving each asset one entry for its file name, source endpoint, format, in-game size, budget, and pivot.

In my build, that manifest caught a Nightjar texture twice the planned size and a fox mask 7.3 percent over its polygon target.

Nothing in the Meshy 7.1 schema stops a 300,000-polygon target, yet the manifest flags a browser prop that heavy before the file reaches the scene.

A simplified Nightjar entry looks like this, with the tolerance and texture limit that GPT-6 Astra added during the build.

{
  "id": "nightjar",
  "file": "nightjar_rigged.glb",
  "folder": "assets",
  "source": "meshy/v7.1/image-to-3d",
  "height_m": 1.75,
  "target_polygons": 20000,
  "tolerance_pct": 5,
  "max_texture_px": 2048,
  "pivot": "feet",
  "clips": ["idle", "walking", "running"]
}

The table below shows the manifest as it stood at the end of my build, including the assets still waiting to be generated.

💡 I'll name exact fal endpoints throughout this guide so you can reproduce the build. You can also let GPT-6 Astra pick models from the fal catalog against your own criteria.

The prompts that open a new generation step also tell GPT-6 Astra to confirm schemas and prices before any call, since both change over time.

You are the lead developer on a small 3D browser game called Velvet Rope.

THE PITCH
Nightjar, a clockwork cat burglar, slips into the east wing of the
fictional Veradine Museum after closing. Nightjar has 90 seconds to lift
five artifacts from their plinths and climb out through the rotunda
skylight while three security drones sweep the galleries with cones of
light.

RULES
1. WASD or arrow keys move Nightjar relative to the camera. Dragging the
   mouse orbits the camera. Holding Shift sneaks at half speed.
2. E lifts an artifact when Nightjar is within 1.5 meters of it.
3. Each drone flies a looping patrol and casts a 60 degree vision cone
   with a 9 meter reach. Walls and pillars block the cone.
4. A detection meter fills while Nightjar stands in an unblocked cone
   and drains outside it. Sneaking halves the fill rate. A full meter
   ends the round as Caught.
5. The skylight rope unlocks after the fifth artifact. Reaching it wins.
6. When the timer runs out, the round ends as Closing Time.
7. Add a start screen and an end screen with a restart button. The HUD
   tracks the artifact count and the detection meter, with the timer at
   the top of the screen. Draw all UI text in code.

TECHNICAL DIRECTION
Use Three.js in a single browser project, and propose the file structure
before you write code. Nightjar collides as a capsule defined in code.
Drones, walls, pillars, and plinths get simple colliders defined in code
as well. No generated mesh ever decides a collision.

BEFORE ANY ART EXISTS
1. Write assets.manifest.json with one entry per asset: file name, fal
   endpoint, format, in-game size in meters, polygon or pixel budget,
   and pivot point.
2. Build the whole game from untextured shapes, with translucent meshes
   standing in for the vision cones.
3. Run the graybox and prove that each end state is reachable. Check
   that cones stop at walls, that sneaking slows detection, and that
   diagonal movement matches straight movement in speed. Confirm that
   hiding the tab pauses the timer and the drones together, that nothing
   spawns inside a cone or a collider, and that restart restores the
   opening state.
4. Send me the run instructions with a short report of what you tested.

Do not call fal in this step. Finish when a graybox round can end in a
win or a loss and restart cleanly, with the manifest saved in the
project.

Step 2: Check the graybox before any art is added

A GPT-6 Astra graybox should pass six checks before any art is added, covering occlusion, sneaking, movement speed, pausing, spawns, and restarts.

Velvet Rope should be winnable as a graybox, the whole game in untextured shapes, before GPT-6 Astra touches fal.

The first check is occlusion, since a drone should lose sight of Nightjar behind every pillar from whichever side you approach.

The detection meter should visibly slow down whenever Shift is held, and diagonal movement should match straight movement in speed so nobody gains ground by running at an angle.

When the browser tab is hidden, the timer and the drones should pause together.

Spawn points get their own pass, with Nightjar kept out of every cone at the start and no artifact overlapping a plinth collider.

A restart should return the whole wing to its opening state, drone positions included.

My graybox shipped with 23 automated tests, a suite that grew to 35 as later steps added animation and asset checks.

GPT-6 Astra's environment had no Chromium for browser tests, so it verified the game in code and with CPU inspection renders while I ran the live playtests myself.

Step 3: Rig Nightjar from a single concept image

A standard mesh with textures on, a 20,000 polygon target, A-pose, auto-rigging at the character's height, and the Idle animation preset turn a GPT Image 2.5 Flare concept into a rigged game character in Meshy 7.1.

According to the Meshy 7.1 schema, auto-rigging gives the best results on humanoid characters with clearly defined limbs, so the concept shows Nightjar in an A-pose with the arms held clear of the body.

A four-legged or winged hero falls outside that design and would need code-driven motion or a separate animation approach.

GPT Image 2.5 Flare takes explicit sizes whose sides are multiples of 16, up to 3840 pixels on the long edge.

A 1024 by 1536 portrait on a transparent background clears the required range of 655,360 to 8,294,400 total pixels with room to spare and keeps the concept limited to Nightjar alone.

The graybox is approved. Now cast Nightjar.

Use fal for this step. Before each call, check the endpoint's current
schema and price and tell me the expected cost.

1. Generate one concept with openai/gpt-image-2.5/flare/text-to-image.
   Nightjar is a slender clockwork automaton, about 1.75 meters tall,
   built from blackened steel with polished brass joints. A narrow
   porcelain face plate carries two amber lens eyes. A charcoal cloth
   hood with stitched cat-ear seams falls over the shoulders, and a coil
   of silk rope hangs from the belt. Show the full body from the front
   in an A-pose, arms held clear of the torso, feet slightly apart.
   Light it with soft, even studio light and no cast shadow. Use 1024 by
   1536, a transparent background, PNG output, and high quality.
2. Show me the concept and wait for my approval.
3. Send the approved image to meshy/v7.1/image-to-3d with the standard
   mesh type, textures on, a 20,000 polygon target, A-pose, auto-rigging
   at 1.75 meters, and animation preset 0 for idle.
4. Download the rigged GLB, the walking and running clips, and the
   idle animation file into the assets folder. Check the polygon count
   and height against the manifest entry, and inspect the skeleton and
   clip names before writing any loader code.
5. Replace the capsule's visual with Nightjar at the manifest scale and
   keep the capsule collider exactly as it is. Use the idle clip when
   Nightjar stands still and the walking clip while sneaking. Switch to
   the running clip at full speed.

Reject the model if the hands fuse to the hips or the feet float above
the floor at rest.

Generated using GPT Image 2.5 Flare on fal, an AI model from OpenAI.

Item 3 in that prompt maps to this Meshy 7.1 request, taken from the settings GPT-6 Astra recorded for both attempts.

{
  "image_url": "APPROVED_NIGHTJAR_CONCEPT_URL",
  "model_type": "standard",
  "topology": "triangle",
  "target_polycount": 20000,
  "should_remesh": true,
  "pose_mode": "a-pose",
  "should_texture": true,
  "enable_rigging": true,
  "rigging_height_meters": 1.75,
  "enable_animation": true,
  "animation_action_id": 0
}

With rigging on, Meshy 7.1 returns rigged_character_glb together with basic_animations, the field that holds the walking and running clips.

The Idle preset arrives separately as animation_glb, which only appears when enable_animation is on.

Preset 0 is the Idle entry in an animation library that accepts IDs from 0 to 696.

Each attempt cost $1.52 at fal's listed rates, made up of $1.20 for the textured model and $0.32 for rigging with the idle preset.

Both attempts came back 1.75 meters tall with a 24-joint humanoid rig and hands clear of the hips.

Meshy 7.1 returned the bind pose as a T-pose, even with pose_mode set to A-pose in the request.

GPT-6 Astra still rejected both attempts, because the Idle clip lifted Nightjar's feet off the floor.

My rule said to reject floating feet without giving a threshold, so a 0.75 cm gap failed the same way a 10 cm gap would have.

Both attempts lifted the feet in the same way, so I treated the gap as an animation offset and approved attempt 02 with numeric rules and a disclosed fix in code.

Thanks for stopping after two attempts. I'm approving attempt 02 with
three explicit changes to the rules.

1. The 20,000 polygon figure is a target with a 5 percent tolerance,
   so 20,731 triangles passes. Record the tolerance in the manifest
   entry.
2. Nightjar keeps its 2048 base-color texture as the hero asset. Props
   stay at 1024.
3. Ground the clips in code and disclose it. For the idle clip,
   re-ground Nightjar's visual root every frame so the lower sole
   touches y=0. For the walking and running clips, apply one constant
   vertical offset per clip, measured from the lowest sole point across
   the cycle. Leave the capsule collider untouched, and keep the
   downloaded files exactly as they are.

Then re-run your sole measurements on all three clips and log each
offset in the manifest. Idle passes if neither sole rises more than
2 cm above the floor at any sample. Walking and running pass if the
contact frames touch y=0 within 1 cm, and flag any foot sliding you
can measure.

If attempt 02 passes, finish item 5 from my previous message: swap the
capsule's visual for Nightjar and switch between idle, walking, and
running. Send inspection renders of each clip from the gameplay camera
angle, and I'll playtest it in the browser myself.

The upward offsets mean the walking and running clips had pushed the feet slightly into the floor before the fix.

With the capsule collider and the downloaded files untouched, 27 tests passed once Nightjar replaced the capsule's visual.

The capsule measures 0.32 meters in radius and 1.5 meters tall, so the hood seams and the coil of rope never widen the hitbox.

Generated using Meshy 7.1 on fal, an AI model from Meshy.

Step 4: Report foot sliding as one measured bug

A good fix request gives GPT-6 Astra one measured symptom and a numeric pass condition, with every other rule frozen.

Frozen rules stop GPT-6 Astra from solving a bug by quietly changing the game around it.

Foot sliding was the real defect in my build, with Nightjar's planted feet drifting 8.56 cm per walking contact and 2.06 cm while running.

The drift came from a speed mismatch, since the walking clip's planted foot swept backward at 1.56 m/s while the game moves a sneaking Nightjar at 2.4 m/s.

Nice work. One fix before the props, and nothing else changes.

The walking clip slides 8.56 cm during contact and running slides
2.06 cm. Match each clip's playback rate to Nightjar's actual ground
speed. Measure how far a planted foot sweeps per cycle in each clip,
then set the clip's time scale so that stride speed equals the movement
speed from the rules, at half speed while sneaking and full speed while
running. Crossfade between the idle, walking, and running clips over
about 0.2 seconds so the switches don't pop.

Leave movement speed and the capsule collider untouched, and keep the
grounding offsets as they are. Walking and running pass if sole travel
stays under 2 cm during contact. Report the before and after values
with fresh inspection sheets.

Both clips passed the 2 cm limit with the crossfades in place, bringing the automated suite to 30 passing tests.

GPT-6 Astra noted that the measurements cover steady walking and running and make no claim about foot locking during crossfades or turns.

Generated using Meshy 7.1 on fal, an AI model from Meshy.

Step 5: Cast the drone and artifacts in Nightjar's style

All six prop concepts passed my approval after GPT Image 2.5 Flare's edit endpoint used the approved Nightjar concept as their reference.

The edit endpoint is consistent, with referenced subjects holding their identity through repeated edits.

One edit request accepts up to 16 reference images, enough room for a palette card or a second angle of Nightjar alongside the main concept.

Meshy 7.1 then converts each concept in Smart Topology mode, which the schema describes as producing clean, natively separated parts capped at 15,000 polygons.

I keep these budgets small, as all six props share the scene with Nightjar.

A faint amber rim light, added in code, separates each artifact from the dark walls so the player can spot it from across a gallery.

For a hero prop that needs accurate sides and a believable back, meshy/v7.1/multi-image-to-3d takes up to four views of one object.

The multi-image endpoint bills at the same listed rates as the single-image one, although its schema has no Smart Topology mode and tops out at 2K geometry.

Nightjar had come back with 2048 pixel textures and 3 to 4 percent over its polygon target, so this prompt builds in a tolerance and a downscaled texture copy from the start.

Nightjar is in the game. Now build the supporting cast in Nightjar's
visual language. Before each call, check the endpoint's current schema
and price and tell me the expected cost.

1. For each concept, call openai/gpt-image-2.5/flare/edit with the
   approved Nightjar concept in image_urls as a style reference, and
   match its materials and lighting. Show one object per image,
   centered, with the whole silhouette in frame, on a transparent
   background at 1024 by 1024.

   The drone is a museum security drone shaped like an antique brass
   lantern and lifted by four ducted rotors, with a thin cyan status
   ring around its smoked glass lens.

   Each of the five artifacts needs a shape a player can recognize from
   across a room.
   a. a jade astrolabe on a small walnut stand
   b. a porcelain fox mask repaired with seams of gold
   c. an obsidian hourglass inside a silver cage
   d. a clockwork songbird on a brass perch
   e. a bronze scarab with two ruby eyes

2. Show me all six concepts together. Regenerate any that drift from
   Nightjar's style.
3. Convert each approved concept with meshy/v7.1/image-to-3d in smart
   topology mode with textures on. Target 6,000 polygons for the drone
   and 4,000 for each artifact, with symmetry turned on for the drone.
   A polygon count within 5 percent of its target passes.
4. If a texture comes back larger than 1024 pixels per edge, keep the
   original and write a downscaled 1024 copy for the game.
5. Check every mesh against its manifest entry, then scale it to the
   manifest and set each pivot at its base. Give each artifact a faint
   amber rim light in code so it reads against the dark walls. In code,
   make the drone bob gently and turn toward its next waypoint.

Reject a prop only if its silhouette is unreadable in an inspection
render from the gameplay camera, or if its polygon count misses the
target by more than 5 percent. Stop after two failed attempts on the
same prop and report back. Keep every collider exactly as it was in the
graybox.

Generated using GPT Image 2.5 Flare and Meshy 7.1 on fal, an AI model from OpenAI.

Smart Topology counts came in 1.2, 4.7, and 7.3% over target, so the fox mask at 4,292 triangles missed the 5% limit.

The follow-up below widened the prop tolerance to 10% while Nightjar kept its separate 5% rule.

Good checkpoint. I'm confirming the remaining work with one rule change.

1. Smart Topology counts are landing up to 7.3 percent over target:
   the drone came back 1.2 percent over, the astrolabe 4.7 percent, and
   the fox 7.3 percent. Widen the Smart Topology tolerance to 10 percent
   and record the reason in the manifest.
2. Re-inspect fox attempt 01 under that tolerance. If its silhouette
   reads clearly in the gameplay inspection render, accept it, write the
   1024 texture copy, and install it on its plinth. No new generation
   for the fox.
3. Resubmit the hourglass once. If the approval review rejects it
   again, stop and show me the full text of the reason exactly as
   returned.
4. Generate the songbird and the scarab with the same settings as the
   accepted props.
5. PBR maps were on for the first three props, although my brief only
   asked for textures. Keep PBR on for the rest so the cast matches,
   and confirm from the request records whether PBR changed the charge.

I approve up to $3.60 for the hourglass, songbird, and scarab. Leave
the colliders and Nightjar untouched, along with the props already
installed, and send me the inspection sheets for each new prop.

GPT-6 Astra accepted the fox without a new generation and fitted the artifacts to their manifest heights, 0.40 meters for the astrolabe and 0.70 meters for the fox mask.

The drone went in at about 0.80 meters across, bobbing 4.5 cm on the simulation clock while its cone and collider follow the original patrol path.

GPT-6 Astra had enabled PBR maps on the props without being asked, though fal's Meshy 7.1 pricing lists no separate PBR charge.

When an automatic approval review in ChatGPT blocked the hourglass call twice, GPT-6 Astra stopped and returned the review's full text without trying a workaround.

The second rejection asked for the reason behind the first block before allowing any retry.

A prompt that tells GPT-6 Astra to record the full reason for any blocked call avoids that loop.

Step 6: Package the game for sharing

My checkpoint became shareable once GPT-6 Astra packaged it as a single 26 MB HTML file that plays offline with a double-click.

I want to see and play the game now, without installing anything.

Package the current checkpoint as one self-contained HTML file that
opens by double-clicking, with no server and no npm. Embed the
JavaScript, the GLB models, and the textures directly in the file.
Keep the graybox stand-ins for the hourglass, songbird, and scarab, and
change nothing about the gameplay, Nightjar, or the installed props.

If this chat can preview or host the game, open it here or publish it
and give me a link as well.

Then list the controls.

The file embeds nine JavaScript modules and seven GLB files and unpacks them in memory, needing neither a server nor a fal account at runtime.

A desktop browser with WebGL 2 and the DecompressionStream API runs it, with a keyboard and mouse as the intended controls.

GPT-6 Astra also published a private hosted copy through the Sites plugin, which asked me to sign in.

A player and developer guide came with the build, covering everything from the controls to the rebuild steps.

GPT-6 Astra's own checks ran in Node with WebGL stubbed, so the double-click playtest in a real browser was mine.

How much does it cost to build a game with GPT-6 Astra on fal?

My checkpoint cost about $7.00 at fal's listed rates across 12 model calls, and three more Meshy 7.1 calls would finish the cast.

The Meshy 7.1 calls make up $6.64 of the checkpoint, including $1.52 for the first Nightjar attempt that stayed rejected.

Models for the hourglass, songbird, and scarab would add three Meshy 7.1 calls at $1.20 each, bringing the complete game to about $10.60 at listed rates.

GPT Image 2.5 Flare bills image tokens at $8.00 per 1M input and $30.00 per 1M output, and text tokens at $5.00 per 1M input and $10.00 per 1M output.

Quality moves Flare pricing sharply, as fal lists a 1024 by 1536 image at $0.01029 on medium against $0.04116 on high.

Early concept rounds can run at medium quality, with high saved for the versions that go into the game.

The listed Flare prices rise with longer prompts and more complex requests, and the edit figures assume one input image per request.

These totals leave out any further retries, as well as your ChatGPT plan.

Recently Added

new

meshy/v6-lite/retexture

Meshy 6 Lite retexture applies new textures to an existing 3D model from a text prompt or a reference image, with optional PBR maps.

3d

textures

pbr

3d-to-3d

new

google/nano-banana-2.1

Nano Banana 2.1 by Google generates images from text prompts, with output resolutions up to 4K, adjustable aspect ratios, and optional web search grounding.

image generation

photorealism

typography

text-to-image

new

google/nano-banana-2.1/edit

Nano Banana 2.1 Edit by Google transforms reference images using text instructions, with output resolutions up to 4K and optional video, audio, or PDF context.

image editing

image to image

photorealism

image-to-image

new

kandinsky6-vsr/lite

Kandinsky 6.0 VSR Lite is a fast, lightweight video super-resolution model for quick, cost-efficient upscaling.

upscale

video-to-video

new

kandinsky6-vsr

Kandinsky 6.0 VSR is a video super-resolution model that upscales and enhances videos with sharper detail and stable, flicker-free frames.

upscale

video-to-video

new

kandinsky6-pro/text-to-video

Kandinsky 6.0 Pro is Kandinsky Lab's flagship text-to-video model, generating high-resolution clips with cinematic motion and precise prompt adherence.

kandinsky

lightweight

text-to-video

new

kandinsky6-pro/image-to-video

Kandinsky 6.0 Pro turns a start frame into a high-resolution, cinematic video clip with controllable motion and strong visual fidelity.

kandinsky

lightweight

image-to-video

new

kandinsky6-lite/image-to-video

Kandinsky 6.0 Lite animates a single image into a short video clip, with fast, lightweight inference and prompt-guided motion.

kandinsky

lightweight

image-to-video

new

kandinsky6-lite/text-to-video

Kandinsky 6.0 Lite is a lightweight, high-speed text-to-video model from Kandinsky Lab, built for fast, efficient generation with strong prompt adherence.

kandinsky

lightweight

text-to-video

new

marigold-v2

Estimate depth from a single image with Marigold V2, a diffusion-based depth model built on Qwen-Image-Edit, returning a colorized depth map.

depth

utility

image-to-image

new

minimax/h3-max-turbo/extend-video

Extend an existing video with H3 Max Turbo: add 1 to 15 seconds of prompt-guided footage, with optional audio references and output resolutions from 480p to 2K.

extend

video

continuation

video-to-video

new

minimax/h3-max/recast

Recast the people in a video using reference photos with H3 Max, while preserving the source motion, camera, cuts, and audio.

video-editing

character-replacement

video-to-video

new

xai/grok-imagine-video/v1.5/lite/image-to-video

Generate videos from images using xAI's Grok Imagine Video 1.5 Lite model.

image-to-video

new

xai/grok-imagine-video/v1.5/lite/text-to-video

Generate videos from text prompts using xAI's Grok Imagine Video 1.5 Lite model.

text-to-video

new

blackforestlabs/flux-3/text-to-image

FLUX 3 Image is Black Forest Labs' newest image model. Generate detailed, well-composed images in native 2K and 4K with precise layout control and improved text rendering.

flux-3-image

black-forest-labs

typography

text-to-image

new

blackforestlabs/flux-3/edit-image

FLUX 3 Image Edit from Black Forest Labs makes precise local edits without changing the rest of the image, and combines up to 10 references into one balanced, well-composed result.

flux-3-image

black-forest-labs

multi-reference

image-to-image

new

ideogram/v4.5/edit

Edit images with Ideogram 4.5: prompt edits with up to 4 reference images, optional mask, and a high-precision mode that keeps unchanged pixels intact.

realism

typography

editing

image-to-image

new

ideogram/v4.5

Generate high-quality images, posters, and logos with Ideogram 4.5, with accurate text rendering and low, medium, or high quality tiers.

realism

typography

stylized

text-to-image

new

pixelcut/looping-video

Turn one product photo into a seamless 5 to 15 second video loop with a locked camera, subtle ambient motion or a full 360° spin.

looping

e-commerce

product

image-to-video

new

veed/clean-audio

Studio-quality speech from noisy recordings

speech enhancement

noise reduction

audio denoise

audio-to-audio

Your first GPT-6 Astra game on fal

A first 3D build stays manageable when the graybox is proven before any model call.

Once the fal plugin is installed and GPT-6 Astra is selected, paste the first prompt with your own game idea in place of the museum.

A haunted lighthouse or an orbital greenhouse would follow the same steps, since a new setting changes the prompts and leaves the structure intact.

A fal account costs nothing to create, and after a top-up you pay only for the models you run.

Check out fal to get started.

Frequently asked questions

Which 3D file format works best for a browser game?

GLB works best for a Three.js browser game, as it packs a mesh and its textures into one binary glTF file, animation clips included, that Three.js loads with GLTFLoader.

Meshy 7.1 returns a GLB for any model it generates on fal, leaving no conversion step between the endpoint and the scene.

Can a Meshy 7.1 character move into another engine later?

Yes, Meshy 7.1 on fal returns FBX and OBJ files alongside the GLB, including a rigged FBX whenever auto-rigging is on.

A desktop engine can pick up Nightjar once the browser prototype proves the idea.

Does the same GPT-6 Astra and fal workflow work for a 2D game?

Yes, a 2D game follows the same graybox-first, manifest-driven pattern, with Meshy 7.1 dropped from the pipeline.

GPT Image 2.5 Flare's transparent background setting suits sprite work, and GPT-6 Astra should confirm each file's alpha channel before loading it into a Canvas game.

What should you do when a generated asset fails its manifest check?

Scale and pivot problems can be fixed in code, while a wrong silhouette or the wrong materials call for a new concept image.

Meshy 7.1 builds the mesh from what the concept shows, which puts a corrected concept image ahead of any regenerated mesh.