Glass by Pickle: The Invisible AI That Remembers Everything You Forget

What if you never had to take meeting notes again? What if your computer could see your screen, hear your conversations, and answer questions about everything you've done—without ever appearing in a screenshot, recording, or even your dock?

Sound like science fiction? It's not. It's Glass by Pickle, and it's already here.

Developers, knowledge workers, and meeting warriors share the same silent scream: too much context, too little capture. We juggle five tabs, three conversations, and a dozen decisions per hour. By Friday, Monday's critical insight is gone forever. Traditional note-taking apps demand your attention. Recording tools clutter your screen. AI assistants need you to prompt them.

Glass changes everything. This digital mind extension lives invisibly on your desktop, observes your workflow in real-time, and transforms every moment into structured, queryable knowledge. No interruptions. No visible interface stealing focus. Just pure, effortless memory augmentation.

Ready to stop forgetting and start knowing? Let's dive into the tool that's making developers abandon their old workflows—and why you should too.

What is Glass by Pickle?

Glass by Pickle is an open-source, fast, and lightweight desktop application that functions as your digital mind extension. Born from a fork of CheatingDaddy and significantly enhanced by the Pickle team, Glass represents a radical reimagining of how AI assistants should integrate with your workflow.

The project is maintained by Pickle, a company with an ambitious mission: building a living digital clone for everyone. Glass serves as Step 1 in this vision—a trusted pipeline that transforms your daily digital exhaust into a scalable, intelligent clone that actually understands you.

Here's what makes Glass genuinely different from every "AI assistant" you've tried:

• True invisibility: Glass never appears in screen recordings, screenshots, or your dock. No awkward explanations in demos. No privacy leaks in shared screens.
• Proactive intelligence: It doesn't wait for prompts—it surfaces action items, summaries, and answers the instant you need them.
• Full multimodal awareness: Screen vision + real-time audio processing = complete context understanding.
• Open-source transparency: Audit the code. Run it locally. Trust but verify.

The project has exploded in popularity since launch, with rapid feature additions including Gemini support, Intel Mac compatibility, Windows beta, Claude integration, and local LLM support—all within days of each other. This isn't vaporware. This is a team shipping at insane velocity.

Want to see what the hype is about? The repository lives at github.com/pickle-com/glass—and yes, you can build it yourself in minutes.

Key Features That Will Blow Your Mind

Glass isn't a note-taking app with AI sprinkled on top. It's a fundamentally different computing paradigm. Here's the technical breakdown of what makes it extraordinary:

🔍 Persistent Visual & Audio Memory

Glass continuously captures your screen activity and audio environment, then structures this data for semantic retrieval. Unlike screenshot tools that save files you'll never find, Glass indexes meaning—turning visual and auditory information into queryable knowledge graphs.

🎯 Proactive Meeting Intelligence

During meetings, Glass operates as an invisible participant that:

• Generates real-time meeting notes without any user intervention
• Creates live summaries as conversations progress
• Maintains session records for later reference
• Surfaces action items the moment decisions are made

💬 Contextual Query Engine

Press Ctrl/Cmd + Enter and ask anything about your recent activity. Glass answers based on all your previous screen actions and audio input. It's like having photographic memory for your entire digital life.

🔐 Privacy-First Architecture

• No always-on capture that phones home
• No hidden sharing of your data
• Use your own API keys or Pickle's free tier
• Local LLM support via Ollama & Whisper for complete air-gapped operation
• Firebase data storage option for encrypted cloud backup you control

🎨 Liquid Glass Design (Coming to macOS 26)

The team is implementing Apple's next-generation Liquid Glass UI aesthetic—translucent, depth-aware interfaces that feel native to the platform's future.

🛠 Cross-Platform with Native Performance

• macOS: Primary platform, with Apple Silicon and Intel support
• Windows: Beta support with Rust-based audio processing
• Advanced Echo Cancellation (AEC): Separates microphone from system audio using Rust for crystal-clear transcription

Real-World Use Cases Where Glass Dominates

1. The Meeting Marathon Survivor

You're in back-to-back Zoom calls from 9 AM to 5 PM. By call #4, you can't remember what was decided in call #2. Glass silently captures everything, generates summaries, and extracts action items. When your manager asks "What did we agree on with the design team?"—you have the answer in seconds, not hours of scrolling through recordings.

2. The Deep Work Developer

You're debugging a complex issue across 12 Stack Overflow tabs, three documentation sites, and your IDE. Three hours later, you need that one configuration snippet you saw. Instead of reconstructing your browsing history, you ask Glass: "What was that Redis timeout setting I looked at?" It knows. Because it saw you look at it.

3. The Compliance-Conscious Consultant

