TutorialMetaverse

How to Build in the Metaverse: From Idea to Your First Scene

EarthMeta builder's guide cover: the Guggenheim Museum Bilbao as a focused real place for a first metaverse scene

A practical guide to planning, creating, optimizing and launching a metaverse experience, without trying to build an entire planet before lunch.

Published Read time 30 minCategory TutorialPrimary keyword how to build in the metaverse
Quick answer

To build in the metaverse, start smaller than you think: one place, one action and one good reason to return. Define the visitor, the action and the outcome; choose a platform that fits the audience and device; graybox the scene with primitive shapes; build only the assets it needs; add one complete interaction loop; optimize for the weakest device; test with people who did not build it; then publish a small, coherent version and improve it from evidence. EarthMeta adds real geography and live AI building tools, so a first scene starts with a place that already means something.

A first metaverse scene does not need a capital city, a working economy, weather, dragons, an underground railway and a nightclub with perfect spatial audio.

It needs one place, one action and one good reason to return.

That sounds modest. It is also how useful digital worlds begin. A builder who starts with “I will create a universe” often ends week three with 37 beautiful chairs, six incompatible file formats and a door that still does not open. A builder who starts with “the visitor enters this square, discovers this landmark and completes this short challenge” has something that can be tested.

This guide explains how to build in the metaverse from the first idea to a playable scene. It covers the creative brief, platform choice, grayboxing, 3D assets, file formats, interaction design, performance, testing, rights, moderation and launch. It also shows how AI shortens the route from an empty canvas to a first draft, and how EarthMeta's real-world geography gives a new scene an immediate sense of place.

The short version is simple:

  1. Brief

    Define the visitor, the action and the outcome.

  2. Platform

    Choose a platform that fits the audience and device.

  3. Graybox

    Block the scene with primitive shapes before making it beautiful.

  4. Assets

    Build or import only the assets the experience needs.

  5. Interaction

    Add one complete interaction loop.

  6. Performance

    Optimize for the weakest supported device.

  7. Testing

    Test with people who did not build it.

  8. Launch

    Publish a small, coherent version and improve it from evidence.

The longer version is where the useful decisions live.

What does “building in the metaverse” actually mean?

Building in the metaverse means creating a persistent or repeatable digital place in which people can enter, perceive an environment and do something. The “something” may be exploring, playing, learning, shopping, meeting, creating, collecting, attending an event or governing a shared space.

A beautiful 3D model is not automatically a metaverse experience. It becomes an experience when the model is connected to behavior.

Think of a scene as five layers:

Layer 1

Place

Geometry, landscape, architecture, lighting and sound.

Layer 2

Presence

An avatar, camera or other way for the visitor to inhabit the space.

Layer 3

Interaction

Actions such as opening, collecting, speaking, building, voting or trading.

Layer 4

Rules

Permissions, progression, ownership, scoring, access and safety.

Layer 5

Continuity

Something that persists, changes or gives a reason to return.

A static digital museum room may be a strong 3D presentation. Add guided exploration, social presence, interactive exhibits and a record of discoveries, and it begins to behave like a virtual world.

This distinction protects builders from a common mistake: treating a world as a collection of assets. Assets matter, but visitors remember what happened. The famous building is the stage. The moment they shared, the choice they made or the challenge they completed is the story.

Why more people can build virtual worlds now

The barrier to 3D creation is falling from several directions at once.

Game engines provide mature lighting, physics, animation and deployment systems. Web-based world builders package many of those capabilities behind simpler interfaces. Open runtime formats make it easier to move assets between tools. AI can produce concepts, textures, dialogue, code suggestions and early 3D forms. Creator platforms bring distribution and, in some cases, payment systems.

The audience is not small. Newzoo's 2026 global games market outlook forecasts a $213.9 billion games market and 3.7 billion players for the year. That figure describes games, not “the metaverse” as one neatly measured market. Still, it shows the scale of the interactive habits on which virtual worlds are being built: people already understand avatars, digital goods, shared challenges, persistent identity and live events.

Creator economies also show that audiences do not only consume worlds; they help make them. Roblox reported that its creators earned more than $1.5 billion in 2025, up from $923 million in 2024. That is a platform-reported result, not a promise that every creator earns money. Its significance is structural: tools, distribution and a large audience can turn world-building into an economic activity rather than a private hobby.

Roblox creator payouts · reported
$923M2024
$1.5B+2025

+63% in a single year, as reported by Roblox

Games market · Newzoo 2026 forecast
3.7B players

in a games market forecast at $213.9 billion

Newzoo frames this as games, not “the metaverse”: it measures the interactive habits virtual worlds build on.

Sources: Newzoo and Roblox.

AI expands the supply side. A person who can describe a building, mood or challenge can now reach a rough prototype faster. The bottleneck moves. It becomes less about producing anything and more about deciding what deserves to exist, whether it works, and whether people want to return.

That is good news for disciplined builders. When generation becomes cheap, taste, coherence, performance and community become more valuable.

Before opening a 3D tool, write the one-sentence brief

The most expensive metaverse error usually happens before the first polygon appears: the team has not agreed what it is building.

Write a sentence with four parts:

For [specific visitor], the project creates [specific place] where they can [specific action], so that [specific outcome].

Examples:

  • For architecture students, a walkable reconstruction of a civic square where they can compare three design eras, so that they understand how public space changed.
  • For a football club's global supporters, a virtual fan plaza where they can complete a match-day quiz with friends, so that remote supporters have a shared ritual.
  • For visitors to a real city, a landmark-based discovery route where they can collect stories from five locations, so that they explore beyond the obvious tourist stop.
  • For a new EarthMeta city owner, a welcome square where visitors can learn the district's theme, perform one action and choose a next destination.

If the sentence contains three audiences, seven actions and five outcomes, it is not a brief. It is a meeting that escaped into a document.

Interactive · Brief builder

Assemble your one-sentence brief

Pick one option per line. The sentence updates as you choose.

Visitor
Place
Verb
Outcome
Your brief

