Introduction

Blocksfield is a new open-source pipeline that turns a one-line pitch into a playable Roblox place, with every model running locally on a single RTX 5090. The MIT-licensed repo went public on October 30 at about 23:22 MYT as an entry in Comfy's Open Source Higgsfield challenge, the contest that drew a cease and desist from Higgsfield earlier this week. Its builders

with a short pitch: "One prompt → a playable Roblox game, built in Studio by a local 27B model that checks its own work."

What you get back isn't a hosted web demo. It's a saved .rbxlx place you open in Roblox Studio, press Play on, and publish, plus a thumbnail, an icon and a scored gameplay trailer.

What shipped

  • Tool: Blocksfield, plus its build harness cybus-harness (branch blocksfield) and a Roblox Studio bridge
  • Builder: GitHub user Hcoder10, posting as SquaredCube on X
  • Modality: full game generation (Luau code, levels, UI), plus image, text-to-3D props, music, sound effects and image-to-video trailers
  • Open vs API: open source (MIT) with open-weight models only. No cloud credits
  • Where to run it today: a Linux box with one 32 GB GPU (the team uses a rented RTX 5090), plus Roblox Studio on Windows or Mac. They can be the same machine
  • Concrete fact: setup pulls about 106 GB of open weights, and a GPU "arbiter" time-slices the card between the LLM and ComfyUI

The model stack

According to the README, every role runs on open weights:

  • Game design, Luau code and vision judge: Qwen3.8-27B NVFP4 on vLLM, in sleep mode
  • Concept art, UI art, icons and thumbnail: Qwen-Image-2.1 turbo int8 with BiRefNet cutouts, in ComfyUI
  • 3D props: TRELLIS.2, decimated under Roblox's 20k-triangle limit
  • Procedural props: Idol turns an image into a Gaussian splat, and splat_to_parts.py clusters it into Roblox Parts as an editable Luau module
  • Trailer: LTX-2.5 distilled NVFP4 image-to-video at 720p
  • Music and SFX: ACE-Step 1.5 turbo and Stable Audio 3 small-sfx

The trick that makes it fit on one card is the arbiter. When ComfyUI needs the GPU for an art job, the 27B model sleeps to host RAM, the workflows run, and then the LLM wakes again. A live dashboard on port 8100 shows which model holds the card at any moment.

How a build works

The model doesn't blindly write a script that builds the world at runtime. It builds real instances in Studio's edit mode, then plays the game and looks at it from the player's view, an overview, a side view and a top-down view. It gets runtime errors and a judge's score against its own generated concept art, and keeps repairing until the result reads right. The harness runs plan, style guide, architecture, build, capture, judge, repair and polish stages, with five critics in the final pass.

The other half is a library of Studio-tested kits. The README is candid that a local 27B model "can't write a vehicle controller, an animated HUD or a lighting rig to the standard of a top Roblox game," but it composes well-made parts reliably. So the model picks and tunes kits instead:

  • LookKit offers one-call art direction presets like toon_bright, neon_night, dark_fantasy and candy
  • LevelKit and WorldKit build dressed, gameplay-tagged levels, with 12 biomes and 63 stylized prop kinds
  • ControllerKit covers platformer, top-down, shooter and arcade-vehicle feel profiles
  • GameplayKit adds rounds, health, NPC AI with waves, crafting, inventory and races
  • UIKit and FXKit provide about 25 themed UI components and 51 VFX presets

Run it

On the GPU box, the README's setup is:

git clone https://github.com/Hcoder10/blocksfield /root/blocksfield && cd /root/blocksfield
bash deploy/box_setup.sh all
bash deploy/start_servers.sh all

Then, on the Studio machine, with the bridge running and cybus-harness cloned next to the repo:

python -m blocksfield.run --check
python -m blocksfield.run "A neon obby tower in the clouds with laser gates and checkpoints" --id neon_obby
python -m blocksfield.marketing runs/neon_obby

The finished place lands in runs/<id>/place/final.rbxlx. If you don't have a GPU, open examples/starbloom_peaks.rbxlx in Studio and press Play. That's the game from the demo video, as the pipeline built it. The eight ComfyUI workflows in workflows/api/ also stand on their own, so you can drag the TRELLIS.2 prop or splat-to-parts graphs into your own canvas.

The honest notes

The README doesn't oversell it. Where a build's own code crashed on a one-line bug the repair rounds missed, the team fixed that line by hand and logged it in OPERATOR_NOTES.md. Left free in Studio, the 27B model "fogged the world, graded everything orange" and wiped its world every round, so the tools now hard-refuse those moves. Prompt advice alone didn't stop it.

Check licenses before you ship anything. The repo is MIT, but Qwen-Image-2.1 is research-only, and LTX-2.5 and Stable Audio 3 use community licenses.

Why it matters

Most prompt-to-game demos stop at a hosted HTML toy. Blocksfield targets a real platform, keeps every model on your own hardware, and closes the loop by making the model play and judge what it built. It's a day-one hackathon release with zero stars so far, but the arbiter and kit approach is a pattern any studio running local models can borrow.

—Titus