The user on whose account the problem was detected:
TreeDan

Coordinates:


Date or time of the incident (according to server time):

Any time
Description:
The attached visuals explain it better than I ever could.

Actions required to repeat the problem:
Any time

Screenshot: 2 Visuals (mp4 - available): Wondering Fireball and Planet Strikes Back

Let me try to explain a few things in words better than your poor resolution photos can. 😇😱😁😜

Still here is a Chupa Chupa for your "efforts" 🍭 🧐

Before anything can be labeled a “bug,” the reporter has to provide the system-level metadata that defines the execution environment. A screenshot is not a bug report—it’s a symptom. To produce actionable signal instead of noise, the report must include: the browser family and exact version, the rendering backend (WebGL1/WebGL2), the GPU driver version, the hardware acceleration state, CPU architecture, OS build, RAM capacity, VRAM availability, memory bandwidth characteristics, and any extensions or flags that modify the compositing model. Without this information, no claim of a “bug” has technical meaning because the behavior cannot be reproduced or isolated across environments.
With that foundation established, the behavior shown here is not a game-engine defect and not a server inconsistency. It is a deterministic client-side render-pipeline stall caused by a concurrency event inside the browser’s compositing engine. The stall occurs when switching between two active Xcraft tabs that have divergent camera zoom states while one of those tabs is mid-frame. That single event forces the browser to issue a cascade of GPU queue operations that exceed what 🍭a constrained memory architecture can resolve within a single vsync interval.
When the tab switch happens, the browser must:
• flush the current WebGL command buffer,
• invalidate FBO (framebuffer object) attachments,
• rebuild projection and view matrices,
• rebind or reallocate uniform buffers and attribute arrays,
• repopulate vertex buffers with updated transform data,
• resubmit GLSL shader programs for state change validation,
• and reconcile the DOM/UI compositing layer with the WebGL layer.
This is not optional. A tab switch in mid-render is a hard state transition—effectively a forced context switch for the GPU.
On high-latency RAM systems, or integrated-GPU systems where CPU and GPU share a unified memory pool, the following bottlenecks occur:
• The GPU command queue stalls waiting for buffer invalidation to complete.
• The CPU thread driving WebGL cannot update uniform blocks fast enough to match the new camera projection.
• Pipeline barriers triggered by tab visibility change block subsequent draw calls.
• Pending trajectory interpolation (motion vectors, Δt integration, Hermite or linear interpolators) references stale data because the uniform buffer hasn’t been updated yet.
• The browser’s compositor presents the frame according to the last fully resolved data, not the partially updated transform set.
In WebGL terms:
The projection matrix is updated immediately because it sits at the front of the draw call sequence, but the vertex shader is still consuming the previous transform data because the buffer upload did not complete before the GPU’s next draw call. The result is a single invalid frame where clip-space coordinates do not match the updated projection matrix. Objects appear stretched, smeared, or distorted because the camera and world transforms are briefly out of phase.
At the hardware level, this is nothing more than:
• a race condition between the compositor’s present() call,
• the GPU’s command queue,
• and the CPU thread issuing WebGL buffer updates.
If memory bandwidth is insufficient or if buffer reallocation is forced, the GPU cannot complete all required uploads inside one vsync interval. The compositor, not waiting for full pipeline synchronization, presents the partially updated framebuffer. This is standard behavior in modern browsers; they prioritize UI responsiveness over full GPU frame integrity during state transitions.
On systems with discrete GPUs and high-bandwidth VRAM, this artifact may never appear. On systems with:
• integrated GPUs,
• DDR3/DDR4 with high CAS latency,
• low available RAM,
• OS-level memory compression,
• or background processes causing GPU scheduling jitter,
the probability of render-pipeline stalls increases dramatically.
Once the next full render pass completes, the pipeline realigns:
• the command queue is flushed,
• buffers are updated,
• interpolation stacks recompute trajectories with correct Δt,
• the camera and world matrices match,
• the compositor receives a synchronized framebuffer,
• the artifact disappears instantly.
Nothing about this process involves the Xcraft server. The server provides deterministic state: positions, velocities, timestamps, and events. All rendering logic—camera transforms, shader execution, buffer management, trajectory interpolation, perspective calculations, LOD selection, texture sampling, and matrix operations—is fully client-side. Therefore, visual distortion created by a GPU pipeline stall cannot be attributed to server logic, game rules, or engine bugs.
This is a classic, fully predictable browser-level compositor timing artifact under memory constraints—not a game issue.

In short: be more thorough in your reporting. A screenshot without system context isn’t a bug report. Before claiming a fault in the game engine, rule out the variables in your own environment. Close unnecessary tabs, update your browser, make sure your GPU drivers are current, and check your resource consumption so you know whether your system is choking during render. If your hardware, drivers, browser version, extensions, or background load are unstable, you will see artifacts that have nothing to do with Xcraft.
Look within your own four walls first. Identify what in your environment might be producing the behavior before escalating it as a “bug.” What you’ve submitted here fits a classic pattern: a visual glitch caused by local resource constraints being misinterpreted as a server fault. That’s not a bug; it’s an environment issue.

Good luck Peanut!!! 👍👽🤯😳😤🤣