How It Works

Core Components Stack

USB Flash Drive (Any Letter:/)
├── OffGrid_AI_ToolKit/
│   ├── OffGridLauncher/
│   │   ├── dist/win-unpacked/    # Electron app (172MB compiled)
│   │   ├── main.js               # Process orchestration
│   │   ├── preload.js            # Security bridge
│   │   └── launcher.html         # System UI
│   ├── Dashboard/
│   │   ├── index.html            # Main chat interface
│   │   ├── saved_conversations.json  # Portable conversation storage
│   │   ├── User_Guide/           # Hot-swappable MD docs
│   │   ├── Ready_Made_Prompts/   # Clickable prompt library
│   │   └── Model_Benchmarks/     # Live documentation
│   ├── Ollama_App/
│   │   └── ollama.exe            # AI inference engine (port 11434)
│   ├── CaddyWS/
│   │   └── caddy.exe             # Zero-config web server (port 8000)
│   └── Ollama/.ollama/models/    # 31GB of AI models
       ├── Gemma3 4B/12B/27B      # Vision-capable models
       └── MedGemma 4B            # Medical specialist

The entire system fits on a 64GB USB 3.2 drive with 18.2GB free space remaining for user data and saved conversations.

1. Dynamic Path Resolution

The system automatically finds itself regardless of USB drive letter assignment:

function getBasePath() {
    let currentDir = exeDir;
    while (currentDir !== path.dirname(currentDir)) {
        const testPath = path.join(currentDir, 'OffGrid_AI_ToolKit');
        if (fs.existsSync(testPath)) return testPath;
        currentDir = path.dirname(currentDir);
    }
}

Why this matters: Users can plug the USB into any port, get any drive letter (E:/, F:/, G:/, etc.), and the system still works perfectly.

2. Mobile-Desktop Bridge Architecture

The cleverest hack in our system - using computer resources from your phone:

• Computer = Brain: Runs heavy AI models using 6-32GB RAM
• Phone = Interface: Lightweight web UI with camera access
• Local WiFi = Bridge: No internet needed, just local network

// Auto-generate QR code for instant mobile access
const detectNetworkIP = async () => {
    const response = await fetch('/local_ip.txt');
    const ip = await response.text();
    return `http://${ip}:8000`;
};

new QRCode("qrcode", {
    text: await detectNetworkIP(),
    width: 128,
    height: 128
});

3. Enhanced Process Management System

A sophisticated ProcessManager class handles all system processes with multiple fallback strategies:

class ProcessManager {
    // Multi-tier shutdown system
    async terminateProcess(processName) {
        // Step 1: Graceful termination
        process.kill('SIGTERM');
        
        // Step 2: Force kill by PID if still running
        await this.forceKillProcess(pid);
        
        // Step 3: Kill by name (cleanup any orphans)
        await this.killProcessByName(processName);
    }
    
    // Dashboard shutdown detection via Caddy logs
    if (logLine.includes('shutdown-signal=true')) {
        this.initiateShutdown('dashboard-signal');
    }
}

Result: Clean shutdown from any entry point - dashboard button, system tray, or launcher - with no orphaned processes.

4. Zero-Installation Model Recognition

Challenge: Ollama needs to recognize models without system installation.

Solution: Dynamic environment variable configuration:

process.env.OLLAMA_HOME = path.join(basePath, 'Ollama', '.ollama');
process.env.OLLAMA_MODELS = path.join(basePath, 'Ollama', '.ollama', 'models');

This ensures models are recognized in both development and production environments without any system registry entries.

Click-to-Prompt System (Industry First?)

We believe we created the first implementation of single-click prompt insertion from markdown documentation:

// Any <code> element in markdown becomes clickable
document.addEventListener('click', function(e) {
    if (e.target.tagName === 'CODE' && e.target.closest('.markdown-content')) {
        // Instantly copy to input field
        document.getElementById('messageInput').value = e.target.textContent;
        autoResize(document.getElementById('messageInput'));
        
        // Visual feedback
        e.target.style.background = '#10b981';
        showNotification('✓ Copied & ready to send!');
    }
});

Impact: 500+ ready-made prompts become instantly usable with a single click. No copy-paste needed.

Hot-Swappable Documentation System

All documentation lives as markdown files that can be edited without touching code:

const CONTENT_PATHS = {
    'user-guide': '/User_Guide/user_guide.md',
    'benchmarks': '/Model_Benchmarks/model-benchmarks.md',
    'ready-prompts': '/Ready_Made_Prompts/ready_made_prompts.md'
};

async function loadExternalContent(contentId) {
    const content = await fetch(CONTENT_PATHS[contentId]);
    const markdown = await content.text();
    const html = marked.parse(markdown);
    addMarkdownMessage(html);
}

Benefits:

• Documentation updates without recompiling
• Users can customize their own prompts
• Version control for docs separate from code
• Live editing while system runs

Intelligent Image Optimization Pipeline

Mobile photos are automatically optimized before AI processing:

function resizeImage(file, maxWidth, maxHeight) {
    // 12MP photo (4MB) → 200KB optimized
    // 5-10x faster inference
    canvas.toBlob(function(blob) {
        const reader = new FileReader();
        reader.onloadend = function() {
            callback(reader.result);
        };
        reader.readAsDataURL(blob);
    }, 'image/jpeg', 0.8);
}

Results:

• 12MP photo processing: 30 seconds → 3 seconds
• No quality loss for AI analysis
• Client-side processing (no server load)

Conversation Save System

Every conversation can be saved directly to the USB drive for true portability:

class ConversationManager {
    saveConversation(title) {
        // Save to USB drive for cross-computer access
        const conversation = {
            title: title,
            messages: this.currentConversation,
            timestamp: new Date().toISOString(),
            model: currentModel
        };
        
        // Limit to 50 most recent conversations
        if (this.savedConversations.length >= 50) {
            this.savedConversations.shift();
        }
        
        this.savedConversations.push(conversation);
        this.saveToDisk(); // Write to saved_conversations.json
    }
}

Features:

• Save up to 50 named conversations
• Portable across computers
• Auto-backup before each save
• Export as text files for sharing

Model Response Times

Note: Response times are for complete answers running from USB 3.2. Times may vary based on query complexity and system resources. See detailed model benchmarks on our website.

Resource Efficiency

Privacy By Design Principles

• No telemetry: Zero tracking code in the entire system
• No accounts: Anonymous by default, no registration
• No cloud: Air-gapped operation possible
• No logs: Nothing stored about usage patterns
• No updates: Can't be remotely modified or disabled
• Data sovereignty: User owns all conversations and data

DigiCert Verification

Our executable is signed with a DigiCert certificate, ensuring:

• Authentic software from OffGrid AI ToolKit, LLC
• Protection against tampering or modification
• Windows SmartScreen approval
• User confidence in software legitimacy

What We Protect Against

• Data exfiltration: No network requests leave localhost
• Model poisoning: Models are read-only
• Prompt injection: Sanitized markdown rendering
• Path traversal: Restricted to USB paths
• Process hijacking: PID verification

What We Trust

• The local machine (no sandboxing)
• The user (no authentication)
• The USB drive (no encryption at rest by default)

Problem: How to run AI without installation?

Solution: Electron app with embedded Ollama + dynamic environment variables

// Set paths at runtime, not install time
process.env.OLLAMA_HOME = path.join(basePath, 'Ollama', '.ollama');
process.env.OLLAMA_MODELS = path.join(basePath, 'Ollama', '.ollama', 'models');

Problem: How to serve web UI without a server?

Solution: Caddy single executable with zero configuration needed

caddy.exe file-server --root Dashboard --listen :8000

Problem: How to handle browser security restrictions?

Solution: Preload script bridges renderer to main process

contextBridge.exposeInMainWorld('electronAPI', {
    shutdown: () => ipcRenderer.invoke('shutdown-request'),
    getProcessStatus: () => ipcRenderer.invoke('process-status'),
    saveConversations: (data) => ipcRenderer.invoke('save-conversations', data),
    loadConversations: () => ipcRenderer.invoke('load-conversations')
});

Problem: How to find the system on any network?

Solution: Multi-strategy IP detection

// Strategy 1: Write IP to file for dashboard access
fs.writeFileSync('local_ip.txt', localIP);

// Strategy 2: QR code generation for mobile
new QRCode(element, `http://${localIP}:8000`);

// Strategy 3: Display in launcher for manual entry
document.getElementById('mobileSpec').textContent = localIP;

Problem: Windows Firewall blocking mobile access?

Solution: Automatic firewall rule configuration

netsh advfirewall firewall add rule name="OffGrid AI - Port 8000" 
    dir=in action=allow protocol=TCP localport=8000

Modular Component Design

• Each piece standalone: Ollama, Caddy, Dashboard can run independently
• Standard protocols: HTTP, WebSocket, REST APIs
• Open formats: Markdown, JSON, HTML5
• Clear separation: UI, Logic, AI, Storage layers
• Extensive comments: Self-documenting code

Hidden Developer Features

// Ctrl+Shift+M reveals developer tools
mainWindow.webContents.on('before-input-event', (event, input) => {
    if (input.control && input.shift && input.key === 'M') {
        Menu.setApplicationMenu(createDeveloperMenu());
    }
});

Graceful Degradation Throughout

try {
    const response = await fetch('/local_ip.txt');
    const ip = await response.text();
} catch {
    // Fallback to manual IP entry
    mobileUrl = 'Enter IP manually';
}

Technical Lessons Learned

What Worked Better Than Expected:

1. Electron for process management: Handles complex orchestration elegantly
2. Caddy over Python: Saved 300MB, zero dependencies
3. Client-side optimization: Faster than server-side processing
4. Markdown for documentation: Users can contribute easily
5. QR codes for mobile: No app store needed

What Required Creative Solutions:

1. Shutdown coordination: Solved with Caddy log monitoring
2. Model recognition: Solved with environment variables
3. Path resolution: Solved with recursive search
4. Mobile camera access: Solved with HTML5 capture attribute
5. Process cleanup: Solved with PID persistence

Key Technologies & Inspirations

• Ollama: The foundation of local AI inference
• Electron: Desktop app framework
• Caddy: Zero-config web server
• Gemma Models: Google's efficient vision models
• marked.js: Markdown parsing
• QRCode.js: Client-side QR generation

Special thanks to the entire open source community. Your commitment to free and open software made it possible to take a dream and turn it into reality. This is what happens when brilliant minds share their work freely. Together we build the future we want to see.

Licensing Status

• OffGrid AI ToolKit Code: Proprietary (custom license)
• Ollama: Apache 2.0 (commercial friendly)
• Electron/Caddy: MIT/Apache (permissive)
• AI Models: Gemma Terms (review for commercial distribution)

The code demonstrates that powerful software doesn't require:

• Cloud infrastructure
• User accounts
• Installation processes
• Internet connectivity
• Privacy compromises

Build on this work. Fork it. Improve it. Keep AI free.