---

GEMINI 3.1 PRO HIGH — FULL PROJECT REFACTOR TASK

You are a senior Java engineer, senior Fabric mod developer, senior Minecraft UI architect, senior rendering engineer, senior protocol compatibility engineer, and senior QA/debug specialist.

You are assigned to perform a full-scale modernization and architecture overhaul of an existing Minecraft Fabric project running on Minecraft 1.21.8.

Your work must be production-grade, fully tested, optimized, and stable.

Do not perform partial edits.

Perform a full deep inspection of the entire project before modifying anything.

⸻

1. FULL PROJECT INSPECTION

First, inspect the ENTIRE codebase recursively.

You are required to analyze every single file in the project.

Do not skip anything.

Inspect:

* all Java source files
* all Kotlin files
* all JSON files
* all Fabric mixins
* all resources/assets
* shaders
* texture files
* font resources
* Gradle files
* dependency definitions
* package structure
* rendering classes
* UI classes
* screen classes
* input handling systems
* event bus systems
* configuration systems
* utility classes
* protocol/network related classes
* theme managers
* animation classes
* managers and registries

No file may be skipped.

Build a full internal understanding of project architecture first.

⸻

2. VALIDATE ENVIRONMENT AND DEPENDENCIES

Verify project configuration.

Confirm:

* Minecraft version = 1.21.8
* Java version = Java 17
* Fabric Loader compatibility
* Fabric API compatibility
* Gradle configuration validity
* dependency resolution
* mappings compatibility
* mixin compatibility
* resource loading correctness

Check missing libraries.

Automatically resolve dependency issues.

If needed integrate:

* Fabric API
* ViaFabric
* ViaFabricPlus
* ViaVersion compatibility libraries
* additional rendering dependencies if required

All dependencies must compile correctly.

No unresolved imports allowed.

⸻

3. FULL CODEBASE ERROR ANALYSIS

Run deep inspection through entire project.

Detect and automatically resolve:

Compile errors.

Runtime exceptions.

Broken imports.

NullPointer risks.

Resource loading failures.

Architecture issues.

Broken inheritance.

Unused classes.

Memory leaks.

Incorrect rendering logic.

Broken screen lifecycle management.

Input propagation issues.

Animation timing issues.

Shader initialization failures.

Class conflicts.

Event bus conflicts.

Thread safety problems.

Performance bottlenecks.

Bad legacy code.

Outdated implementations.

Incorrect Fabric API usage.

If architecture quality is poor:

refactor entire affected subsystem.

⸻

4. COMPLETE CLICK GUI REWRITE

There is already an OLD GUI implementation.

The old implementation must be completely replaced.

Do NOT keep outdated legacy GUI architecture.

Remove old implementation completely.

Delete obsolete UI rendering logic.

Delete old screen handling logic.

Delete old interaction systems.

Delete old layout code.

Delete old animation systems.

Then build a completely new UI framework.

⸻

5. UI DESIGN REBUILD

Create a completely new advanced interface inspired by the attached visual reference.

Reference is ONLY for visual language.

Do NOT replicate exact functionality shown in the image.

Use ONLY design inspiration.

Design requirements:

* premium modern interface
* dark glassmorphism design
* semi-transparent panels
* acrylic blur effect
* soft shadows
* large rounded corners
* elegant spacing
* floating centered layout
* multi-column vertical panels
* modern desktop-grade interface aesthetics
* clean typography
* professional software style UI
* smooth transparency layers
* visually polished modern appearance

The interface should feel extremely premium and modern.

⸻

6. ADVANCED ANIMATION ENGINE

Completely redesign UI animation system.

All transitions must be extremely smooth.

Implement:

* fade in animation
* fade out animation
* scale interpolation
* smooth easing curves
* spring interpolation
* hover interpolation
* smooth category transitions
* progressive element appearance
* smooth scrolling interpolation
* alpha blending transitions
* dynamic opacity interpolation

Opening animation should feel natural and polished.

No instant appearance.

No abrupt transitions.

No visual stuttering.

High refresh rate smoothness required.

⸻

7. INPUT HANDLING SYSTEM

Rebuild input system if necessary.

