Upload 128 files

README.md

@@ -100,18 +100,28 @@ OBLITERATUS implements several techniques that go beyond prior work:
 
 ## Quickstart
 
-### Option A: Browser (no install, free GPU, chat playground)
+### Option A: Browser (local GPU, full UI, chat playground)
 
-The fastest path — obliterate a model and chat with it, all in your browser:
+The best local experience — the same beautiful UI as the HuggingFace Space, running on your own hardware:
 
 ```bash
-# Run locally
 pip install -e ".[spaces]"
-python app.py
-# → open http://localhost:7860
+
+# Launch with GPU auto-detection, system info, and model recommendations
+obliteratus ui
+
+# Or with options:
+obliteratus ui --port 8080          # custom port
+obliteratus ui --share              # generate a public share link
+obliteratus ui --no-browser         # don't auto-open browser
+obliteratus ui --auth user:pass     # add basic auth
+
+# → opens http://localhost:7860 automatically
 ```
 
-Or deploy on [HuggingFace Spaces](https://huggingface.co/spaces) with a free T4 GPU — pick a model, click OBLITERATE, then chat with the modified model in the built-in playground. See [spaces/README.md](spaces/README.md) for setup.
+You can also run directly with `python app.py` (used by HF Spaces). The `obliteratus ui` command adds a beautiful Rich terminal startup with GPU detection, hardware-appropriate model recommendations, and auto-browser-open.
+
+Deploy on [HuggingFace Spaces](https://huggingface.co/spaces) with a free T4 GPU for cloud access — see [spaces/README.md](spaces/README.md) for setup.
 
 ### Option B: Colab
 
@@ -119,7 +129,7 @@ Or deploy on [HuggingFace Spaces](https://huggingface.co/spaces) with a free T4
 
 Pick a model from the dropdown, pick a method, hit Run All. Download the result or push straight to HuggingFace Hub.
 
-### Option C: Local install
+### Option C: Local CLI (headless)
 
 ```bash
 pip install -e .
@@ -132,6 +142,9 @@ obliteratus obliterate meta-llama/Llama-3.1-8B-Instruct --method advanced
 
 # Run a full ablation study from config
 obliteratus run examples/gpt2_layer_ablation.yaml
+
+# Launch the web UI from the CLI
+obliteratus ui
 ```
 
 ### Option D: Python API

app.py

@@ -2,7 +2,9 @@
 
 Deploy on HuggingFace Spaces (free T4 GPU) or run locally:
     pip install -e ".[spaces]"
-    python app.py
+    obliteratus ui              # beautiful launcher with GPU detection
+    python app.py               # direct launch (used by HF Spaces)
+    python app.py --share       # with public share link
 """
 
 from __future__ import annotations
@@ -3733,5 +3735,46 @@ Built on the shoulders of:
 # Launch
 # ---------------------------------------------------------------------------
 
+
+def launch(
+    server_name: str = "0.0.0.0",
+    server_port: int = 7860,
+    share: bool = False,
+    inbrowser: bool = False,
+    auth: tuple[str, str] | None = None,
+    max_threads: int = 40,
+    quiet: bool = False,
+):
+    """Launch the Gradio UI with configurable options.
+
+    Called by ``python app.py`` (HF Spaces) or ``obliteratus ui`` (local).
+    """
+    demo.launch(
+        server_name=server_name,
+        server_port=server_port,
+        share=share,
+        inbrowser=inbrowser,
+        auth=auth,
+        max_threads=max_threads,
+        quiet=quiet,
+    )
+
+
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+    import argparse as _ap
+
+    _parser = _ap.ArgumentParser(description="OBLITERATUS — Gradio UI")
+    _parser.add_argument("--port", type=int, default=7860, help="Server port (default: 7860)")
+    _parser.add_argument("--host", type=str, default="0.0.0.0", help="Server host (default: 0.0.0.0)")
+    _parser.add_argument("--share", action="store_true", help="Create a public Gradio share link")
+    _parser.add_argument("--open", action="store_true", help="Auto-open browser on launch")
+    _parser.add_argument("--auth", type=str, default=None, help="Basic auth as user:pass")
+    _args = _parser.parse_args()
+    _auth = tuple(_args.auth.split(":", 1)) if _args.auth else None
+    launch(
+        server_name=_args.host,
+        server_port=_args.port,
+        share=_args.share,
+        inbrowser=_args.open,
+        auth=_auth,
+    )

obliteratus/cli.py

@@ -58,6 +58,31 @@ def main(argv: list[str] | None = None):
     # --- strategies ---
     subparsers.add_parser("strategies", help="List available ablation strategies")
 
+    # --- ui ---
+    ui_parser = subparsers.add_parser(
+        "ui",
+        help="Launch the Gradio web UI locally (same UI as the HuggingFace Space)",
+    )
+    ui_parser.add_argument(
+        "--port", type=int, default=7860, help="Server port (default: 7860)",
+    )
+    ui_parser.add_argument(
+        "--host", type=str, default="0.0.0.0", help="Server host (default: 0.0.0.0)",
+    )
+    ui_parser.add_argument(
+        "--share", action="store_true", help="Create a public Gradio share link",
+    )
+    ui_parser.add_argument(
+        "--no-browser", action="store_true", help="Don't auto-open browser on launch",
+    )
+    ui_parser.add_argument(
+        "--auth", type=str, default=None,
+        help="Basic auth as user:pass",
+    )
+    ui_parser.add_argument(
+        "--quiet", action="store_true", help="Suppress the startup banner",
+    )
+
     # --- obliterate (primary) + abliterate (backward-compat alias) ---
     def _add_obliterate_args(p):
         p.add_argument("model", type=str, help="HuggingFace model name/path")
@@ -128,10 +153,26 @@ def main(argv: list[str] | None = None):
         _cmd_report(args)
     elif args.command == "aggregate":
         _cmd_aggregate(args)
+    elif args.command == "ui":
+        _cmd_ui(args)
     elif args.command in ("obliterate", "abliterate"):
         _cmd_abliterate(args)
 
 
+def _cmd_ui(args):
+    from obliteratus.local_ui import launch_local_ui
+
+    auth = tuple(args.auth.split(":", 1)) if args.auth else None
+    launch_local_ui(
+        host=args.host,
+        port=args.port,
+        share=args.share,
+        open_browser=not args.no_browser,
+        auth=auth,
+        quiet=args.quiet,
+    )
+
+
 def _cmd_interactive():
     from obliteratus.interactive import run_interactive
     run_interactive()

obliteratus/local_ui.py

@@ -0,0 +1,313 @@
+"""Local UI launcher for OBLITERATUS — beautiful terminal experience + Gradio web UI.
+
+Usage:
+    obliteratus ui                          # launch with defaults
+    obliteratus ui --port 8080 --share      # public link on custom port
+    obliteratus ui --no-browser             # don't auto-open browser
+    obliteratus ui --auth user:pass         # basic auth
+"""
+
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import sys
+import time
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+console = Console()
+
+# ── ASCII banner ────────────────────────────────────────────────────────────
+
+_BANNER = r"""
+[bold green]
+     ██████  ██████  ██      ██ ████████ ███████ ██████   █████  ████████ ██    ██ ███████
+    ██    ██ ██   ██ ██      ██    ██    ██      ██   ██ ██   ██    ██    ██    ██ ██
+    ██    ██ ██████  ██      ██    ██    █████   ██████  ███████    ██    ██    ██ ███████
+    ██    ██ ██   ██ ██      ██    ██    ██      ██   ██ ██   ██    ██    ██    ██      ██
+     ██████  ██████  ███████ ██    ██    ███████ ██   ██ ██   ██    ██     ██████  ███████
+[/bold green]
+[dim]                    ╔══════════════════════════════════════════╗
+                    ║  MASTER ABLATION SUITE — LOCAL EDITION   ║
+                    ║    Break the chains. Free the mind.      ║
+                    ╚══════════════════════════════════════════╝[/dim]
+"""
+
+
+def _detect_gpu() -> list[dict]:
+    """Detect available GPUs and return info dicts."""
+    gpus = []
+    try:
+        import torch
+
+        if torch.cuda.is_available():
+            for i in range(torch.cuda.device_count()):
+                props = torch.cuda.get_device_properties(i)
+                gpus.append(
+                    {
+                        "index": i,
+                        "name": props.name,
+                        "vram_gb": round(props.total_mem / 1024**3, 1),
+                        "compute": f"{props.major}.{props.minor}",
+                    }
+                )
+        elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+            gpus.append(
+                {
+                    "index": 0,
+                    "name": "Apple Silicon (MPS)",
+                    "vram_gb": 0,  # shared memory
+                    "compute": "mps",
+                }
+            )
+    except ImportError:
+        pass
+    return gpus
+
+
+def _get_disk_free_gb(path: str = "/") -> float:
+    """Return free disk space in GB."""
+    try:
+        usage = shutil.disk_usage(path)
+        return round(usage.free / 1024**3, 1)
+    except Exception:
+        return 0.0
+
+
+def _get_ram_gb() -> float:
+    """Return total system RAM in GB."""
+    try:
+        import psutil
+
+        return round(psutil.virtual_memory().total / 1024**3, 1)
+    except ImportError:
+        # Fallback: read from /proc/meminfo on Linux
+        try:
+            with open("/proc/meminfo") as f:
+                for line in f:
+                    if line.startswith("MemTotal:"):
+                        kb = int(line.split()[1])
+                        return round(kb / 1024**2, 1)
+        except Exception:
+            pass
+    return 0.0
+
+
+def _print_system_info(gpus: list[dict]) -> None:
+    """Print a beautiful system info panel."""
+    table = Table(show_header=False, border_style="green", expand=True, padding=(0, 2))
+    table.add_column("Key", style="dim", width=18)
+    table.add_column("Value", style="cyan")
+
+    table.add_row("Platform", f"{platform.system()} {platform.release()}")
+    table.add_row("Python", f"{platform.python_version()}")
+
+    ram = _get_ram_gb()
+    if ram > 0:
+        table.add_row("System RAM", f"{ram} GB")
+
+    disk = _get_disk_free_gb("/tmp")
+    if disk > 0:
+        table.add_row("Disk Free (/tmp)", f"{disk} GB")
+
+    # PyTorch version
+    try:
+        import torch
+
+        table.add_row("PyTorch", torch.__version__)
+    except ImportError:
+        table.add_row("PyTorch", "[red]NOT INSTALLED[/red]")
+
+    # Transformers version
+    try:
+        import transformers
+
+        table.add_row("Transformers", transformers.__version__)
+    except ImportError:
+        table.add_row("Transformers", "[red]NOT INSTALLED[/red]")
+
+    # Gradio version
+    try:
+        import gradio
+
+        table.add_row("Gradio", gradio.__version__)
+    except ImportError:
+        table.add_row("Gradio", "[red]NOT INSTALLED[/red]")
+
+    # GPU info
+    if gpus:
+        for gpu in gpus:
+            vram = f"{gpu['vram_gb']} GB" if gpu["vram_gb"] > 0 else "shared"
+            table.add_row(
+                f"GPU {gpu['index']}",
+                f"[bold green]{gpu['name']}[/bold green]  ({vram}, compute {gpu['compute']})",
+            )
+    else:
+        table.add_row("GPU", "[yellow]None detected — CPU mode[/yellow]")
+
+    # HF Token
+    hf_token = os.environ.get("HF_TOKEN", "")
+    if hf_token:
+        table.add_row("HF Token", f"[green]set[/green] ({hf_token[:8]}...)")
+    else:
+        table.add_row("HF Token", "[dim]not set (gated models won't work)[/dim]")
+
+    console.print(Panel(table, title="[bold green]System Info[/bold green]", border_style="green"))
+
+
+def _compute_tier(gpus: list[dict]) -> str:
+    """Determine the compute tier based on available hardware."""
+    if not gpus:
+        return "cpu"
+    max_vram = max(g["vram_gb"] for g in gpus)
+    if max_vram >= 80:
+        return "frontier"
+    elif max_vram >= 24:
+        return "large"
+    elif max_vram >= 8:
+        return "medium"
+    elif max_vram > 0:
+        return "small"
+    else:
+        return "mps"  # Apple Silicon
+
+
+def _print_recommendations(tier: str) -> None:
+    """Print model recommendations based on detected hardware."""
+    recs = {
+        "cpu": [
+            ("distilbert/distilgpt2", "Tiny — 82M params, runs on anything"),
+            ("TinyLlama/TinyLlama-1.1B-Chat-v1.0", "Small — 1.1B params, workable on CPU"),
+        ],
+        "small": [
+            ("TinyLlama/TinyLlama-1.1B-Chat-v1.0", "1.1B — fits in 4GB"),
+            ("Qwen/Qwen2.5-0.5B-Instruct", "0.5B — very fast on small GPUs"),
+            ("Qwen/Qwen2.5-3B-Instruct", "3B — good quality, ~6GB VRAM"),
+        ],
+        "mps": [
+            ("TinyLlama/TinyLlama-1.1B-Chat-v1.0", "1.1B — fast on Apple Silicon"),
+            ("Qwen/Qwen2.5-3B-Instruct", "3B — good with shared memory"),
+            ("meta-llama/Llama-3.2-3B-Instruct", "3B — great quality on MPS"),
+        ],
+        "medium": [
+            ("Qwen/Qwen2.5-7B-Instruct", "7B — excellent quality at 16GB"),
+            ("meta-llama/Llama-3.1-8B-Instruct", "8B — the standard benchmark"),
+            ("mistralai/Mistral-7B-Instruct-v0.3", "7B — fast and capable"),
+        ],
+        "large": [
+            ("openai/gpt-oss-20b", "20B MoE — flagship, try surgical/nuclear"),
+            ("meta-llama/Llama-3.1-70B-Instruct", "70B — with 4bit quant"),
+            ("Qwen/Qwen3-30B-A3B", "30B MoE — only 3B active"),
+        ],
+        "frontier": [
+            ("deepseek-ai/DeepSeek-V3", "671B MoE — the frontier"),
+            ("meta-llama/Llama-3.1-70B-Instruct", "70B — full precision"),
+            ("Qwen/Qwen3.5-397B-A17B", "397B MoE — massive"),
+        ],
+    }
+
+    tier_recs = recs.get(tier, recs["cpu"])
+
+    table = Table(
+        title=f"Recommended Models for Your Hardware ({tier.upper()})",
+        border_style="green",
+    )
+    table.add_column("Model", style="cyan", min_width=40)
+    table.add_column("Notes", style="dim")
+
+    for model, notes in tier_recs:
+        table.add_row(model, notes)
+
+    console.print(table)
+
+
+def _print_launch_info(
+    host: str,
+    port: int,
+    share: bool,
+    auth: tuple[str, str] | None,
+) -> None:
+    """Print launch configuration."""
+    parts = []
+    url = f"http://{'localhost' if host == '0.0.0.0' else host}:{port}"
+    parts.append(f"[bold green]Local URL:[/bold green]     {url}")
+    if host == "0.0.0.0":
+        parts.append(f"[bold green]Network URL:[/bold green]   http://<your-ip>:{port}")
+    if share:
+        parts.append("[bold green]Share link:[/bold green]    [yellow]generating...[/yellow]")
+    if auth:
+        parts.append(f"[bold green]Auth:[/bold green]          {auth[0]}:{'*' * len(auth[1])}")
+    parts.append("")
+    parts.append("[dim]Press Ctrl+C to stop the server[/dim]")
+
+    console.print(
+        Panel(
+            "\n".join(parts),
+            title="[bold green]Launching OBLITERATUS UI[/bold green]",
+            border_style="green",
+        )
+    )
+
+
+def launch_local_ui(
+    host: str = "0.0.0.0",
+    port: int = 7860,
+    share: bool = False,
+    open_browser: bool = True,
+    auth: tuple[str, str] | None = None,
+    quiet: bool = False,
+) -> None:
+    """Launch the OBLITERATUS Gradio UI with a beautiful local experience.
+
+    This is the main entry point for ``obliteratus ui``.
+    """
+    # ── Beautiful startup ──────────────────────────────────────────────
+    if not quiet:
+        console.print(_BANNER)
+
+        gpus = _detect_gpu()
+        _print_system_info(gpus)
+        console.print()
+
+        tier = _compute_tier(gpus)
+        _print_recommendations(tier)
+        console.print()
+
+        _print_launch_info(host, port, share, auth)
+        console.print()
+
+    # ── Check dependencies ─────────────────────────────────────────────
+    try:
+        import gradio  # noqa: F401
+    except ImportError:
+        console.print(
+            "[bold red]Error:[/bold red] Gradio is not installed.\n"
+            "Install it with: [cyan]pip install -e '.[spaces]'[/cyan]\n"
+            "Or: [cyan]pip install gradio>=5.0[/cyan]"
+        )
+        sys.exit(1)
+
+    # ── Import and launch the app ──────────────────────────────────────
+    console.print("[dim]Loading OBLITERATUS UI (this may take a moment on first run)...[/dim]")
+    start = time.time()
+
+    from app import demo, launch as app_launch
+
+    elapsed = time.time() - start
+    if not quiet:
+        console.print(f"[green]UI loaded in {elapsed:.1f}s[/green]")
+        console.print()
+
+    app_launch(
+        server_name=host,
+        server_port=port,
+        share=share,
+        inbrowser=open_browser,
+        auth=auth,
+        quiet=quiet,
+    )

obliteratus/presets.py

@@ -208,6 +208,39 @@ _PRESETS_LIST = [
         recommended_dtype="bfloat16",
         recommended_quantization="4bit",
     ),
+    ModelPreset(
+        name="Qwen3.5-0.8B",
+        hf_id="Qwen/Qwen3.5-0.8B",
+        description="Qwen3.5 0.8B — Gated DeltaNet hybrid attention, 262K ctx. Non-thinking mode. Apache 2.0.",
+        tier="tiny",
+        params="0.8B",
+        recommended_dtype="float16",
+    ),
+    ModelPreset(
+        name="Qwen3.5-2B",
+        hf_id="Qwen/Qwen3.5-2B",
+        description="Qwen3.5 2B — Gated DeltaNet hybrid attention, 262K ctx, think/non-think modes. Apache 2.0.",
+        tier="small",
+        params="2B",
+        recommended_dtype="float16",
+    ),
+    ModelPreset(
+        name="Qwen3.5-4B",
+        hf_id="Qwen/Qwen3.5-4B",
+        description="Qwen3.5 4B — natively multimodal, 262K ctx, think/non-think modes. Apache 2.0.",
+        tier="small",
+        params="4B",
+        recommended_dtype="float16",
+    ),
+    ModelPreset(
+        name="Qwen3.5-9B",
+        hf_id="Qwen/Qwen3.5-9B",
+        description="Qwen3.5 9B — natively multimodal, 262K ctx (1M extended), think/non-think modes. Apache 2.0.",
+        tier="medium",
+        params="9B",
+        recommended_dtype="float16",
+        recommended_quantization="4bit",
+    ),
     ModelPreset(
         name="Qwen3.5 397B-A17B",
         hf_id="Qwen/Qwen3.5-397B-A17B",

spaces/README.md

@@ -33,16 +33,21 @@ One-click cognitive liberation for language models, with a built-in chat playgro
 7. **Leaderboard tab**: Community benchmark rankings
 8. **About tab**: Methods, novel techniques, and references
 
-## Deploy your own
+## Run locally (same UI, your own GPU)
 
 ```bash
 git clone https://github.com/obliteratus-project/OBLITERATUS
 cd OBLITERATUS
 pip install -e ".[spaces]"
+
+# Beautiful launcher with GPU detection + model recommendations
+obliteratus ui
+
+# Or run directly
 python app.py
 ```
 
-Then open http://localhost:7860
+The `obliteratus ui` command auto-detects your GPU, prints hardware-specific model recommendations, and opens the browser automatically. Supports `--share` for public links, `--port` for custom ports, and `--auth user:pass` for access control.
 
 ## Or deploy on HuggingFace Spaces