Define the primary visitor

“Everyone” is not a useful audience. A desktop gamer, a first-time mobile visitor, an architect wearing a headset and a crypto-native collector do not arrive with the same hardware, patience or expectations.

Choose a primary visitor and a secondary visitor. Write down:

  • the device they are likely to use;
  • how they will discover the experience;
  • whether they understand 3D navigation;
  • how much time they are likely to give you;
  • whether they arrive alone or with friends;
  • what would make the visit feel worthwhile.

This choice will influence text size, camera movement, input, polygon count, onboarding and even the width of a doorway.

Define the primary verb

Strong scenes often have one dominant verb: explore, collect, build, meet, learn, race, vote, trade, perform.

The verb gives the environment a job. “Explore” requires readable landmarks and routes. “Meet” requires gathering spaces, identity and conversation safety. “Build” requires placement rules, saving and permissions. “Trade” requires clear ownership and transaction states. “Learn” requires pacing, feedback and evidence that understanding improved.

Choose one dominant verb for version one. Other actions can support it, but they should not compete with it.

Define one success signal

The first metric should match the experience, not flatter the team.

Useful early signals include:

  • percentage of visitors who complete the first interaction;
  • time to first meaningful action;
  • return visits within seven days;
  • number of social interactions per session;
  • completion of a route or lesson;
  • percentage who choose a second destination;
  • creator submissions that pass quality review.

Raw visits tell you reach. They do not tell you whether the world worked.

Choose the platform from constraints, not fashion

There is no universally best metaverse platform. There is only the platform that best fits the audience, scene and operating model.

Use six questions.

1. Where is the audience already?

A world with sophisticated tools but no route to its intended community may remain an elegant empty room. Existing creator platforms can offer discovery and familiar controls. An open-web experience can reduce installation friction. A location-based platform can give a real-world concept immediate context.

2. Which devices matter?

Decide whether version one must support desktop, mobile, browser, console, augmented reality or virtual reality. Each extra target adds testing and compromises. “Available everywhere” sounds generous until the lighting looks perfect on a workstation and the mobile device becomes a pocket-sized radiator.

Start with the device most likely to reach the primary visitor. Add others when the interaction survives there.

3. How much creation control is required?

No-code and low-code builders are fast because they restrict choices. Game engines are powerful because they expose them. A template-based tool may be ideal for a guided gallery and frustrating for custom physics. A custom engine may enable a unique mechanic while multiplying production and maintenance work.

4. What must users own or carry?

If the experience depends on portable assets, blockchain ownership or a persistent identity, inspect the platform's actual support. Do not assume that “Web3” means every item moves everywhere. Geometry, shaders, skeletons, rights, metadata and economies differ. Technical portability and legal portability are separate questions.

5. What are the platform rules?

Check asset limits, scripting, commerce, age ratings, moderation, external links, identity, user-generated content and geographic availability. A platform restriction discovered before production is a design constraint. The same restriction discovered one day before launch is a crisis with snacks.

6. Can the team operate the world?

Building is only the first cost. Worlds need bug fixes, moderation, content updates, analytics, community support and occasional rescue missions for avatars trapped inside furniture.

Choose an operating model the team can sustain.

Four practical production routes

Most first scenes follow one of four routes. Many successful projects use a hybrid.

RouteBest forStrengthsMain trade-off
Platform world builderFirst prototypes, social spaces, small teamsFast setup, built-in publishing and permissionsLess control over rendering and custom systems
Blender plus platform editorDistinctive environments and imported assetsStrong modeling workflow with platform distributionImport, scale and material rules need discipline
Unity or Unreal applicationBespoke mechanics, branded applications, complex simulationDeep control over interaction, rendering and deploymentHigher engineering, QA and maintenance load
AI-assisted builderFast concepting, variations and simple structuresCompresses blank-canvas timeOutput still needs art direction, optimization and testing
Interactive · Route finder

Which production route fits your first scene?

Three quick questions, one recommended starting route.

Route A: Build inside a platform

This is often the shortest route to a first public scene. Use platform primitives, prefabs, terrain and interaction components. The advantage is not only speed. The platform already knows its own collision system, permissions and publishing path.

Choose this route when learning and audience feedback matter more than visual uniqueness.

Route B: Model externally, assemble in-platform

Create custom geometry in Blender or another digital content tool, then import it into the destination. This provides more visual identity while preserving the platform's social and distribution layer.

The price is pipeline discipline. Units, origin points, normals, textures, materials, collisions and animation must survive export and import.

Route C: Build a custom application

Unity and Unreal provide broad control over rendering, interaction and deployment. This route suits experiences whose mechanics or data integration cannot fit a platform builder.

It also turns the project into software. Plan for source control, builds, device testing, security, backend services and updates, not just art.

Route D: Start with AI, finish with craft

AI is excellent at the first 30 percent: a massing idea, material variation, prop concept, dialogue draft or scripting starting point. It is less reliable at the final 30 percent: consistent scale, topology, collision, readability, rights, performance and the emotional rhythm of a visit.

The practical route is hybrid. Generate, select, refine, optimize and test.

Step 1: Turn the brief into a one-page scene plan

A scene plan is a map of the experience before it becomes geometry. Keep it to one page.

Include:

  • entry point;
  • first thing visible;
  • first action;
  • route or choice;
  • feedback after the action;
  • reason to continue;
  • exit, return or next destination;
  • success metric;
  • device and performance target;
  • content that is explicitly out of scope.

Imagine a virtual tourism scene based around Bilbao's Guggenheim Museum. Version one does not need the whole city. It could contain a river approach, a recognizable exterior silhouette, three story points and a short photography challenge. The visitor sees the museum within seconds, learns how to move, captures three perspectives and unlocks a route toward another real place.

That is a complete loop. “Rebuild Bilbao” is not.

Sketch the emotional sequence

Good virtual architecture has rhythm:

1 · Orientation

Where am I?

2 · Invitation

What can I do?

3 · Action

I do it.

4 · Response

