AppForge

Native macOS Web Wrapper Builder

AppForge is a powerful macOS application that transforms any website into a lightweight, native macOS app using Swift and WKWebView. Create standalone desktop applications from your favorite web services with full macOS integration, native performance on Apple Silicon, and a tiny footprint.

Why AppForge?

Many popular web services don't offer native Mac apps, forcing you to keep dozens of browser tabs open. AppForge solves this by creating true native macOS applications that:

• ✅ Run independently from your browser
• ✅ Appear in your Dock with custom icons
• ✅ Support native macOS features (notifications, keyboard shortcuts, etc.)
• ✅ Consume minimal resources (no Electron bloat)
• ✅ Launch instantly with Apple Silicon optimization
• ✅ Work fully sandboxed for security
• ✅ Are code-signed and ready to distribute

Popular Web Apps You Can Create

Communication & Productivity

• Google Messages - Native texting from your Mac (messages.google.com)
• WhatsApp Web - Desktop messaging without the browser (web.whatsapp.com)
• Telegram Web - Lightweight Telegram client (web.telegram.org)
• Discord Web - Gaming communication platform (discord.com/app)
• Slack Web - Team collaboration (if you don't want the Electron app)
• Microsoft Teams Web - Enterprise communication
• Google Chat - Workspace messaging

AI & Assistant Tools

• Google Gemini - AI assistant without browser tabs (gemini.google.com)
• Claude Web - Anthropic's AI assistant (claude.ai)
• ChatGPT Web - OpenAI's chatbot (chat.openai.com)
• Perplexity - AI-powered search (perplexity.ai)
• You.com - AI search engine
• Poe - Multi-model AI chat platform

Social Media

• Twitter/X Web - Social networking (x.com)
• LinkedIn Web - Professional networking
• Instagram Web - Photo sharing (instagram.com)
• Reddit Web - Community discussions
• Mastodon Web - Decentralized social media

Development & Design

• GitHub Web - Code hosting and collaboration
• GitLab Web - DevOps platform
• Figma - Design and prototyping (figma.com)
• Excalidraw - Whiteboarding tool (excalidraw.com)
• CodeSandbox - Online code editor
• StackBlitz - Instant dev environments
• Replit - Collaborative coding

Productivity & Note-Taking

• Notion Web - All-in-one workspace (notion.so)
• Google Docs - Document editing
• Google Sheets - Spreadsheets
• Airtable - Database/spreadsheet hybrid
• Coda - Collaborative documents
• ClickUp - Project management
• Linear - Issue tracking

Entertainment & Media

• YouTube Music Web - Music streaming
• Spotify Web - Music player (open.spotify.com)
• SoundCloud - Audio platform
• Netflix - Video streaming (where supported)
• Plex Web - Media server access

Finance & Crypto

• Coinbase - Cryptocurrency exchange
• Binance - Crypto trading
• TradingView - Financial charts
• Robinhood Web - Stock trading
• Mint - Budget tracking

Specialized Tools

• Excalidraw - Drawing and diagramming
• Photopea - Online Photoshop alternative
• Canva - Graphic design
• Miro - Collaborative whiteboard
• Loom - Video messaging

Features

Core Capabilities

• Simple 3-Step Wizard: URL → Configure → Generate
• Icon Management:
  • Upload custom icons
  • Auto-generate from app name initials
  • Integration with macosicons.com API (coming soon)
• Advanced Configuration:
  • Custom user agents
  • JavaScript enable/disable
  • Proxy settings (HTTP/HTTPS/SOCKS5)
  • Custom CSS injection
  • Navigation toolbar toggle
  • Window size presets
• Code Signing:
  • Ad-hoc signing (default)
  • Certificate-based signing for distribution
  • Hardened runtime support
• Native Performance: Built with Swift and SwiftUI, optimized for Apple Silicon

Technical Highlights

• Uses WKWebView for maximum compatibility and performance
• Fully sandboxed for security
• Supports macOS notifications
• Respects system appearance (light/dark mode)
• Native menu bar integration
• Keyboard shortcut support
• Memory efficient (typically <50MB RAM)

Installation

Quick Install (Recommended)

1. Download AppForge.dmg from your Downloads folder
2. Open the DMG file
3. Drag AppForge to your Applications folder
4. Launch AppForge from Applications

Build from Source

Requirements:

• macOS 13.0+ (Ventura or later)
• Xcode 15.0+
• Command Line Tools installed

Steps:

# Clone the repository
git clone https://github.com/yourusername/appforge.git
cd appforge

# Build the wrapper template (required first)
./build_wrapper_template.sh

# Build AppForge
./build_appforge_release.sh

# The app will be in build/AppForge.app

Usage

Creating Your First Web App

1. Launch AppForge from your Applications folder

2. Enter the URL of the website you want to wrap

   • Example: https://messages.google.com
   • Example: https://gemini.google.com

3. Configure your app:

   • App Name: Display name (e.g., "Google Messages")
   • Bundle Identifier: Unique ID (e.g., com.myapps.googlemessages)
   • Icon: Upload a custom .png or .icns, or let AppForge generate one
   • User Agent: Leave default or customize
   • Window Size: Choose a preset or use default
   • Features: Toggle navigation toolbar, JavaScript, notifications

4. Generate and wait for the app to be created

5. Install the generated app by clicking "Show in Finder" and dragging to Applications

Example: Google Messages App

URL: https://messages.google.com
App Name: Google Messages
Bundle ID: com.google.messages
Icon: Upload Google Messages icon or use auto-generated "GM"
User Agent: Default (or customize to match mobile)
Window Size: Medium (1200x800)
Navigation Toolbar: Off
Notifications: On

Example: Gemini AI App

URL: https://gemini.google.com
App Name: Gemini
Bundle ID: com.google.gemini
Icon: Upload Gemini icon or use auto-generated "GE"
User Agent: Default
Window Size: Large (1400x900)
Navigation Toolbar: Off
Notifications: On

Project Structure

AppForge/
├── AppForge/                       # Main application
│   ├── App/
│   │   └── AppForgeApp.swift      # App entry point
│   ├── Views/                      # SwiftUI views
│   │   ├── URLInputView.swift     # Step 1: URL entry
│   │   ├── ConfigurationView.swift # Step 2: Settings
│   │   └── GenerationView.swift   # Step 3: Progress
│   ├── ViewModels/                # MVVM view models
│   ├── Models/                    # Data models
│   ├── Services/                  # Core services
│   │   ├── BundleGenerator.swift  # App bundle creation
│   │   ├── CodeSigner.swift       # Code signing
│   │   ├── IconProcessor.swift    # Icon conversion
│   │   └── DMGCreator.swift       # DMG packaging
│   └── Resources/                 # Assets and icons
│
├── WrapperTemplate/               # Template for generated apps
│   ├── WrapperApp.swift          # Generated app entry
│   ├── WebViewManager.swift      # WKWebView management
│   └── Resources/
│       └── AppConfig.json        # Per-app configuration
│
├── Config/                        # Build configuration
│   ├── Shared.xcconfig           # Shared build settings
│   └── MyProject.entitlements    # Entitlements
│
└── build/                         # Build output
    ├── AppForge.app              # Main application
    └── WrapperTemplate.app       # Wrapper template

Development

Architecture

AppForge uses the MVVM (Model-View-ViewModel) pattern with SwiftUI:

• Models: WrapperConfig, ProxyConfig, SigningIdentity
• ViewModels: WrapperConfigViewModel, GenerationViewModel
• Views: SwiftUI views with declarative UI
• Services: Single-responsibility classes for core functionality

Key Services

• BundleGenerator: Creates .app bundle structure, copies template, generates Info.plist
• IconProcessor: Converts images to .icns, generates generic icons
• CodeSigner: Handles ad-hoc and certificate-based code signing
• MacOSIconsAPI: Fetches icons from macosicons.com (planned)
• DMGCreator: Creates installer DMG files (planned)

Running Tests

# Unit tests
xcodebuild test -scheme AppForge -destination 'platform=macOS'

# UI tests
xcodebuild test -scheme AppForgeUITests -destination 'platform=macOS'

Contributing

Contributions are welcome! Please:

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Follow Swift coding standards
4. Write tests for new features
5. Commit your changes (git commit -m 'Add amazing feature')
6. Push to the branch (git push origin feature/amazing-feature)
7. Open a Pull Request

Technical Details

Code Signing

Generated apps are signed with either:

• Ad-hoc signature (default, no certificate required)
• Developer certificate (for distribution outside App Store)
• Distribution certificate (for App Store submission - future)

All apps run with hardened runtime and proper entitlements.

Security

• AppForge runs fully sandboxed
• Generated wrappers run fully sandboxed
• Network access limited to specified domains (future enhancement)
• No data collection or telemetry

Performance

• AppForge size: ~5MB
• Generated wrapper size: ~500KB - 1MB
• Runtime memory: <50MB per wrapper
• Launch time: <1 second on Apple Silicon

Troubleshooting

"AppForge can't be opened because it is from an unidentified developer"

Right-click the app and select "Open", then click "Open" in the dialog. This only needs to be done once.

Generated app won't launch

Ensure the wrapper was code-signed properly. Check Console.app for error messages.

Web content not loading

Check that the URL is correct and accessible. Some sites may block embedding in WKWebView.

Icons not displaying

Ensure your icon is at least 512x512 pixels. AppForge will auto-resize and generate all required icon sizes.

Roadmap

• Basic web wrapper generation
• Icon processing and conversion
• Ad-hoc code signing
• Certificate-based signing
• macosicons.com API integration
• DMG installer creation
• App Store packaging
• Menu bar extras (pinned websites)
• Multi-site tabs support
• URL pattern whitelisting
• Custom keyboard shortcuts
• Browser extension support

License

This project is licensed under the MIT License - see the LICENSE file for details.

Credits

Built with:

• Swift 5.9+
• SwiftUI
• WKWebView
• AppKit

Inspired by:

• Nativefier (Electron-based)
• Coherence X (Commercial)