First-party case study · In development

Bloxiti: keeping a high-fidelity creator sandbox coherent

Bloxiti combines the clarity of block-based construction with the visual ambition of a modern Unreal Engine project. Creators can work with full-fidelity meshes, authored materials, stamps, reusable Blueprint kits, weather, lighting, cameras, streamed terrain, and persistent worlds rather than being limited to a library of identical cubes.

A high-angle modular maze over turquoise water with red and cyan blocks and a material palette in Bloxiti
A glossy coral-pink modular corridor with selection wireframe from Bloxiti Factory Island
01 · Coming soon on Steam

2025 Epic MegaGrant recipient

First-party Bloxiti capture

That breadth is the product’s appeal. It is also the engineering challenge.

A single placement can cross chunk coordinates, sparse world data, instanced rendering, custom material parameters, water boundaries, undo history, inventory records, save data, thumbnails, and export flows. In this case study, the Gamibase workflow turns that chain into one reviewable development model: identify the owning data contract, trace the state transition end to end, define what counts as proof, and keep roadmap work separate from features that are already usable.

Project snapshot

Bloxiti at a glance

First-party relationship, product surface, and the Gamibase role on this project.

Relationship

First-party project; not a client engagement

Product

A creator-focused sandbox for modular construction and high-quality scene building

Engine

Unreal Engine 5

Recognition

2025 Epic MegaGrant recipient

Core surfaces

Blocks, materials, stamps, Blueprint kits, undo and redo, weather, cameras, procedural worlds, water, persistence, export, and capture

Gamibase role

System mapping, contract traceability, bounded technical review, evidence design, and release-honest reporting

Public status

In development; public Steam page available

01 · Situation

The situation

Bloxiti’s creator loop begins simply: choose something, place it, adjust it, and keep building. Underneath that interaction is a heterogeneous content system.

Block definitions connect curated meshes, materials, and icons. Custom materials carry tiling, roughness, metallic, emissive, imperfection, overlay, and glass parameters. Stamps combine textures and appearance data. Blueprint kits group blocks and stamps into reusable constructions. Weather profiles alter sky, volumetrics, light, fog, wind, and post-processing. Camera and exposure changes can be part of the same reversible creative session.

The world around those creations is generated and streamed in chunks. Seeded noise produces terrain, caves, water, surface layers, and tree placement. Chunk state expands across borders so visibility and water can respond to neighboring data. Modified chunks, creator inventories, custom materials, external media, and world metadata all need to survive save, reload, export, and handoff.

The result is not one system. It is a network of systems that must agree about the same creator action.

02 · Constraint

The engineering constraint

The project’s own technical analysis identified several places where a visually successful action could diverge from authoritative state:

01

block edits perform validation, instancing, border propagation, water work, visibility updates, and dirty-state tracking in one path;

02

undo commands can manipulate rendered instances without necessarily proving that canonical chunk data changed with them;

03

sparse block arrays require repeated linear searches as worlds and edit sessions grow;

04

water changes can trigger full-volume mesh work and neighboring refreshes;

05

custom materials, thumbnails, and external-media records can be duplicated across chunk saves and player inventories;

06

chunk unload can intersect with synchronous or overlapping persistence work;

07

dedicated-server replication, server-side edit validation, navigation, and NPC ownership remain development work rather than shipped guarantees.

Those are not reasons to reduce the creative ambition. They are reasons to make the development boundary more precise.

03 · Where Gamibase helped

Where Gamibase helped

01

It made the creator action traceable

The Gamibase workflow organizes the Bloxiti review around one question: where does the authoritative record of a creator action live?

For a block, material, stamp, or Blueprint kit, the review path is designed to follow the item from catalog and inventory data through preview and placement, undo and redo, chunk ownership, save serialization, reload, export, and capture. That connects systems that are otherwise documented or implemented in separate modules.

The intended benefit is traceability. Designers, engineers, and reviewers can discuss the same asset and the same state transition using one contract and one evidence trail.

02

It separated visual state from saved state

