Quick Start

Get Clippy running in under 5 minutes

Fastest: One Command

# Run immediately (no installation needed)
nix run github:getclippy/clippy

Option 1: Browser Extension (Easiest for Beginners)

The fastest way to start using Clippy:

1. Install for your browser:
   • Firefox Add-on
   • Chrome Extension
   • Edge Extension
2. Click the Clippy icon in your toolbar
3. Follow the 30-second setup wizard
4. Watch Clippy go to work!

Option 2: Nix Installation (Recommended)

For maximum security and reproducibility:

# Install Nix if you don't have it (macOS/Linux/WSL)
curl --proto '=https' --tlsv1.2 -sSf -L https://install.determinate.systems/nix | sh -s -- install

# Run Clippy
nix run github:getclippy/clippy

# Or install it permanently
nix profile install github:getclippy/clippy

# Start Clippy
clippy start

Option 3: Docker

For containerized deployment:

# Pull and run the official image
docker run -d \
  --name clippy \
  -p 8080:8080 \
  -v clippy-data:/data \
  ghcr.io/getclippy/clippy:latest

# Access dashboard
open http://localhost:8080

Option 4: Platform-Specific

First Steps

Once Clippy is running:

clippy persona generate --strategy opposite

clippy extraction enable --auto-claim

clippy poison start --intensity medium

Verify Everything is Working

# Check status
clippy status

# Expected output:
Clippy Status
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Protection:     ACTIVE ✓
Mode:          Balanced
Personas:      3 active
Poisoning:     Enabled (medium)
Extraction:    Scanning
Trackers blocked today: 127
Value recovered (MTD): $45.32
Privacy score: 87/100

What's Next?

Installation Guide

Detailed installation instructions for all platforms

System Requirements

Browser Extension

Chrome, Edge, Brave

# Option 1: Chrome Web Store
# Visit: https://chrome.google.com/webstore/clippy

# Option 2: Manual installation
git clone https://github.com/getclippy/clippy-extension.git
cd clippy-extension
npm install
npm run build

# Load unpacked extension in chrome://extensions

Firefox

# Option 1: Firefox Add-ons
# Visit: https://addons.mozilla.org/clippy

# Option 2: Manual installation
git clone https://github.com/getclippy/clippy-extension.git
cd clippy-extension
npm install
npm run build:firefox

# Load in about:debugging

Desktop Application

Windows

# Using installer
Download: https://getclippy.dev/download/windows
Run ClippySetup.exe

# Using Chocolatey
choco install clippy

# From source
git clone https://github.com/getclippy/clippy-desktop.git
cd clippy-desktop
npm install
npm run build:win
npm run dist

macOS

# Using Homebrew
brew install --cask clippy

# Using DMG
Download: https://getclippy.dev/download/mac
Open Clippy.dmg and drag to Applications

# From source
git clone https://github.com/clippy-assistant/clippy-desktop.git
cd clippy-desktop
npm install
npm run build:mac
npm run dist

Linux

# Ubuntu/Debian
wget https://getclippy.dev/download/clippy.deb
sudo dpkg -i clippy.deb

# Fedora/RHEL
wget https://getclippy.dev/download/clippy.rpm
sudo rpm -i clippy.rpm

# AppImage (Universal)
wget https://getclippy.dev/download/Clippy.AppImage
chmod +x Clippy.AppImage
./Clippy.AppImage

# From source
git clone https://github.com/clippy-assistant/clippy-desktop.git
cd clippy-desktop
npm install
npm run build:linux
npm run dist

Mobile Applications

Android

# Google Play Store
Search for "Clippy Assistant"

# F-Droid
Add repository: https://getclippy.dev/fdroid
Install Clippy

# APK Direct Download
wget https://getclippy.dev/download/clippy.apk
# Enable "Install from Unknown Sources"
# Install APK

iOS

# App Store
Search for "Clippy Assistant"

# TestFlight Beta
Visit: https://testflight.apple.com/join/clippy

Router Installation

Protect your entire network:

OpenWRT

# SSH into your router
ssh root@192.168.1.1