You work with sensitive client data. Recording tools are banned. Screenshot tools leave evidence. Glass's invisible operation means it never appears in screen shares, recordings, or screenshots—yet you still get complete session records for your private reference. Ethical capture without exposure.

4. The Async-First Remote Worker

Your team spans 12 time zones. You can't attend every standup, but you need context. Glass session records let you "catch up" on meetings you missed by querying what happened, not watching hour-long recordings. "What blockers did Sarah mention?" Instant answer.

5. The Local-First Privacy Advocate

You don't trust cloud AI with your data. Glass supports local LLMs via Ollama and local speech-to-text via Whisper. Your data never leaves your machine. Your digital memory stays yours.

Step-by-Step Installation & Setup Guide

⚡ Instant Launch (Recommended for Most Users)

Skip the setup entirely. Pickle provides a ready-to-run macOS app:

Download Glass_latest.dmg

Drag to Applications, launch, and you're invisible.

🛠 Quick Start (Local Build)

For developers who want to customize, contribute, or audit:

Prerequisites

First, install the foundation tools:

Verify your Node version before proceeding:

# Check your Node.js version—must be 20.x.x
node --version

# If wrong version, install via nvm (recommended):
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
nvm install 20
nvm use 20

Installation

With prerequisites satisfied, installation is one command:

npm run setup

This executes the full setup script, which handles:

• Native dependency compilation
• Python environment configuration
• Electron application bundling
• Audio processing module initialization

Configuration

After installation, configure your AI backend:

Option A: Cloud APIs (Easiest)

• OpenAI: Get your API key at platform.openai.com/api-keys
• Gemini: Get your API key at aistudio.google.com/apikey
• Claude: Available as of July 7 update

Option B: Local Models (Maximum Privacy)

• Install Ollama for local LLM inference
• Install Whisper for local speech-to-text
• Select models in Glass settings—zero data leaves your machine

Option C: Pickle's Free Tier Sign up through the app for managed API access at no cost.

REAL Code Examples from the Repository

Let's examine actual implementation patterns from Glass's codebase and documentation.

Example 1: Keyboard Shortcut System

Glass uses global shortcuts for instant access without interface clutter:

// Global keyboard shortcuts for Glass operation
// These work system-wide, even when Glass is invisible

// Toggle main window visibility
// Mac: Cmd + \  |  Windows/Linux: Ctrl + \
'Ctrl/Cmd + \\' : 'show_and_hide_main_window',

// Query AI with full context of screen + audio history
// Mac: Cmd + Enter  |  Windows/Linux: Ctrl + Enter  
'Ctrl/Cmd + Enter' : 'ask_ai_using_all_previous_screen_and_audio',

// Reposition the invisible window without mouse
// Mac: Cmd + Arrow Keys  |  Windows/Linux: Ctrl + Arrow Keys
'Ctrl/Cmd + Arrows' : 'move_main_window_position'

Why this matters: Traditional assistants force you to click, type, or summon them. Glass's global shortcuts mean you can query your digital memory without breaking flow. Coding intensely? Cmd + Enter, ask your question, get back to work. The window positioning via arrow keys is crucial for multi-monitor setups—keep Glass where you need it without ever revealing it in recordings.

Example 2: Setup Automation

The entire build process is abstracted to a single command:

# One-command setup handles all complexity
# - Installs Python dependencies for audio processing
# - Builds native Node modules (requires Node 20.x.x)
# - Configures Electron for desktop embedding
# - Sets up Whisper for local speech recognition
# - Initializes Ollama integration paths for local LLMs

npm run setup

The technical story: This isn't npm install. Glass requires native compilation for audio processing (Rust-based AEC), Python bridges for ML pipelines, and Electron's complex native module rebuild process. The setup script orchestrates all of this, detecting your platform and adjusting accordingly. The Node 20.x.x requirement exists because node-gyp—used for compiling native addons—has specific ABI compatibility requirements that break on newer or older versions.

Example 3: Version Verification (Prerequisite Check)

# Verify Node.js version before attempting setup
# Incorrect versions cause cryptic native module build failures

node --version
# Expected output: v20.x.x
# If you see v18.x.x or v22.x.x, STOP and use nvm

# nvm installation and version switching
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
nvm install 20      # Download Node 20 LTS
nvm use 20          # Activate for current session

Critical insight: This pattern prevents the #1 support issue in native Electron apps—version mismatch build failures. By enforcing Node 20, Glass ensures electron-rebuild produces compatible binaries for the V8 engine version bundled in their Electron release. The nvm approach lets developers switch without breaking other projects.

Example 4: API Key Configuration Pattern

// Glass supports multiple AI providers with unified interface
// Users can switch or combine based on task requirements

