Gojo logo

How to vibe codeGojo

Your Mac, one hover away

gojo.rohoswagger.com

Mac Productivity Utility

macOS app
62/ 100
Solid side project

The verdict: can you vibe code Gojo?

You can build a personal clone of Gojo, but expect weeks of rigorous Swift debugging with macOS window levels and Accessibility APIs.

Replicating a native macOS menu bar and notch-overlay utility is a rewarding challenge for a Swift developer using AI coding agents. The primary stumbling blocks will not be business logic or database schemas, but low-level AppKit edge cases: making an NSPanel float above full-screen spaces, getting Accessibility window snapping hooks to behave across macOS updates without crashing, and bundling Whisper.cpp locally for offline dictation without bloating the binary or draining the battery.

Estimated effort: 2-4 weeks part-time

What you can't replicate

  • Instant distribution and zero-friction notarization pipeline across existing Mac utility users

Founded

Raised

Team

1-2

Cheapest paid tier

$2.99 / month

What Gojo does

A native macOS productivity utility that turns the area surrounding a MacBook’s physical camera notch into an interactive control center for media, clipboard, window snapping, files, and local dictation.

Core features

  • Notch-anchored hover overlay window with responsive AppKit geometry
  • Media player controls integrating with active macOS media sources
  • Clipboard history with sensitive data filtering and quick search
  • Window switcher and grid snapping via macOS Accessibility APIs
  • Temporary file staging shelf
  • Night Shift / display comfort and brightness adjustments
  • On-device private speech-to-text dictation
  • Mini utilities (Calendar, Battery status, camera mirror, shortcuts)

The business

Pricing

  • Personal (1 Mac)$2.99 / month
  • Personal Lifetime$9.99 one-time
  • Multi-Mac (Up to 3 Macs)$4.99 / month
  • Multi-Mac Lifetime$19.99 one-time

Funding

Unknown / bootstrapped

Pay vs build, cumulative

Break-even at month 7 — after that, every month is money kept.

The hard parts of vibe coding Gojo

  • Constructing a native AppKit overlay window that precisely masks and anchors to physical camera notches across various MacBook chassis dimensions (Air/Pro, 14"/16") without visual clipping
  • Managing robust low-level permissions for Accessibility APIs (`AXUIElement`) and global event listeners for window manipulation and clipboard tracking
  • Maintaining near-zero CPU and idle battery drain while running continuously as a background menu bar and floating window daemon
  • Embedding and executing a reliable, low-latency offline speech-to-text model locally inside the native binary

How to vibecode Gojo

Prerequisites

  • macOS ComputerOwned hardware

    Required to compile, test, and run native AppKit and SwiftUI code targeting MacBook notches

  • XcodeFree

    Official IDE for Swift and macOS desktop app development

  • GitHubFree

    Source control repository for managing the Swift project codebase

AI coding tools

Recommended stack

FrontendSwift, SwiftUI, AppKit
BackendSwift (Local Daemon)
DatabaseLocal SQLite (via GRDB.swift for clipboard history and preferences)
AuthNone (Personal single-user local app)
PaymentsNone (Personal-use clone)
OtherWhisper.cpp (packaged locally for offline dictation), Combine / CoreAudio (for media player integration)

Hosting & infrastructure

Local ExecutionRuns locally as a native macOS application daemon on your own machine$0/mo