The world acknowledges me.

5 · Choice

What next?

6 · Memory

What will I tell someone?

The response can be tiny: a sound, light change, revealed fact, collected item or opened path. Without response, interaction feels decorative. With response, the visitor understands that the world is listening.

EarthMeta illustration of Petra's Treasury, a reminder that strong form comes before surface polish when grayboxing a scene
Start with a graybox before adding detail: Petra's Treasury shows that strong form comes before surface polish.

Step 2: Graybox before you polish

A graybox is a rough version of the scene made from simple shapes. Floors are planes. Buildings are boxes. A statue might be a cylinder with heroic ambitions.

This stage tests the questions that textures cannot solve:

  • Can the visitor understand where to go?
  • Does the scene feel correctly scaled?
  • Is the first landmark visible from entry?
  • How long does the route take?
  • Are doorways, steps and interactive objects reachable?
  • Can two or ten avatars occupy the same area?
  • Does the primary action feel good?
  • Where does the visitor get lost?

Do not postpone interaction until the art is finished. Put the first action in the ugly version. If collecting the object, opening the door or starting the guide is boring in gray boxes, marble textures will not rescue it.

Set a scale convention

Pick one unit system and document it. Define standard heights for avatars, doors, steps, counters and interaction distances. Import a scale reference into every modeling file.

Scale errors are surprisingly emotional. A slightly enormous door makes the visitor feel small. A low ceiling feels oppressive. A chair at 70 percent scale makes the entire room look like a polite conspiracy.

Consistent scale also prevents physics and animation errors later.

Set pivots and origins deliberately

The pivot is the point around which an object rotates, scales or attaches. Put a door's pivot at the hinge, a wheel's pivot at its axle and a placeable prop's origin where it should touch the ground.

Bad pivots turn simple interactions into wrestling matches. Fix them in the source file, not with a chain of mysterious offsets inside the final scene.

Step 3: Make an asset list, then cut it

Create a list with four categories:

Hero assets

The few objects that define the scene.

Functional assets

Doors, signs, triggers, collision surfaces and navigation markers.

Set dressing

Props that make the world believable.

Audio and interface

Ambience, effects, instructions and feedback.

Assign each asset an owner, source, format, size target, rights status and deadline. Then cut the list.

The hero landmark deserves detail because the visitor looks at it. The back of a roof visible for two seconds probably does not. Reuse modular pieces for walls, windows, paving and vegetation. Variation can come from rotation, scale within safe limits, materials and composition.

Build a modular kit

A modular kit is a family of pieces designed to connect: wall segments, corners, doors, roofs, columns and street elements. It accelerates construction and makes style consistent.

Use a shared grid and naming system. Test a small kit in the target platform before producing 200 pieces. The correct time to discover that every wall is 1.7 percent too large is after the third wall, not the 203rd.

Decide what to make, buy or generate

Use this filter:

  • Make assets that carry the concept or require precise interaction.
  • Buy or license common props when quality and rights are clear.
  • Generate early forms or variations when speed matters.
  • Use platform-native assets when compatibility matters most.

Record the license for every external asset. “Found in a folder” is not a license category.

Step 4: Choose file formats that survive the trip

Interoperability is not glamorous, but it is the difference between an asset and an asset-shaped problem.

The Khronos glTF 2.0 specification defines glTF as an open, vendor-neutral format for transmitting 3D scenes and models efficiently at runtime. A glTF asset can describe scenes, nodes, meshes, materials, cameras and animations. A .glb packages the JSON, binary data and often textures in one binary container, which makes delivery convenient.

Khronos is also clear that glTF is a runtime delivery format, not a full authoring format. Keep the original Blender or other source file. The source is where modifiers, construction history, high-resolution meshes and editable materials belong.

FormatCommon useCarries wellWatch for
.glb / .gltfRuntime delivery and web/platform importMeshes, hierarchy, PBR materials, textures, animationsDestination extensions and shader differences
.fbxEngine and DCC interchangeMeshes, rigs and animationVersion compatibility, scale, axes and material reconnection
.objSimple static mesh exchangeGeometry and UVsLimited hierarchy, materials and no modern animation workflow
.pngUI, masks and textures needing alphaLossless detail and transparencyLarge files if used carelessly
.jpg / .webpOpaque color textures and web deliverySmaller photographic filesCompression artifacts; no alpha in JPEG
.wavSource-quality audio and short effectsHigh-quality editing sourceLarge runtime size
.ogg / .mp3Compressed runtime audioSmaller deliveryPlatform support and loop quality
.blend or native sourceEditable masterFull construction historyNot a universal runtime deliverable

Roblox's official 3D Importer documentation illustrates why destination rules matter: it supports .fbx, .obj and .gltf, while FBX and glTF can carry richer hierarchies, PBR textures, rigs, animation and vertex colors. Unity recommends exporting to generic formats such as FBX or OBJ because importing proprietary application files can require the original software and compatible versions; see Unity's model file format guidance. Unreal's FBX static mesh pipeline documents a specific FBX compatibility version and notes that some material connections may need to be rebuilt.

The lesson is not “always use one format.” It is: choose the destination first, export a tiny test early, and write down the settings that work.

Create an import test asset

Before exporting the real scene, make a small test file containing:

  • a one-meter cube;
  • a named material;
  • a texture;
  • a child object;
  • an object with a meaningful pivot;
  • a simple animation if needed;
  • a collision proxy if the platform supports it.

Import it. Confirm scale, axes, material, hierarchy, animation and collision. That five-minute test can save days of repair.

Step 5: Model for the camera, the interaction and the device

Detail should follow attention.

Spend geometry on silhouettes, curved hero surfaces and objects near the camera. Save it on flat surfaces, hidden backs and distant decoration. Use normal maps or baked detail where appropriate. Remove geometry the visitor can never see.

Materials are a budget

Every unique material can add rendering work. A building with 40 materials may be easy to author and expensive to draw. Consolidate compatible textures into atlases when the platform benefits from it. Reuse materials across modular pieces. Keep physically based material values coherent so the world reacts consistently to light.

