Dream Studio: AI Game Creation for Everyone

An AI-powered browser editor that turns natural l language into playable worlds.

Comment

Inspiration

Someone can spend years playing games and quietly designing their own worlds in their head.

They know the streets they want to drive through, the side quests, characters, weather, jokes, missions, enemies, and the feeling they want players to experience. They know what should happen when someone opens a door, speaks to an NPC, misses a jump, solves a puzzle, earns money, or completes the final challenge.

But then they open a professional game engine, and the idea often dies at the first blank project screen.

Before there is a playable prototype, there are barriers:

  • Programming
  • 3D modelling
  • Animation
  • Physics
  • Asset importing
  • Camera systems
  • Debugging
  • File organisation
  • Expensive software and assets
  • Powerful hardware
  • Production planning
  • Team coordination

The first lesson is not creativity. It is setup friction.

This happens to lifelong players who want to build their dream game, storytellers with no programming experience, students experimenting with interactive media, teachers creating playable lessons, and solo creators who cannot afford a complete development team.

The bottleneck is not imagination.

The bottleneck is the translation layer between a human idea and an editable, inspectable, playable artifact.

Morphus & Dream Studio was built to become that translation layer.

It is a browser-based AI game-creation environment where creators can describe an idea, generate editable 3D scenes or browser games, inspect the result, refine it through conversation, and learn from the files and systems the AI creates.

What it does

Morphus & Dream Studio combines two complementary creative workspaces.

Dream Studio

Dream Studio is the live 3D world editor.

Its AI copilot can inspect and modify scenes through structured editor tools covering:

  • Geometry placement
  • Mesh editing
  • Materials
  • Lighting
  • Entities
  • Paths
  • Gameplay hooks
  • Behaviour trees
  • Surface authoring
  • Articulated assets
  • Viewport screenshots

The AI does not only describe what the creator should build. It can call real editor tools, inspect their results, request a screenshot, and continue refining the world.

Morphus

Morphus is the standalone game-building workspace.

It creates and maintains playable HTML, CSS, and JavaScript projects inside the browser.

Morphus can:

  • Generate complete browser games
  • Create and edit project files
  • Search existing files
  • Read bounded sections of code
  • Apply targeted fixes
  • Import assets
  • Preview the result
  • Request confirmation before destructive operations
  • Export the final project as a ZIP file

Together, the two workspaces allow a creator to move between visual worldbuilding and code-based game creation without leaving the same product.

Typical workflow

A creator asks:

“Build a small open-world neighbourhood with shops, NPCs, a delivery mission, a garage, and a night-time chase route.”

The system then:

  1. Interprets the request and creates a plan.
  2. Selects appropriate Dream Studio editor tools.
  3. Places geometry, lights, paths, NPCs, and gameplay elements.
  4. Captures a viewport screenshot.
  5. Uses visual feedback to inspect scale, composition, and placement.
  6. Refines the scene based on the result.
  7. Opens Morphus when the creator requests a standalone minigame or web experience.
  8. Generates and maintains the necessary HTML, CSS, and JavaScript files.
  9. Lets the creator preview, edit, understand, and export the result.

The output is not a static image or a one-off chat response.

It is an editable scene or runnable game artifact.

OpenAI Build Week extension

Morphus & Dream Studio existed before OpenAI Build Week. During the submission period, the project was meaningfully extended using Codex and GPT-5.6.

The Build Week work focused on strengthening the agentic creation workflow and adapting the system so GPT-5.6 could participate in the same structured tool loop already used by the editor.

The extension preserves the existing editor, Morphus workspace, tool catalog, visual-feedback loop, game-code memory, and provider architecture.

Instead of replacing those systems, the OpenAI work expands them.

The Build Week implementation includes:

  • GPT-5.6 support inside the model-provider architecture
  • Codex-assisted auditing of the existing agent loop
  • Improvements to tool schemas and execution boundaries
  • Better handling of long, multi-step worldbuilding tasks
  • Stronger file-search and targeted-edit behaviour in Morphus
  • Improved separation between Dream Studio’s editor tools and Morphus file tools
  • Documentation distinguishing the pre-existing project from the Build Week work
  • Validation of the editor, agent loop, tool execution, and game-generation workflow

Keep only the items above that are present in the final repository and demonstrated in your video.

How AI is used