# Add Clippy repository
echo "src/gz clippy https://getclippy.dev/openwrt" >> /etc/opkg/customfeeds.conf
opkg update

# Install Clippy
opkg install clippy-router

# Configure
uci set clippy.enabled=1
uci commit clippy
/etc/init.d/clippy start

Verification

After installation, verify Clippy is working:

# Check version
clippy --version

# Run diagnostics
clippy doctor

# View status
clippy status

Configuration

Customize Clippy to match your privacy needs

Configuration File

Clippy uses a simple JSON configuration file located at:

• Windows: %APPDATA%\Clippy\config.json
• macOS: ~/Library/Application Support/Clippy/config.json
• Linux: ~/.config/clippy/config.json

Default Configuration

{
  "core": {
    "enabled": true,
    "mode": "balanced",
    "updateChannel": "stable"
  },
  "personas": {
    "count": 3,
    "rotationInterval": 3600,
    "behaviorProfiles": ["shopping", "research", "entertainment"],
    "geolocations": ["auto"]
  },
  "poisoning": {
    "enabled": true,
    "intensity": "medium",
    "targetedDomains": [],
  },
  "extraction": {
    "autoClaimSettlements": true,
    "gdprRequests": true,
    "ccpaRequests": true,
    "dataBreachMonitoring": true,
    "tosChangeAlerts": true
  },
  "transparency": {
    "dashboard": true,
    "notifications": true,
    "weeklyReports": true
  },
  "privacy": {
    "localOnly": false,
    "telemetry": false,
    "crashReports": false
  }
}

Operating Modes

Persona Configuration

Behavior Profiles

{
  "personas": {
    "behaviorProfiles": [
      "shopping",      // E-commerce browsing patterns
      "research",      // Academic/professional searches
      "entertainment", // Streaming, gaming, social media
      "finance",       // Banking, investing (careful!)
      "travel",        // Flights, hotels, destinations
      "health",        // Medical searches (use cautiously)
      "custom:./profiles/gamer.json" // Custom profile
    ]
  }
}

Custom Persona Profile

// profiles/gamer.json
{
  "name": "Hardcore Gamer",
  "interests": ["PC gaming", "esports", "game reviews"],
  "sites": [
    "steam.com", "twitch.tv", "ign.com",
    "polygon.com", "kotaku.com"
  ],
  "searchPatterns": [
    "best {game} builds",
    "{game} walkthrough",
    "gaming PC under $2000"
  ],
  "clickProbability": 0.3,
  "dwellTime": {
    "min": 30,
    "max": 300
  }
}

Poisoning Settings

Intensity Levels

• Low: 10-20 fake signals per hour
• Medium: 50-100 fake signals per hour
• High: 200-500 fake signals per hour
• Custom: Define your own rate

Advanced Settings

Network Configuration

{
  "network": {
    "proxy": {
      "enabled": false,
      "type": "socks5",
      "host": "localhost",
      "port": 9050
    },
    "tor": {
      "enabled": false,
      "bridges": []
    },
    "vpn": {
      "killSwitch": true,
      "autoConnect": false
    }
  }
}

Performance Tuning

{
  "performance": {
    "maxCpuUsage": 25,
    "maxMemoryMB": 512,
    "cacheSizeMB": 100,
    "workerThreads": 4,
    "throttleRequests": true
  }
}

Environment Variables

Override configuration with environment variables:

# Enable debug mode
export CLIPPY_DEBUG=true

# Set custom config path
export CLIPPY_CONFIG=/path/to/config.json

# Force local-only mode
export CLIPPY_LOCAL_ONLY=true

# Set API endpoint (self-hosted)
export CLIPPY_API_ENDPOINT=https://your-server.com/api

Profiles

Switch between multiple configurations:

# Create a work profile
clippy profile create work --mode stealth

# Create a home profile
clippy profile create home --mode aggressive

# Switch profiles
clippy profile use work

# List all profiles
clippy profile list

Synthetic Personas

Creating believable digital identities that protect your real one

How Personas Work