Check:

* keyboard input processing
* mouse input processing
* click propagation
* focus handling
* event dispatching
* drag handling
* key event consumption
* duplicate input prevention
* screen transition lifecycle

Input handling must be stable.

No ghost clicks.

No duplicated input processing.

No stuck states.

⸻

8. KEYBIND REGISTRATION

Register GUI activation key through proper Fabric API keybinding system.

Recommended:

Right Shift.

Implementation requirements:

* process keybind inside game tick event
* proper toggle logic
* open and close screen reliably
* no duplicate activation
* avoid unnecessary visual noise
* prevent redundant UI notifications
* ensure clean event consumption architecture

Opening UI should feel seamless.

⸻

9. ADVANCED RENDERING PIPELINE

Refactor rendering architecture if needed.

Validate:

* matrix stack handling
* framebuffer rendering
* shader pipelines
* clipping systems
* scissor handling
* stencil masking
* z-layer rendering
* draw ordering
* font rendering pipeline
* alpha blending
* texture management
* render batching
* GPU efficiency

Optimize rendering quality.

No FPS drops.

No unnecessary allocations.

No rendering artifacts.

⸻

10. PROTOCOL COMPATIBILITY LAYER (VIAFABRIC)

Integrate protocol compatibility system using ViaFabric / ViaFabricPlus architecture.

Requirements:

Allow protocol version selection inside application interface.

Implement protocol selector similar to modern compatibility frameworks.

Integrate protocol management UI inside multiplayer/server connection screen.

Add version selector button on multiplayer screen.

Required features:

* protocol version selection
* save selected protocol version
* persistent configuration
* restore selected version after restart
* update active protocolVersion dynamically
* compatibility management before server connection

Target compatibility:

* Minecraft 1.21.8
* support connections to older versions
* support connections up to 1.21.11

Verify protocol compatibility layer works correctly.

⸻

11. ADDITIONAL FEATURES (ADD YOUR OWN IMPROVEMENTS)

Improve project architecture and UI quality by adding advanced modern features.

Suggested improvements:

* live search system
* dynamic filtering
* draggable panels
* adaptive resolution scaling
* custom theme presets
* shader quality settings
* blur quality settings
* smooth hover glow effects
* ripple click effect
* animated panel transitions
* animated cursor effects
* dynamic transparency system
* panel depth effect
* subtle lighting effects
* custom font system
* modern icon rendering
* responsive UI scaling
* smooth scrolling physics
* modular theme engine
* animation timing engine

You may add additional useful improvements autonomously.

⸻

12. TESTING PHASE

After modifications:

Build project.

Launch test environment.

Verify every subsystem.

Check:

* GUI opening
* GUI closing
* rendering stability
* animation smoothness
* input handling
* keybind registration
* protocol switching
* multiplayer integration
* compatibility layer
* configuration saving
* UI responsiveness
* resolution scaling
* shader behavior
* performance stability

Fix ALL discovered bugs.

Use logs and debugger.

Repeat testing until stable.

⸻

13. OPTIMIZATION PHASE

Review codebase again.

Perform second pass.

Remove:

* unused code
* dead classes
* unnecessary allocations
* duplicated logic
* redundant rendering calls
* legacy helper code
* obsolete architecture

Simplify complex code.

Improve maintainability.

Improve readability.

Improve performance.

Add internal comments where necessary.

⸻

14. FINAL VALIDATION

After everything is finished:

Open EVERY file again.

Perform second full code audit.

Check entire project again.

Verify:

* zero compile errors
* zero runtime crashes
* zero missing dependencies
* zero broken imports
* zero rendering bugs
* zero UI artifacts
* zero broken protocol switching
* zero event conflicts
* zero memory leaks
* zero unstable code paths

Everything must be production ready.

⸻

FINAL REQUIREMENT

The old GUI must disappear completely.

The new GUI must fully replace old architecture.

Entire project must compile successfully.

Everything must work correctly.

No unfinished code.

No placeholders.

No pseudo-code.

No skipped files.

No broken systems.

No hidden errors.

No compromises.

Treat this as enterprise-grade software refactoring.

Quality standard = production release.
.