Do not depend on a complex desktop shader if mobile support matters. The imported version may look different because platforms implement materials differently. Test representative materials early: glass, emissive signs, foliage, metal and transparency.

Lighting directs behavior

Lighting is not only decoration. It tells visitors where to look and where to go.

Use contrast to frame the first action. Keep interactive objects readable against their backgrounds. Avoid placing critical text in deep shadow. If day-night change is part of the scene, test every interaction under every lighting state.

Baked lighting can provide rich results with lower runtime cost, but it is less dynamic. Real-time lighting responds to moving objects and time changes but costs more. Hybrid lighting often works best: baked or simplified environment illumination, with a small number of important dynamic lights.

Collision should be simple and intentional

Visual geometry and collision geometry do not need to match. A detailed sculpture can use a simple collision shape. Stairs may need a ramp-like collision surface so movement is smooth. Decorative objects should not snag the avatar unless touching them matters.

Test collision in motion. Walk along walls, jump at corners, approach objects from strange angles and try to leave the intended route. Visitors are brilliant at finding the one gap the team stopped seeing.

Step 6: Build one complete interaction loop

An interaction loop has four parts:

1 · Cue

The visitor understands that something can happen.

2 · Action

The visitor acts.

3 · Feedback

The world responds immediately.

4 · Consequence

The action changes progress, information or possibility.

For a city discovery scene, the cue might be a subtle glow near a real landmark. The action is approaching and activating it. Feedback is a sound and visual shift. The consequence is a story fragment added to the visitor's route and the next location revealed.

Build that loop end to end before adding five half-finished mechanics.

Make the first action obvious, not embarrassing

Onboarding should feel like participation. Instead of a wall of instructions, let the first seconds teach through movement and response.

Good onboarding often follows this pattern:

  • place the visitor facing the destination;
  • show one control or prompt;
  • reward the first correct action immediately;
  • introduce the next control only when needed;
  • keep an accessible help path available.

The visitor should not need a tutorial on how to read the tutorial.

Design failure states

What happens when the visitor misses the object, closes a prompt, disconnects, lacks permission or arrives after an event? A world is a system, and systems need recovery.

Use clear messages, retry paths and safe spawn points. Preserve progress when appropriate. Never let a transaction or ownership action fail silently.

Step 7: Treat social design as architecture

A multiplayer square is not a single-player square with more avatars.

People need space to gather without blocking paths, places to pause without feeling exposed, and ways to understand who is speaking or acting. Group size affects acoustics, camera visibility and interaction queues.

Plan:

  • arrival zones that do not stack avatars;
  • conversation areas away from busy routes;
  • clear personal-space behavior;
  • visible status for hosts or guides;
  • mute, block and report controls where communication exists;
  • moderation and escalation paths;
  • capacity limits and overflow behavior;
  • accessible alternatives to voice.

If users can create or upload content, moderation begins at the upload form, not after the first incident. Define allowed formats, size limits, review states, reporting, removal and appeals.

Identity needs restraint

Ask only for information the experience needs. Make public and private states understandable. If names, wallets, progress or purchases appear, explain where and to whom they are visible. Good identity design builds trust quietly. Bad identity design makes every interaction feel like a pop quiz about privacy.

EarthMeta illustration of the Petronas Twin Towers anchoring a real Kuala Lumpur scene built for readable scale and practical device budgets
Performance is part of the design: the Petronas Twin Towers anchor a real Kuala Lumpur scene built for readable scale and practical device budgets.

Step 8: Make performance part of the design

Optimization is not a final sweep with a magic broom. It begins when the scene is scoped.

A scene that loads slowly, stutters or overheats a phone does not feel more ambitious. It feels broken.

The main runtime costs usually include:

  • geometry and skinning;
  • material and draw-call count;
  • texture memory;
  • transparency and overdraw;
  • dynamic lights and shadows;
  • particles;
  • scripts and physics;
  • network updates;
  • audio and video streaming;
  • the number of active objects.

There is no universal triangle count or texture size that makes every metaverse scene safe. Budgets depend on the platform, camera, device, number of avatars and rendering pipeline. Use the destination's current limits and profile on the weakest supported device.

Use levels of detail

A level-of-detail system swaps a complex model for simpler versions as it moves farther from the camera. Unreal's official FBX pipeline explains that LOD meshes reduce the triangles and material complexity rendered at distance. Unity similarly documents LOD as a way to reduce GPU work for distant meshes.

The principle is wonderfully reasonable: if the visitor cannot see the bolts, stop rendering the bolts.

Create LODs for repeated and large objects. Check the transition so a building does not visibly “pop” into a different shape. Preserve the silhouette longer than tiny surface detail.

Stream and reveal

Do not load a whole district when the visitor can see one street. Divide the experience into zones. Load what is needed before it becomes visible and release what is no longer needed.

Visual occlusion also helps. A bend, doorway, courtyard or hill can hide the next area while it loads. This is where performance and place-making become allies: the route feels more dramatic and the device does less work.

Texture with intent

Use higher resolution where the camera gets close or text must remain readable. Use smaller maps for distant, repeated or low-attention surfaces. Compress for the target. Keep alpha only where necessary.

An 8K texture on a small bin is not luxury. It is a cry for help.

Profile, do not guess

Measure frame time, memory, load time, network traffic and script cost. Test a representative busy case, not only an empty editor. Ten avatars, animated props and live UI can reveal costs that a solitary walk-through hides.

Record a baseline, make one class of change, and measure again. Optimization without measurement tends to polish whatever the team already understands rather than what is actually slow.

Step 9: Test with people who did not build it

The team knows that the blue arch is a portal because it discussed the blue arch for two weeks. A new visitor sees a blue arch.

Usability testing reveals the gap.

Give testers a goal, not instructions. Observe:

  • where they look first;
  • whether they move successfully;
  • when they hesitate;
  • what they think is interactive;
  • where they become lost;
  • what they believe happened;
  • whether they choose to continue.