Build guide

  1. 01Project Initialization & Menu Bar Daemon

    Initialize a new macOS App project in Xcode configured as a menu bar utility app (LSUIElement set to true in Info.plist to hide the dock icon).

    Create a new Swift Package or Xcode project structure for a native macOS utility app named GojoClone. Configure the target to run strictly as a background menu bar item by ensuring `LSUIElement` is true in the Info.plist. Implement a robust `NSStatusItem` status bar controller that responds to left and right clicks, presenting a base menu structure. Set up clean MVVM architecture using Swift concurrency (async/await) and structure the project directories for Views, ViewModels, Models, and Services.
  2. 02Notch Geometry & Floating Overlay Panel

    Build a custom NSPanel window subclass that detects the active MacBook display metrics, identifies physical camera notch dimensions, and anchors an interactive hover overlay seamlessly.

    Implement a custom `NSPanel` subclass in Swift called `NotchOverlayPanel`. This panel must be borderless, non-activating (`isFloatingPanel = true`, `.canBecomeKey = false`), and transparent by default. Write a service utility that queries `NSScreen.screens` and detects built-in camera housing safe areas / notch geometry across different MacBook models (Air/Pro, 14" and 16"). Implement mouse hover tracking (`NSScreen` mouse location listeners or global event monitors) that smoothly animates the panel expanding downward from the camera notch when the cursor dwells near the top edge, and retracts when the cursor leaves.
  3. 03Media Player & Active Source Integration

    Integrate with macOS media control APIs via MediaPlayer framework to surface track details, album art, scrubbing, and playback commands.

    Create a `MediaService` class using the Swift `MediaPlayer` framework (`MPNowPlayingInfoCenter` and `MPRemoteCommandCenter`) to inspect currently active media sources on macOS (Apple Music, Spotify, web browsers). Expose published properties for track title, artist, album artwork image, playback state (playing/paused), and current playback position. Implement playback control methods for play, pause, skip forward, skip backward, and scrubbing that dispatch remote commands to the active media player.
  4. 04Clipboard History & Sensitive Data Filtering

    Monitor system pasteboard changes, store snippets in a local GRDB SQLite database, and provide quick search while ignoring password manager formats.

    Build a `ClipboardService` that polls `NSPasteboard.general` or listens to change counts using a background timer. Automatically capture copied text strings, checking pasteboard data types to ignore sensitive entries from password managers (such as 1Password or Bitwarden type identifiers like `org.nspasteboard.ConcealedType` or `org.nspasteboard.AutoGeneratedType`). Store captured snippets in a local SQLite database using GRDB.swift with automatic pruning of entries older than 7 days. Expose a searchable list view model for the notch overlay.
  5. 05Window Switcher, Grid Snapping & File Shelf

    Implement Accessibility API hooks to list open windows, bring windows into focus, execute window snapping grids, and provide a temporary file staging tray.

    Implement a `WindowManagementService` utilizing macOS Accessibility APIs (`AXUIElementCreateSystemWide`, `kAXWindowAttribute`) to enumerate open windows across running applications, capturing window titles, owner application icons, and active bounds. Provide functions to focus a selected window and snap windows to halves, quadrants, or custom screen grids. Additionally, build a drag-and-drop `FileShelf` view inside the notch overlay that accepts file URL drops, storing temporary file references in memory so users can stage files while moving between folders and desktops.
  6. 06Display Comfort & Local Speech-to-Text Dictation

    Integrate display warmth/Night Shift controls and package Whisper.cpp locally for offline private speech-to-text dictation.

    Implement a `DisplayService` to control screen brightness and color temperature adjustments via CoreDisplay private APIs or standard screen utility bindings. Next, integrate an offline speech-to-text capability by embedding a lightweight Whisper.cpp wrapper or utilizing Apple's native `SFSpeechRecognizer` framework configured for on-device recognition (`requiresOnDeviceRecognition = true`). Build a dictation toggle button in the notch overlay that records microphone input, transcribes speech locally without hitting external servers, and pastes the resulting text directly into the frontmost application using CGEvent key simulation.
  7. 07Polish, Performance Profiling & Launch Optimization

    Refine animations, optimize CPU/battery footprint during idle states, and package the application for local release.

    Perform a comprehensive performance review of the GojoClone codebase. Profile CPU and memory usage in Xcode Instruments to ensure idle CPU usage remains under 0.5% and memory footprint stays compact. Smooth out all SwiftUI and AppKit transition animations for the notch hover reveal/hide sequence. Add configuration settings for user customization (toggling individual modules like calendar, battery status, and shortcuts, rearranging media controls, and tuning accent colors).

Cost vs paying for Gojo

What will you build it with?

Est. 12M in / 3.5M out tokens· Includes access to introductory usage of the default model with dynamic rate limits.$0

Starting total with Claude Code$0 one-time

Starting costs (one-time)

  • AI Coding Assistant Subscription$20.00

Total~$20 one-time

Ongoing costs (monthly)

  • App Hosting & Database$0.00 (Local execution)

Total$0/mo

Paying for Gojo

$2.99 / mo

Your time to build

35-50 hours

AI tool credits

$20 (1 month of Claude Pro / Cursor)

Break-even

7 months vs Personal Monthly Plan

Vibe code Gojo: FAQ

Can you vibe code Gojo yourself?
Solid side project — 62/100 vibecodeable. You can build a personal clone of Gojo, but expect weeks of rigorous Swift debugging with macOS window levels and Accessibility APIs.
How long does it take to vibe code Gojo?
2-4 weeks part-time — roughly 35-50 hours of hands-on time with an AI coding agent.
How do you build your own Gojo?
Scoped to personal use: Swift, SwiftUI, AppKit on the front, Swift (Local Daemon) behind it, Local SQLite (via GRDB.swift for clipboard history and preferences) for data. Follow the 7-step build guide on this page — each step has a paste-ready prompt for an AI coding agent.
How do you code your own Gojo without being an expert?
Use an AI coding tool (Claude Code or Cursor) and work in small steps: scaffold, data model, core screens, then deploy. Realistic effort: 2-4 weeks part-time. The prompts on this page are written so the AI does the heavy lifting.
How much does it cost to vibe code Gojo instead of paying?
About ~$20 one-time to start and $0/mo to run, versus $2.99 / mo for Gojo. Break-even: 7 months vs Personal Monthly Plan.
What stack should you use to vibe code Gojo?
Swift, SwiftUI, AppKit; Swift (Local Daemon); Local SQLite (via GRDB.swift for clipboard history and preferences); plus Whisper.cpp (packaged locally for offline dictation), Combine / CoreAudio (for media player integration).

Sources

Alternatives & community builds

All alternatives →
How to Vibe Code Your Own Gojo (and Stop Paying for It)