A block that appears in the world is not automatically a block that will reload correctly. A successful undo animation is not automatically an authoritative reversal. A custom material that looks right on one component is not automatically a portable creator asset.

Gamibase checklists make those distinctions explicit. Acceptance evidence is defined around the full loop:

  • 01

    place or change the creator asset;

  • 02

    verify the owning chunk and canonical data record;

  • 03

    undo and redo through the same state-changing path;

  • 04

    unload or save the affected world state;

  • 05

    reload it and compare the reconstructed asset;

  • 06

    export or capture the result with the expected metadata.

This did not magically remove every architectural risk. It stopped those risks from remaining invisible.

03

It turned world-generation review into repeatable scenarios

Bloxiti’s terrain pipeline is already data-driven enough to support reproducible review. World generation uses seed-derived random streams, multiple terrain-noise layers, cave noise, water fill, surface materials, tree selection, and expanded chunk-border data.

The Gamibase workflow uses that determinism as the basis for bounded evidence scenarios: the same seed, the same chunk coordinates, the same border conditions, and the same expected content before and after a change. Streaming, water, instancing, and persistence recommendations can then be tied to an owner module and a repeatable scenario instead of a vague report that a large world “felt slow.”

No frame-rate or latency improvement is claimed here because the checkout does not contain a controlled before-and-after benchmark. The useful outcome was a testable route to those measurements.

04

It connected engineering evidence to visual review

Bloxiti already contains useful capture primitives: runtime texture-to-PNG export, structured JSON job results, weather-preset import and export, saved camera state, showcase maps, and creator-facing scene controls.

The Gamibase model treats those as part of the engineering proof surface. A review package can identify the seed or scene, camera, weather profile, affected content, and output artifacts alongside the code or data change. That makes visual review reproducible enough to support design feedback, technical QA, and later marketing capture without presenting a screenshot as proof of persistence or networking behavior.

05

It kept the roadmap honest

Bloxiti contains foundations for online services, cloud storage, dedicated targets, and marketplace-oriented import and export, plus a design proposal for AI-authored terrain recipes. Presence in the repository does not make every one of those paths production-complete.

Gamibase’s contribution in this case-study model is to label the boundary clearly. The core creation, atmosphere, water, undo, serialization, packaging utilities, capture, and database surfaces are source-documented implementation surfaces. Server-authoritative chunk replication, validated multiplayer edits, broader social systems, marketplace plumbing, navigation and NPC completion, AI terrain, and expanded cloud-save UX remain roadmap or active-development work. Each surface still needs its owning runtime proof before publication makes a stronger operational claim.

That distinction makes the current product story stronger because it is specific enough to trust.

04 · What changed

What changed

Gamibase does not replace Bloxiti’s world generator, art direction, or creator tools. It provides a shared way to reason across them.

The workflow establishes:

01

a system map connecting creator-facing features to the modules and data structures that own them;

02

a contract path from inventory data to placement, undo, persistence, reload, export, and capture;

03

repeatable seeded scenarios for chunk, border, water, and world-generation review;

04

explicit one-writer and server-authority requirements for future multiplayer work;

05

evidence checklists that separate visual correctness from saved-state correctness;

06

release notes that distinguish implemented foundations from proposals and integration surfaces.

05 · Detailed technical report

Scope

This report focuses on the technical path that most directly supports Bloxiti’s product promise:

creator input → authoritative content record → streamed world state → persistence → export and visual evidence

The report covers current architecture, observed seams, the Gamibase review model, and the validation work needed before stronger performance or multiplayer claims can be made.

System map

Product and system map

01

Blocks

Current technical basis

Block definitions, world-to-chunk placement, sparse chunk data, instanced mesh components

Review concern

The rendered instance, canonical block data, undo record, and saved record must remain aligned

02

Materials

Current technical basis

Serialized custom parameters and runtime dynamic material instances

Review concern

Repeated payloads and material instances can increase save and runtime cost

03

Stamps

Current technical basis

Actor-based prefabs carrying texture, appearance, transform, layer, and save data