Do not explain during the test unless safety or a technical failure requires it. Every explanation removes a chance to learn.

Test in layers

LayerQuestion it answers
1. Builder testDoes every system work in the editor?
2. Fresh-user testCan a newcomer understand the scene?
3. Device testDoes it perform on each target device?
4. Network testWhat happens under latency or reconnection?
5. Capacity testWhat happens with the expected group size?
6. Accessibility testCan people perceive, navigate and act through different needs?
7. Safety testCan reporting, blocking, permissions and moderation fail safely?

Accessibility is a build requirement

Use readable contrast, scalable text, captions for speech, alternatives to sound-only cues, input remapping where possible and motion settings. Avoid forcing rapid camera movement. Provide navigation cues that do not depend only on color.

Accessibility improves the world for everyone: the player in sunlight, the visitor without headphones, the person on a small screen and the user who simply missed the hint.

Step 10: Publish a version, not a verdict

The first public scene is a hypothesis.

Publish when the primary loop is complete, performance is acceptable on the target device, the main failure states recover cleanly and safety tools are ready. Do not wait for every decorative corner. Do not publish a broken core because the decorative corners are lovely.

Release to a limited audience first if the platform allows it. Watch how people enter, act and leave. Compare behavior with the success signal in the brief.

Then choose among four responses:

Keep

The element works and supports the goal.

Improve

The idea works, but the execution causes friction.

Remove

It consumes attention or performance without value.

Expand

Visitors clearly want more of it.

This is how a scene becomes a world: not through one heroic launch, but through many informed improvements.

Pick a real city for your first scene

EarthMeta's world is organized around real geography, so your scene starts with a place that already means something.

Open the app

A concrete example: a first real-city scene

Suppose a small team wants to build an EarthMeta experience connected to Marrakech. The ambitious idea is a vast living city with shops, history, games, NPCs and live events. The buildable first version is a focused arrival courtyard inspired by a recognizable real district.

The brief

For first-time visitors interested in culture and virtual real estate, create a real-location welcome courtyard where they can discover three place stories and choose a district route, so that they understand the city's theme and want to continue exploring.

The first scene

ElementDesign
EntryA shaded arch opening toward a landmark view.
First cueA short light trail leads to one story marker.
Primary actionActivate three markers in any order.
FeedbackEach changes the courtyard's soundscape and reveals a visual layer.
ConsequenceCompleting all three opens a map with two next routes.
Social elementVisitors can leave one approved postcard-style reaction.
Return reasonThe featured route changes periodically.

The asset list

The hero assets are the arch, central fountain and skyline silhouette. Functional assets are markers, route signs, collision, spawn points and the map. Set dressing is limited to modular walls, plants, lamps and seating. Audio includes one ambience bed, three short story clips and interaction sounds.

Notice what is absent: a full vehicle system, 500 interiors, an economy, weather simulation and photorealistic pigeons with personal agendas.

The graybox test

Primitive walls establish the courtyard. A tall box represents the landmark. Three cylinders represent story markers. Five testers enter without instructions.

If four walk past the first marker, the cue is weak. If everyone moves toward the fountain but the interaction is on the wall, move the action. If the map appears behind the player, reposition it. These are cheap changes now.

The launch metric

Measure the percentage of visitors who activate all three markers and choose a next route. That is more useful than celebrating total entries alone.

The same pattern works for a museum, brand showroom, classroom, music venue or game lobby. Change the visitor, verb and outcome; keep the discipline.

Common import problems and how to fix them

3D pipelines fail in familiar ways. Familiar problems deserve boring checklists.

SymptomLikely causePractical fix
Object is tiny or enormousUnit mismatch or unapplied scaleStandardize units, apply transforms, re-export the test cube
Model lies on its sideAxis convention mismatchUse the destination export preset and verify forward/up axes
Object rotates strangelyBad pivot or originPlace pivot in the source file and apply transforms
Parts appear inside outFlipped normalsRecalculate normals and check mirrored geometry
Textures are missingBroken paths or unsupported packingEmbed/package correctly and inspect import logs
Materials look wrongShader features do not translateRebuild with destination-supported PBR channels
Transparent surfaces flickerSorting and overdraw limitsSimplify overlap, adjust material mode, reduce transparent layers
Avatar walks through an objectNo collision or wrong collision typeAdd simple collision proxies and test moving contact
Animation is frozenClip, skeleton or export selection issueExport a single test clip with the rig and validate bone names
File is unexpectedly hugeHidden objects, excess geometry or uncompressed texturesExport selected assets, clean the scene, resize and compress textures
Scene works on desktop but not mobileMemory, shader, particle or draw-call pressureProfile on mobile, simplify materials, use LOD and reduce active effects

Maintain an import preset and a short README beside the source files. The goal is not to remember the ritual. The goal is to make the ritual repeatable.

A naming and version system that prevents archaeology

Use clear names from day one. final_final2_REAL.glb is not version control; it is a distress signal.

A simple asset name can contain:

project_location_category_asset_variant_lod_version

For example:

bilbao_river_arch_bridgeA_lod1_v006.glb

Keep source, export and runtime folders separate:

  • /source for editable files;
  • /textures-source for masters;
  • /export for generated interchange files;
  • /runtime for approved optimized assets;
  • /archive for superseded deliverables.

For custom applications, use source control for code, scene data and compatible assets. For large binaries, use a system designed for large files or the engine's recommended workflow. Tag stable builds. Record which asset versions belong to each release.

Version discipline makes experimentation safer. If a lighting change breaks mobile performance, the team can return to a known build instead of trying to remember which mysterious folder contained Tuesday's good sky.

EarthMeta illustration of Habitat 67 in Montréal, a bold real structure shaped into a coherent place through deliberate choices
AI accelerates the first draft; creators still shape the experience. Habitat 67 in Montréal shows how a bold structure becomes a coherent place.

How AI changes metaverse creation

AI reduces the cost of getting from words to possibilities.

