Spaces:

AEUPH
/

NeuralOS-Hypervisor

Sleeping

App Files Files Community

AEUPH commited on Jan 23

Commit

f2abc27

verified ·

1 Parent(s): 79c30ac

Update Dockerfile

Browse files

Files changed (1) hide show

Dockerfile +366 -428

Dockerfile CHANGED Viewed

@@ -4,281 +4,239 @@ FROM python:3.10-slim
 # Set working directory
 WORKDIR /app
-# 1. Install System Dependencies & Fonts
-# We add 'curl' to download the font and 'git' for diffusers compatibility.
 RUN apt-get update && apt-get install -y \
     git \
     curl \
     && rm -rf /var/lib/apt/lists/*
-# 2. Download Retro Font (VT323) for Python PIL
-# This fixes the "text too small" issue by allowing us to load a specific large font size.
 RUN curl -L -o /app/VT323.ttf https://github.com/google/fonts/raw/main/ofl/vt323/VT323-Regular.ttf
 # 3. Install Python Dependencies
 RUN pip install --no-cache-dir \
     torch \
     flask \
     flask-sock \
     diffusers \
     transformers \
     accelerate \
     safetensors \
     scipy
-# 4. Create a non-root user (Required for Hugging Face Spaces)
 RUN useradd -m -u 1000 user
 USER user
 ENV HOME=/home/user \
     PATH=/home/user/.local/bin:$PATH
 # 5. Write the Monolith Application to disk
 COPY --chown=user <<'EOF' app.py
-import sys
-import os
-import time
-import io
-import json
-import base64
-from dataclasses import dataclass, field
-from typing import Dict, List
 # ============================================================================
-# 1. DEPENDENCY CHECK & IMPORTS
 # ============================================================================
-print(f"[*] NeuralOS Monolith v9.3 OPTIMIZED (Running in: {sys.executable})")
-try:
-    import torch
-    from flask import Flask
-    from flask_sock import Sock
-    from diffusers import StableDiffusionPipeline, LCMScheduler, AutoencoderTiny
-    from PIL import Image, ImageDraw, ImageFont
-except ImportError as e:
-    print(f"\n[!] CRITICAL: Missing dependency: {e.name}")
-    sys.exit(1)
-# ============================================================================
-# 2. OPTIMIZED EMBEDDED GUI (Responsive & High-DPI Ready)
-# ============================================================================
-HTML_TEMPLATE = """
 <!DOCTYPE html>
 <html lang="en">
 <head>
     <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
-    <title>NeuralOS | Monolith</title>
     <style>
-        @import url('https://fonts.googleapis.com/css2?family=VT323&display=swap');
-        body {
-            background: #050505;
-            margin: 0;
-            padding: 0;
-            width: 100vw;
-            height: 100vh;
-            overflow: hidden;
-            display: flex;
-            justify-content: center;
-            align-items: center;
-            font-family: 'VT323', monospace;
         }
-        /* Responsive Monitor Case */
-        .monitor-case {
-            background: #1a1a1a;
-            padding: 1.5vmin; /* Responsive padding */
-            border-radius: 1vmin;
-            box-shadow: 0 0 0 0.4vmin #222, 0 0 4vmin rgba(0,0,0,0.8), inset 0 0 2vmin rgba(0,0,0,0.5);
             position: relative;
-            /* Responsive Sizing Logic */
-            width: auto;
-            height: auto;
-            max-width: 95vw;
-            max-height: 90vh;
-            aspect-ratio: 1 / 1; /* Force Square Aspect Ratio */
-            display: flex;
-            flex-direction: column;
         }
-        .screen-container {
-            width: 100%;
-            height: 100%;
-            position: relative;
             background: #000;
-            overflow: hidden;
-            border-radius: 0.5vmin;
-            flex-grow: 1;
         }
-        .crt-overlay {
-            position: absolute;
-            inset: 0;
-            background: linear-gradient(rgba(18, 16, 16, 0) 50%, rgba(0, 0, 0, 0.25) 50%);
-            background-size: 100% 4px;
-            pointer-events: none;
-            z-index: 10;
         }
-        .scanline {
-            width: 100%;
-            height: 100px;
-            z-index: 10;
-            background: linear-gradient(0deg, rgba(0,0,0,0) 0%, rgba(255, 255, 255, 0.04) 50%, rgba(0,0,0,0) 100%);
-            opacity: 0.1;
-            position: absolute;
-            bottom: 100%;
-            animation: scanline 10s linear infinite;
-            pointer-events: none;
         }