Review concern

Actor lifecycle, external media, undo, save, and authority need one replayable path

04

Blueprint kits

Current technical basis

Reusable groups of blocks and stamps with command data

Review concern

A grouped action must remain atomic across undo, persistence, and future replication

05

Weather and camera

Current technical basis

Data-backed weather profiles and undoable light, time, exposure, and camera changes

Review concern

Visual state should be portable and attributable to a specific review setup

06

Terrain

Current technical basis

Asynchronous seeded chunk generation with terrain layers, caves, water, surface materials, and trees

Review concern

Queue throughput, lookup cost, game-thread materialization, border coherence, and determinism

07

Water

Current technical basis

Per-chunk procedural meshes, flow and level data, border expansion, neighbor notifications

Review concern

Full rebuilds and neighbor coupling can amplify a small edit

08

Persistence

Current technical basis

Dirty chunks, asynchronous save operations, optional compression, integrity headers, temporary and backup files

Review concern

One-writer ownership, deduplication, unload races, and recovery behavior

09

Export and capture

Current technical basis

PNG texture export, JSON job reports, weather JSON, saved camera and showcase scenes

Review concern

Artifacts need stable scene and state provenance to be useful as evidence

10

Online and cloud

Current technical basis

Direct database/storage integration surfaces plus online and object-storage plugins

Review concern

Integration presence must not be marketed as complete deployment, secure auth, or server authority

Runtime flow

Runtime flow under review

01

The chunk manager decides which chunks should load, generate, materialize, or unload.

02

The world generator and asynchronous chunk task derive deterministic terrain data from the configured seed, noise layers, and terrain parameters.

03

The chunk actor and block-instance task materialize meshes, custom assets, visibility, and water on engine-owned components.

04

Block-edit paths can update world data, rendering state, border data, water, undo history, and dirty-state markers; the documented review risk is that those surfaces can drift when an alternate path updates only part of the state.

05

Save and inventory systems serialize chunk state, creator assets, world metadata, and external references for reload or export.

The risk is concentrated between steps, not inside the diagram. A small change can cross asynchronous work, game-thread components, several copies of asset data, and an unload-triggered save. Gamibase therefore treated each boundary as an ownership and evidence question.

Findings

Key findings and response

01

Observed fact

Chunk operations are queued, but documented analysis identifies one-operation and callback constraints

Engineering risk

Large movement or generation bursts can accumulate work

Gamibase workflow response

Define queue-depth and completion events; replay fixed movement paths against a fixed seed

Claim boundary

No throughput gain claimed without measurements

02

Observed fact

Sparse block data is searched repeatedly during edits and generation

Engineering risk

Lookup and edit cost can grow with chunk density

Gamibase workflow response

Bind profiles to representative chunk densities; consider a dense or indexed authority owned by the world subsystem

Claim boundary

A proposed optimization, not a shipped rewrite

03

Observed fact

Block edits trigger visibility, border, and water work inline

Engineering risk

A burst of creator edits can multiply game-thread work

Gamibase workflow response

Batch authoritative edit records, then coalesce dependent rendering and water updates

Claim boundary

No frame-time improvement claimed

04

Observed fact

Undo commands can act on engine components independently of canonical chunk data

Engineering risk

Visual and persistent worlds can diverge

Gamibase workflow response

Route undo and redo through the same authoritative edit service used by placement

Claim boundary

Current undo is not marketed as fully save-authoritative

05

Observed fact

Custom material and external-media payloads appear in multiple save and inventory structures

Engineering risk

Save size, hydration, and consistency risks increase

Gamibase workflow response

Introduce shared catalog identities and validate hydration before exposing entries

Claim boundary

Deduplication remains future implementation work

06

Observed fact

Persistence includes asynchronous work, compression, integrity checks, and recovery files

Engineering risk

Concurrent unload or save work needs explicit one-writer ownership

Gamibase workflow response

Journal save ownership, bound in-flight work, and verify recovery using interrupted-save scenarios

Claim boundary

Architecture evidence is not an uptime or durability benchmark

