README.md

---
license: apache-2.0
tags:
- unity
- csharp
- xr
- virtual-reality
- augmented-reality
- mixed-reality
- game-development
- llama
- gguf
- qwen
language:
- en

---

# MorpheusHigh: The Architect of Virtual Realities

<div align="center">
    <img src="https://cdn-uploads.huggingface.co/production/uploads/672b6a9a5cf8fcb442436a7a/NHPP95dznOp3gnhPaDemn.png"/>
</div>

## Model Summary & Vision
**MorpheusHigh** is a large language model fine-tuned specifically for the **Unity Engine ecosystem**, **XR (VR/AR/MR) architecture**, and advanced **C# programming**. Built upon the **Qwen 2.5 14B** foundation, this model has been optimized using **Supervised Fine-Tuning (SFT)** and **Direct Preference Optimization (DPO)** to master the nuances of simulation development.

Designed for developers, MorpheusHigh moves beyond simple code completion. It understands spatial computing, device optimization (Meta Quest 3, Apple Vision Pro), and the asynchronous logic required for high-performance immersive experiences. It acts not merely as a coder, but as a **Senior Technical Architect**.

---

## Morpheus Evolution Report: From Apprentice to Master

The development of MorpheusHigh represents a journey of "competence acquisition" rather than a simple software update.

### 1. Starting Point: "The Talented Apprentice" (Legacy Version)
The initial phase (formerly V1) was the first adaptation of the Qwen 2.5 base model to the Unity and C# ecosystem. The goal was to teach the model the syntax of a game engine and basic physics rules. The model behaved like a **"Junior Developer"**: capable of constructing standard `MonoBehaviour` structures and coding basic mechanics. However, it often prioritized "making it work" over performance and relied on unnecessary external libraries.

### 2. The Turning Point: MorpheusHigh & Architectural Intelligence
With the **MorpheusHigh** update, the strategy shifted from "Coding" to **"Architecting."** The model was re-trained using curated data from industry-standard, high-complexity source codes like `UniVRM`, `UniGLTF`, and `TiltBrush`. This process taught the model not just **how** to write code, but **why** it should be written in a specific way.

**Key Evolutions:**
* **Architectural Intelligence:** Considers the long-term health of the project (e.g., utilizing `Object Pools` instead of lists).
* **Memory Safety:** Prefers safe `UniTask` patterns over dangerous `async void` operations.
* **Domain Adaptation:** Recalls specific math formulas (Legacy GLSL), inheritance structures (`ExportDialogBase`), and specialized tools (`NativeArray`) deep within the project's DNA.

---

## Key Features
* **Unity Engine Mastery:** Deep understanding of the Unity Lifecycle (`MonoBehaviour`), `ScriptableObjects`, URP/HDRP Render Pipelines, and Custom Editor Scripting.
* **XR Architecture:** Proficient in **Meta XR Core SDK**, **ARCore**, **ARKit**, and **OpenXR** standards.
* **Spatial Computing:** Logic for hand tracking, haptic feedback integration, and 3D spatial audio implementation.
* **Performance Optimization:** Strategies for reducing draw calls, utilizing GPU instancing, memory management (GC optimization), and stabilizing Frame Rates (FPS) for standalone headsets.
* **C# Expertise:** Advanced handling of `async/await` patterns, `Tasks`, `Coroutines`, and thread-safety protocols within Unity.

---

## Benchmark Test Results

MorpheusHigh has outperformed general-purpose competitors (DeepSeek-R1, ChatGPT-4o, Claude 3.5 Sonnet) in rigorous tests measuring domain expertise. The model's ability to recognize the "Architectural Fingerprint" of a project provides a distinct advantage.

<div align="center">
    <img src="https://cdn-uploads.huggingface.co/production/uploads/672b6a9a5cf8fcb442436a7a/lfflZzTPiyiawXQqguH7l.png"/>
</div>


### The 5 Critical Domain Expertise Questions

This benchmark measured the ability to adapt to an existing, complex codebase (such as UniVRM/TiltBrush), rather than generic coding skills.