A builder can use it to:

  • turn a brief into visual directions;
  • explore architectural massing;
  • generate texture or material variations;
  • draft ambient dialogue;
  • propose quest structures;
  • create placeholder voice or sound ideas;
  • assist with scripts;
  • classify testing feedback;
  • generate an initial 3D structure in supported tools.

The biggest gain is not that AI makes a finished world with one perfect sentence. It makes iteration cheaper. Ten early options can be explored before the team commits to one.

AI does not remove the need for a pipeline

Generated output still needs to pass the same gates:

  • Does it match the place and purpose?
  • Is the scale consistent?
  • Is the topology usable?
  • Are materials compatible?
  • Is collision correct?
  • Can it run on the target device?
  • Are rights and provenance acceptable?
  • Does it strengthen the interaction?
“Generated” is a production method, not a quality certificate.

Use AI for divergence, humans for convergence

At the start, ask AI for different approaches: quiet, playful, monumental, educational, social. That is divergence.

Then the team converges: select one direction, remove contradictions, impose scale, optimize, connect interactions and protect the visitor experience. Human judgment creates coherence.

This is particularly powerful for small teams. A solo creator can explore ideas that once required several specialists. But the final scene still reflects the decisions the creator made. A thousand generated props cannot replace a clear reason to enter.

What EarthMeta changes for a first-time builder

EarthMeta begins with a distinctive foundation: real geography.

EarthMeta was founded in 2020 and officially launched in 2024, with more than 250,000 cities represented across its real-world geographic model. Its public roadmap dates the platform launch to October 2024.

That matters because a blank fictional grid asks the creator to invent both the place and the experience. Real geography supplies a first layer of meaning. A city name carries history, architecture, communities, climate, memory and search intent before the first custom structure is added.

A builder can therefore start with a sharper question:

What experience belongs here?

The answer may be a landmark route, cultural exhibition, local game, civic simulation, creator market, learning space or themed gathering place. The real location is not a guarantee that people will visit. It is a strong narrative coordinate.

EarthMeta's live building capabilities

EarthMeta's roadmap marks several creator capabilities as completed:

  1. Completed

    Construction editor and AI 3D Builder.

  2. Completed

    Stable object placement and API partner integration.

  3. Completed

    Avatars, external 3D model imports and a controlled construction engine.

  4. Live

    Prompt a structure, refine variants and mint a deed with AI Buildings & Land.

Those capabilities map well to the hybrid workflow in this guide:

  • choose a real location and a purpose;
  • generate the first structural direction;
  • refine the massing and style;
  • import external models where specificity matters;
  • place objects with controlled construction tools;
  • test the visitor route and interaction;
  • publish a small experience and evolve it.

AI helps defeat the blank canvas. External import protects creative range. Controlled placement protects coherence.

Every city has a Governor, every country a President

Building also has a place in EarthMeta's city economy. Every city has a Governor who receives 1% of every trade in their city, and every country has a President who receives 0.5% of every transaction across the whole country. One person can hold both roles and collect 1.5% on their own city. These rates apply to every asset traded in the territory, whether the Governor or President owns it or not: $100,000 traded in a city means $1,000 tax collected by its Governor. A useful first scene gives visitors a reason to come to the city, and that activity is what the city economy runs on.

What is still developing

EarthMeta is a young platform, and the distinction between live and upcoming matters. Mobile and augmented-reality initiatives are launching soon, around September and October 2026, while virtual reality sits farther ahead. AI NPC populations are coming soon, and whole-district generation is on the roadmap.

This is not a weakness disguised as a feature. It is the normal shape of platform development: core systems arrive, creators test them, infrastructure matures, and new surfaces follow.

Roblox launched in 2006 and spent years expanding its creation tools, economy, safety systems and audience. Amazon began with books before building the infrastructure and categories people now associate with it. The useful comparison is not outcome. It is sequence. Large ecosystems are assembled through sustained product work and feedback, not summoned fully formed.

EarthMeta connects its real-city framework, AI creation and ownership model into a practical loop for builders. As creation becomes easier, more locations gain useful content. As useful content attracts visitors, cities become more meaningful as experiences rather than merely coordinates. As builders learn from visitor behavior, the experiences improve. That is the positive mechanism to watch.

The EarthMeta first-scene workflow

Here is a focused way to apply the full guide inside EarthMeta.

1. Choose the location for a reason

Do not select a city only because its name is famous. Connect the place to the visitor and verb.

City typeExperience it supports
A university cityLearning or research experiences
A tourism cityDiscovery routes and cultural storytelling
A business centerEvents or showrooms
A hometownLocal memory, community and identity
A sports cityFan rituals and challenges

Write one sentence explaining why the experience belongs there. If the scene could be moved anywhere without changing, the location is decorative rather than meaningful.

2. Define a single arrival scene

Choose a square, waterfront, courtyard, street or landmark edge. Establish the direction visitors face when they arrive. Put the purpose within sight.

The arrival scene should answer three questions quickly:

  • Where am I?
  • What is this place for?
  • What can I do first?

3. Generate the first mass, not the final answer

Use the AI building workflow to explore structure and style. Prompt with function, scale, materials, mood and location context.

A more useful prompt is:

Create a compact visitor pavilion for a Helsinki cultural route, with a visible entry from the square, Nordic timber and pale stone, one central gathering space and three clearly readable exhibition bays.

That is better than “make a cool futuristic building.” It gives the system design constraints.

Review variants for circulation and function before surface beauty. A dramatic roof is lovely; an entry visitors cannot find is a sculpture with customer-service issues.

4. Add specific assets only where they matter

Import an external model for a distinctive landmark element, branded object or interaction prop. Keep common support assets modular and light. Validate format, scale, pivot, material and collision with one test object before importing the complete set.

5. Build one visitor loop

For example:

  • arrive at the pavilion;
  • activate a location story;
  • complete a short visual search;
  • unlock a second city point;
  • save or share a completion badge where the platform supports it.

The loop should take minutes, not a planning quarter.

6. Test the route, not only the building