AI is the intelligence layer connecting a creator’s request to real editor and file operations.

Requests move through the generation route with:

  • Conversation history
  • A mode-specific system prompt
  • The relevant tool catalog
  • Previous structured tool results
  • Optional viewport screenshots
  • Optional reference images
  • Project and scene context

The model either responds directly or requests a tool action.

The application executes the requested action, records the result, and returns it to the model for the next reasoning step.

The core workflow is:

creator goal → model reasoning → structured tool call → editor execution → result → visual or file inspection → refinement → playable artifact

Tool-using world editor

Dream Studio exposes 104 structured tools for live 3D editor control.

These cover:

  • Scene discovery
  • Geometry creation
  • Object transformation
  • Mesh topology
  • UV operations
  • Materials
  • Surface painting
  • Behaviour trees
  • Gameplay hooks
  • Scene paths
  • Events
  • Articulated assets
  • Screenshot capture
  • Game synchronisation

This gives the AI enough authority to create meaningful scenes while keeping every action typed, inspectable, and bounded.

Visual-feedback loop

The editor includes a viewport screenshot tool.

After making meaningful changes, the AI can request an image of the current scene and use it during the next model step.

The workflow becomes:

plan → call tools → receive results → capture screenshot → inspect → refine

This is important because a scene can be technically valid while still being visually incorrect.

Screenshot feedback helps the model identify problems with:

  • Scale
  • Placement
  • Lighting
  • Composition
  • Spacing
  • Camera framing

Morphus game-building agent

Morphus exposes eight focused file and game tools:

  1. generate_game_html
  2. morphus_list_files
  3. morphus_search_files
  4. morphus_read_file
  5. morphus_write_file
  6. morphus_create_file
  7. morphus_request_delete_file
  8. morphus_request_rename_file

Morphus behaves like a coding agent inside a generated game project.

It searches before reading, reads bounded file sections, applies targeted changes, creates files when necessary, and requests approval before destructive operations.

Character and voice layer

Creators can define NPC personalities and communicate with those characters inside the preview environment.

The system supports optional ElevenLabs text-to-speech through its multilingual voice model, allowing creators to produce voice-enabled characters and multilingual game content.

How Codex and GPT-5.6 were used

Codex was used throughout the Build Week development process to understand, extend, debug, and validate the project.

It assisted with:

  • Auditing the existing editor and agent architecture
  • Mapping the 112-tool command surface
  • Inspecting the model-provider abstraction
  • Integrating GPT-5.6 without removing existing providers
  • Reviewing tool declarations and execution handlers
  • Debugging multi-step tool calls
  • Strengthening Morphus file operations
  • Preserving the existing interface and editor behaviour
  • Reviewing context-management limits
  • Improving documentation and setup instructions
  • Running TypeScript and build validation
  • Identifying where the implementation differed from the intended architecture

GPT-5.6 was used for tasks that required reasoning across the editor, tool catalog, agent loop, visual inputs, project files, and creator experience at the same time.

I remained responsible for the final product, design, and engineering decisions. Codex accelerated implementation and review, while I decided which changes matched the project’s creative goals and technical boundaries.

How we built it

The submitted editor is built with:

  • React 19
  • TypeScript
  • Vite
  • Three.js
  • React Three Fiber
  • Rapier
  • Tailwind CSS
  • Valtio
  • OpenAI Codex
  • GPT-5.6
  • Google GenAI
  • Pinecone
  • Gemini embeddings
  • ElevenLabs
  • IndexedDB
  • Custom Dream Studio packages

The system deliberately avoids asking one model to produce one enormous answer.

Each workspace receives a specialised prompt and a limited tool surface.

Dream Studio receives tools for scene and world manipulation.

Morphus receives tools for inspecting and maintaining a multi-file browser-game project.

This reduces accidental actions and keeps the AI’s work visible to the creator.

Tool surface

Morphus & Dream Studio exposes 112 structured tools:

Tool group Count Purpose
Dream Studio tools 104 Live 3D editor and world control
Morphus tools 8 Browser-game file generation and editing
Total 112 Complete world and game creation workflow

The tool design follows one principle:

Give the AI enough authority to act, while keeping every action structured, inspectable, and bounded.

Game-code memory

Morphus & Dream Studio includes a Pinecone-backed game-code memory subsystem.