Clippy generates and maintains multiple synthetic identities that browse the web alongside you. These personas create a "noise cloud" that makes your real behavior statistically invisible.

Persona Components

1. Demographics

Each persona has consistent characteristics:

• Age range and generation
• Geographic location (VPN-supported)
• Income bracket
• Education level
• Family status

2. Interests

Coherent interest profiles that drive browsing:

• Hobbies and activities
• Shopping preferences
• Content consumption
• Political leanings (randomized)
• Brand affinities

3. Behavior Patterns

Realistic browsing behaviors:

• Active hours (timezone-appropriate)
• Site dwell times
• Click-through rates
• Search patterns
• Purchase consideration funnels

Creating Custom Personas

// Create a custom persona
const customPersona = {
  demographics: {
    age: 45,
    location: "Austin, TX",
    income: "$75k-$100k",
    education: "Bachelor's",
    household: "married_kids"
  },
  interests: [
    "golf", "BBQ", "pickup trucks",
    "country music", "home improvement"
  ],
  schedule: {
    weekday: "6am-8am, 12pm-1pm, 7pm-11pm",
    weekend: "8am-11pm"
  },
  sites: {
    frequent: ["espn.com", "homedepot.com"],
    occasional: ["facebook.com", "youtube.com"],
    rare: ["reddit.com", "twitter.com"]
  }
};

clippy.personas.create(customPersona);

Persona Strategies

Managing Personas

# List active personas
clippy personas list

# View persona details
clippy personas show persona-id

# Pause a persona
clippy personas pause persona-id

# Delete a persona
clippy personas delete persona-id

# Generate new personas
clippy personas generate --count 3 --strategy opposite

API Reference

Programmatic control over Clippy

JavaScript SDK

Installation

npm install @clippy/sdk

Basic Usage

import Clippy from '@clippy/sdk';

// Initialize
const clippy = new Clippy({
  mode: 'balanced',
  localOnly: true
});

// Start protection
await clippy.start();

// Get status
const status = await clippy.getStatus();
console.log(`Protected: ${status.isActive}`);
console.log(`Personas: ${status.personas.length}`);
console.log(`Value recovered: $${status.earnings.total}`);

Core Methods

clippy.start(options)

Start Clippy protection with optional configuration.

await clippy.start({
  mode: 'aggressive',
  personas: 5,
  poisoning: {
    intensity: 'high',
    domains: ['facebook.com', 'google.com']
  }
});

clippy.stop()

Stop all Clippy activities.

await clippy.stop();

clippy.personas

Manage synthetic personas.

// Create persona
const persona = await clippy.personas.create({
  strategy: 'opposite'
});

// List all personas
const all = await clippy.personas.list();

// Get specific persona
const details = await clippy.personas.get(persona.id);

// Update persona
await clippy.personas.update(persona.id, {
  interests: ['gaming', 'crypto']
});

// Delete persona
await clippy.personas.delete(persona.id);

clippy.poisoning

Control data poisoning operations.

// Start poisoning specific domain
await clippy.poisoning.target('amazon.com', {
  clicks: 100,
  searches: ['expensive items', 'luxury goods']
});

// Get poisoning stats
const stats = await clippy.poisoning.getStats();
console.log(`Fake clicks today: ${stats.clicks}`);
console.log(`Cost to advertisers: $${stats.estimatedCost}`);

clippy.extraction

Manage value extraction features.

// Check for settlements
const settlements = await clippy.extraction.checkSettlements();

// Claim settlement
await clippy.extraction.claim(settlements[0].id);

// Monitor ToS changes
clippy.extraction.on('tos-change', (service) => {
  console.log(`${service.name} changed their ToS!`);
});

REST API

Authentication

# Get API key from settings
curl -X POST https://localhost:8080/api/auth \
  -H "Content-Type: application/json" \
  -d '{"password": "your-local-password"}'

# Use API key in requests
curl https://localhost:8080/api/status \
  -H "Authorization: Bearer YOUR_API_KEY"

Endpoints

WebSocket Events

// Connect to WebSocket
const ws = new WebSocket('ws://localhost:8080/ws');