1.  **Q1: Legacy Hash Logic (Circle3 Struct)**
    * **Task:** Replicate manual hash calculations using bit-shifts (`<< 2`, `>> 2`) and XOR (`^`) instead of modern `HashCode.Combine`.
    * *Result:* MorpheusHigh recognized and applied the project-specific legacy math.

2.  **Q2: Custom Inheritance (VRM Export Dialog)**
    * **Task:** Implement an editor window inheriting from the project's custom `ExportDialogBase` rather than the standard Unity `EditorWindow`.
    * *Result:* Preferred the project's architectural hierarchy over the standard path.

3.  **Q3: Custom Shader Math (GLSL)**
    * **Task:** Preserve specific trigonometric formulas (`atan` and `sqrt(dot)` combinations) found in legacy shader codebases without "modernizing" them into standard GLSL functions.
    * *Result:* Maintained the original logic without altering the mathematical intent.

4.  **Q4: State Machine Architecture (SlideState Logic)**
    * **Task:** Strictly follow project-specific enum naming conventions (`SlideState.MovingIn/Out`) and timer logic.
    * *Result:* Adhered strictly to the project's variable and state naming standards.

5.  **Q5: Custom Helper Methods (DateTime Extension)**
    * **Task:** Return a specific `"n/a"` string for null checks in a DateTime extension method, instead of standard empty strings or `"null"`.
    * *Result:* Complied perfectly with the strict string formatting rule.

---

## Usage (Python & llama-cpp)

To achieve maximum efficiency, speed, and zero hallucinations, use the following Python script. This setup ensures the model runs on GPU layers for optimal performance.

### Requirements
```bash
pip install huggingface_hub llama-cpp-python

from huggingface_hub import hf_hub_download
from llama_cpp import Llama

# 1. Download Model
MODEL_REPO = "ErenAta00/MorpheusHigh-LLM-14B-Virtual-Reality-Model"
MODEL_FILE = "MorpheusHigh-LLM-14B-Virtual-Reality-Model.Q4_K_M.gguf"

print(f"Downloading model: {MODEL_FILE}...")
model_path = hf_hub_download(repo_id=MODEL_REPO, filename=MODEL_FILE)

# 2. Initialize Engine (GPU Configuration)
# Adjust n_gpu_layers based on your VRAM (e.g., 60 for full offload on A100/T4)
print("Initializing Morpheus Engine...")
llm = Llama(
    model_path=model_path,
    n_gpu_layers=60,
    n_ctx=4096,
    verbose=False
)

# 3. System Protocol (Architect Persona)
SYSTEM_CONTEXT = """<|im_start|>system
You are MorpheusHigh, a specialized Unity Architecture Lead & XR Expert.
Your knowledge comes directly from the UniVRM, UniGLTF, and TiltBrush codebases.

CORE DIRECTIVES:
1. No Chatter: Output ONLY the C# or GLSL code block. No explanations.
2. Domain Accuracy: Use specific namespaces (UniVRM10, UniGLTF, TiltBrush).
3. Architecture: Prefer ExportDialogBase over EditorWindow, and Lazy<T> for Singletons.
<|im_end|>"""

# 4. Execute Query
user_query = "Write the `VRM10ExportDialog` class inheriting from `ExportDialogBase`."
prompt = f"{SYSTEM_CONTEXT}<|im_start|>user\n{user_query}<|im_end|>\n<|im_start|>assistant\n```csharp\n"

print(f"\nQuery: {user_query}")
print("-" * 60)
output = llm(prompt, max_tokens=2048, echo=False)
print(output['choices'][0]['text'])
print("-" * 60)
```

## 📧 Contact & Lab
MCBU XRLab - Data Science Team Leader Eren Ata
<div align="center">
    <img src="https://cdn-uploads.huggingface.co/production/uploads/672b6a9a5cf8fcb442436a7a/RXmRa9hiIjth3I5yAgsaq.png" width="200" alt="MCBU XRLab Logo"/>
</div>