The existing corpus contains more than 1,000 HTML, JavaScript, TypeScript, TSX, CSS, and JSON files covering browser-game and interactive-experience patterns.

Instead of fine-tuning directly on a varied and inconsistently structured collection, the system uses retrieval-augmented generation:

  1. The backend chunks the source code.
  2. Gemini embeddings convert the chunks into vectors.
  3. Pinecone stores and retrieves relevant examples.
  4. Retrieved examples are formatted as contextual references for the game-building agent.

The memory can provide patterns for:

  • Input handling
  • Collision
  • Cameras
  • Dialogue
  • User interfaces
  • Inventory
  • Physics
  • Enemy behaviour
  • Animation loops
  • Level logic

The next stage is exposing retrieval as a first-class Morphus tool so the agent can search previous examples autonomously before generating or debugging a game.

Challenges we ran into

Scope

Game creation includes geometry, physics, lighting, materials, behaviour, audio, code, assets, UI, and export.

One generic assistant was not enough.

The project required typed tools, specialised prompts, and separate creation modes.

Context management

Sending an entire scene or project into every request would be slow and brittle.

Dream Studio instead allows the AI to inspect progressively:

  • Scene settings
  • Node lists
  • Object details
  • Topology
  • Materials
  • Hooks
  • Paths
  • Events

Morphus follows a similar search-first process for game files.

Visual correctness

Spatial output must be seen.

Screenshot capture became part of the agent loop because valid geometry can still have poor scale, lighting, placement, or composition.

Safe code iteration

Morphus projects can become multi-file codebases.

Search-first debugging, bounded reads, targeted writes, and approval-gated destructive operations help prevent unnecessary rewrites.

Supporting multiple AI providers

The project already contained an existing hosted-model architecture.

The Build Week extension needed to introduce GPT-5.6 without destroying the previous provider abstractions or changing the creator-facing workflow.

Accomplishments that we are proud of

  • Built a browser-based 3D world editor
  • Built Morphus as a standalone browser-game workspace
  • Exposed 112 structured AI tools
  • Connected AI reasoning to real editor operations
  • Added viewport screenshot feedback
  • Added multi-file game generation and maintenance
  • Added approval gates for destructive file operations
  • Added project persistence through IndexedDB
  • Added Pinecone-backed game-code memory
  • Added multilingual NPC dialogue and optional voice generation
  • Extended the architecture for OpenAI GPT-5.6
  • Used Codex to audit, implement, debug, and validate the Build Week work
  • Preserved the existing product rather than replacing it with a new hackathon-only interface
  • Produced editable scenes and runnable artifacts instead of static mockups

What we learned

A beginner does not only need a generated file.

They need a loop:

make → see → edit → understand → play → repeat

Dream Studio makes spatial creation inspectable.

Morphus makes game-code generation maintainable.

Screenshots make visual verification possible.

Structured tools make actions auditable.

File operations make iteration safer.

Codex and GPT-5.6 helped strengthen that loop, but the central product lesson remained the same: AI creativity tools become more useful when users can inspect, modify, and own the artifacts they produce.

What is next

  • Expose game-code retrieval as a first-class Morphus tool
  • Expand GPT-5.6-powered visual world evaluation
  • Add stronger project-level memory
  • Add collaborative world editing
  • Add local-first model support through Ollama or llama.cpp
  • Add complete editor localisation
  • Add right-to-left interface support
  • Expand game export and deployment options
  • Add more reusable world and gameplay templates
  • Improve AI-generated debugging explanations for new creators

Team

Miles — solo builder

Responsibilities:

  • Product strategy
  • Product design
  • AI workflow architecture
  • Full-stack development
  • Editor and runtime integration
  • Tool-system architecture
  • Codex-assisted engineering
  • GPT-5.6 integration
  • Documentation
  • Validation
  • Demo preparation

Built With

  • 3d
  • ai-agents
  • browser-game-engine
  • css3
  • elevenlabs
  • gemini-embeddings
  • google-genai
  • gpt-5.6
  • html5
  • indexeddb
  • javascript
  • multimodal-ai
  • openai-codex
  • pinecone
  • rapier
  • react
  • react-three-fiber
  • retrieval-augmented-generation
  • tailwind-css
  • three.js
  • tool-calling
  • typescript
  • valtio
  • vite
  • webgl
Share this project:

Updates

Submission history