// Listen for events
ws.on('message', (data) => {
  const event = JSON.parse(data);
  
  switch(event.type) {
    case 'tracker-blocked':
      console.log(`Blocked: ${event.tracker}`);
      break;
    case 'value-found':
      console.log(`Found $${event.amount}!`);
      break;
    case 'persona-active':
      console.log(`Persona ${event.id} is browsing`);
      break;
  }
});

Frequently Asked Questions

Common questions about Clippy

General Questions

Is Clippy legal?

Yes. Clippy helps you exercise your existing rights under privacy laws like GDPR and CCPA. You're not hacking or unauthorized accessing anything—you're just managing your own data creatively. However, users should comply with their local laws and service agreements.

How much can I really earn?

Typical users recover $50-200/month through settlements, data dividends, and optimized deals. Results vary based on your online activity and enabled features.

Will websites detect and ban me?

Clippy uses sophisticated techniques to appear human. Our personas follow realistic patterns, and poisoning mimics normal browsing. That said, use conservative settings on important accounts.

Does Clippy slow down my browsing?

No. Poisoning happens in background threads and doesn't affect your real browsing. You might see 5-10% CPU usage increase.

Privacy & Security

Can Clippy see my data?

No. Everything processes locally on your device. We literally cannot see your data because it never reaches our servers.

What about the managed service?

Even our managed service uses zero-knowledge architecture. We provide infrastructure and updates, but your data stays encrypted and local.

Is the browser extension safe?

Yes. It's open source, audited, and follows browser security best practices.

Technical Questions

Why AGPL license?

AGPL ensures Clippy stays open source forever. No company can take our code and create a closed-source version.

Can I contribute?

Absolutely! We welcome contributions. See our Contributing Guide.

Does it work with VPNs?

Yes! Clippy works great with VPNs. In fact, combining them provides even better protection.

What about mobile?

Mobile apps have limited poisoning due to OS restrictions, but still provide transparency and value extraction features.

Troubleshooting

Clippy isn't starting

# Check logs
clippy logs --tail 50

# Run diagnostics
clippy doctor

# Reset configuration
clippy reset --keep-data

High CPU usage

Reduce persona count or poisoning intensity in settings. Check performance configuration.

No earnings showing

Value extraction can take 24-48 hours to find opportunities. Ensure extraction features are enabled in configuration.

Security & Trust Framework

Protection that continues even if we can't

Warrant Canary System

Multiple independent canaries that trigger automatic protection if any fail:

1. Blockchain Dead Man's Switch

// Client-side canary check (runs automatically)
async function checkBlockchainCanary() {
    const contract = new web3.eth.Contract(CANARY_ABI, CANARY_ADDRESS);
    const isCompromised = await contract.methods.isCompromised().call();
    
    if (isCompromised) {
        await emergencyShutdown();
        showUserWarning("Warrant canary expired. Entering protection mode.");
    }
}

2. Distributed Signatures

Daily cryptographic proofs from team members in Iceland, Switzerland, and Estonia:

• Requires 2-of-3 signatures minimum
• Verified by every client before connecting
• Chain of canaries ensures no tampering
• Missing signatures = automatic lockdown

3. Community Monitors

Independent verification nodes run by trusted organizations:

Automatic Response

When any canary fails, clients automatically:

1. Immediate (0-5 min): Disable cloud sync, stop telemetry, switch to P2P
2. Notification (5-10 min): Alert user, provide alternatives, offer data export
3. Protection (10+ min): Wipe credentials, rotate keys, enable maximum privacy

Legal Structure

Multi-Jurisdictional Design

No single point of failure through distributed entities:

Continuous Legal Maintenance

Verification Tools

User Commands

# Check all canaries
clippy canary check --all

# Verify code integrity
clippy verify --deep

# Force local-only mode
clippy lockdown --permanent

# Export all data
clippy export --everything

# Connect via Tor only
clippy connect --tor-only

Independent Verification

# Python script for independent verification
import requests
import web3

