Spaces:

AEUPH
/

NeuralOS-Hypervisor

Sleeping

App Files Files Community

AEUPH commited on Jan 23

Commit

2c14c01

verified ·

1 Parent(s): 6962bce

Update Dockerfile

Browse files

Files changed (1) hide show

Dockerfile +119 -387

Dockerfile CHANGED Viewed

@@ -5,21 +5,22 @@ FROM python:3.10-slim
 WORKDIR /app
 # 1. Install System Dependencies
-# Basic tools required for the OS simulation
 RUN apt-get update && apt-get install -y \
     curl \
     git \
     libgomp1 \
     && rm -rf /var/lib/apt/lists/*
-# 2. Upgrade pip (Essential for finding modern wheels)
-RUN pip install --upgrade pip setuptools wheel
 # 3. Download Retro Font (VT323)
 RUN curl -L -o /app/VT323.ttf https://github.com/google/fonts/raw/main/ofl/vt323/VT323-Regular.ttf
-# 4. Install Core Python Dependencies (Split for caching)
-# These are safe and install quickly.
 RUN pip install --no-cache-dir \
     torch \
     torchvision \
@@ -33,52 +34,33 @@ RUN pip install --no-cache-dir \
     pillow \
     diskcache \
     safetensors \
-    scipy
-# 5. ATTEMPT Fast Llama Install (Optional)
-# --only-binary: Prevents the slow compilation loop.
-# || true: Allows the build to continue even if this fails.
-# We will handle the missing library in app.py
-RUN pip install llama-cpp-python \
-    --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu \
-    --only-binary=llama-cpp-python \
-    || echo "⚠️ Llama-CPP wheel not found. Skipping to avoid compile hang."
-# 6. Create a non-root user
 RUN useradd -m -u 1000 user
 USER user
 ENV HOME=/home/user \
     PATH=/home/user/.local/bin:$PATH
-# 7. Write the Monolith Application to disk
 COPY --chown=user <<'EOF' app.py
-import sys, os, io, base64, json, pickle, time
-import numpy as np
 import torch
-from pathlib import Path
-from dataclasses import dataclass
-from typing import Dict, List, Optional
-from flask import Flask, request, send_file, render_template_string
 from flask_sock import Sock
-from diffusers import StableDiffusionPipeline, AutoencoderTiny, LCMScheduler
 from PIL import Image, ImageDraw
-# ============================================================================
-# SAFE IMPORT LOGIC
-# ============================================================================
-try:
-    from llama_cpp import Llama
-    HAS_LLM = True
-    print("[*] Llama-CPP module loaded successfully.")
-except ImportError:
-    HAS_LLM = False
-    print("[!] NOTICE: Llama-CPP not found. Text generation features will be disabled.")
-    print("[!] The graphical OS and image generation will still work perfectly.")
 # ============================================================================
-# 1. FRONTEND ASSET
 # ============================================================================
 HTML_TEMPLATE = r"""
 <!DOCTYPE html>
 <html lang="en">
@@ -91,420 +73,170 @@ HTML_TEMPLATE = r"""
     <script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>
     <link href="https://fonts.googleapis.com/css2?family=Tahoma:wght@400;700&family=Fira+Code:wght@300;500&display=swap" rel="stylesheet">
     <style>
-        * { box-sizing: border-box; }
-        body {
-            background: #010102;
-            color: #e2e2e2;
-            font-family: 'Tahoma', sans-serif;
-            margin: 0;
-            overflow: hidden;
-            cursor: auto;
-        }
-        .desktop-area {
-            position: relative;
-            width: 100vw;
-            height: 100vh;
-            background: #3A6EA5;
-            background-image: linear-gradient(to bottom, #5A9FD4 0%, #306088 100%);
-        }
-        .canvas-viewport {
-            position: absolute;
-            top: 50%;
-            left: 50%;
-            transform: translate(-50%, -50%);
-            width: 1024px;
-            height: 1024px;
-            background: #000;
-            box-shadow: 0 0 100px rgba(0,0,0,0.9);
-            border: 2px solid #1a1a1e;
-            image-rendering: pixelated;
-        }
-        .canvas-viewport img { width: 100%; height: 100%; image-rendering: pixelated; }
-        .taskbar {
-            position: absolute; bottom: 0; left: 0; right: 0; height: 48px;
-            background: linear-gradient(to bottom, #1F4788 0%, #1A3E6F 50%, #0E2950 100%);
-            border-top: 2px solid #4D7DB5; display: flex; align-items: center; padding: 0 4px; gap: 4px;
-        }
-        .start-button {
-            background: linear-gradient(to bottom, #3F8B3F 0%, #2F6B2F 100%);
-            border: 2px outset #5FAF5F; color: white; font-weight: bold; padding: 4px 12px;
-            border-radius: 3px; cursor: pointer; font-size: 13px; display: flex; align-items: center; gap: 6px;
         }
-        .taskbar-window {
-            background: linear-gradient(to bottom, #B5D3E7 0%, #7BA7C7 100%);
-            border: 2px outset #D0E5F5; padding: 4px 10px; border-radius: 3px; cursor: pointer;
-            font-size: 11px; max-width: 160px; color: #000;
         }
-        .taskbar-window.active { background: linear-gradient(to bottom, #7BA7C7 0%, #5A86A7 100%); border-style: inset; color: white; }
-        .sidebar {
-            position: fixed; left: 0; top: 0; bottom: 48px; width: 320px;
-            background: rgba(10, 10, 12, 0.95); border-right: 1px solid #1a1a1e;
-            backdrop-filter: blur(10px); z-index: 1000; overflow-y: auto; padding: 20px;
-            font-family: 'Fira Code', monospace;
-        }
-        .inspector {
-            position: fixed; right: 0; top: 0; bottom: 48px; width: 340px;
-            background: rgba(10, 10, 12, 0.95); border-left: 1px solid #1a1a1e;
-            backdrop-filter: blur(10px); padding: 20px; font-family: 'Fira Code', monospace; overflow-y: auto;
-        }
-        .code-block { background: #0a0a0c; border: 1px solid #1a1a1e; padding: 12px; font-size: 10px; color: #34d399; }
     </style>
 </head>
 <body>
     <div id="root"></div>
     <script type="text/babel">
         const { useState, useEffect, useRef } = React;
-        const APPS = [
-            { id: 'notepad', name: 'Notepad', icon: '📝' },
-            { id: 'paint', name: 'Paint', icon: '🎨' },
-            { id: 'cmd', name: 'Command Prompt', icon: '⌨️' },
-            { id: 'explorer', name: 'Explorer', icon: '📁' },
-        ];
         function App() {
             const [desktopImage, setDesktopImage] = useState(null);
-            const [processes, setProcesses] = useState([]);
-            const [startMenuOpen, setStartMenuOpen] = useState(false);
             const socketRef = useRef(null);
-            const canvasRef = useRef(null);
             useEffect(() => {
-                const proto = window.location.protocol === 'https:' ? 'wss' : 'ws';
-                const ws = new WebSocket(`${proto}://${window.location.host}/kernel`);
                 socketRef.current = ws;
                 ws.onmessage = (e) => {
                     const msg = JSON.parse(e.data);
-                    if (msg.type === 'desktop_ready' || msg.type === 'frame_update') {
                         setDesktopImage(msg.data);
-                        if (msg.processes) setProcesses(msg.processes);
                     }
                 };
                 return () => ws.close();
             }, []);
-            const handleCanvasClick = (e) => {
-                if (!canvasRef.current) return;
-                const rect = canvasRef.current.getBoundingClientRect();
                 const x = Math.floor(((e.clientX - rect.left) / rect.width) * 128);
                 const y = Math.floor(((e.clientY - rect.top) / rect.height) * 128);
                 socketRef.current?.send(JSON.stringify({ type: 'click', x, y }));
             };
-            const launchApp = (appId) => {
-                socketRef.current?.send(JSON.stringify({ type: 'launch_app', app: appId }));
-                setStartMenuOpen(false);
-            };
             return (
-                <div className="desktop-area">
-                    <div ref={canvasRef} className="canvas-viewport" onClick={handleCanvasClick}>
                         {desktopImage && <img src={`data:image/png;base64,${desktopImage}`} />}
                     </div>
-                    <div className="taskbar">
-                        <div className="start-button" onClick={() => setStartMenuOpen(!startMenuOpen)}>start</div>
-                        {processes.map(p => <div key={p.pid} className="taskbar-window">{p.name}</div>)}
-                    </div>
-                    {startMenuOpen && (
-                        <div style={{ position: 'absolute', bottom: '50px', left: '4px', width: '220px', background: '#f0f0f0', border: '2px outset #ccc' }}>
-                            {APPS.map(app => (
-                                <div key={app.id} onClick={() => launchApp(app.id)} style={{ padding: '8px', cursor: 'pointer', color: 'black' }}>
-                                    {app.icon} {app.name}
-                                </div>
-                            ))}
-                        </div>
-                    )}
-                    <div className="sidebar">
-                        <h1>🔧 Neural_IDE</h1>
-                        <p>Monolith Build v9.3</p>
                     </div>
                 </div>
             );
         }
-        const root = ReactDOM.createRoot(document.getElementById('root'));
-        root.render(<App />);
     </script>
 </body>
 </html>
 """
 # ============================================================================
-# 2. DRIVERS & KERNEL LOGIC
 # ============================================================================
-DRIVERS = {
-    "TITLE_BAR": torch.zeros((1, 4, 4, 32), dtype=torch.float16),
-    "TITLE_BAR_INACTIVE": torch.zeros((1, 4, 4, 32), dtype=torch.float16),
-    "CLOSE_BTN": torch.zeros((1, 4, 4, 4), dtype=torch.float16),
-    "TASKBAR": torch.zeros((1, 4, 6, 128), dtype=torch.float16),
-    "START_BTN": torch.zeros((1, 4, 6, 24), dtype=torch.float16),
-    "DESKTOP_BG": torch.zeros((1, 4, 128, 128), dtype=torch.float16),
-    "ICON_NOTEPAD": torch.zeros((1, 4, 8, 8), dtype=torch.float16),
-    "ICON_PAINT": torch.zeros((1, 4, 8, 8), dtype=torch.float16),
-    "ICON_CMD": torch.zeros((1, 4, 8, 8), dtype=torch.float16),
-    "ICON_FOLDER": torch.zeros((1, 4, 8, 8), dtype=torch.float16),
-}
-def initialize_drivers():
-    DRIVERS["TITLE_BAR"][:, 0, 0:1, :] = 2.0
-    DRIVERS["TITLE_BAR"][:, 0, 1:3, :] = 1.2
-    DRIVERS["TITLE_BAR"][:, 1, :, :] = -1.0
-    DRIVERS["CLOSE_BTN"][:, 2, :, :] = 2.5
-    DRIVERS["TASKBAR"][:, 0, 0, :] = 1.2
-    DRIVERS["START_BTN"][:, 1, 1:5, 2:22] = 1.8
-    DRIVERS["DESKTOP_BG"][:, 1, 0:80, :] = 1.2
-    DRIVERS["DESKTOP_BG"][:, 2, 0:80, :] = 1.5
-    DRIVERS["DESKTOP_BG"][:, 1, 80:128, :] = 0.8
-    DRIVERS["ICON_NOTEPAD"][:, 0, :, :] = 1.5
-    print("[*] LiteWin High-Fidelity DNA v4 initialized")
-@dataclass
-class Process:
-    pid: int
-    name: str
-    app_type: str
-    position: tuple
-    size: tuple
-    latent_state: torch.Tensor
-    status: str = "running"
-    z_order: int = 0
-    def to_dict(self):
-        return {"pid": self.pid, "name": self.name, "app_type": self.app_type, "position": self.position, "size": self.size}
-@dataclass
-class Application:
-    name: str
-    icon_dna: str
-    window_prompt: str
-    content_prompt: str
-    default_size: tuple
-PROGRAMS = {
-    "notepad": Application("Notepad", "ICON_NOTEPAD", "high quality windows_xp notepad", "white text editor", (48, 40)),
-    "paint": Application("Paint", "ICON_PAINT", "official MS Paint", "white canvas", (64, 48)),
-    "cmd": Application("Command Prompt", "ICON_CMD", "windows terminal", "black console", (56, 40)),
-    "explorer": Application("Explorer", "ICON_FOLDER", "windows explorer", "file browser", (72, 56))
-}
-class OSKernel:
     def __init__(self):
-        self.processes: Dict[int, Process] = {}
-        self.next_pid = 1
-        self.focused_pid: Optional[int] = None
-        self.desktop_latent = DRIVERS["DESKTOP_BG"].clone()
-        self.desktop_icons = [
-            {"app": "notepad", "x": 4, "y": 4, "label": "Notepad"},
-            {"app": "paint", "x": 4, "y": 16, "label": "Paint"},
-            {"app": "cmd", "x": 4, "y": 28, "label": "Command Prompt"},
-            {"app": "explorer", "x": 4, "y": 40, "label": "My Computer"},
-        ]
-        self.start_menu_open = False
-    def spawn_process(self, app_type: str, x: int, y: int) -> int:
-        if app_type not in PROGRAMS: return -1
-        app = PROGRAMS[app_type]
-        pid = self.next_pid
-        self.next_pid += 1
-        w, h = app.default_size
-        proc = Process(pid, app.name, app_type, (x, y), (w, h), torch.zeros((1, 4, h, w), dtype=torch.float16), "running", pid)
-        self.processes[pid] = proc
-        self.focus_process(pid)
-        return pid
-    def kill_process(self, pid: int):
-        if pid in self.processes:
-            del self.processes[pid]
-            if self.focused_pid == pid: self.focused_pid = None
-    def focus_process(self, pid: int):
-        if pid in self.processes:
-            self.focused_pid = pid
-            max_z = max((p.z_order for p in self.processes.values()), default=0)
-            self.processes[pid].z_order = max_z + 1
-    def composite_frame(self) -> torch.Tensor:
-        output = self.desktop_latent.clone()
-        for icon in self.desktop_icons:
-            app = PROGRAMS[icon['app']]
-            if app.icon_dna in DRIVERS:
-                dna = DRIVERS[app.icon_dna]
-                x, y = icon['x'], icon['y']
-                output[:, :, y:y+8, x:x+8] = dna
-        running_procs = [p for p in self.processes.values() if p.status == "running"]
-        for proc in sorted(running_procs, key=lambda p: p.z_order):
-            x, y = proc.position
-            w, h = proc.size
-            if x + w > 128 or y + h > 128: continue
-            output[:, :, y:y+h, x:x+w] = proc.latent_state
-        taskbar = DRIVERS["TASKBAR"].clone()
-        taskbar[:, :, :, 0:24] = DRIVERS["START_BTN"]
-        output[:, :, 122:128, :] = taskbar
-        return output
-    def handle_click(self, x: int, y: int) -> Dict:
-        if y >= 122:
-            if x < 24:
-                self.start_menu_open = not self.start_menu_open
-                return {"action": "toggle_start_menu", "open": self.start_menu_open}
-            return {"action": "none"}
-        for icon in self.desktop_icons:
-            ix, iy = icon['x'], icon['y']
-            if ix <= x < ix+8 and iy <= y < iy+8:
-                pid = self.spawn_process(icon['app'], x=32, y=24)
-                return {"action": "launch", "app": icon['app'], "pid": pid}
-        for proc in sorted(self.processes.values(), key=lambda p: p.z_order, reverse=True):
-            if proc.status != "running": continue
-            px, py = proc.position
-            pw, ph = proc.size
-            if px <= x < px+pw and py <= y < py+ph:
-                self.focus_process(proc.pid)
-                if py <= y < py+4 and px+pw-4 <= x < px+pw:
-                    self.kill_process(proc.pid)
-                    return {"action": "close", "pid": proc.pid}
-                return {"action": "focus", "pid": proc.pid}
-        return {"action": "none"}
 # ============================================================================
-# 3. SERVER & ML PIPELINE
 # ============================================================================
 app = Flask(__name__)
 sock = Sock(app)
-pipe = None
-llm = None
-kernel = OSKernel()
-GGUF_MODEL_PATH = "models/qwen2.5-coder-0.5b-instruct-q8_0.gguf"
-STEPS = 1
-def get_pipe():
-    global pipe, STEPS
-    if pipe is None:
-        print("[*] Booting Neural Kernel...")
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        dt = torch.float16 if device == "cuda" else torch.float32
-        pipe = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", torch_dtype=dt).to(device)
-        try:
-            if device == "cuda":
-                pipe.load_lora_weights("latent-consistency/lcm-lora-sdv1-5")
-                pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
-                pipe.vae = AutoencoderTiny.from_pretrained("madebyollin/taesd", torch_dtype=dt).to(device)
-                STEPS = 1
-                print("[✓] LCM + TAE Enabled")
-            else:
-                STEPS = 4
-        except Exception as e:
-            print(f"[!] Optimization failed: {e}")
-    return pipe
-def decode_layer(latents, p):
-    with torch.no_grad():
-        latents = 1 / 0.18215 * latents
-        latents = latents.to(device=p.device, dtype=p.vae.dtype)
-        image = p.vae.decode(latents).sample
-        image = (image / 2 + 0.5).clamp(0, 1).nan_to_num()
-        image = image.cpu().permute(0, 2, 3, 1).numpy()
-        image = p.numpy_to_pil(image)[0]
-        buf = io.BytesIO()
-        image.save(buf, format="PNG")
-        return base64.b64encode(buf.getvalue()).decode()
-def render_perfect_window_latent(p, w_blocks, h_blocks, title="Window"):
-    width, height = w_blocks * 8, h_blocks * 8
-    img = Image.new('RGB', (width, height), color=(236, 233, 216))
-    draw = ImageDraw.Draw(img)
-    draw.rectangle([0, 0, width-1, height-1], outline=(0, 0, 0))
-    draw.rectangle([1, 1, width-2, 31], fill=(0, 84, 227)) # Blue Title
-    draw.rectangle([4, 32, width-5, height-5], fill=(255, 255, 255)) # Content
-    img_t = torch.from_numpy(np.array(img)).permute(2, 0, 1).float() / 255.0
-    img_t = (img_t * 2.0 - 1.0).unsqueeze(0).to(device=p.device, dtype=p.vae.dtype)
-    with torch.no_grad():
-        latent = p.vae.encode(img_t).latent_dist.sample() * 0.18215
-    return latent.cpu()
-def generate_window_fast(p, kernel, pid):
-    device = p.device
-    proc = kernel.processes[pid]
-    app = PROGRAMS[proc.app_type]
-    w, h = proc.size
-    # Inject Frame
-    base_latent = render_perfect_window_latent(p, w, h, title=app.name)
-    # Fill Content (Simplified for Monolith)
-    prompt = f"{app.content_prompt}, pixel perfect"
-    text_inputs = p.tokenizer([prompt], padding="max_length", max_length=p.tokenizer.model_max_length, truncation=True, return_tensors="pt")
-    prompt_embeds = p.text_encoder(text_inputs.input_ids.to(device))[0]
-    uncond_inputs = p.tokenizer(["blurry"], padding="max_length", max_length=p.tokenizer.model_max_length, truncation=True, return_tensors="pt")
-    neg_embeds = p.text_encoder(uncond_inputs.input_ids.to(device))[0]
-    embeds = torch.cat([neg_embeds, prompt_embeds])
-    latents = base_latent.to(device)
-    p.scheduler.set_timesteps(STEPS, device=device)
-    for t in p.scheduler.timesteps:
-        latent_input = torch.cat([latents] * 2)
-        latent_input = p.scheduler.scale_model_input(latent_input, t)
-        with torch.no_grad():
-            noise_pred = p.unet(latent_input, t, encoder_hidden_states=embeds, return_dict=False)[0]
-        uncond, text = noise_pred.chunk(2)
-        noise_pred = uncond + (1.0 if STEPS==1 else 7.5) * (text - uncond)
-        next_latents = p.scheduler.step(noise_pred, t, latents).prev_sample
-        # Lock Title Bar (Top 4 blocks)
-        mask = torch.ones_like(latents)
-        mask[:, :, 0:4, :] = 0.0
-        latents = (mask * next_latents) + ((1.0 - mask) * latents)
-    proc.latent_state = latents.cpu()
-@sock.route('/kernel')
-def kernel_ws(ws):
-    p = get_pipe()
-    initialize_drivers()
-    print("[*] Client connected to Monolith Kernel")
-    frame = kernel.composite_frame()
     ws.send(json.dumps({
-        "type": "desktop_ready",
-        "data": decode_layer(frame, p),
-        "processes": [proc.to_dict() for proc in kernel.processes.values()]
     }))
-    while True:
-        try:
-            data = ws.receive()
-            if not data: break
-            msg = json.loads(data)
-            if msg['type'] == 'click':
-                res = kernel.handle_click(msg['x'], msg['y'])
-                if res['action'] == 'launch':
-                    generate_window_fast(p, kernel, res['pid'])
-            elif msg['type'] == 'launch_app':
-                pid = kernel.spawn_process(msg['app'], 12, 12)
-                generate_window_fast(p, kernel, pid)
-            ws.send(json.dumps({
-                "type": "frame_update",
-                "data": decode_layer(kernel.composite_frame(), p),
-                "processes": [proc.to_dict() for proc in kernel.processes.values()]
-            }))
-        except Exception as e:
-            print(f"[ERR] {e}")
-            break
 @app.route('/')
 def index():
     return render_template_string(HTML_TEMPLATE)
 if __name__ == '__main__':
-    print("="*40)
-    print(" NEURAL OS MONOLITH v1.0 RUNNING")
-    print("="*40)
-    app.run(host='0.0.0.0', port=7860, threaded=True)
 EOF
-# 8. Launch the Monolith
 EXPOSE 7860
 CMD ["python", "app.py"]

 WORKDIR /app
 # 1. Install System Dependencies
+# Minimal runtime libs only. No compilers needed.
 RUN apt-get update && apt-get install -y \
     curl \
     git \
     libgomp1 \
     && rm -rf /var/lib/apt/lists/*
+# 2. Upgrade pip
+RUN pip install --upgrade pip
 # 3. Download Retro Font (VT323)
 RUN curl -L -o /app/VT323.ttf https://github.com/google/fonts/raw/main/ofl/vt323/VT323-Regular.ttf
+# 4. Install Python Dependencies
+# - transformers & accelerate: For running Qwen via Hugging Face
+# - diffusers: For the Neural Desktop (GUI)
 RUN pip install --no-cache-dir \
     torch \
     torchvision \
     pillow \
     diskcache \
     safetensors \
+    scipy \
+    sentencepiece
+# 5. Create a non-root user
 RUN useradd -m -u 1000 user
 USER user
 ENV HOME=/home/user \
     PATH=/home/user/.local/bin:$PATH
+# 6. Write the Application
 COPY --chown=user <<'EOF' app.py
+import sys, os, io, base64, json, warnings
 import torch
+import numpy as np
+from flask import Flask, render_template_string
 from flask_sock import Sock
 from PIL import Image, ImageDraw
+# [CHANGED] Import Hugging Face Transformers instead of Llama-cpp
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from diffusers import StableDiffusionPipeline, AutoencoderTiny, LCMScheduler
+# Silence Warnings
+warnings.filterwarnings("ignore")
 # ============================================================================
+# 1. FRONTEND (React Desktop)
 # ============================================================================
 HTML_TEMPLATE = r"""
 <!DOCTYPE html>
 <html lang="en">
     <script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>
     <link href="https://fonts.googleapis.com/css2?family=Tahoma:wght@400;700&family=Fira+Code:wght@300;500&display=swap" rel="stylesheet">
     <style>
+        body { background: #000; color: #e2e2e2; margin: 0; overflow: hidden; font-family: 'Tahoma', sans-serif; }
+        .canvas-viewport {
+            position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%);
+            width: 1024px; height: 1024px; border: 2px solid #333;
+            image-rendering: pixelated;
         }
+        .canvas-viewport img { width: 100%; height: 100%; }
+        .console-log {
+            position: fixed; bottom: 0; left: 0; width: 300px; height: 200px;
+            background: rgba(0,0,0,0.8); color: #0f0; font-family: 'Fira Code', monospace;
+            font-size: 10px; padding: 10px; overflow-y: auto; z-index: 1000;
         }
     </style>
 </head>
 <body>
     <div id="root"></div>
     <script type="text/babel">
         const { useState, useEffect, useRef } = React;
         function App() {
             const [desktopImage, setDesktopImage] = useState(null);
+            const [logs, setLogs] = useState(["System Booting..."]);
             const socketRef = useRef(null);
+            const addLog = (msg) => setLogs(prev => [...prev.slice(-10), msg]);
             useEffect(() => {
+                const ws = new WebSocket(`ws://${window.location.host}/kernel`);
                 socketRef.current = ws;
                 ws.onmessage = (e) => {
                     const msg = JSON.parse(e.data);
+                    if (msg.type === 'frame_update' || msg.type === 'desktop_ready') {
                         setDesktopImage(msg.data);
                     }
+                    if (msg.type === 'log') addLog(msg.data);
                 };
                 return () => ws.close();
             }, []);
+            const handleClick = (e) => {
+                const rect = e.target.getBoundingClientRect();
                 const x = Math.floor(((e.clientX - rect.left) / rect.width) * 128);
                 const y = Math.floor(((e.clientY - rect.top) / rect.height) * 128);
                 socketRef.current?.send(JSON.stringify({ type: 'click', x, y }));
             };
             return (
+                <div style={{width: '100vw', height: '100vh', background: '#3A6EA5'}}>
+                    <div className="canvas-viewport" onClick={handleClick}>
                         {desktopImage && <img src={`data:image/png;base64,${desktopImage}`} />}
                     </div>
+                    <div className="console-log">
+                        {logs.map((l, i) => <div key={i}>{l}</div>)}
                     </div>
                 </div>
             );
         }
+        ReactDOM.createRoot(document.getElementById('root')).render(<App />);
     </script>
 </body>
 </html>
 """
 # ============================================================================
+# 2. AI ENGINES (QWEN + DIFFUSION)
 # ============================================================================
+class NeuralSystem:
     def __init__(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.dt = torch.float16 if self.device == "cuda" else torch.float32
+        print(f"[*] System Device: {self.device}")
+        # A. LOAD DIFFUSION (The Display)
+        print("[*] Loading Neural GPU (Diffusion)...")
+        self.pipe = StableDiffusionPipeline.from_pretrained(
+            "runwayml/stable-diffusion-v1-5", torch_dtype=self.dt
+        ).to(self.device)
+        self.pipe.vae = AutoencoderTiny.from_pretrained("madebyollin/taesd", torch_dtype=self.dt).to(self.device)
+        # B. LOAD QWEN (The Brain)
+        # [CHANGED] Using AutoModelForCausalLM
+        print("[*] Downloading/Loading Qwen 2.5 (0.5B)...")
+        self.model_id = "Qwen/Qwen2.5-Coder-0.5B-Instruct"
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_id)
+        self.llm = AutoModelForCausalLM.from_pretrained(
+            self.model_id,
+            torch_dtype=self.dt,
+            low_cpu_mem_usage=True
+        ).to(self.device)
+        print("[*] Qwen Online.")
+    def think(self, prompt_text):
+        """ Runs Qwen to generate text or commands """
+        inputs = self.tokenizer.apply_chat_template(
+            [{"role": "user", "content": prompt_text}],
+            return_tensors="pt",
+            add_generation_prompt=True
+        ).to(self.device)
+        outputs = self.llm.generate(
+            inputs,
+            max_new_tokens=128,
+            do_sample=True,
+            temperature=0.7
+        )
+        response = self.tokenizer.decode(outputs[0][len(inputs[0]):], skip_special_tokens=True)
+        return response
+    def render_window(self, app_name, context):
+        """ Generates a window image """
+        prompt = f"pixel art windows xp window of {app_name}, {context}, sharp focus"
+        # Simple rendering logic for brevity
+        with torch.no_grad():
+            img = self.pipe(prompt, num_inference_steps=1, guidance_scale=1.0).images[0]
+        return img
 # ============================================================================
+# 3. KERNEL LOGIC
 # ============================================================================
+# Initialize System Global
+sys_engine = None
 app = Flask(__name__)
 sock = Sock(app)
+@sock.route('/kernel')
+def kernel(ws):
+    global sys_engine
+    if sys_engine is None:
+        sys_engine = NeuralSystem()
+    # Send initial boot screen
+    ws.send(json.dumps({"type": "log", "data": "Qwen Kernel Loaded."}))
+    # Generate initial desktop
+    desktop = sys_engine.render_window("Desktop", "blue wallpaper")
+    buf = io.BytesIO()
+    desktop.save(buf, format="PNG")
+    b64_img = base64.b64encode(buf.getvalue()).decode()
     ws.send(json.dumps({
+        "type": "desktop_ready",
+        "data": b64_img
     }))
+    while True:
+        data = ws.receive()
+        if not data: break
+        msg = json.loads(data)
+        if msg['type'] == 'click':
+            # Example: Ask Qwen what happened
+            response = sys_engine.think(f"The user clicked at coordinate {msg['x']},{msg['y']}. What app should open?")
+            ws.send(json.dumps({"type": "log", "data": f"Qwen: {response}"}))
 @app.route('/')
 def index():
     return render_template_string(HTML_TEMPLATE)
 if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=7860)
 EOF
+# 7. Launch
 EXPOSE 7860
 CMD ["python", "app.py"]