const AI_PROVIDERS = {
  openai: {
    keyUrl: 'https://platform.openai.com/api-keys',
    models: ['gpt-4o', 'gpt-4-turbo'],
    useCase: 'Best general intelligence'
  },
  gemini: {
    keyUrl: 'https://aistudio.google.com/apikey', 
    models: ['gemini-1.5-pro', 'gemini-1.5-flash'],
    useCase: 'Long context, multimodal'
  },
  claude: {
    // Added July 7
    models: ['claude-3-5-sonnet', 'claude-3-opus'],
    useCase: 'Complex reasoning, coding'
  },
  local: {
    // Ollama + Whisper for air-gapped operation
    ollamaModels: ['llama3', 'mistral', 'codellama'],
    whisperModel: 'base', // tiny/base/small/medium/large
    useCase: 'Maximum privacy, zero latency'
  }
};

Architecture insight: This multi-provider abstraction lets Glass optimize per-task. Meeting summaries might use Gemini's 2M token context. Coding questions route to Claude. Sensitive data stays local. The user controls everything—no vendor lock-in, no forced cloud dependency.

Advanced Usage & Best Practices

🎯 Optimize for Your Workflow

• Position strategically: Use Ctrl/Cmd + Arrows to place Glass on your least-used monitor edge—accessible but invisible
• Batch queries: During deep work, jot questions mentally, then fire them all at once during breaks
• Hybrid AI strategy: Use local models for sensitive work, cloud APIs for complex reasoning

🔒 Privacy Hardening

• Run Ollama + Whisper locally for complete data sovereignty
• Review the Firebase Data Storage settings—disable cloud sync if desired
• Audit the open-source code at github.com/pickle-com/glass for transparency

⚡ Performance Tuning

• The Rust-based AEC (Acoustic Echo Cancellation) dramatically reduces CPU load vs. JavaScript implementations
• On older Intel Macs, use smaller Whisper models (base vs. large) for real-time performance
• Close unused browser tabs—Glass indexes what you see, so visual clutter becomes memory clutter

🚀 Contribution Opportunities

The team actively marks help wanted issues for newcomers. Current major work includes:

• Liquid Glass UI for macOS 26
• Full code modularization (recently completed July 6)
• Windows stability improvements

Comparison with Alternatives

Why Glass wins: It's the only tool combining true invisibility, open-source auditability, local execution, and full multimodal context. Others force compromises—visibility, vendor lock-in, cloud dependency, or audio-only capture.

FAQ

Is Glass actually invisible in screen recordings?

Yes. Glass uses OS-level window flags that exclude it from screen capture APIs, screenshots, and recording tools. It also hides from the dock. This is core to its design, not an afterthought.

Does Glass send my data to Pickle's servers?

Only if you choose Pickle's free API tier. Use your own OpenAI/Gemini/Claude keys, or run completely local with Ollama + Whisper. The code is open-source—verify the network calls yourself.

What's the difference between Glass and Rewind.ai?

Rewind captures screen history but requires visible operation and lacks real-time meeting intelligence. Glass is invisible, proactive, and open-source. Rewind is macOS-only and closed-source; Glass is expanding to Windows with full transparency.

How much disk space does continuous capture use?

Glass structures data intelligently—textual extraction and semantic indexing, not raw video storage. Actual usage depends on activity level but is optimized for long-term retention without bloat.

Can I use Glass without an internet connection?

Absolutely. Local LLM (Ollama) + local STT (Whisper) = fully air-gapped operation. You'll sacrifice some model capability but gain complete privacy and zero latency.

Is Windows support production-ready?

Windows is currently in beta (added July 8). The core functionality works, with Rust-improved audio processing. macOS remains the primary platform. Check GitHub issues for current Windows status.

How do I contribute to Glass development?

The team welcomes contributions! Start with help wanted issues for scoped features. A full code refactor completed July 6 makes the codebase more approachable. See CONTRIBUTING.md for guidelines.

Conclusion: Your Memory, Augmented

We've accepted digital amnesia as inevitable—too many tabs, too many meetings, too much context lost to time. Glass by Pickle rejects that resignation entirely.

This isn't another productivity app demanding your attention. It's a fundamental upgrade to human-computer interaction—invisible, proactive, and finally useful in the way we actually work. The open-source foundation means trust through verification. The multi-provider AI architecture means freedom from lock-in. The local execution option means privacy without compromise.

The Pickle team ships at velocity that puts enterprise software to shame: Gemini, Claude, Windows, local LLMs, Rust audio processing—all in days, not quarters. Their mission extends far beyond notes: a living digital clone for everyone. Glass is Step 1, and it's already transformative.

Stop forgetting. Start knowing.

👉 Download the ready-to-run app or ⭐ star the repository at github.com/pickle-com/glass and build your digital mind extension today.

Join the Discord community to shape what comes next. Your future self—the one who actually remembers Monday's decisions—will thank you.