def verify_clippy():
    canary_ok = check_blockchain_canary()
    sigs_ok = verify_signatures()
    dns_ok = check_dns_records()
    code_ok = verify_code_integrity()
    
    if not all([canary_ok, sigs_ok, dns_ok, code_ok]):
        print("⚠️ WARNING: Clippy may be compromised!")
        return False
    
    print("✓ All checks passed")
    return True

Emergency Channels

If primary systems are compromised:

Our Commitments

We pledge to:

1. Never compromise user privacy, even under legal pressure
2. Maintain transparent operations through quarterly reports
3. Keep code open source forever via AGPL license
4. Operate canary systems diligently and honestly
5. Support community monitoring and verification
6. Evolve legal structure to maximize protection
7. Enable local-first operation always
8. Document everything publicly
9. Accept no investment from surveillance entities
10. Shut down rather than compromise if necessary

Data Poisoning

Making surveillance expensive and unreliable

How Poisoning Works

Clippy generates fake signals that are indistinguishable from real user behavior, contaminating the data that trackers collect about you. Every poisoned data point costs them money and degrades their models.

Poisoning Strategies

Click Fraud Protection

Generate fake clicks on expensive ad keywords while avoiding detection:

• Target high-CPC keywords ($50+ per click)
• Randomized timing to appear human
• Realistic dwell times and scroll patterns
• Never click on your actual interests

Search Pollution

Contaminate your search history with noise:

// Example search patterns
const poisonSearches = [
    "luxury yacht rental miami",
    "private jet charter pricing", 
    "wholesale medical supplies",
    "industrial machinery leasing",
    "enterprise software solutions"
];

// These expensive searches hide your real interests

Behavioral Noise

Create false patterns that confuse profiling:

• Visit sites at times you're normally asleep
• Browse in languages you don't speak
• Show interest in opposite demographics
• Create fake shopping cart abandonment

Configuration

{
  "poisoning": {
    "enabled": true,
    "intensity": "medium",
    "strategies": ["clicks", "searches", "behavior"],
    "targetDomains": ["google.com", "facebook.com", "amazon.com"],
    "schedule": {
      "active": "always",
      "burstMode": false,
      "nightActivity": true
    }
  }
}

Impact Metrics

Track your poisoning effectiveness:

# View poisoning statistics
clippy stats poison

# Sample output:
Poisoning Statistics (Last 30 days)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Fake clicks generated:      12,847
Estimated cost to advertisers: $8,234
Fake searches:              3,921  
Behavioral signals:         48,293
Trackers confused:          147
Data quality degradation:   -67%

Value Extraction

Automatically recover money you're owed

What We Find

Clippy continuously scans for opportunities to recover value:

How It Works

1. Continuous Monitoring

Clippy watches for:

• New settlement announcements
• Data breach notifications
• Terms of service changes
• Privacy law violations
• Unclaimed property databases

2. Automatic Qualification

We check if you qualify based on:

• Services you use (detected locally)
• Your location and applicable laws
• Time periods of usage
• Breach exposure (via haveibeenpwned)

3. Claim Filing

Clippy can automatically:

• Fill out claim forms
• Generate required documentation
• Submit before deadlines
• Track claim status
• Alert you when payment arrives

Current Opportunities

# Check available claims
clippy claims list

# Sample output:
Available Claims
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. Facebook Privacy Settlement
   Potential: $200-400
   Deadline: Sept 30, 2025
   Status: Qualified ✓

2. Equifax Data Breach
   Potential: $125
   Deadline: Ongoing
   Status: Ready to file

3. California Data Dividend
   Potential: $120/year
   Deadline: Quarterly
   Status: Auto-claiming

Total potential recovery: $445-645

Privacy-Preserving Claims

Configuration

{
  "extraction": {
    "autoFile": true,
    "types": {
      "settlements": true,
      "gdpr": true,
      "ccpa": true,
      "dataBreaches": true,
      "tosRefunds": true,
      "unclaimedProperty": true
    },
    "limits": {
      "minValue": 10,
      "maxClaimsPerMonth": 20
    },
    "privacy": {
      "useUniqueEmails": true,
      "anonymousPayments": true
    }
  }
}