07

Observed fact

Server, client, online, object-storage, and database surfaces exist

Engineering risk

Integration can be mistaken for production-ready authority or security

Gamibase workflow response

Keep deployment, credentials, RPC validation, and replication as separately gated claims

Claim boundary

No end-to-end cloud or multiplayer completion claim

Evidence

Evidence design

For a representative creator asset, the Gamibase validation package should contain:

  • 01

    the owning catalog or inventory record;

  • 02

    the placement request and resolved chunk coordinates;

  • 03

    the canonical chunk-data delta;

  • 04

    the instanced mesh or actor result;

  • 05

    the undo and redo records;

  • 06

    affected border, water, and dirty-state events;

  • 07

    the save operation and integrity result;

  • 08

    the reload comparison;

  • 09

    the exported creator asset or world reference;

  • 10

    the PNG or scene capture plus structured job metadata;

  • 11

    a reviewer decision listing any remaining unknowns.

That package is intentionally broader than a screenshot and narrower than a full release test. It is designed to prove one creator loop without claiming that unrelated roadmap surfaces are complete.

Verification gates

Recommended verification gates

01

Gate 1: deterministic generation

Generate the same reviewed chunks from the same seed and configuration. Compare canonical terrain, cave, surface, tree, water, and border data before rendering begins.

02

Gate 2: creator edit authority

Place, replace, and remove blocks, custom meshes, stamps, and a grouped Blueprint kit. Confirm that one authoritative record drives rendering, undo, save, and future replication data.

03

Gate 3: persistence and recovery

Save modified chunks and creator inventories, unload them, reload them, and compare reconstructed state. Interrupt a save at controlled boundaries and verify the integrity, temporary-file, and backup behavior.

04

Gate 4: visual parity

Recreate the same camera, weather, time, and content state. Capture consistent PNG evidence and attach structured scene and camera metadata. Use visual evidence to assess appearance, not to stand in for save or network proof.

05

Gate 5: multiplayer authority

When the server-authoritative path is implemented, submit edits through validated server operations, join a second client, compare chunk revisions, and verify that persistence is owned only by the server. Until this gate exists and passes, multiplayer creation remains a development claim.

Result

Result

Bloxiti’s technical foundation supports a distinctive creator loop: high-quality assets and materials, modular construction, atmosphere control, streamed worlds, persistent creator data, and capture and export tools.

Gamibase is the workflow layer that keeps that loop legible as it crosses project boundaries. It turns architectural analysis into owner-specific decisions, converts visual interactions into end-to-end evidence requirements, and keeps future systems from being described as present-tense outcomes.

The intended workflow outcomes presented in this case study are:

  • 01

    shared technical vocabulary across design, engineering, QA, and review;

  • 02

    traceability from a creator action to its rendered and persisted state;

  • 03

    repeatable world-generation and visual-review scenarios;

  • 04

    explicit ownership for future edit, save, and multiplayer authority;

  • 05

    a clearer separation between implemented foundations, integration surfaces, and roadmap proposals.

Claim boundary

What this case study does not claim

Those systems are either active development, integration surfaces, or proposals in the reviewed checkout. They should receive their own evidence before they become marketing promises. Configuration presence in a checkout is not treated as evidence of a completed Gamibase run.

The boundary

No invented metrics

No measured performance gains for frame time, build speed, memory, bandwidth, productivity, or player capacity.

No multiplayer completion

No production-complete dedicated-server path, finished chunk replication, or server RPC validation claim.

No roadmap as present tense

No live creator marketplace, deployed AI-authored terrain, end-to-end cloud readiness, or security certification.

Why it matters

Why it matters

The hardest part of a creator sandbox is not adding one more tool. It is keeping every tool connected to a world that can stream, save, reload, travel, and eventually support more than one creator without losing authority.

Bloxiti shows why Gamibase is useful before that complexity becomes invisible: one project map, one bounded workflow, and evidence that follows the creator action all the way through the system.

Bring your project

Need the same engineering discipline on one bounded outcome?