Repetere AI 1.0 Sovereign Workstation

● Systems Engineering · Deep Technical Specifications

Systems Architecture & Deep Technical Specifications

Out-of-process native C++ orchestrator (Dear ImGui, GLFW, OpenGL 3), Win32 Job Object process containment, DXGI dynamic layer partitioning, and isolated multi-modal neural execution pipelines.

Section 01 · Host Runtime & Process Containment

1. Underlying Systems & Compute Architecture

Repetere AI 1.0 is engineered as an out-of-process orchestrator written in native C++ (Dear ImGui, GLFW, OpenGL 3), operating completely free of Electron, Node.js, Chromium, or Python runtimes.

┌────────────────────────────────────────────────────────────────────────┐ │ Repetere AI Host (FREEAI.exe) │ │ - DXGI Hardware Profiler & VRAM Scanner (HardwareScanner.h) │ │ - Job Object Process Supervisor & OOM Guard (ProcessManager.h) │ │ - Asynchronous CPR REST Dispatcher (InferenceClient.h/.cpp) │ └───────────────┬────────────────────────────┬───────────────────────────┘ │ Win32 Job Containment │ IPC / Loopback HTTP ▼ ▼ ┌───────────────────────────────┐ ┌──────────────────────────────────────┐ │ bin/llama-server.exe (:8080) │ │ bin/audio/audiocpp_cli.exe │ │ - ggml / cuBLAS / Vulkan │ │ - YuE2 3B Full-Context Transformer │ │ - Dynamic Layer Offload │ │ - Neural VAE Acoustic Decoder │ └───────────────────────────────┘ └──────────────────────────────────────┘
  • Process Isolation via Win32 Job Objects: Instead of linking inference libraries into the UI thread or running a shared Python kernel, all backends (llama-server.exe, audiocpp_cli.exe, sd.exe) are spawned as isolated child processes via Win32 CreateProcessW. Every process is bound to a Win32 Job Object with JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE. If the main executable faults or exits, the OS hardware scheduler guarantees every sidecar process drops instantly, leaving no orphaned server daemons consuming ports or VRAM.
  • Dynamic Compute Backends: The inference engine hot-swaps between two low-level acceleration runtimes: NVIDIA CUDA 12 (cuBLAS) for Tensor Core pipelines and Vulkan 1.3 (SPIR-V / ggml-vulkan) for hardware-neutral execution across AMD Radeon, Intel Arc, and unified memory architectures (APUs).
  • Dynamic Layer Partitioning (-ngl Offloading):
    • In GPU Mode, weights and context are pinned strictly to VRAM via -ngl 99, minimizing latency and maximizing memory bandwidth.
    • In Hybrid Mode, HardwareScanner.h leverages DirectX Graphics Infrastructure (DXGI) to poll dedicated video memory against total host RAM. The orchestrator calculates the exact layer budget the GPU can safely hold, streaming the overflow layers into system RAM. This architecture enables 14B and 32B checkpoints to run on mainstream 8 GB–12 GB GPUs without throwing CUDA Out-of-Memory (cudaErrorMemoryAllocation) faults.
  • Modality Hot-Swapping & VRAM Garbage Collection: Because consumer GPUs cannot concurrently hold a quantized 8B LLM, a 3B autoregressive audio model, and a 12B parameter rectified flow diffusion pipeline, navigating between workspaces executes a deterministic unload pipeline. The host sends an ejection command to the running sidecar, drops memory-mapped buffers (UnloadFromMemory), flushes OpenGL display textures, and then bootstraps the next engine cleanly.

Section 02 · Multimodal Execution Pipelines

2. Deep Dive: Model Workloads & Inference Pipelines

A. Interactive IDE & In-Place AST Diff Engine (CodingUI.h/.cpp)

  • Target Architectures: Qwen 2.5 Coder 7B, 14B, and 32B (Q4_K_M quantizations).
  • AST Search/Replace Patching: The UI does not simply print raw completions; an integrated parser continuously monitors streaming outputs for unified search/replace anchors:
    <<<<<<< SEARCH
    [original AST/source snippet]
    =======
    [synthesized replacement snippet]
    >>>>>>> REPLACE
    The diff engine matches the target search block against the active 62% editor buffer. It applies automatic tab/space normalization and CRLF sanitization, reconciling any indentation discrepancies produced by the model's tokenizer before executing an in-place AST block substitution.
  • Context Preservation: Chat history and token state are dynamically serialized to OpenAI-compliant REST schemas via detached cpr::PostAsync worker threads on port 8080, leaving the 60 FPS Dear ImGui rendering loop unblocked.

B. Generative Reasoning & Narrative Engines (ChatUI & CreativeUI)

  • Target Checkpoints: Meta Llama 3.1 8B Instruct and Hermes 3 Llama 3.1 8B (Q4_K_M).
  • KV-Cache Optimization: Utilizes 4-bit KV caching (q4_0), enabling long active context windows (up to 64k+ tokens) within an 8 GB VRAM envelope without saturating memory budgets.
  • Story Bible Context Injection: In the Creative Studio, external markdown/text lore files are tokenized and injected directly into the system context prompt dynamically before each generation pass. A 30-step snapshot ring buffer tracks continuous edits to the manuscript buffer to maintain local undo/redo state.

C. Neural Audio & Singing Voice Synthesis (MusicStudioUI.h/.cpp)

  • Pipeline: Autoregressive dual-track token generation powered by YuE2 3B (yue2-3b-q4_0.gguf or q8_0) paired with a neural audio VAE decoder (yue2-vae-f16.gguf).
  • CLI Stream Sanitization: The lyrics engine processes an 8,192-byte input buffer parsing section delimiters ([Verse], [Chorus], [Bridge]). To prevent subshell command chopping inside the Win32 CLI interface (cmd.exe), strings are pre-flattened, double-quotes are escaped, and arguments are pushed directly into audiocpp_cli.exe.
  • VAE Decoding: YuE produces discrete acoustic tokens over timeline iterations up to 360 seconds (6 minutes). These acoustic tokens are passed to the neural VAE decoder at FP16 precision, synthesizing the final 44.1 kHz multi-track stereo WAV directly to the drive.