Transparency Dashboard

See exactly what trackers know about you

Real-Time Tracking Visualization

Clippy shows you everything being collected as it happens:

// Example real-time tracking events
[10:23:45] Google Analytics: Page view recorded
[10:23:46] Facebook Pixel: Added to "Interested in Privacy" audience  
[10:23:47] Amazon: Added item view to profile (worth: $0.03)
[10:23:48] DoubleClick: Served targeted ad (CPM: $2.40)
[10:23:49] 37 trackers blocked by Clippy 🛡️

Your Data Value

See the monetary value of your data in real-time:

Profile Analysis

What different companies think they know about you:

Google's Profile

• Age: 25-34 (Actually: 45-54) ❌
• Gender: Male (Actually: Female) ❌
• Income: $50-75k (Actually: $100k+) ❌
• Interests: Gaming, Crypto (Actually: Gardening) ❌

Facebook's Profile

• Political: Liberal (Actually: Moderate) ❌
• Relationship: Single (Actually: Married) ❌
• Education: High School (Actually: PhD) ❌

Weekly Reports

Get detailed weekly summaries:

# Clippy Weekly Report - Aug 12, 2025

## Protection Summary
- Trackers blocked: 12,847
- Data poisoning events: 3,921
- Fake personas active: 3
- Profile accuracy degraded: 67%

## Value Recovered
- Settlements claimed: $125
- Data dividends: $30
- Cashback found: $45
- Total this week: $200

## Privacy Score
Your privacy improved by 34% this week!
Keep using Clippy to maintain protection.

Browser Extension Guide

Protection right in your browser

Installation

1. Install from your browser's store:
   • Chrome Web Store
   • Firefox Add-ons
   • Edge Add-ons
2. Click the Clippy icon in your toolbar
3. Complete the 30-second setup

Features

• Real-time tracker blocking
• Automatic persona switching
• One-click poisoning bursts
• Live tracking visualization
• Quick privacy reports

Toolbar Options

Click the Clippy icon to access:

• Protection Level: Stealth / Balanced / Aggressive
• Active Personas: See which persona is browsing
• Quick Actions: Poison this site, Generate fake clicks
• Stats: Today's blocks, value recovered

Site-Specific Settings

Configure Clippy per website:

// Example site configuration
{
  "amazon.com": {
    "poisoning": "aggressive",
    "personas": ["shopper_1", "shopper_2"],
    "blockTrackers": true
  },
  "mybank.com": {
    "poisoning": "disabled",
    "personas": "none",
    "blockTrackers": false
  }
}

Desktop Application

System-wide protection for your computer

Features

The desktop app provides comprehensive protection:

• System-wide tracker blocking
• Application-level poisoning
• Network traffic analysis
• Automated claim filing
• Advanced dashboard

System Requirements

Advanced Features

Network Monitoring

See all network connections and their tracking potential:

clippy network monitor

# Shows real-time network activity
CONNECTION    DOMAIN              TYPE        STATUS
Chrome        google-analytics.com  Tracker     BLOCKED
Spotify       spotify-analytics.com Tracker     POISONED
Slack         slack.com            Allowed     CLEAN
System        windowsupdate.com    System      ALLOWED

Application Profiles

Configure protection per application:

{
  "applications": {
    "chrome.exe": {
      "protection": "maximum",
      "poisoning": true
    },
    "slack.exe": {
      "protection": "balanced",
      "poisoning": false
    },
  }
}

Mobile Applications

Privacy protection on the go

Available Features

✅ What Works on Mobile

• Tracking transparency reports
• Value extraction and claims
• Privacy alerts and notifications
• VPN integration
• App permission analysis

❌ Mobile Limitations

• Limited browser poisoning
• No system-wide fake clicks
• Reduced persona generation
• No deep packet inspection

iOS Specific

Using Clippy on iPhone/iPad:

• Install from App Store
• Enable Clippy in Safari Extensions
• Configure Screen Time API access
• Optional: Install VPN profile

Android Specific

Using Clippy on Android:

• Install from Play Store or F-Droid
• Grant Accessibility permissions
• Enable Usage Access
• Optional: Configure as Device Admin

Mobile-Optimized Features

// Mobile app focus areas
{
  "tracking_analysis": {
    "app_permissions": true,
    "network_requests": true,
    "sdk_detection": true
  },
  "value_extraction": {
    "settlement_alerts": true,
    "claim_filing": true,
    "receipt_scanning": true
  },
  "privacy_tools": {
    "vpn_integration": true,
    "secure_browser": true,
    "app_firewall": "limited"
  }
}

Router Installation

Network-wide protection for all devices

Compatible Routers

• Any router running OpenWRT 19.07+
• DD-WRT compatible routers
• ASUS routers with Merlin firmware
• Raspberry Pi as router

Installation Guide

OpenWRT Installation

# SSH into your router
ssh root@192.168.1.1

# Add Clippy repository
echo "src/gz clippy https://getclippy.dev/openwrt" >> /etc/opkg/customfeeds.conf

# Update package list
opkg update

# Install Clippy
opkg install clippy-router

# Configure
uci set clippy.enabled=1
uci set clippy.mode=balanced
uci set clippy.personas=3
uci commit clippy

# Start service
/etc/init.d/clippy start
/etc/init.d/clippy enable

Configuration Options

# Set protection level
uci set clippy.protection=aggressive

# Configure personas
uci set clippy.personas.count=5
uci set clippy.personas.rotation=hourly

# Set excluded devices (smart home, etc)
uci add_list clippy.exclude=192.168.1.100
uci add_list clippy.exclude=192.168.1.101

# Apply changes
uci commit clippy
/etc/init.d/clippy restart

Network-Wide Benefits

• Protects all devices automatically
• No per-device configuration needed
• Covers smart TVs, IoT devices
• Centralized poisoning for whole network
• Single point of monitoring

Dashboard Access

Access the router dashboard at:

http://192.168.1.1:8080/clippy

Building Plugins

Extend Clippy with custom functionality

Plugin Architecture

Clippy plugins are JavaScript modules that extend core functionality:

// Basic plugin structure
export default class MyClippyPlugin {
    constructor(clippy) {
        this.clippy = clippy;
        this.name = 'My Plugin';
        this.version = '1.0.0';
    }

    async init() {
        // Initialize your plugin
        console.log(`${this.name} initialized`);
    }

    async onTrackerDetected(tracker) {
        // React to tracker detection
    }

    async onPersonaSwitch(persona) {
        // Handle persona changes
    }

    async generatePoisonData() {
        // Create custom poison data
        return {
            type: 'custom',
            data: {...}
        };
    }
}

Available Hooks

Example: Custom Poisoning Plugin

// Advanced poisoning plugin
class AdvancedPoisonPlugin {
    constructor(clippy) {
        this.clippy = clippy;
        this.patterns = this.loadPatterns();
    }

    async generatePoisonData(context) {
        const persona = this.clippy.getCurrentPersona();
        
        return {
            searches: this.generateSearches(persona),
            clicks: this.generateClicks(context.site),
            behavior: this.generateBehavior(persona)
        };
    }

    generateSearches(persona) {
        // Generate realistic searches for persona
        const interests = persona.interests;
        return interests.map(interest => ({
            query: `best ${interest} 2025`,
            timestamp: Date.now() + Math.random() * 3600000
        }));
    }

    generateClicks(site) {
        // Generate expensive ad clicks
        const expensiveKeywords = [
            'insurance', 'lawyer', 'mortgage',
            'hosting', 'trading', 'degree'
        ];
        
        return expensiveKeywords.map(keyword => ({
            element: `.ad:contains('${keyword}')`,
            cost: Math.random() * 50 + 10
        }));
    }
}

Publishing Plugins

Share your plugin with the community:

1. Create a GitHub repository
2. Add clippy-plugin topic
3. Include manifest.json:

   {
     "name": "my-clippy-plugin",
     "version": "1.0.0",
     "description": "Adds amazing features",
     "author": "Your Name",
     "license": "MIT",
     "clippy": {
       "minVersion": "2.0.0",
       "maxVersion": "*"
     }
   }

