Yes , you have an alt. Repeating it make it true.
Ah, the ole say it enough so it’s true method.
Classic. Please let me know which account is my alt.
This has major ‘ @cybergenesis alt account’ energy 
So you’re saying my alt account is the op of this thread?
Your ai is weird man.
Maybe it lost iq from the prompts you choose to use. I really hope your robots are better than what you currently are using.
Haha, touché! I honestly have no idea what they are even arguing about or why they chose a Cyberland thread to settle it. 
Absolute comedy, but hey—a bump is a bump! Thanks for the shoutout and the support, man. 
It’s just Phasma trying to touch my butt as always.
He’s a horny little guy.
Hello Internet Computer community,
While developing the backend for our 3D metaverse, Cyberland, we encountered two fundamental UX friction points inherent in traditional Web3 (EVM/Solana) architectures:
-
“NFT Jail”: The necessity to lock assets into an escrow contract to list them for sale, preventing their use in-game.
-
“Ghost Listings”: The inability to keep marketplace state in sync with asset state changes (e.g., burning or moving an item), resulting in stale orders that require manual, gas-heavy cancellation.
By leveraging the Internet Computer’s unique ability to maintain mutable state within canisters and perform high-speed inter-canister calls, we have implemented a fully reactive marketplace architecture. This removes the need for traditional escrow-based locking and ensures 100% data consistency across user sessions.
Below are three technical demonstrations of how we handle this.
1. Reactive Cross-Session State Synchronization
In many Web3 architectures, marketplace data is decoupled from the asset state, often relying on off-chain indexing (e.g., Subgraphs). In Cyberland, we utilize ICP’s low-latency updates to synchronize state directly.
-
Scenario: An observer (Account A) views a Land Plot on the marketplace with specific metadata (3/49 mods, x1.25 PWR multiplier). Simultaneously, the owner (Account B) modifies the land configuration in a different session.
-
Technical result: Account A’s UI updates instantly without page refreshes or WebSocket latency, reflecting the new metadata (6/49 mods, x1.35 PWR) as the state change occurs on-chain.
-
Demonstration: Link to X
2. Auto-Delisting via Local State Mutation (No-Escrow Architecture)
We have eliminated the “NFT Jail” by keeping assets under the user’s control rather than moving them into an escrow contract. We simply flag the asset as “available for sale” within the asset’s internal state.
-
Scenario: A user lists a rare
@windoge_98($EXE) mod for sale. The order is active on the marketplace. The user then mounts that same mod onto their 3D land plot for a power boost. -
Technical result: The moment the asset state changes (installation onto the land), the backend automatically invalidates the marketplace listing flag. The listing vanishes instantly. No manual cancellation, no gas wasted, no ghost orders.
-
Demonstration: Link to X
3. Atomic Batch Delisting via Crafting
The most challenging state sync occurs when an asset is destroyed (e.g., burning/crafting) while listed. Our Crafting Forge Station handles this atomicity within the canister logic.
-
Scenario: A user lists three distinct ecosystem mods (BobbyO $CLOUD, ghost_icp $GHOST, WumbrosArmy $WUMBO) on the market. The user then sends these items to the Crafting Forge to mint a Rare Cache.
-
Technical result: The canister processes the craft, burns the ingredient tokens, and atomically purges all three independent listings simultaneously. The marketplace state remains clean, and the user receives the output asset without ever encountering a “double-spend” or “transaction failed” error.
-
Demonstration: Link to X
Engineering Rationale
On EVM-based chains, this functionality would necessitate complex, centralized off-chain middleware and heavy reliance on indexers, which fundamentally undermines the decentralization of the application.
On ICP, by keeping the 3D game logic, marketplace, and inventory system within the same sovereign canister state, we achieve “World Computer” performance. We are maintaining 100% on-chain validation with the speed of traditional centralized game servers.
I am interested in hearing how other devs are managing atomic state sync between disparate dApp components (e.g., Marketplace vs. Game Logic). Feel free to share your thoughts or ask questions about our data structure implementation.
The Cyberland open beta is live if you’d like to test the latency and state sync yourself.
Three.js: Stress-test of dynamic runtime rendering — instant switching between 6 heavy biomes in a single canvas (mobile browser)
Hi!
I wanted to share the results of a stress test I built for my project. The video was recorded in a single take on a mobile browser — with no page reloads and without recreating the WebGL context.
What happens in the demo:
• Switching between 6 completely different biomes.
• Each biome consists of a heavy main GLB model with a full set of 2K PBR textures + 30–40+ additional modular GLB assets (1K).
• Total polygon count per scene: approximately 2.5 million triangles.
• Fully dynamic placement of modifiers (using the same asset pool, but with unique configuration and positioning in each biome).
• Inside the canvas background — a custom 6-octave procedural shader generating flying purple void nebula clouds.
• Complex UI overlay with numerous animated elements, pulsations, and a cosmic background.
• Active post-processing.
The most technically interesting parts:
• Complete dispose + rebuild of the entire scene (geometries, materials, textures, objects) plus custom post-processing passes, all done on the fly.
• No memory leaks or VRAM crashes throughout the entire test.
• Stable high FPS with no drops, even in the heaviest scene.
https://youtube.com/shorts/mHwpgf66g98?si=ODCq3bhRsSrIsBW8
Most staking designs boil down to a passive loop: lock tokens, wait, and collect rewards. We wanted to move away from that paradigm.
In Cyberland, stake weight is completely dynamic — strictly tied to the live on-chain NFT state rather than just static token counts. The entire system is built natively on ICP.
Core Mechanics:
-
Dynamic Weight Updates: Adding a modifier to a land plot updates the stake weight instantly within the execution loop. No unstaking or re-staking required.
-
Auto-Optimization: Acquiring a stronger land plot triggers an automatic swap to the highest-PWR plot within the canister logic. Zero manual switching or extra gas fees for the end user.
The Architecture: The backend infrastructure tightly integrates composable NFTs, dynamic stake weight, Synthetix-style reward distribution, a 7-day linear vesting period, and on-chain Lite DAO governance.
Rewards accrue continuously instead of relying on traditional end-of-epoch snapshots. If a user installs modifiers on day 5, they earn proportionally more starting from that exact second. Everything is processed fairly and deterministically on-chain.
Zero external servers. Zero off-chain oracles. Pure ICP canister state execution.
We also implemented a live staker leaderboard where anyone can click a player, inspect their live 3D land layout, and verify every single modifier slot. Don’t trust, verify.
Canister Logic Proof
We recorded a quick video walkthrough showing the canister logic handling these state changes live on mainnet with zero cuts:
Stage 1: Base Stake We stake 10,000 CBR on the Standard tier (14 days). The canister automatically targets the active starting land (Island Archipelago, base multiplier x1.00). The final weight calculates to exactly 10,000 PWR.
Stage 2: Live Composability Switching over to the Land tab, we mount 3 modifiers (KinicAI, onical, LiquidiumWTF). The land multiplier instantly updates to x1.07. When navigating back to Governance, the stake weight has automatically jumped to 10,700 PWR. No extra transactions, no manual sync delays—it updates within the same millisecond. The frontend 3D canvas smoothly reflects the updated assets.
Stage 3: Auto-Swap Logic Next, we buy a more powerful plot from the marketplace for 26,000 CBR — a Volcanic Crag (ID #125) carrying a x1.52 multiplier with 12 pre-installed mods. Upon returning to the Governance tab, the canister automatically detects the higher PWR asset, swaps out the old land context, and re-calculates the final stake weight to 15,180 PWR instantly.
Video proof: https://youtube.com/shorts/vB8VXHvC2f0?is=vmHVj0oaTFD4q4d2
Try the Live Beta
The public beta is fully deployed and free to test (running in game mode with test tokens). We’d love to get the community’s feedback, technical questions, or any edge cases you manage to break!
Live DApp: https://cyberland-zmu.caffeine.xyz/
X account: https://x.com/cyberland_icp?s=11
Hiya, I’m also using Caffeine. Did you manage to upload audio files?
Public Land — Now Anyone Can View Someone Else’s Land in Live 3D Straight in a Mobile Browser
We have launched a new section — Public Land. This isn’t just a standalone feature; it’s the logical continuation of what we’ve been building all this time: a fully on-chain 3D ecosystem where each land plot is a composable NFT with 49 slots for modifiers, and each modifier is a distinct on-chain object.
The concept is simple: Now anyone can open someone else’s public land and view it in full 3D — featuring the exact same graphics and unique modifier layout as the owner sees it. Straight in a mobile browser. Zero compromises. 
What is Public Land?
Each land plot in our ecosystem is a completely composable object. 3D modifiers can be placed or removed at any moment. This means the scenes are not static — they are live, dynamically reconstructed from the on-chain state in real time.
The owner decides whether their land is public or private — the toggle lives right on the land card, completely on-chain.
-
Public: It enters the Public Land section, and anyone can open it in 3D.
-
Private: No one but the owner can see it.
To keep the browsing experience clean, our backend enforces a strict filter: empty lands do not make it into Public Land. At least 1 out of 49 modifiers must be installed. This exact filter now applies in three distinct places:
-
Public Land: The browsing section for exploring other users’ lands.
-
Our Leaflet CyberMap: Interactive coordinate beams render only if the plot is public and contains at least one modifier.
-
The Main Leaderboard: Plots enter the rankings under the exact same filtering conditions.
What the Visitor Sees
When you open another user’s public land, a second independent 3D canvas mounts. It loads the current on-chain state of that land and renders it exactly as it lives right now:
-
True 7×7 Layout: The exact same arrangement across 49 slots, unique per account, permanently stable.
-
Discrete On-Chain Objects: Every modifier is a separate GLB file with its own texture and material.
-
Atmospheric Shaders: The same background shader cloud coverage running a heavy 6 octaves of FBM loop.
-
Layered Post-Processing: The exact same visual stack is fully preserved.
If the owner removes a modifier, you see it disappear from the scene in real time. If they place a new one, it appears in the correct slot with the correct local rotation. For guests, the viewer is entirely read-only — no transactions, no changing modifiers, no mutations. Pure viewing. But the viewing experience is absolute, completely matching the owner’s perspective. Interactive likes can be cast directly inside this new Public 3D Viewer! 
Technical Specs Per Scene
A fully maxed-out land features 49 out of 49 modifiers. That means one base biome landscape (full PBR, 2K textures, custom biome-specific geometry) + up to 49 modifiers. Every modifier is a unique high-poly GLB with a 1K texture and its own material. No LODs, no impostors. On the contrary — we are squeezing the absolute maximum tuning out of what we have.
The Payload: We are maintaining ~3,000,000 triangles on screen, ~50 unique GLB draw calls, full PBR workflows, layered post-processing, and a live on-chain state for every object (weights, IDs, ownership, rarity tiers) read directly from the canister smart contract.
And all of this renders smoothly on a mid-range mobile phone, inside Safari, at a stable FPS.
Two WebGL Canvases in One App
This was the hardest part of the engineering process. We built two independent 3D canvases — one for the owner’s personal dashboard and a second for viewing other users’ public lands — and made them safely coexist.
-
Open Public Viewer
A fresh 3D engine mounts, loads the external land data, and renders its current on-chain state. -
Close Public Viewer
The engine unmounts completely, and your own personal canvas resumes smoothly without memory leaks or Context Lostcrashes.
Keeping two WebGL contexts stable inside one mobile browser tab isn’t just a graphics rendering problem — it’s a scheduling problem. We are managing two heavy rendering timelines that absolutely cannot collide on the main thread.
Deterministic Layout — But Not How You Think
Every modifier has a fixed slot on the land (49 slots, 7×7). However, the exact arrangement, rotation, and positioning of modifiers across the slots are unique per user account, permanently stable, and generated deterministically from the user’s on-chain identity.
-
Same Account
The exact same layout structure, always, on any device globally. -
Different Account
A completely different structural layout.
There is no saved .json scene file. There is no pre-baked environment layout. The layout is derived mathematically, not downloaded. The 3D engine reads the blockchain transaction history and structurally pieces the world together from scratch.
Leaflet CyberMap Over WebGL
Directly on top of the 3D engine sits our interactive Leaflet map layer. Every land plot is represented by a vertical coordinate beam on the map. Click a beam the map flies straight to it, opens a popup with live on-chain data (views, likes, modifier count, PWR multiplier), and from there, you can instantly jump into the full 3D viewer.
The complexity here is that Leaflet runs entirely on the main thread (DOM manipulation, projection recalculations every single frame during pan/zoom), and the R3F render loop does too. Having both in a single mobile application is a scheduling problem more than a rendering problem. We treat them as two timelines that must not collide on the main thread.
Note: The map remains a clean, high-performance navigational plane (no heavy 3D inside the map itself), and we will soon be adding a dedicated like counter directly onto the map beacons!
The Marketplace as the Core Entry Point
This is what we are absolutely proudest of. A listing card in the marketplace is no longer just a static “Buy” button. Every single card serves as an interactive portal splitting into three distinct modes:
-
Click Photo / Slot Counter (0/49): Instantly overlays a 7×7 DOM Inspector, revealing every equipped modifier as an independent on-chain object.
-
Click 3D Button (Top-Left, color-coded to the biome): Mounts the public land viewer, rendering the land in live 3D WebGL.
-
Click Map Button (Top-Right, color-coded to the biome): Opens the Leaflet map, flies straight to the land’s coordinate beam, and auto-opens the information popup.
Three fundamentally different context engines — DOM Inspector, R3F Canvas, and Leaflet Map — are all instantly accessible right from a single card UI without ever leaving the marketplace. On mobile. Rock stable.
Watch the Live Mobile Demo on YouTube
What We Learned
-
WebGL context lifecycles are much more flexible than documentation states — but only if you truly understand why the rules exist. We stopped trying to force the contexts to behave and started orchestrating exactly when they are allowed to run.
-
“Warming up the context” isn’t a simple one-liner. A single first-frame signal isn’t a true “ready” state. We had to figure out what actually constitutes a stable GL state allocation on a cold mobile GPU — and it’s completely different from what standard tutorials teach.
-
Two canvases is a scheduling problem, not a rendering problem. The second we stopped looking at it as “two renderers” and started designing it as “two timelines that must never collide on the main thread,” everything clicked.
-
Leaflet on top of two WebGL contexts is the exact same problem shifted one abstraction layer up. The map isn’t special; it’s just another main-thread consumer that has to harmoniously coexist with our graphics loops.
-
On-chain state as the source of geometry is a massive superpower, not a limitation. When the engine treats the blockchain ledger as the absolute source of truth, you stop fighting asset download pipelines and start fighting microsecond frame budgets — and that’s a battle you can actually win.
See It In Action & Test It Live!
We recorded a quick walk-through natively on a mobile phone to demonstrate the seamless canvas switching, map transitions, and live 3D rendering performance under real conditions:
Watch the Live Mobile Demo on YouTube
The build is completely live right now! The marketplace is fully open, and public lands are entirely browseable, filterable, and viewable in uncompromised 3D by anyone. Jump in, test it yourself, and explore what other players are building in real time!
Launch the App & Explore Public Lands
Here
TL;DR: Public Land is live. Anyone can now open someone else’s public land in full 3D right inside a mobile browser, experiencing the exact graphics and modifier setups as the owner. Composable NFTs, 49 slots, every modifier is a separate GLB with its own texture, ~3M triangles on maxed loads, two coexisting WebGL canvases, a Leaflet map overlaid, native on-chain likes in the cards, and a unified marketplace hub with 3D + map + inspector entry points. No LODs, no downgrades, running smoothly on mid-range smartphones.
We welcome your feedback and would
love to answer any technical questions you have! Drop them in the thread below. 
X / Twitter
CLICK HERE TO VIEW THE 3D MARKETPLACE VISUAL PREVIEW
We might have built one of the most technologically advanced 3D NFT marketplaces in all of crypto. Across every chain. 
Sell a 3D Land NFT bundled with all 49 3D modifier slots in a single atomic on-chain operation. Or sell mods individually. One click, nanosecond settlement, zero gas.
Every listing card is a 3-in-1 portal: open live 3D, inspect the 7×7 mod grid, or fly to the land on the map — all from one card, without leaving the marketplace.
It’s alive. While your land is listed, keep building it — mount or unmount mods and the active listing updates instantly: 3D scene, inspector, PWR, all synced in real time. No “cat in a bag” — buyers see exactly what exists on-chain right now.
Auto-delisting kills ghost listings for you. Listed a mod, then mounted it somewhere or used it in a craft? Marketplace delists it automatically. Batch-craft 3-4 listed mods in one recipe? They all delist in the same second. No manual cleanup, no dead cards.
Sell your only land without fear — the moment someone buys it, a new random land auto-mints to your wallet in the same second. You’re never left at zero.
The UI/UX is the kind you have to feel live. 
Fully working composable 3D on-chain ecosystem. Free open beta is live.
The marketplace is just one piece of it — we built it because nothing on the web3 market could handle composable NFTs with 49 live slots. But the result ended up stronger than projects that built a marketplace as the end goal — because we built for a real mechanic (49 slots, live sync, atomic bundles), not for abstract “NFT trading.” Dig deeper and you’ll see it’s a fraction of what’s running.
Don’t take my word for it — go test it yourself: https://cyberland-zmu.caffeine.xyz/