D. Rectified Flow & Turbo Diffusion Studio (ImageStudioUI.h/.cpp)

  • Target Architecture: Quantized FLUX.1 Schnell (4-step rectified flow) & SDXL Turbo (sd_xl_turbo_1.0_q4_0.gguf) low-latency latent diffusion pipelines.
  • Quantized Text Conditioning & Memory Safety: The workspace inspects and maps multiple discrete quantized companion encoders required for low-VRAM inference, eliminating the 70% VRAM load freeze common with unquantized weights:
    • t5xxl_q4_k.gguf (Quantized high-capacity secondary text encoder preventing VRAM allocation faults)
    • clip_l.safetensors / clip_l.gguf (Primary semantic text encoder)
    • ae.safetensors / ae.gguf (Diffusion Autoencoder decoder)
    • sd_xl_turbo_1.0_q4_0.gguf (Ultra-fast 1-to-4 step quantized diffusion checkpoint)
  • Format Flexibility: The loader scans for both .gguf and .safetensors model formats, verifying component binary integrity before issuing inference passes through sd.exe.

Section 03 · Binary Integrity & CDN Streaming

3. Native Model Distribution & Verification Pipeline

  • Chunked CPR Streaming: Model acquisition bypasses third-party package managers via an in-app CPR client executing chunked HTTP/HTTPS streaming directly against Hugging Face CDN endpoints.
  • Network Resilience: The network client explicitly resolves multi-hop HTTP 302 and 307 redirects commonly served by Git LFS storage nodes, mitigating zero-byte corruptions.
  • Magic Header Inspection: Before a .part file is renamed and bound to the server instance, the binary stream reads the leading 4 bytes to validate the GGUF specification header:
    Magic Header = 0x46554747 ("GGUF" in ASCII)
    Files failing this verification check are safely dropped to protect the engine runtime from segmentation faults during memory mapping (mmap).

Section 04 · Architectural Benchmarks

4. Technical Trade-Offs: Local Native vs. Cloud-Hosted SaaS

Dimension Cloud SaaS Architectures (ChatGPT, Copilot, Midjourney) Repetere AI 1.0 (Local C++ Engine)
Inference Hardware High-density enterprise clusters (H100/H200/B200 SXM5 pools connected via 3.2 Tbps InfiniBand). Consumer GPU silicon (NVIDIA RTX Ada/Blackwell, AMD RDNA 3, or unified memory APUs).
Quantization & Precision FP8, FP16, or unquantized FP32 weights run across distributed tensor-parallel shards. 4-bit to 8-bit quantization (Q4_K_M, Q4_0, Q8_0) using dynamic matrix scaling with minimal perplexity degradation.
Memory Bandwidth & Throughput Multi-terabyte/sec HBM3/HBM3e bandwidth delivering 100+ tokens/sec on massive 70B–405B parameter models. VRAM bus limited (128-bit to 384-bit GDDR6/GDDR7). Achieves 50–65 tokens/sec on 7B–8B checkpoints, with throughput throttled by host memory bus when using Hybrid mode.
System Footprint & Overhead Massive web client / Electron wrapper overhead idling between 800 MB and 2 GB system RAM. Direct Win32 / Dear ImGui rendering layer idling under 90 MB of RAM, reserving host resources entirely for weights and KV caches.
Latency Bottlenecks Network RTT, cloud dispatch routing, multi-tenant queue contention, and cold-start scheduling delays. Zero network latency. Pure hardware compute cycle time; generation begins the moment matrices load into VRAM.
Privacy & Security Boundaries Zero data sovereignty; prompts, ASTs, and assets cross external network boundaries subject to provider data retention policies. Fully isolated host sandbox (127.0.0.1:8080). Zero external network packets leave the system; full parameter execution is air-gapped.

Section 05 · Autonomous Reasoning Engine

5. DeepThink Architecture & Python AST Script Splicing

Separate from the primary modality studios, the DeepThink Autonomous Lab provides a dedicated backend subsystem for recursive reasoning, deterministic code modification, and automated local self-correction.

A. Python Abstract Syntax Tree (AST) Splicing Pipeline

When performing advanced code refactoring or multi-file repairs, DeepThink bypasses fragile text-matching heuristics by compiling source files into Python Abstract Syntax Trees (ast module). The engine traverses node hierarchies, identifies target functions, classes, or imports, executes structural AST transformations, and unparses the modified tree back into pristine source code—guaranteeing zero syntax corruption.

B. HD Hook Liveness Probes & Process Supervision

Long-running autonomous loops are governed by ProcessManager.h and HD Hook liveness probes. These background routines poll sidecar socket responsiveness, measure KV-cache allocation velocity, and verify VRAM thermal/memory headroom every 250ms, ensuring that recursive reasoning tasks execute stably without external telemetry or cloud intervention.

C. Autonomous Iteration & Self-Correction Engine

DeepThink coordinates iterative prompt execution cycles. Intermediate outputs are evaluated against rigid structural constraints, compiler diagnostic outputs, and user-defined rules. If discrepancies or syntax errors are detected, the orchestrator feeds error logs back into the local context window for automated correction before final disk serialization.

Deploy Bare-Metal Sovereign AI on Your Hardware

Evaluate the architecture with Free Beta v0.9 or unlock Commercial 1.0 ($49.99 perpetual).