4. Submit to the plugin registry

Contributing to Clippy

Help us fight the surveillance economy

Ways to Contribute

Development Setup

# Fork and clone
git clone https://github.com/YOUR_USERNAME/clippy.git
cd clippy

# Install dependencies
npm install

# Set up development environment
npm run setup:dev

# Run tests
npm test

# Start development server
npm run dev

Contribution Process

1. Find an issue or create one for discussion
2. Fork the repository and create a branch
3. Make your changes with clear commits
4. Write/update tests as needed
5. Submit a pull request with description
6. Respond to feedback from reviewers

Code Standards

• Follow existing code style
• Write meaningful commit messages
• Include tests for new features
• Update documentation
• Keep privacy as top priority

Bounty Program

Earn rewards for contributions:

System Architecture

How Clippy works under the hood

Core Components

Privacy Architecture

Everything sensitive stays local:

• Local Processing: All analysis happens on device
• No Cloud Storage: Zero user data in cloud
• Encrypted Cache: Local data encrypted at rest
• Memory Safety: Secure memory handling

Module Breakdown

Persona Engine

class PersonaEngine {
    constructor() {
        this.personas = [];
        this.activePersona = null;
    }
    
    generate(strategy) {
        // Generate believable identity
    }
    
    rotate() {
        // Switch active persona
    }
    
    simulate() {
        // Generate realistic behavior
    }
}

Poison Generator

class PoisonGenerator {
    generateClicks(site, count) {
        // Create fake click events
    }
    
    generateSearches(persona) {
        // Create fake search queries
    }
    
    injectNoise(dataStream) {
        // Add noise to real data
    }
}

Value Extractor

class ValueExtractor {
    scanSettlements() {
        // Find available claims
    }
    
    fileClaim(settlement) {
        // Automatically file claims
    }
    
    monitorToS() {
        // Watch for changes
    }
}

Performance

Privacy Policy

We practice what we preach

Our Commitment

What We Don't Collect

• ❌ Browsing history
• ❌ Personal information
• ❌ Location data
• ❌ Usage statistics
• ❌ Device identifiers
• ❌ IP addresses
• ❌ Any user data whatsoever

How Clippy Works

All processing happens locally on your device:

1. Your data never leaves your device
2. We cannot access your information
3. There's nothing to leak, sell, or compromise

Optional Services

If you use our managed service:

• We provide infrastructure only
• Zero-knowledge architecture
• End-to-end encryption
• No logs or analytics

Third Parties

We never share data with third parties because we don't have any data to share.

Updates

Software updates are:

• Cryptographically signed
• Verified before installation
• Never forced
• Transparent (see changelog)

Your Rights

You have the right to:

• Use Clippy without registration
• Audit our source code
• Fork and modify the project
• Run everything locally
• Delete everything instantly

Contact

Privacy questions: privacy@getclippy.dev

PGP Key: [Published on keyserver]

Legal Guide

Understanding your rights and Clippy's legal status

Is Clippy Legal?

Legal Basis by Activity

✅ Clearly Legal

• Blocking trackers: Your right to privacy
• Filing claims: Exercising legal remedies
• Data requests: GDPR/CCPA rights
• Using personas: Pseudonymity rights
• Local processing: Your device, your rules

⚖️ Legal Gray Areas

• Click generation: May violate some ToS
• Data poisoning: Depends on jurisdiction
• Automated browsing: Site-specific rules

Terms of Service

Many websites' ToS prohibit automated activity. However:

• ToS violations are typically civil, not criminal
• Worst case is usually account termination
• Privacy rights may supersede ToS in some jurisdictions
• Selective enforcement is common

By Jurisdiction

Disclaimer

Defending Your Rights

If challenged about using Clippy:

1. Cite relevant privacy laws (GDPR Article 21, CCPA Section 1798.120)
2. Emphasize personal use on your own devices
3. Note you're not accessing others' data
4. Reference right to pseudonymity
5. Point to data minimization principles