ForgeVerse is a sovereign metaverse platform built on Bitcoin SV, designed to provide true digital property ownership, hyper-realistic rendering, and a zero-barrier access model. Unlike every existing metaverse platform, ForgeVerse does not require a download, does not custody user assets, and does not own the land it renders. Ownership lives on the BSV blockchain. World state runs on a sovereign OpenSimulator fork. Rendering happens through Unreal Engine 5. Access happens through a browser via Pixel Streaming. Every parcel of virtual land is bound to a real-world GPS coordinate through ForgePlanetary. Every avatar is a LiDAR-scanned representation of the actual user, chain-stamped as a 1Sat Ordinal.
ForgeVerse is Product #4 in the Forgechain ecosystem of 24 sovereign products. It serves as the Spirit sphere in the Forgechain Trifecta, alongside ForgeView (Mind) and ForgePlanetary (Body). Together, these three spheres present a unified triple-viewport model of reality: knowledge, physical space, and the space between worlds.
This whitepaper defines the complete 7-layer architecture, explains each layer's role and its interactions with adjacent layers, describes the parcel system, avatar pipeline, rendering infrastructure, access model, and federation protocol. It provides a competitive analysis against existing metaverse platforms, outlines the revenue model, and presents a phased development roadmap.
Version 1.0 of this whitepaper, chain-stamped at TX a71db137, described ForgeVerse in terms of spatial sovereignty as a general concept. Version 2.0 replaces that document entirely with the full architectural specification decided on March 15, 2026.
The metaverse as a concept has existed for decades, from Neal Stephenson's Snow Crash to the virtual world experiments of the early 2000s. The current generation of metaverse platforms, however, shares a set of fundamental problems that no amount of iteration can fix. These problems are structural. They are baked into the architecture.
Decentraland runs on Ethereum. The Sandbox runs on Ethereum. Meta Horizon Worlds runs on Meta's servers. Second Life runs on Linden Lab's servers. In every case, the platform operator or the platform's chosen blockchain determines what you can and cannot own. Decentraland's LAND tokens exist on Ethereum, which means your virtual property is subject to Ethereum's gas fees, congestion, and governance decisions. Second Life's "land" is a database entry on Linden Lab's servers. If Linden Lab shuts down, your property ceases to exist.
ForgeVerse places ownership on BSV, where a parcel deed is a UTXO and an object is a 1Sat Ordinal. Transfer is a transaction. The chain does not care about the platform. If ForgeVerse's servers go offline, the ownership record persists on the blockchain. The deed survives the world.
Decentraland renders in low-polygon browser graphics. The Sandbox uses voxel art. Meta Horizon Worlds renders legless avatars in a cartoon aesthetic. Second Life, despite 20 years of development, still renders at a level that was dated in 2010. None of these platforms have invested in photorealistic rendering because their architectures cannot support it.
ForgeVerse renders through Unreal Engine 5, using Nanite for virtualized geometry (billions of polygons with no LOD popping), Lumen for real-time global illumination, and MetaHuman for hyper-realistic avatar rendering. The visual standard is wire-mesh realism. Cartoon avatars are not supported. The goal is a virtual space that looks and feels like physical reality.
Most metaverse platforms require a client download, a specific operating system, or a VR headset. This creates an immediate barrier to entry. A user who wants to visit a virtual space must first install software, create an account, configure hardware, and hope their machine meets the minimum specifications.
ForgeVerse uses Pixel Streaming. The full UE5 experience is rendered server-side and streamed to the user's browser via WebRTC. The front door is a URL. Phone, tablet, desktop, any device with a modern browser can enter ForgeVerse. No download. No app store. No minimum hardware specification beyond a browser and an internet connection.
Existing metaverse platforms exist in abstract coordinate spaces. A plot of "land" in Decentraland has no relationship to any place on Earth. This makes virtual real estate a purely speculative asset with no grounding in physical reality.
ForgeVerse binds every virtual parcel to a real-world GPS coordinate through the ForgePlanetary layer. Your virtual property sits above your physical property. A business can have a ForgeVerse presence at its actual street address. Geocaching, geofenced commerce, and proof-of-presence become native features. The virtual world is not an escape from physical reality. It is a layer on top of it.
Meta Horizon Worlds is built by Facebook. The business model is data extraction. Every interaction, every conversation, every movement through virtual space is captured and monetized. The user is not the customer. The user is the product.
ForgeVerse runs on sovereign infrastructure. The BSV chain provides the ownership layer. OpenSimulator provides the world state. Users can run their own sims and interconnect via HyperGrid. There is no central authority collecting behavioral data. There is no advertising model. There is no surveillance.
ForgeVerse is not a game. It is not a social media platform with 3D graphics. It is not a speculative real estate market.
ForgeVerse is a sovereign spatial computing platform where:
ForgeVerse is built on a vertical stack of seven distinct layers. Each layer has a specific responsibility. No layer duplicates the function of another. The boundaries between layers are clean and protocol-defined.
Role: Source of truth for all ownership. Parcels, objects, avatars, deeds.
The BSV blockchain is the foundation of ForgeVerse. It is not a feature of the platform. It is the bedrock on which the platform stands.
Every parcel of virtual land is a UTXO (Unspent Transaction Output) on the BSV chain. The UTXO contains metadata defining the parcel's boundaries, GPS coordinates, creation timestamp, and owner. Transferring a parcel means spending the UTXO to a new owner's address. This is a standard Bitcoin transaction. No smart contract complexity. No gas fees measured in dollars. BSV's transaction fees are measured in fractions of a cent.
Every in-world object is a 1Sat Ordinal. A 1Sat Ordinal is a single satoshi (the smallest unit of Bitcoin) inscribed with data. For ForgeVerse, that data is the object's 3D mesh, texture references, scripting logic, and provenance chain. When you build a table in ForgeVerse and sell it, the buyer receives a 1Sat Ordinal containing that table. They own it the way you own a Bitcoin. No platform can revoke it.
Avatar meshes are also 1Sat Ordinals. When you scan yourself with a LiDAR-equipped phone and generate your wire-mesh avatar, that mesh is inscribed on-chain. Your avatar is your property. It persists across sessions, across servers, across the entire HyperGrid federation.
The chain does not run the world. It does not simulate physics. It does not render frames. It does one thing: it records who owns what. That single function, performed immutably by the most scalable proof-of-work blockchain in existence, is what makes everything above it sovereign.
Key design principle: The chain owns the land, not OpenSim. OpenSim runs the world state on top of chain ownership. If the OpenSim server goes offline, the ownership record on BSV remains intact. The world can be rebuilt from chain state.
Technical specifications:
Role: Physics simulation, object persistence, parcel management, scripting, permissions, HyperGrid federation.
OpenSimulator is an open-source virtual world server, BSD-licensed, originally developed as a compatible server for the Second Life viewer protocol. It has been in active development since 2007. It handles everything that makes a virtual world function as a world: physics, object placement, parcel boundaries, avatar positioning, scripting, permissions, terrain, and inter-region teleportation.
ForgeVerse uses a custom fork of OpenSim 0.9.3.0. The fork is called the ForgeChain Module and consists of five components:
OpenSim's scripting language (LSL, with OSSL extensions) allows users to build interactive objects, automated systems, and immersive experiences in-world. This is one of OpenSim's greatest strengths and a key reason it was chosen over building a custom world state engine. Two decades of scripting libraries, tutorials, and community knowledge transfer directly.
Why OpenSim and not a custom engine?
Building a virtual world server from scratch would take years and millions of dollars. OpenSim is battle-tested, BSD-licensed (no copyleft restrictions), handles physics, permissions, scripting, and federation. The ForgeChain Module adds sovereignty on top of a proven foundation. This is the Forgechain philosophy: build on what works, add the chain layer where it matters.
Role: Bind every virtual parcel to a real-world GPS coordinate. Enable geospatial features.
ForgePlanetary is Product #7 in the Forgechain ecosystem and the Body sphere of the Trifecta. Within ForgeVerse, it serves as the coordinate translation layer.
Every ForgeVerse parcel has two sets of coordinates: its OpenSim region coordinates (used for world state simulation) and its ForgePlanetary GPS coordinates (latitude, longitude, altitude). The GPS binding is inscribed in the parcel's on-chain deed. It is part of the ownership record.
This binding enables several capabilities that no other metaverse platform offers:
Physical-digital property alignment. A homeowner can mint a ForgeVerse parcel at their home's GPS coordinates. Their virtual property sits directly above their physical property. When viewed through the Trifecta viewport, the physical world (ForgePlanetary) and the virtual world (ForgeVerse) share a coordinate system. You can see your digital house above your physical house.
Geofenced commerce. A business can create a ForgeVerse storefront at its physical address. Users physically near that location can enter the virtual storefront with proximity-based features. Proof-of-presence is chain-stamped: the user's device GPS is verified, and a transaction records that they were physically at those coordinates at that time.
Geocaching and exploration. Objects can be placed at specific GPS coordinates and discovered only by users who are physically present. Chain-stamped proof-of-discovery creates verifiable records of who found what and when.
Sovereign geotags. Unlike Google Maps pins or Apple Maps annotations, ForgePlanetary geotags are owned by the user and recorded on BSV. No platform can remove your geotag. No algorithm can suppress your location data.
Coordinate translation pipeline:
Coordinate system: WGS 84 (same as GPS). Altitude is measured in meters above sea level. Parcel boundaries are defined as polygons in lat/long space. The OpenSim region grid is mapped to a Mercator-like projection with configurable scale (default: 1 OpenSim meter = 1 physical meter).
Role: Render the world. Nanite geometry. Lumen lighting. MetaHuman avatars. The visual layer.
Unreal Engine 5 is the most advanced real-time rendering engine available. It is the renderer for ForgeVerse. It does not manage world state, ownership, or physics simulation. It receives scene data from OpenSim (via the protocol bridge) and renders it.
Nanite Virtualized Geometry. Nanite allows ForgeVerse to render scenes with billions of polygons without traditional level-of-detail (LOD) management. A user can build a detailed structure with millions of triangles, and Nanite will stream and render only the visible triangles at pixel-level granularity. This eliminates the polygon budgets that constrain every other virtual world platform. In Decentraland, a parcel is limited to a few thousand triangles. In ForgeVerse, the limit is the available compute, and Nanite manages it gracefully.
Lumen Global Illumination. Lumen provides real-time global illumination and reflections. Light bounces off surfaces naturally. A candle in a virtual room illuminates the walls with warm, indirect light. A glass window refracts and reflects the environment. Shadows are soft and accurate. This is not baked lighting. It is dynamic. If a user moves an object, the lighting updates in real time.
MetaHuman. MetaHuman is Unreal Engine's system for creating and rendering hyper-realistic human characters. In ForgeVerse, MetaHuman is used as one of two avatar rendering pathways (the other being the LiDAR wire-mesh pipeline). MetaHuman provides the skeletal mesh, skin shader, hair system, and clothing simulation. The LiDAR scan provides the unique geometry. ARKit provides the face tracking data. Together, they produce an avatar that looks like the actual human user and moves like the actual human user.
Why Unreal Engine 5 and not Unity, Godot, or a custom renderer?
Rendering pipeline:
Frame targets:
Role: Create a hyper-realistic avatar from a phone LiDAR scan. Chain-stamp it. Track the face in real time.
The LiDAR Avatar System is ForgeVerse's identity layer. It answers the question: who are you in this world?
The answer is: you. Not a preset. Not a cartoon. Not a selection from a menu of hairstyles and skin tones. You, scanned by the LiDAR sensor on your phone, converted to a wire-mesh 3D model, chain-stamped as a 1Sat Ordinal on BSV.
The scanning process:
Face tracking:
ARKit (Apple's face tracking framework) provides 52 blendshapes that capture the full range of human facial expression. These blendshapes map to the avatar's face mesh in real time. When you smile, your avatar smiles. When you raise an eyebrow, your avatar raises an eyebrow. When you speak, your avatar's lips move in sync.
For Android users without ARKit, MediaPipe Face Mesh provides 468 face landmarks that can be mapped to a comparable blendshape system.
Why LiDAR and not photogrammetry or AI generation?
LiDAR provides millimeter-accurate depth data in real time. Photogrammetry requires multiple photos and significant processing time. AI-generated avatars are not representations of the actual user. They are hallucinations. ForgeVerse's commitment to hyper-realism requires that the avatar is a direct measurement of the human body, not an approximation or a fabrication.
Chain-stamped identity implications:
Non-negotiable design principle: Hyper-realism. ForgeVerse does not support cartoon avatars, anime-style characters, furry avatars, or any non-human avatar representation. The avatar is you. This is a deliberate philosophical choice. ForgeVerse is a space for human connection grounded in physical reality, not escapism into fantasy characters. The wire-mesh aesthetic, even at lower polygon counts, communicates authenticity in a way that a cartoon avatar never can.
Role: Stream the rendered UE5 experience to any browser via WebRTC. Zero barrier to entry.
Pixel Streaming is the access layer. It eliminates every barrier between a user and ForgeVerse.
No download. No app store approval. No minimum hardware specification. No operating system requirement. The user receives a URL. They open it in a browser. The full UE5 experience, Nanite geometry, Lumen lighting, MetaHuman avatars, is rendered on the server and streamed to the browser as a video feed via WebRTC. User input (mouse, keyboard, touch, gamepad) is captured by the browser and sent back to the server in real time.
How Pixel Streaming works:
Latency: The critical metric for Pixel Streaming is input-to-display latency. This is the time from when the user moves the mouse to when they see the result on screen. Target latency is under 100ms on a wired connection and under 150ms on a strong WiFi connection. This is achievable with NVENC hardware encoding, which adds approximately 2-5ms of encoding latency.
Bandwidth requirements:
The URL as the front door. This is a fundamental architectural decision. Every other metaverse platform adds friction between the user and the experience. ForgeVerse removes it. A user can share a link to their virtual property on social media, in an email, in a text message. The recipient clicks the link and is immediately in that space, looking at it, interacting with it. This is how the web works. ForgeVerse makes the metaverse work like the web.
Signaling server architecture:
The Pixel Streaming signaling server manages WebRTC session negotiation. ForgeVerse uses a custom signaling server that integrates with the ForgeChain Module to verify user identity (BSV address) before establishing the stream. This means that parcel access permissions are enforced at the streaming level. If a parcel is set to private, the signaling server will not establish a stream to unauthorized users.
Multi-user sessions:
Each Pixel Streaming session is a separate rendering instance. For shared spaces (multiple users in the same region), the OpenSim server provides the authoritative world state. Each user's UE5 rendering instance receives the same scene data but renders from that user's camera position. This means each user sees other users' avatars, object movements, and environmental changes in real time, even though each user has their own rendering stream.
Role: Unite ForgeVerse (Spirit) with ForgeView (Mind) and ForgePlanetary (Body) in a single viewport.
The Trifecta is the convergence layer. It is not a feature of ForgeVerse alone. It is the architectural integration point where all three Forgechain spheres meet.
The three spheres:
The unified viewport:
The Trifecta viewport displays all three spheres simultaneously. The user can focus on one sphere, switch between spheres, or view all three overlaid. The key is that all three spheres share a coordinate system anchored to ForgePlanetary's GPS coordinates.
When the user looks at a location on the ForgePlanetary globe:
Cross-sphere dependency arcs:
The Trifecta is not three separate views. It is three views of one reality with dependency arcs between them:
These arcs are rendered as visual connections in the Trifecta viewport, showing the user how their actions in one sphere ripple through the others.
Implementation:
The Trifecta viewport is a custom application built on the Forgechain UI framework. It communicates with:
All three data streams converge in a single rendering context. The viewport itself is lightweight. The heavy computation happens in the respective backend services (UE5 for ForgeVerse, the knowledge engine for ForgeView, the geospatial engine for ForgePlanetary).
The 7 layers of ForgeVerse interact through well-defined interfaces. Understanding the data flow between layers is essential to understanding how the system works as a whole.
The ForgeChain Module continuously monitors the BSV chain for transactions relevant to the ForgeVerse world. When a new parcel deed is inscribed, the Parcel Validator creates the corresponding region in OpenSim. When a parcel is transferred, the Parcel Validator updates permissions. When an object is inscribed, the Asset Service Wrapper registers it in OpenSim's asset database.
Data flow is primarily chain-to-OpenSim (the chain is the source of truth, OpenSim is the consumer). However, the Transaction Logger also writes from OpenSim to chain, recording in-world economic actions as BSV transactions.
The protocol bridge is the most complex interface in the stack. OpenSim's scene graph (objects, terrain, avatars, lighting) must be translated into UE5's actor/component model.
The bridge operates as a bidirectional socket connection:
ForgePlanetary provides the coordinate translation service. When a new parcel is minted, ForgePlanetary validates the GPS coordinates, checks for conflicts with existing parcels, and provides the coordinate mapping data that is inscribed on-chain. OpenSim's Parcel Validator queries ForgePlanetary to resolve GPS coordinates to region coordinates.
This is a native UE5 data path. The Pixel Streaming plugin captures rendered frames from the GPU, encodes them via NVENC, and sends them through the WebRTC pipeline. No custom code is needed for this interface. The customization is in the signaling server (which adds BSV identity verification) and the JavaScript frontend (which integrates with the Trifecta viewport).
The Trifecta layer does not directly interact with Layers 1-3. It consumes the outputs of ForgeView, ForgePlanetary, and ForgeVerse (via Pixel Streaming) and composites them in a unified viewport. It is a presentation layer, not a data layer.
The parcel system is the economic foundation of ForgeVerse. Parcels are the primary asset class, and their design reflects ForgeVerse's core principles of sovereignty, physical-world grounding, and chain-backed ownership.
A new parcel is minted by creating a BSV transaction with an OP_RETURN output containing the parcel's metadata:
{
"type": "forgeverse_parcel",
"version": 2,
"gps": {
"lat": 41.4312,
"lon": -73.6807,
"alt": 152.4
},
"bounds": {
"type": "polygon",
"vertices": [
[41.4312, -73.6807],
[41.4313, -73.6807],
[41.4313, -73.6806],
[41.4312, -73.6806]
]
},
"opensim_region": "forge-001",
"opensim_coords": {
"x": 128,
"y": 128,
"z": 25
},
"size": {
"x": 256,
"y": 256,
"unit": "meters"
},
"name": "Forge Homestead",
"created": "2026-03-15T00:00:00Z",
"owner_pubkey": "02abc123..."
}
The UTXO created by this transaction is the deed. The owner of the UTXO owns the parcel. Transfer is a standard BSV transaction spending the UTXO to a new address.
ForgeVerse defines four standard parcel sizes, aligned with OpenSim's region model:
Custom sizes are supported but must be approved by the ForgePlanetary coordinate validation system to prevent overlaps and ensure GPS alignment.
The parcel owner can set permissions on their parcel through OpenSim's permission system, enforced by the ForgeChain Module's Parcel Validator:
All permission changes are recorded on-chain by the Transaction Logger.
Parcel minting fees are denominated in BSV satoshis. The fee is a one-time payment that covers the on-chain inscription cost plus a small protocol fee:
| Size | Fee (sats) | Approx. USD |
|---|---|---|
| Plot (64m x 64m) | 10,000 | ~$0.05 |
| Quarter (128m x 128m) | 25,000 | ~$0.12 |
| Region (256m x 256m) | 100,000 | ~$0.50 |
| Mega (512m x 512m) | 400,000 | ~$2.00 |
These prices are illustrative and will be calibrated based on BSV price and demand at launch. The principle is that virtual land should be accessible, not speculative. ForgeVerse is not Decentraland, where a plot costs $5,000. A ForgeVerse parcel costs less than a cup of coffee.
Transferring a parcel is a BSV transaction. The seller spends the parcel UTXO to the buyer's address. The transaction can include a payment output (buyer pays seller) and a fee output (protocol fee of 1-2%). This can be executed through the ForgeMarketplace or directly between users.
The avatar system is ForgeVerse's most visible differentiator. Every other metaverse platform allows users to create fantasy characters. ForgeVerse requires users to represent themselves.
The avatar pipeline transforms a physical human body into a real-time digital representation in six stages:
Stage 1: LiDAR Capture
The user holds their phone and performs a slow 360-degree rotation while the LiDAR sensor captures depth data and the camera captures color data. The app guides the user with visual indicators showing which areas have been scanned and which need more coverage. Total scan time: 60-90 seconds.
Stage 2: Point Cloud Processing
The raw LiDAR data is a point cloud: millions of 3D points with color values. The processing stage filters noise, fills gaps, and aligns frames to produce a clean, dense point cloud.
Stage 3: Mesh Generation
The point cloud is triangulated into a mesh using Poisson surface reconstruction. The resulting mesh is a continuous surface that represents the user's body with high geometric accuracy.
Stage 4: Optimization
The raw mesh may contain millions of triangles, which is too many for real-time rendering of multiple avatars. The optimization stage reduces the triangle count while preserving visual fidelity. Target: 50,000-100,000 triangles for the body mesh, with higher detail (20,000-30,000 triangles) preserved for the face. Normal maps baked from the high-resolution mesh retain fine detail at the lower polygon count.
Stage 5: Rigging
The optimized mesh is automatically rigged to the MetaHuman skeleton using machine learning-based joint estimation. This maps the mesh's vertices to skeletal bones, allowing the avatar to be animated with standard humanoid animations. The rigging process also configures the 52 ARKit blendshapes for facial animation.
Stage 6: Chain Inscription
The final avatar package (mesh, textures, normal maps, rig data, blendshape configuration) is inscribed on BSV as a 1Sat Ordinal. The inscription TXID becomes the avatar's permanent identifier.
During a ForgeVerse session, the user's front-facing camera captures facial expressions. ARKit (or MediaPipe on Android) extracts blendshape coefficients 60 times per second. These coefficients are sent to the rendering server via the Pixel Streaming data channel and applied to the avatar's face mesh in real time.
The result: when you laugh, your avatar laughs. When you concentrate, your avatar furrows their brow. When you speak, your avatar's lips sync to your words. This is not lip-syncing from audio analysis. This is direct visual tracking of the actual mouth movements.
ForgeVerse's visual identity includes a distinctive wire-mesh rendering mode. In this mode, the avatar is displayed as a wireframe with visible triangle edges, giving a technical, authentic appearance. This aesthetic serves three purposes:
Users can toggle between wire-mesh mode and full shaded mode (using MetaHuman's skin, hair, and clothing shaders) at any time.
The ForgeChain Module is the custom code that transforms vanilla OpenSimulator into a BSV-sovereign world state engine. It is designed as a set of OpenSim region modules that can be loaded at runtime, minimizing changes to OpenSim's core codebase and simplifying future upgrades.
OpenSim's native asset service stores assets (meshes, textures, scripts, animations) in a local database or a remote asset server. The Asset Service Wrapper intercepts all asset storage and retrieval calls and routes them through BSV.
On asset creation:
StoreAsset(asset).On asset retrieval:
GetAsset(assetId).This design means that all assets are stored on BSV but cached locally for performance. The local cache can be rebuilt from the chain at any time. If a sim server dies, all its assets survive on the chain.
The Parcel Validator runs as a background service that maintains a local index of all ForgeVerse parcel UTXOs. It subscribes to BSV block notifications and updates the index when new parcel transactions are confirmed.
When OpenSim processes a permission check (can this user modify this parcel?), the Parcel Validator:
This adds minimal latency (the index is local) while ensuring that all permission decisions are grounded in on-chain ownership.
The Avatar Identity Manager bridges BSV identity and OpenSim identity. It implements a custom authentication module for OpenSim's login service.
Login flow:
This means there is no separate ForgeVerse username or password. Your BSV keypair is your identity. Your avatar mesh is your appearance. Both are on-chain.
The Transaction Logger monitors all economically significant OpenSim events and records them on BSV:
Each event is recorded as a BSV transaction with OP_RETURN metadata describing the event. This creates an immutable, auditable history of all economic activity in ForgeVerse.
OpenSim's HyperGrid protocol allows avatars to teleport between independently operated grids. The HyperGrid Bridge extends this protocol with BSV verification:
Outbound teleport (leaving a ForgeVerse sim for another):
Inbound teleport (arriving from another grid):
This means that identity and appearance are consistent across the entire federation. A user looks the same on every sim. Their ownership credentials travel with them. No sim operator can impersonate another user or fabricate assets.
The rendering pipeline is the path from OpenSim world state to pixels on the user's screen. It involves three systems: OpenSim (world state), UE5 (rendering), and Pixel Streaming (delivery).
The protocol bridge is a standalone service that runs alongside OpenSim and UE5. It maintains persistent connections to both and translates between their data models.
From OpenSim, the bridge receives:
To UE5, the bridge sends:
From UE5 (via Pixel Streaming), the bridge receives:
To OpenSim, the bridge sends:
OpenSim uses a proprietary mesh format internally (sculpted prims, mesh assets in LLSD format). UE5 uses FBX, OBJ, or its native UASSET format. The protocol bridge includes a mesh translator that converts OpenSim mesh data to UE5-compatible formats at load time. For chain-stamped assets (1Sat Ordinals), the bridge fetches the mesh data from BSV, converts it, and loads it into UE5's content pipeline.
Textures follow a similar path. OpenSim stores textures as JPEG2000. UE5 uses compressed formats (DXT, ASTC). The bridge handles the conversion.
The bridge maintains a scene graph that mirrors both OpenSim's object tree and UE5's actor hierarchy. When OpenSim updates an object (moves it, changes a property), the bridge updates the corresponding UE5 actor. When UE5 detects a user interaction, the bridge routes it to the corresponding OpenSim object.
Synchronization runs at 20 Hz (20 updates per second), which is sufficient for smooth object movement and responsive interaction. Avatar positions update at 30 Hz for smoother animation.
Pixel Streaming is ForgeVerse's access layer. Its design determines the user experience for every person who enters ForgeVerse.
A ForgeVerse Pixel Streaming deployment consists of:
ForgeVerse's Pixel Streaming implementation includes adaptive quality:
Pixel Streaming includes bidirectional audio. The user's microphone audio is sent to the server via WebRTC. Spatial audio is rendered by UE5 and streamed back. When another avatar speaks in ForgeVerse, the audio comes from the avatar's position in 3D space, with appropriate attenuation and environmental effects (reverb in a room, echo in a canyon).
The GPS binding system is what makes ForgeVerse unique among metaverse platforms. No other virtual world maps its coordinate space to Earth's surface.
Global level: WGS 84 GPS coordinates (latitude, longitude, altitude). This is the same coordinate system used by every GPS device on Earth. A ForgeVerse parcel's global coordinates are accurate to the centimeter level when derived from RTK GPS sources, or to the meter level when derived from consumer GPS.
Region level: OpenSim region coordinates (X, Y, Z in meters relative to the region origin). Each region is a 256m x 256m area (standard size). The region origin is mapped to a specific GPS coordinate.
Local level: Object coordinates within a region. Standard 3D Cartesian coordinates relative to the region origin.
The translation between GPS coordinates and OpenSim coordinates is performed by the ForgePlanetary Coordinate Service:
This translation is reversible. Given an OpenSim region and local coordinates, the service can return the corresponding GPS coordinate.
When two users attempt to mint parcels at overlapping GPS coordinates, the ForgePlanetary Coordinate Service rejects the second minting attempt. First to chain wins. The parcel deed that is confirmed in an earlier block (or earlier in the same block) has priority. This is consistent with Bitcoin's first-seen rule and prevents double-claiming of virtual territory.
ForgeVerse does not pre-mint the entire surface of the Earth. Parcels are minted on demand by users. The virtual world grows organically as users claim coordinates that are meaningful to them: their homes, their businesses, their favorite places. Over time, clusters of parcels form in populated areas while remote areas remain unclaimed and available.
The Trifecta is the culmination of three Forgechain products converging into a single user experience. It is not a metaphor. It is a literal triple-viewport application.
The Trifecta viewport divides the user's screen (or arranges in a spatial layout) into three zones:
The user can resize, rearrange, or collapse any sphere. They can also enter "focus mode" where one sphere fills the screen and the others appear as small overlays.
All three spheres share ForgePlanetary's GPS coordinate system as their anchor. When the user focuses on a location:
Panning on one sphere pans all three. Zooming on one sphere zooms all three (unless the user decouples them). This creates a unified spatial experience where information, physical reality, and virtual reality are layers of the same view.
The Trifecta is not just three views side by side. Actions in one sphere can trigger responses in others:
These cross-sphere actions are the Trifecta's distinguishing feature. They make the three spheres feel like one unified reality rather than three separate applications.
ForgeVerse is not a single server. It is a federation of sovereign servers, interconnected through OpenSim's HyperGrid protocol, enhanced with BSV chain verification.
ForgeClan members who operate at the Elder or Founding Father tier can run their own OpenSim regions and join the ForgeVerse federation. Each ForgeClan member's server is independently operated. They control their own hardware, their own bandwidth, their own content policies.
The HyperGrid Bridge connects these independent servers into a seamless virtual world. A user on one server can teleport to another server, carrying their chain-verified identity and avatar with them.
ForgeClan members register their servers in a federation directory (a BSV-anchored registry of server addresses, region names, and metadata). Users can browse the directory to discover new regions to visit. The directory is decentralized: any ForgeClan member can register, and the registration is a BSV transaction.
ForgeVerse does not exist in isolation. It is Product #4 in a 24-product ecosystem, and it interfaces with many of the other products. These connections are not theoretical. They are specific integration points defined by the architecture.
The Trifecta partner for knowledge. ForgeView knowledge nodes can be pinned to ForgeVerse locations. ForgeVerse events generate ForgeView records. The two spheres share a coordinate system through ForgePlanetary.
The Trifecta partner for physical reality. ForgePlanetary provides the GPS coordinate system that grounds ForgeVerse in the real world. Every ForgeVerse parcel has a ForgePlanetary coordinate. The two spheres share a spatial index.
In-world transactions. When a user purchases an object, a parcel, or a service in ForgeVerse, the transaction is processed through ForgePay. ForgePay handles BSV micropayments, fee splitting, and transaction confirmation.
Virtual venue rental. ForgeSpace manages bookable spaces within ForgeVerse: conference rooms, event venues, co-working spaces. Users can reserve a ForgeVerse space through ForgeSpace and receive a Pixel Streaming URL for the reserved time slot. ForgeSpace takes a 1-5% booking fee.
Buy and sell virtual assets. ForgeMarketplace lists ForgeVerse objects (furniture, buildings, art, scripts) as 1Sat Ordinals for sale. Buyers browse the marketplace, purchase an ordinal, and the object appears in their ForgeVerse inventory.
Raspberry Pi as thin client. ForgeNode devices connect to ForgeVerse via Pixel Streaming, providing a dedicated hardware entry point for users who want a purpose-built ForgeVerse appliance rather than a browser tab.
Wearable hardware. The ForgeExoframe includes a LiDAR scanner for avatar creation and an AR visor for mixed-reality ForgeVerse viewing. The visor overlays ForgeVerse content on the physical world, using ForgePlanetary coordinates for alignment.
AI content pipeline. ForgeCreate generates textures, meshes, terrain features, and architectural elements for ForgeVerse world building. Users describe what they want, ForgeCreate generates it, and the result is inscribed on BSV and placed in ForgeVerse.
Chain-verified art. ForgeArt pieces can be displayed in ForgeVerse galleries. Each piece is a 1Sat Ordinal with provenance tracked on the chain. Virtual gallery owners purchase display rights or host ForgeArt exhibitions.
Music streaming in virtual venues. ForgeVerse venues can stream ForgeTunes audio. Live music events in ForgeVerse use ForgeTunes for audio delivery and artist compensation (BSV micropayments per stream).
Identity layer. ForgeSocial provides the social graph that connects ForgeVerse users. Friend lists, group memberships, and social interactions in ForgeVerse are managed through ForgeSocial's Nostr-compatible protocol.
World persistence across node death. If a ForgeVerse server goes offline, ForgeBlackStart provides the recovery protocol: chain state is intact, asset data is on BSV, world configuration is recoverable. A new server can boot from chain state and restore the world to its last known good state.
ForgeVerse enters a market with several established competitors. The following analysis compares ForgeVerse's architecture against each.
| Feature | Decentraland | ForgeVerse |
|---|---|---|
| Blockchain | Ethereum | BSV |
| Transaction cost | $5-50+ per TX | < $0.01 per TX |
| Land cost | $5,000+ per LAND | < $1 per parcel |
| Graphics | Low-poly browser | UE5 Nanite/Lumen |
| Access model | Browser client download | Pixel Streaming (no download) |
| Avatar system | Preset components | LiDAR scan |
| Physical binding | None | GPS coordinates |
| Self-hosting | No | Yes (HyperGrid) |
| Governance | DAO | Sovereign |
Decentraland's fundamental limitation is Ethereum. High gas fees make land prohibitively expensive and discourage microtransactions. The low-poly graphics are a consequence of the browser-based client, which cannot support modern rendering techniques. ForgeVerse's Pixel Streaming approach solves this by moving rendering to the server.
| Feature | The Sandbox | ForgeVerse |
|---|---|---|
| Blockchain | Ethereum | BSV |
| Art style | Voxel (Minecraft-like) | Photorealistic |
| Focus | Gaming | General purpose |
| Land ownership | Ethereum NFT | BSV UTXO |
| User creation | VoxEdit tool | OpenSim in-world + ForgeCreate AI |
| Physical binding | None | GPS coordinates |
| Federation | No | HyperGrid |
The Sandbox has carved a niche in gaming-focused virtual worlds with a distinctive voxel aesthetic. ForgeVerse is not competing for the same audience. ForgeVerse targets users who want realistic virtual spaces for business, collaboration, education, and social interaction. The two platforms address fundamentally different use cases.
| Feature | Second Life | ForgeVerse |
|---|---|---|
| Ownership model | Linden Lab owns everything | BSV chain owns deeds |
| Asset storage | Linden Lab servers | BSV chain |
| Graphics | OpenGL (dated) | UE5 Nanite/Lumen |
| Client | Desktop download required | Pixel Streaming (browser) |
| Creation tools | In-world building | In-world building (OpenSim) + UE5 |
| Federation | No | HyperGrid |
| Self-hosting | No | Yes |
| Land cost | $229/month (region) | One-time minting fee |
Second Life is the closest architectural ancestor of ForgeVerse. OpenSim itself is a reimplementation of Second Life's server protocol. ForgeVerse inherits Second Life's greatest strength (in-world building tools, scripting, social spaces) while solving its greatest weaknesses (centralized ownership, dated graphics, desktop-only access, monthly land fees).
| Feature | Meta Horizon Worlds | ForgeVerse |
|---|---|---|
| Operator | Meta (Facebook) | Self-hosted |
| Business model | Data extraction | Micropayment fees |
| Ownership | Meta owns everything | BSV chain |
| Privacy | Surveillance architecture | No tracking |
| Hardware | Quest headset required | Any browser |
| Graphics | Cartoon avatars, no legs | MetaHuman, LiDAR scan |
| Physical binding | None | GPS coordinates |
Meta Horizon Worlds is the antithesis of ForgeVerse. It is a surveillance platform disguised as a metaverse. Users do not own their data, their identity, or their creations. The Quest headset requirement creates a hardware moat that benefits Meta's hardware business at the expense of accessibility. ForgeVerse's Pixel Streaming approach is the opposite: any device, any browser, no surveillance.
ForgeVerse's competitive advantages are:
ForgeVerse's server-side rendering model means that hardware requirements fall on the operator, not the user.
That is the complete list. No GPU. No minimum RAM. No specific operating system. A $200 Chromebook can access ForgeVerse at full quality.
The initial ForgeVerse rendering server runs on the existing Bro Horse machine:
The RTX 2070 SUPER can handle 3-5 concurrent Pixel Streaming sessions at 720p/30fps, or 1-2 sessions at 1080p/60fps. This is sufficient for MVP development and small-group testing.
As ForgeVerse grows, the rendering infrastructure scales in two ways:
Vertical scaling: Upgrade to more powerful GPUs (RTX 4090, RTX 5090, or professional-grade A6000). A single RTX 4090 can handle 8-12 concurrent sessions.
Horizontal scaling: Add more rendering servers behind the load balancer. Each server is an independent rendering node that can serve a pool of users. Servers can be physical machines, cloud instances (AWS G5, GCP A2), or a mix.
Hardware upgrades are justified by demand, not speculation. ForgeVerse does not pre-provision a server farm. It starts with one GPU and adds capacity as users arrive. This is consistent with the Forgechain philosophy of building for reality, not hype.
ForgeNode (Raspberry Pi) devices can serve as thin-client entry points but cannot render. They connect to a remote rendering server via Pixel Streaming.
ForgeVerse generates revenue through transaction fees and service fees, not through advertising, data extraction, or speculative land pricing.
One-time fees paid when a new parcel is created. The fee covers the BSV inscription cost plus a protocol margin. At the parcel prices described earlier (10,000-400,000 sats), the protocol margin is approximately 50% of the fee.
A 1-2% fee on the transaction value when a parcel is sold through ForgeMarketplace or the in-world marketplace. For direct transfers (user-to-user without the marketplace), the fee is optional but encouraged to support the protocol.
ForgeSpace takes a 1-5% fee on venue bookings. This applies to conference rooms, event spaces, co-working spaces, and other bookable areas within ForgeVerse.
ForgeMarketplace takes a 2-5% fee on asset sales (objects, scripts, textures, avatar accessories). All fees are collected in BSV.
ForgeClan members at the Elder and Founding Father tiers receive premium parcels, priority rendering capacity, and HyperGrid federation access. Tier fees are BSV-denominated and paid monthly or annually.
For high-demand events (concerts, conferences, launches), additional rendering capacity may be provisioned on a per-event basis. The event organizer pays a compute fee proportional to the number of concurrent sessions and the duration of the event.
ForgeVerse is technology with a philosophy. The Gnostic layer is not a feature of the software. It is the meaning behind the architecture. It is why ForgeVerse exists, not just how.
In Gnostic cosmology, reality has three aspects: Hyle (matter), Psyche (soul), and Pneuma (spirit). The Forgechain Trifecta maps directly to this framework:
ForgeVerse is the Pneumatic realm. Entering it is not escapism. It is an expansion of reality into a sovereign space where creation, interaction, and ownership are governed by the individual, not by a Demiurge.
In Gnostic tradition, the Demiurge is a false creator god who constructed a prison of matter to trap the divine spark (Pneuma) within human souls. The Archons are the Demiurge's servants, enforcing the prison's rules.
In the digital world:
Meta Horizon Worlds is the Demiurge's metaverse. It is a prison built to look like freedom. Users create content that Meta owns. Users interact in spaces that Meta surveils. Users wear hardware that Meta controls.
ForgeVerse is the Pleroma: the fullness of reality, unchained. Ownership is on BSV, not on a platform database. Identity is a keypair, not a username. Access is a URL, not an app store download. Creation tools are open-source. Federation means no single authority.
Entering ForgeVerse is, symbolically, the moment the divine spark recognizes itself. The user is not logging into a game. They are stepping into a sovereign space where their body (LiDAR scan), their property (BSV deed), and their identity (BSV keypair) are theirs.
The wire-mesh avatar aesthetic reinforces this. The wire-mesh does not hide reality behind polished textures. It reveals the structure. It says: this is what you are, digitally. Triangles and vertices, measured by light and recorded on a chain that no one can alter.
This is not religion. It is architecture with meaning. The Gnostic framework provides a narrative structure for understanding why sovereignty matters, why surveillance is harmful, and why ForgeVerse is built the way it is.
ForgeVerse's development is organized into seven phases. Each phase delivers a working capability that can be demonstrated and tested. The phases build on each other sequentially, though some work within later phases can begin in parallel with earlier phases.
Objective: Install Unreal Engine 5 on Bro Horse. Create a test scene. Demonstrate Pixel Streaming from server to browser.
Deliverables: UE5 installed and running on Bro Horse (RTX 2070 SUPER). A test scene with Nanite geometry, Lumen lighting, and a MetaHuman character. Pixel Streaming configured and functional. A browser client that can connect, view the scene, and navigate with mouse/keyboard. Latency and bandwidth benchmarks.
Success criteria: A user on a separate machine can open a browser, connect to Bro Horse, and navigate a photorealistic 3D scene at 30+ FPS with under 150ms input latency.
2-3 WEEKSObjective: Fork OpenSim 0.9.3.0. Build the five ForgeChain Module components. Demonstrate BSV-backed parcel minting and ownership verification.
Deliverables: OpenSim 0.9.3.0 forked and building from source. All five module components operational (Asset Service Wrapper, Parcel Validator, Avatar Identity Manager, Transaction Logger, HyperGrid Bridge). Test parcel minted on BSV with GPS coordinates.
Success criteria: A user can log into the ForgeVerse OpenSim grid with their BSV keypair, teleport to a parcel they own (verified on-chain), and create an object that is inscribed on BSV.
4-6 WEEKSObjective: Build the bridge that translates OpenSim world state into UE5 rendered scenes. First unified scene: OpenSim-managed objects rendered by UE5 and streamed via Pixel Streaming.
Deliverables: Protocol bridge service running alongside OpenSim and UE5. Object sync, avatar sync, terrain sync, and input relay. Bidirectional state synchronization at 20+ Hz.
Success criteria: A user in a browser (via Pixel Streaming) can see a UE5-rendered scene that reflects the OpenSim world state, interact with objects, and see changes from other users in real time.
6-8 WEEKSObjective: Build the avatar scanning, processing, and chain inscription pipeline. Demonstrate a LiDAR-scanned avatar rendered in ForgeVerse with real-time face tracking.
Deliverables: iOS app (or prototype) for LiDAR body scanning. Point cloud to mesh processing pipeline. Mesh optimization, MetaHuman skeleton rigging, BSV inscription as 1Sat Ordinal. ARKit face tracking integration (52 blendshapes). Wire-mesh rendering mode.
Success criteria: A user scans themselves with an iPhone, the resulting avatar appears in ForgeVerse looking recognizably like them, and their facial expressions are tracked in real time.
6-8 WEEKSObjective: Integrate ForgePlanetary's coordinate system into ForgeVerse. Demonstrate a parcel minted at a specific GPS coordinate and visible at that coordinate in both ForgePlanetary and ForgeVerse.
Deliverables: ForgePlanetary Coordinate Service integrated with ForgeChain Module. GPS-to-OpenSim coordinate translation. Parcel minting with GPS coordinates. Conflict detection for overlapping GPS claims.
Success criteria: A user mints a parcel at their home's GPS coordinates. The parcel is visible in ForgeVerse at the correct location. The parcel is visible on the ForgePlanetary map at the correct location on Earth.
3-4 WEEKSObjective: Build the triple-sphere viewport that combines ForgeView, ForgePlanetary, and ForgeVerse. Demonstrate cross-sphere interaction.
Deliverables: Trifecta viewport application with three sphere zones. Shared coordinate system navigation. Cross-sphere actions. Dependency arc visualization. Color-coded UI (Gold/Green/Violet).
Success criteria: A user can view all three spheres simultaneously, navigate using a shared coordinate system, and perform actions that ripple across spheres.
4-6 WEEKSObjective: Open ForgeVerse to ForgeClan members. Enable self-hosted sims. Launch public parcel sales. Demonstrate inter-server teleportation.
Deliverables: ForgeClan registration and tier system. Documentation for self-hosted setup. Federation directory (BSV-anchored). Public parcel minting interface. ForgeMarketplace integration. Inter-server teleportation with BSV identity verification. Onboarding flow for new users.
Success criteria: Multiple independently operated ForgeVerse servers are interconnected. Users can teleport between them with their chain-verified identity. Parcels can be purchased, transferred, and built upon.
6-8 WEEKSTotal Estimated Timeline: Phases 1 through 7, executed sequentially with some parallel work where possible, represent approximately 31-43 weeks of development. This is an aggressive but achievable timeline for a focused team.
ForgeVerse is the most architecturally ambitious metaverse project built on BSV. It combines seven layers of technology into a system that provides true digital property ownership, hyper-realistic rendering, zero-barrier access, physical-world grounding, sovereign identity, and federated world hosting.
No other metaverse platform offers this combination. Decentraland has blockchain ownership but cartoon graphics. Second Life has creation tools but centralized control. Meta Horizon Worlds has capital but surveillance architecture. None of them bind virtual space to physical coordinates. None of them use LiDAR to create actual human avatars. None of them stream full-quality rendering to a browser with no download.
ForgeVerse is Product #4 in the Forgechain ecosystem, and its connections to the other 23 products create a network effect that no standalone metaverse can replicate. ForgePay handles transactions. ForgeMarketplace handles commerce. ForgeCreate handles content generation. ForgeSocial handles identity. ForgeBlackStart handles resilience. ForgeNode handles hardware. ForgeExoframe handles wearables. Every product reinforces every other product.
The Spirit sphere completes the Trifecta. Mind, Body, and Spirit. Knowledge, Earth, and the space between worlds. Three views of one reality, unified by a coordinate system and secured by a chain.
ForgeVerse is not a game. It is not a toy. It is not speculation.
It is sovereign spatial computing. Built on the most scalable blockchain. Rendered by the most advanced engine. Delivered to any browser on Earth.
The Pleroma is open.
ForgeVerse is a product of the Forgechain ecosystem, conceived and architected by Jack Mosel.
Original whitepaper (v1.0) was inscribed on the BSV blockchain at transaction: a71db137...fecd311
That inscription establishes the priority date for the ForgeVerse concept, including sovereign metaverse architecture, chain-backed virtual property ownership, and the spatial sovereignty framework.
This document (v2.0) supersedes the original whitepaper in its entirety. It defines the complete 7-layer architecture, the OpenSim fork with ForgeChain Module, the LiDAR avatar pipeline, the Pixel Streaming access model, the ForgePlanetary GPS binding, and the Trifecta integration. All concepts described herein are original work.
v2.0 will be inscribed on the BSV blockchain following review and approval. The chain timestamp will establish the priority date for all architectural decisions and technical specifications contained in this document.
Legal notice: This whitepaper and all concepts described herein are the intellectual property of Jack Mosel and the Forgechain project. The BSV blockchain inscription constitutes a timestamped, immutable proof of authorship. All rights reserved.
"The Pleroma is open."
ForgeVerse v2.0 Whitepaper — March 15, 2026
Forgechain Product #4 — #7B68EE Metaverse Violet
The Spirit Sphere. Sovereign Metaverse. Chain-Backed Reality.