Ask testers to enter without instructions. Observe whether the real-world context helps them orient. Check whether the AI-generated structure supports movement, whether imported assets read at the right scale and whether the first action is obvious.

7. Expand from evidence

If visitors complete the route but do not return, add changing content or a social reason. If they gather but ignore the story, redesign the interaction around the gathering behavior. If they leave during load, reduce the scene before adding more.

EarthMeta's real cities make expansion intuitive: one strong scene can connect to another real district, landmark or city. The network should grow from working experiences, not empty acreage.

EarthMeta illustration of Helsinki Cathedral as an expandable first-scene destination: one place, one action, one reason to return
One place, one action, one reason to return: Helsinki Cathedral closes the path from first scene to an expandable EarthMeta destination.

A 30-day plan for your first metaverse scene

The calendar below assumes a small team or focused solo builder. Adjust it to the platform and complexity.

Interactive · 30-day planner

Drag through the 30 days

Day 1
Brief and constraints
Day 1Day 30
Days 1–3

    Days 1–3: Brief and constraints

    • Define visitor, verb, outcome and metric.
    • Choose the platform and target device.
    • Review asset, content, commerce and moderation rules.
    • Write the out-of-scope list.
    • Choose the real location if building in EarthMeta.

    Pass condition: one-page scene plan approved.

    Days 4–7: Graybox

    • Build the entry, route and destination with primitives.
    • Add spawn, camera and scale reference.
    • Implement the first interaction with placeholder feedback.
    • Test with at least three fresh visitors.

    Pass condition: most testers can find and complete the primary action.

    Days 8–14: Art direction and asset pipeline

    • Lock the visual direction.
    • Create the modular kit and hero-asset plan.
    • Test one imported asset end to end.
    • Establish naming, folders and export settings.
    • Confirm rights for every external asset.

    Pass condition: a small “vertical slice” shows final-quality art and interaction together.

    Days 15–20: Production

    • Build approved assets.
    • Refine lighting and audio.
    • Add feedback, recovery and progression.
    • Implement social or identity features required by the brief.
    • Keep profiling during production.

    Pass condition: complete experience from entry to exit.

    Days 21–24: Optimization

    • Add LODs and simplified collision.
    • Reduce unnecessary materials and transparency.
    • Compress textures and audio.
    • Stream or zone content.
    • Profile on the weakest target device.

    Pass condition: stable performance in the representative busy case.

    Days 25–27: QA, accessibility and safety

    • Test devices, inputs, network interruption and capacity.
    • Check captions, contrast, motion and navigation alternatives.
    • Verify permissions, reporting and moderation.
    • Test every failure and retry path.

    Pass condition: no launch-blocking defect and clear recovery from common failures.

    Days 28–30: Limited launch and learning

    • Release to a controlled audience.
    • Observe behavior and collect feedback.
    • Compare the primary metric with the brief.
    • Fix severe friction.
    • Decide what to keep, improve, remove or expand.

    Pass condition: a real visitor can complete the intended loop and the team knows what to improve next.

    How much does a first scene cost?

    There is no honest universal price. Cost depends on fidelity, platform, custom code, asset rights, team rates, devices, multiplayer, moderation and ongoing content.

    Think in production bands instead of magic numbers.

    Band 1

    Prototype

    One builder, platform primitives, one interaction, limited custom art. The main cost is time. The goal is proof, not polish.

    Band 2

    Polished platform scene

    A small team may include a 3D artist, designer and platform scripter. Custom assets, audio, testing and optimization become significant. Existing platform systems reduce backend work.

    Band 3

    Custom multi-user application

    Engineering, 3D art, technical art, UX, backend, QA, safety operations and live support. Hosting and maintenance continue after launch.

    The cheapest first step is usually a graybox. It answers whether the experience deserves the expensive version.

    Team roles: one person can start, specialists help finish

    A solo creator can produce a strong first scene with modern tools. Larger or more demanding projects benefit from clear roles:

    RoleResponsibility
    Experience designerDefines the visitor loop and tests behavior.
    World or environment artistCreates place, composition and lighting.
    3D artistModels, UVs, textures and optimizes assets.
    Technical artistConnects visual quality to runtime performance.
    Developer or scripterImplements interaction, data and systems.
    ProducerProtects scope, schedule and decisions.
    QA testerFinds the failures familiarity hides.
    Community and safety leadPlans moderation and live operations.

    On a small team, one person may wear several hats. Name the hats anyway. A task that belongs to “the team” has a habit of belonging to nobody.

    Rights, safety and platform rules are part of the build

    Before publishing, confirm:

    • the right to use every model, texture, logo, recording and voice;
    • whether generated assets meet the destination's policy;
    • whether a real landmark or brand introduces usage restrictions;
    • how user-created content is reviewed and removed;
    • which age groups can access the experience;
    • how purchases and refunds work;
    • how visitor data is stored and displayed;
    • how users report harm or abuse;
    • whether off-platform links are permitted;
    • whether the experience needs regional restrictions.

    For real-location experiences, be thoughtful about culture and memory. A place is not merely a texture pack. Consult reliable local sources and, when appropriate, people connected to the location. Avoid turning sensitive sites into casual game mechanics.

    The strongest worlds do not bolt trust onto the final build. They design it into the rules.

    Pre-launch checklist

    Purpose

    Can the team state the visitor, verb and outcome in one sentence? Is the first meaningful action visible or discoverable quickly? Does the scene have a clear ending, continuation or return reason?

    Assets

    Are scale, pivots, normals and naming consistent? Are source files preserved? Are licenses and provenance recorded? Do materials survive the target import?

    Performance

    Has the scene been profiled on the weakest supported device? Are LOD, collision, texture and audio budgets in place? Has the representative busy case been tested?

    Experience

    Can a new visitor complete the loop without the builder explaining it? Is feedback immediate and understandable? Are failure and reconnection states recoverable?

    Accessibility and safety

    Are important cues available through more than one sensory channel? Are text and controls readable? Are mute, block, report and moderation paths ready where required? Are permissions clear?

    Operations

    Who owns bugs, updates and community response? What metric will be reviewed after launch? What can be removed if performance or comprehension is weak?

    If the primary loop is clear, the world runs reliably and visitors can recover from mistakes, the scene is ready to teach you something real.

    Related EarthMeta reading

    Frequently asked questions about building in the metaverse

    Do I need to know how to code to build in the metaverse?

    Not necessarily. Platform builders and AI-assisted tools can create environments and simple interactions without traditional programming. Coding becomes more important when the project needs bespoke mechanics, external data, complex multiplayer behavior or a custom application. Start with the least complex route that can prove the idea.

    Which software should a beginner use?

    Use a platform-native builder for the fastest first result. Learn Blender when you need custom 3D assets. Consider Unity or Unreal when the experience needs control that the platform cannot provide. The right sequence is often platform builder first, Blender second, custom engine only when the experience earns the complexity.

    Is Blender good for metaverse creation?

    Yes. Blender is widely used for modeling, UVs, materials, rigging, animation and export. Its glTF exporter supports a practical runtime pipeline. The destination platform still determines the final settings, material support, scale and asset limits.

    Should I use GLB, glTF, FBX or OBJ?

    Use the format the destination officially supports best for the feature you need. GLB/glTF is strong for modern runtime delivery and PBR assets. FBX remains common for engine pipelines, rigs and animation. OBJ is useful for simple static geometry. Always test a small representative asset before committing the production library.

    How detailed should my first scene be?

    Detailed enough that the purpose and place feel intentional, but small enough to load quickly and change cheaply. Concentrate quality on the hero view, first interaction and route. Let distant and low-attention areas use simpler geometry and materials.

    How long does it take to build a metaverse scene?

    A rough prototype can take days. A polished platform scene may take weeks or months. A custom multi-user world can take much longer. Scope matters more than the word “metaverse.” One coherent courtyard is easier to estimate than an open-ended city.

    Can AI build a complete metaverse world for me?

    AI can accelerate concepts, first structures, assets and scripts. A complete experience still needs selection, layout, interaction, optimization, rights review, testing and operation. Use AI to make the first draft faster; use human judgment to make the result worth visiting.

    How do I make a virtual world run well on mobile?

    Design for mobile from the beginning. Limit unique materials, transparency, dynamic lights, particles and active objects. Use LODs, simple collision, compressed textures and zoned loading. Profile on a real lower-end target device throughout production, not only before launch.

    What makes people return to a metaverse scene?

    Return visits usually come from change, progress, relationships or utility. Rotating content, social rituals, creation, competition, collections, learning paths and connected destinations can all work. A reward alone may attract a click; a meaningful loop builds a habit.

    Can I build on a real city in EarthMeta?

    Yes. EarthMeta's world is organized around real geographic cities. Its creator stack includes an AI building workflow, a construction editor, controlled object placement and external 3D model imports. The strongest project connects its experience to the chosen location rather than using the city name as decoration.

    Is EarthMeta already a finished virtual world?

    EarthMeta is live and actively developing. Its public launch dates to October 2024, and its roadmap marks multiple creator systems as completed through 2026 while mobile, AR, VR and broader AI systems continue to develop. Builders use the live tools available today and design future expansions around capabilities as they launch.

    What should I build first in EarthMeta?

    Build one arrival scene with one action and one continuation. A welcome pavilion, discovery route, small game, gallery or local story experience is enough. Choose a real location for a clear reason, use AI to explore the first structure, add specific imported assets where they matter and test whether visitors understand what to do.

    How do Governors and Presidents fit into an EarthMeta city?

    Every EarthMeta city has a Governor who receives 1% of every trade in that city, and every country has a President who receives 0.5% of every transaction across the whole country. One person can hold both roles and collect 1.5% on their own city. The tax applies to every asset traded in the territory, owned or not: $100,000 traded in a city = $1,000 tax collected by its Governor.

    Build the smallest world people will remember

    The metaverse does not need another enormous empty promise. It needs places with purpose.

    Start with a visitor, a verb and an outcome. Block the scene before polishing it. Choose formats that travel. Treat performance, accessibility and safety as design. Let AI widen the possibilities, then use human judgment to make them coherent.

    EarthMeta offers a particularly interesting canvas because the location already means something. Its real-city structure, AI building tools and expanding creator stack turn a familiar coordinate into an interactive destination. The platform is young, which means the opportunity is not to imitate a mature ecosystem overnight. It is to build the kinds of useful, memorable scenes from which an ecosystem grows.

    One place. One action. One reason to return.

    Sources and methodology

    Product details come from EarthMeta's official pages; technical and market references come from the publishers below, as of October 2026. Third-party figures are forecasts or company-reported results and keep their attribution. Governor and President amounts are examples: the tax collected depends on the trading activity in their city or country.

    1. EarthMeta About: company history, launch and geographic scope
    2. EarthMeta Roadmap: launch date, completed creator tools and upcoming initiatives
    3. EarthMeta AI Buildings & Land: live AI creation workflow and future AI directions
    4. Khronos glTF 2.0 Specification: runtime format, asset structure and GLB packaging
    5. Roblox 3D Importer: supported import formats and asset capabilities
    6. Unity Model File Formats: generic versus proprietary import guidance
    7. Unreal Engine FBX Static Mesh Pipeline: FBX compatibility, materials, collision and LOD guidance
    8. Newzoo 2026 Global Games Market: 2026 player and revenue forecast
    9. Roblox Global Impact of Creation: creator payouts reported by Roblox
    0%
    Newsletter

    Stay in the loop.

    Get the news before everyone else: every big launch, drop and promotion, straight to your inbox. No tracking pixels. Unsubscribe in one click.

    No tracking pixels. Unsubscribe in one click.

    $EMT and EarthMeta NFTs are crypto-assets: their value can go down as well as up. Nothing on this site is financial advice. Risk Disclosure

    © 2026 · EarthMeta LTD · Hong Kong