-        @keyframes scanline { 0% { bottom: 100%; } 100% { bottom: -100px; } }
-        /* KEY FIX: Ensure pixel art stays sharp when scaled down */
-        #display {
-            width: 100%;
-            height: 100%;
-            object-fit: contain;
-            image-rendering: pixelated;
-            image-rendering: crisp-edges;
-            display: block;
         }
-        .controls {
-            display: flex;
-            justify-content: flex-end;
-            align-items: center;
-            gap: 1vmin;
-            padding-top: 1vmin;
-            height: 4vmin;
         }
-        .pwr-btn {
-            background: #333;
-            color: #0f0;
-            border: 0.2vmin solid #222;
-            padding: 0.5vmin 1.5vmin;
-            font-family: 'VT323';
-            font-size: 2vmin;
-            cursor: pointer;
-            text-transform: uppercase;
-            box-shadow: 0 0.4vmin 0 #111;
         }
-        .pwr-btn:active { transform: translateY(0.4vmin); box-shadow: none; }
-        .led {
-            width: 1.5vmin;
-            height: 1.5vmin;
-            border-radius: 50%;
-            background: #111;
-            box-shadow: 0 0 0.2vmin #000;
-        }
-        .led.on { background: #0f0; box-shadow: 0 0 0.5vmin #0f0; }
-        .led.busy { background: #f00; box-shadow: 0 0 0.5vmin #f00; animation: blink 0.1s infinite; }
-        @keyframes blink { 0% { opacity: 0.5; } 100% { opacity: 1; } }
     </style>
 </head>
 <body>
-    <div class="monitor-case">
-        <div class="screen-container">
-            <div class="crt-overlay"></div>
-            <div class="scanline"></div>
-            <img id="display" src="" alt="AWAITING SIGNAL..." />
-        </div>
-        <div class="controls">
-            <div class="led on"></div>
-            <div id="hdd-led" class="led"></div>
-            <button class="pwr-btn" onclick="location.reload()">RESET</button>
-        </div>
-    </div>
-    <script>
-        const display = document.getElementById('display');
-        const hddLed = document.getElementById('hdd-led');
-        let ws = null;
-        function connect() {
-            const proto = window.location.protocol === 'https:' ? 'wss' : 'ws';
-            ws = new WebSocket(`${proto}://${window.location.host}/kernel`);
-            ws.onmessage = (e) => {
-                const msg = JSON.parse(e.data);
-                if (msg.type === 'frame_update') {
-                    display.src = `data:image/jpeg;base64,${msg.data}`;
-                    hddLed.classList.add('busy');
-                    setTimeout(() => hddLed.classList.remove('busy'), 50);
-                }
             };
-            ws.onclose = () => { setTimeout(connect, 3000); };
-        }
-        display.addEventListener('mousedown', (e) => {
-            if (!ws) return;
-            // Responsive coordinate calculation
-            const rect = display.getBoundingClientRect();
-            // Map the clicked position (0 to rect.width) to internal resolution (0 to 128)
-            const x = Math.floor(((e.clientX - rect.left) / rect.width) * 128);
-            const y = Math.floor(((e.clientY - rect.top) / rect.height) * 128);
-            ws.send(JSON.stringify({ type: 'click', x: x, y: y }));
-        });
-        document.addEventListener('keydown', (e) => {
-            if (!ws) return;
-            if (['Backspace', 'Tab', 'ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'].includes(e.key)) {
-                e.preventDefault();
-            }
-            ws.send(JSON.stringify({ type: 'keydown', key: e.key }));
-        });
-        connect();
     </script>
 </body>
 </html>
 """
 # ============================================================================
-# 3. KERNEL & HARDWARE
 # ============================================================================
 DRIVERS = {
     "TITLE_BAR": 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_CMD": torch.zeros((1, 4, 8, 8), dtype=torch.float16),
     "ICON_FOLDER": torch.zeros((1, 4, 8, 8), dtype=torch.float16),
-    "ICON_GAME": torch.zeros((1, 4, 8, 8), dtype=torch.float16),
 }
-def init_drivers():
-    DRIVERS["TITLE_BAR"][:, 0, 0:1, :] = 2.0; 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
-    DRIVERS["ICON_CMD"][:, 1, :, :] = -1.0
-    DRIVERS["ICON_GAME"][:, 0, 2:6, 2:6] = 2.0
-@dataclass
-class Application:
-    name: str
-    icon_dna: str
-    default_size: tuple
-    is_game: bool = False
-PROGRAMS = {
-    "notepad": Application("Notepad", "ICON_NOTEPAD", (48, 40)),
-    "cmd": Application("Terminal", "ICON_CMD", (56, 40)),
-    "explorer": Application("My Computer", "ICON_FOLDER", (72, 56)),
-    "doom": Application("NeuroDoom", "ICON_GAME", (64, 48), True)
-}
 @dataclass
 class Process:
@@ -288,274 +246,254 @@ class Process:
     position: tuple
     size: tuple
     latent_state: torch.Tensor
-    text_buffer: List[str] = field(default_factory=list)
-    input_focus: bool = False
     status: str = "running"
     z_order: int = 0
-    meta: Dict = field(default_factory=dict)
 class OSKernel:
     def __init__(self):
-        self.processes = {}
-        self.next_pid = 1000
-        self.focused_pid = None
-        self.system_state = "BOOT"
-        self.boot_log = []
-        self.desktop_latent = None
-        self.desktop_icons = []
-        self.start_menu_open = False
-        self.current_dir = "C:\\Users\\Admin"
-    def init_desktop(self):
         self.desktop_latent = DRIVERS["DESKTOP_BG"].clone()
         self.desktop_icons = [
-            {"app": "notepad", "x": 4, "y": 4},
-            {"app": "cmd", "x": 4, "y": 16},
-            {"app": "explorer", "x": 4, "y": 28},
-            {"app": "doom", "x": 4, "y": 40},
         ]
-        self.system_state = "DESKTOP"
-    def spawn(self, app_type, x, y):
-        if app_type not in PROGRAMS: return
         app = PROGRAMS[app_type]
         pid = self.next_pid
         self.next_pid += 1
-        buf = []
-        if app_type == "cmd":
-            buf = ["NEURAL OS [v9.3]", "(C) Monolith", "", f"{self.current_dir}>"]
-        elif app_type == "notepad":
-            buf = ["_"]
-        elif app_type == "doom":
-            buf = ["[INIT] LOADING...", "[INIT] CONNECTING..."]
-        self.processes[pid] = Process(
-            pid, app.name, app_type, (x, y), app.default_size,
-            torch.zeros((1, 4, app.default_size[1], app.default_size[0]), dtype=torch.float16),
-            buf, False, "running", pid, {"state": "menu"} if app.is_game else {}
-        )
-        self.focus(pid)
         return pid
-    def focus(self, pid):
         if pid in self.processes:
-            for p in self.processes.values(): p.input_focus = False
-            self.processes[pid].input_focus = True
-            self.processes[pid].z_order = max([p.z_order for p in self.processes.values()], default=0) + 1
             self.focused_pid = pid
-    def kill(self, pid):
-        if pid in self.processes: del self.processes[pid]
-    def input(self, key):
-        if not self.focused_pid: return
-        proc = self.processes[self.focused_pid]
-        if proc.app_type == "cmd":
-            if key == "Enter":
-                cmd = proc.text_buffer[-1].split(">")[-1].strip()
-                proc.text_buffer.append("")
-                if cmd == "dir": proc.text_buffer.append("  <DIR> Documents")
-                elif cmd == "cls": proc.text_buffer = []
-                elif cmd == "exit": self.kill(proc.pid)
-                elif cmd.startswith("start "):
-                    target = cmd.split(" ")[1]
-                    if target in PROGRAMS:
-                        proc.meta["spawn_req"] = target
-                        proc.text_buffer.append(f"Starting {target}...")
-                else: proc.text_buffer.append("Unknown command")
-                proc.text_buffer.append(f"{self.current_dir}>")
-            elif key == "Backspace":
-                if ">" in proc.text_buffer[-1] and len(proc.text_buffer[-1].split(">")[-1]) > 0:
-                    proc.text_buffer[-1] = proc.text_buffer[-1][:-1]
-            elif len(key) == 1: proc.text_buffer[-1] += key
-        elif proc.app_type == "notepad":
-            if key == "Enter": proc.text_buffer.append("")
-            elif key == "Backspace":
-                if len(proc.text_buffer[-1]) > 0: proc.text_buffer[-1] = proc.text_buffer[-1][:-1]
-                elif len(proc.text_buffer) > 1: proc.text_buffer.pop()
-            elif len(key) == 1: proc.text_buffer[-1] += key
-        elif proc.app_type == "doom":
-            proc.meta["last_key"] = key
-            proc.meta["needs_update"] = True
-    def composite(self):
-        if self.system_state == "BOOT": return None
-        out = self.desktop_latent.clone()
-        for i in self.desktop_icons:
-            if PROGRAMS[i['app']].icon_dna in DRIVERS:
-                dna = DRIVERS[PROGRAMS[i['app']].icon_dna]
-                out[:, :, i['y']:i['y']+8, i['x']:i['x']+8] = dna
-        for p in sorted(self.processes.values(), key=lambda x: x.z_order):
-            x, y = p.position
-            w, h = p.size
-            if x+w <= 128 and y+h <= 128:
-                out[:, :, y:y+h, x:x+w] = p.latent_state
-        tb = DRIVERS["TASKBAR"].clone()
-        tb[:, :, :, 0:24] = DRIVERS["START_BTN"]
-        out[:, :, 122:128, :] = tb
-        return out
 # ============================================================================
-# 4. SERVER & RENDERER
 # ============================================================================
 app = Flask(__name__)
 sock = Sock(app)
 pipe = None
 kernel = OSKernel()
-# Load the font downloaded in Dockerfile. Size 32 is large enough for 1024px render.
-try:
-    SYSTEM_FONT = ImageFont.truetype("/app/VT323.ttf", 32)
-except Exception:
-    print("[!] Font load failed, using default")
-    SYSTEM_FONT = ImageFont.load_default()
-def init_ai():
-    global pipe
-    print("[*] Loading Neural Graphics Pipeline...")
-    if torch.cuda.is_available():
-        device = "cuda"
-        dtype = torch.float16
-        print(f"[✓] CUDA Detected: {torch.cuda.get_device_name(0)}")
-    else:
-        device = "cpu"
-        dtype = torch.float32
-        print("[!] WARNING: CUDA Not Found. Running CPU Mode.")
-    try:
-        pipe = StableDiffusionPipeline.from_pretrained(
-            "runwayml/stable-diffusion-v1-5",
-            torch_dtype=dtype,
-            variant="fp16" if device=="cuda" else None
-        ).to(device)
-        if device == "cuda":
-            try:
                 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=dtype).to(device)
-                print("[✓] Optimizations (LCM+TAE) Enabled")
-            except:
-                print("[!] Using Standard Scheduler")
-    except Exception as e:
-        print(f"[!] AI Init Error: {e}")
-def render_frame(k_obj):
-    latent_tensor = k_obj.composite()
-    if latent_tensor is not None:
-        with torch.no_grad():
-            latents = (1 / 0.18215) * latent_tensor.to(pipe.device)
-            if pipe.device.type == 'cpu': latents = latents.float()
-            img = pipe.vae.decode(latents).sample
-            img = (img / 2 + 0.5).clamp(0, 1).nan_to_num()
-            img = img.cpu().permute(0, 2, 3, 1).numpy()
-            pil_img = pipe.numpy_to_pil(img)[0]
-    else:
-        pil_img = Image.new('RGB', (128, 128), (0,0,0))
-    # Keep 1024px render for high detail, but Font Size 32 makes it readable
-    pil_img = pil_img.resize((1024, 1024), resample=Image.NEAREST)
-    draw = ImageDraw.Draw(pil_img)
-    if k_obj.system_state == "BOOT":
-        y = 50
-        for log in k_obj.boot_log:
-            draw.text((50, y), log, fill=(0, 255, 0), font=SYSTEM_FONT)
-            y += 35 # Increased spacing for larger font
-    scale = 8
-    for p in k_obj.processes.values():
-        wx, wy = p.position
-        cx = (wx * scale) + 16 # Padding adjusted for scale
-        cy = (wy * scale) + 40
-        # Draw Title
-        draw.text(((wx*scale)+10, (wy*scale)+5), p.name, fill=(255,255,255), font=SYSTEM_FONT)
-        if p.text_buffer:
-            # Show fewer lines because font is larger, ensuring it fits in window
-            lines_to_show = p.text_buffer[-12:]
-            for i, line in enumerate(lines_to_show):
-                col = (0, 255, 0) if p.app_type == "cmd" else (0,0,0)
-                if p.app_type == "doom": col = (255, 50, 50)
-                draw.text((cx, cy + (i*30)), line, fill=col, font=SYSTEM_FONT)
-    buf = io.BytesIO()
-    pil_img.save(buf, format="JPEG", quality=80)
-    return base64.b64encode(buf.getvalue()).decode()
-@app.route('/')
-def index():
-    return HTML_TEMPLATE
 @sock.route('/kernel')
-def websocket_kernel(ws):
-    global kernel
-    if not pipe: init_ai()
-    init_drivers()
-    kernel = OSKernel()
-    boot_msgs = ["BIOS DATE 01/23/2026", "DETECTING NEURAL NET...", "LOADING VFS...", "BOOTING..."]
-    for msg in boot_msgs:
-        kernel.boot_log.append(msg)
-        ws.send(json.dumps({"type": "frame_update", "data": render_frame(kernel)}))
-        time.sleep(0.5)
-    kernel.init_desktop()
-    ws.send(json.dumps({"type": "frame_update", "data": render_frame(kernel)}))
     while True:
         try:
             data = ws.receive()
             if not data: break
             msg = json.loads(data)
-            needs_update = False
             if msg['type'] == 'click':
-                x, y = msg['x'], msg['y']
-                if y >= 122 and x < 24:
-                    kernel.start_menu_open = not kernel.start_menu_open
-                    needs_update = True
-                elif kernel.system_state == "DESKTOP":
-                    for i in kernel.desktop_icons:
-                        if i['x'] <= x < i['x']+8 and i['y'] <= y < i['y']+8:
-                            kernel.spawn(i['app'], 30, 20)
-                            needs_update = True
-                    for p in sorted(kernel.processes.values(), key=lambda z: z.z_order, reverse=True):
-                        px, py = p.position
-                        pw, ph = p.size
-                        if px <= x < px+pw and py <= y < py+ph:
-                            kernel.focus(p.pid)
-                            if py <= y < py+4 and px+pw-4 <= x < px+pw: kernel.kill(p.pid)
-                            needs_update = True
-                            break
-            elif msg['type'] == 'keydown':
-                kernel.input(msg['key'])
-                if kernel.focused_pid:
-                    p = kernel.processes[kernel.focused_pid]
-                    if "spawn_req" in p.meta:
-                        kernel.spawn(p.meta.pop("spawn_req"), 40, 40)
-                    if p.app_type == "doom" and p.meta.get("needs_update"):
-                        p.text_buffer.append(f"ACTION: {p.meta.get('last_key')}")
-                        p.meta["needs_update"] = False
-                needs_update = True
-            if needs_update:
-                ws.send(json.dumps({"type": "frame_update", "data": render_frame(kernel)}))
         except Exception as e:
-            print(f"WS Error: {e}")
             break
-if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=7860, threaded=True)
 EOF
 # 6. Launch the Monolith

 # Set working directory
 WORKDIR /app
+# 1. Install System Dependencies
+# 'build-essential' is added to compile llama-cpp-python wheels.
+# 'git' and 'curl' are retained for asset downloads and diffusers compatibility.
 RUN apt-get update && apt-get install -y \
     git \
     curl \
+    build-essential \
     && rm -rf /var/lib/apt/lists/*
+# 2. Download Retro Font (VT323)
+# Keeps the aesthetic consistent with your "NeuralOS" theme.
 RUN curl -L -o /app/VT323.ttf https://github.com/google/fonts/raw/main/ofl/vt323/VT323-Regular.ttf
 # 3. Install Python Dependencies
+# Merged from your requirements.txt.
+# Note: llama-cpp-python is installed with default settings (CPU only) for broad compatibility.
 RUN pip install --no-cache-dir \
     torch \
+    torchvision \
+    numpy \
     flask \
     flask-sock \
     diffusers \
     transformers \
     accelerate \
+    peft \
+    llama-cpp-python \
+    pillow \
+    diskcache \
     safetensors \
     scipy
+# 4. Create a non-root user (Best practice for security)
 RUN useradd -m -u 1000 user
 USER user
 ENV HOME=/home/user \
     PATH=/home/user/.local/bin:$PATH
 # 5. Write the Monolith Application to disk
+# This merges drivers.py, index.html, and server.py into one file.
 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
+from llama_cpp import Llama
 # ============================================================================
+# 1. FRONTEND ASSET (index.html embedded)
 # ============================================================================
+HTML_TEMPLATE = r"""
 <!DOCTYPE html>
 <html lang="en">
 <head>
     <meta charset="UTF-8">
+    <title>LiteWin XP - Neural OS Desktop</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script src="https://unpkg.com/react@18/umd/react.production.min.js"></script>
+    <script src="https://unpkg.com/react-dom@18/umd/react-dom.production.min.js"></script>
+    <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:
     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"}
+class LatentFileSystem:
+    def __init__(self, root_path="./litewin_disk"):
+        self.root = Path(root_path)
+        self.root.mkdir(exist_ok=True)
+class LatentVM:
+    def execute(self, bytecode: str, target_latent: torch.Tensor) -> torch.Tensor:
+        return target_latent # Placeholder for VM execution
 # ============================================================================
+# 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
 # 6. Launch the Monolith