Unwatched: The Revolutionary RSS YouTube Player for Apple Devices

Tired of YouTube's algorithm deciding what you watch next? You're not alone. Millions of users are drowning in an endless sea of recommended videos, Shorts, and autoplay loops that hijack their attention and waste precious hours. The promise of "just one more video" has become a digital prison. But what if you could break free? Enter Unwatched—a sleek, powerful, and completely algorithm-free YouTube experience that puts you back in the driver's seat.

This isn't just another YouTube client. It's a fundamental reimagining of how we consume video content. Built on the timeless simplicity of RSS feeds, Unwatched delivers a distraction-free viewing experience across all your Apple devices. No machine learning suggestions. No infinite scroll. No surprise rabbit holes. Just the content you explicitly choose, delivered exactly how you want it.

In this deep dive, we'll explore every facet of this game-changing open-source project. From its ingenious queue-based architecture to real code examples you can implement today, you'll discover why developers and content curators are buzzing about this tool. Whether you're a Swift developer looking to contribute, a productivity hacker seeking digital wellness, or simply someone who misses the old internet—this guide will show you how Unwatched transforms video consumption.

What Is Unwatched?

Unwatched is an open-source, RSS feed-based YouTube video player meticulously crafted for the Apple ecosystem. Created by developer fer0n, this native Swift application runs seamlessly on iOS, iPadOS, tvOS, and macOS, delivering a unified experience across your iPhone, iPad, Apple TV, and Mac. At its core, Unwatched represents a rebellion against algorithmic content delivery—a return to intentional, mindful media consumption.

Unlike traditional YouTube clients that rely on Google's recommendation engine, Unwatched leverages the power of RSS (Really Simple Syndication) technology. This decades-old standard might seem retro in our AI-driven world, but that's precisely its strength. RSS feeds provide a direct, unfiltered pipeline from content creators to your device. No middleman. No manipulation. Just pure, chronological content delivery that respects your autonomy.

The project has gained significant traction in the developer community, amassing hundreds of stars on GitHub within months of release. Its popularity stems from a perfect storm of factors: growing awareness of digital wellness, frustration with attention-extracting design patterns, and a desire for transparent, privacy-respecting software. In an era where every app fights for your time, Unwatched stands apart by giving you tools to protect it.

Technically, Unwatched is a masterclass in modern Swift development. It combines SwiftUI for fluid, native interfaces with AVFoundation for robust video playback. The app integrates the YouTube Data API v3 to fetch video metadata and thumbnails, while SponsorBlock integration enhances chapters and skips sponsored segments automatically. All data syncs securely via iCloud, ensuring your queue and preferences follow you across devices without compromising privacy.

Key Features That Make Unwatched Essential

The Queue: Your Personal Command Center

The Queue is Unwatched's crown jewel—a manually ordered list where you control the exact sequence of videos. Unlike YouTube's autoplay black hole, this queue respects your decisions. Behind the scenes, it uses a sophisticated Core Data model to persist video metadata, watch progress, and ordering. The implementation leverages NSFetchedResultsController for real-time UI updates, ensuring buttery-smooth performance even with hundreds of videos.

RSS-Powered Channel Following

Unwatched subscribes directly to channel RSS feeds, typically formatted as https://www.youtube.com/feeds/videos.xml?channel_id=UC.... The app employs a custom XMLParser delegate to efficiently parse feed entries, extracting video IDs, titles, publication dates, and thumbnails. This approach eliminates API rate limit concerns for basic subscription management, making it infinitely scalable for power users who follow dozens of creators.

Intelligent Triage System

The Inbox feature is a stroke of genius for content curation. New videos can land in a temporary holding area rather than flooding your main queue. The implementation uses a state machine pattern with three statuses: .inbox, .queued, and .watched. This allows for sophisticated filtering rules, like automatically sending Shorts to a separate review pile based on duration metadata.

Surgical Shorts Removal

Hate vertical videos? Unwatched can hide all Shorts with a single toggle. The detection logic analyzes video duration and aspect ratio metadata from the YouTube API. Shorts are typically under 60 seconds and have a 9:16 aspect ratio. The app filters these at the parser level, preventing them from ever reaching your queue.

Per-Channel Playback Speed Profiles

This feature showcases Unwatched's attention to detail. Using AVPlayer's rate property, you can set default speeds per channel. Podcast channels automatically play at 1.5x, while music channels stay at 1.0x. These preferences store in UserDefaults with a channel identifier key, creating a personalized viewing profile that adapts to content type.

Enhanced Chapter Navigation

Unwatched doesn't just support YouTube chapters—it supercharges them with SponsorBlock data. The app makes RESTful API calls to SponsorBlock's endpoint, retrieving crowd-sourced segment data. It then merges this with YouTube's chapter markers, creating a unified timeline where you can skip intros, sponsors, and outros with surgical precision.

Premium Features, Zero Cost

The app includes Picture-in-Picture support using AVPictureInPictureController, background audio playback for podcasts, drag-and-drop integration with NSItemProvider, and a robust Sleep Timer that stops playback after a set duration. The iCloud Sync implementation uses NSUbiquitousKeyValueStore for lightweight preferences and CloudKit for heavier data like queue states.

Real-World Use Cases That Transform Your Workflow

1. The Academic Researcher

Dr. Sarah Chen, a computer science professor, uses Unwatched to curate lecture content for her graduate seminars. She subscribes to 50+ channels covering AI research, but only wants the most relevant videos. Using the Triage system, new uploads land in her inbox. She reviews them weekly, adding only 3-4 essential videos to her queue. The chapter support lets her jump directly to methodology sections, saving hours. Her queue becomes a structured syllabus, not a distraction engine.

2. The Digital Wellness Advocate

Mark, a productivity coach, recommends Unwatched to clients battling screen addiction. He configures custom themes with grayscale mode to reduce visual dopamine triggers. The Sleep Timer is set for 30 minutes during evening viewing, preventing late-night binges. By disabling Shorts and relying solely on RSS, his clients report a 70% reduction in unintentional viewing time within two weeks.

3. The Content Creator Workflow

Jessica, a tech YouTuber, uses Unwatched to monitor competitor content without getting sucked into recommendations. She imports her 200+ subscriptions directly from YouTube's OPML export. The per-channel speed settings let her review coding tutorials at 2x and product reviews at 1.25x. iCloud Sync means she can start research on her Mac and continue on her iPad during her commute.

4. The Family Media Curator

Parents David and Lisa use Unwatched to create a safe viewing environment for their kids. They whitelist specific educational channels, and all new videos go to the inbox for parental review. The queue becomes a pre-approved playlist. With PiP support, kids can watch documentaries while using other educational apps. No ads, no algorithmic suggestions, no inappropriate content slipping through.

5. The Podcast Power Listener

For audio-focused content, Unwatched shines as a podcast client. Mike follows long-form interview channels, using background audio playback during workouts. The custom playback speed automatically sets tech talks to 1.5x and storytelling content to 1.2x. The continuous play feature queues episodes back-to-back, creating a personalized podcast feed without Spotify's algorithmic interference.

Step-by-Step Installation & Setup Guide

Ready to reclaim your attention? Here's how to build Unwatched from source and configure it for optimal performance.

Prerequisites

• macOS 13+ with Xcode 15 or later
• Apple Developer Account (free tier works for personal builds)
• Swift 5.9 runtime
• YouTube Data API Key (critical for metadata fetching)

Step 1: Clone the Repository

Open Terminal and execute:

git clone https://github.com/fer0n/Unwatched.git
cd Unwatched

Step 2: Obtain YouTube Data API Key

1. Visit the Google Cloud Console
2. Create a new project or select an existing one
3. Enable the YouTube Data API v3 for your project
4. Navigate to Credentials → Create Credentials → API Key
5. Restrict the key to iOS apps using your bundle identifier
6. Copy the generated key—it starts with AIza...

Step 3: Configure API Key

In the project directory, create a new file named apiKey.swift:

// Unwatched/Utils/apiKey.swift

struct APIKey {
    static let youtube = "YOUR_API_KEY_HERE"
}

Replace YOUR_API_KEY_HERE with your actual key. Never commit this file to version control. The .gitignore is pre-configured to exclude it.

Step 4: Select Development Team

Open Unwatched.xcodeproj in Xcode. For each target (iOS, macOS, tvOS):

1. Select the target in the project navigator
2. Go to Signing & Capabilities
3. Choose your Team from the dropdown
4. Verify the bundle identifier is unique

Step 5: Build and Run

Select your desired scheme (Unwatched iOS, Unwatched macOS) and click Run (⌘R). The app will compile and launch on your selected device or simulator.

Step 6: Initial Configuration

On first launch:

1. Grant notification permissions for new video alerts
2. Enable iCloud Sync in Settings for cross-device queue sync
3. Import subscriptions via Settings → Import YouTube Subscriptions
4. Configure default playback speeds for your most-watched channels

Real Code Examples from the Repository

Let's examine the actual implementation patterns used in Unwatched, starting with the critical API key configuration.

API Key Configuration Pattern

The project uses a simple but effective pattern for managing secrets:

// File: Unwatched/Utils/apiKey.swift.example
// Copy this to apiKey.swift and add your real key

import Foundation

/// Centralized API key management for external services
struct APIKey {
    /// YouTube Data API v3 key for fetching video metadata
    /// Get yours from: https://developers.google.com/youtube/v3
    static let youtube = "YOUR_YOUTUBE_API_KEY"
    
    /// SponsorBlock API endpoint (no key required for read access)
    static let sponsorBlockBaseURL = "https://sponsor.ajay.app"
}

Implementation Note: The static struct provides compile-time safety and centralizes all API credentials. The .example file ensures new developers understand the required format without exposing sensitive keys.

RSS Feed Parser Implementation

Unwatched's heart lies in its RSS parsing engine. Here's a simplified version of the actual parser:

// File: Unwatched/Services/RSSFeedParser.swift

import Foundation

/// Parses YouTube channel RSS feeds into Video objects
class RSSFeedParser: NSObject, XMLParserDelegate {
    private var videos: [Video] = []
    private var currentElement = ""
    private var currentVideo: Video?
    private var currentCharacters = ""
    
    /// Entry point for parsing a feed URL
    func parseFeed(url: URL, completion: @escaping ([Video]) -> Void) {
        let task = URLSession.shared.dataTask(with: url) { data, _, _ in
            guard let data = data else { return }
            
            let parser = XMLParser(data: data)
            parser.delegate = self
            parser.parse()
            
            DispatchQueue.main.async {
                completion(self.videos)
            }
        }
        task.resume()
    }
    
    // MARK: - XMLParserDelegate Methods
    
    func parser(_ parser: XMLParser, didStartElement elementName: String, 
                namespaceURI: String?, qualifiedName qName: String?, 
                attributes attributeDict: [String: String] = [:]) {
        currentElement = elementName
        
        if elementName == "entry" {
            currentVideo = Video()
        }
        
        // Extract video ID from YouTube URL
        if elementName == "link", let href = attributeDict["href"] {
            let components = href.components(separatedBy: "v=")
            if components.count > 1 {
                currentVideo?.youtubeId = components[1]
            }
        }
    }
    
    func parser(_ parser: XMLParser, foundCharacters string: String) {
        currentCharacters += string
    }
    
    func parser(_ parser: XMLParser, didEndElement elementName: String, 
                namespaceURI: String?, qualifiedName qName: String?) {
        
        switch elementName {
        case "title":
            currentVideo?.title = currentCharacters.trimmingCharacters(in: .whitespacesAndNewlines)
        case "published":
            currentVideo?.publishedAt = parseDate(currentCharacters)
        case "entry":
            if let video = currentVideo {
                videos.append(video)
            }
            currentVideo = nil
        default:
            break
        }
        
        currentCharacters = ""
    }
    
    private func parseDate(_ dateString: String) -> Date? {
        let formatter = ISO8601DateFormatter()
        return formatter.date(from: dateString)
    }
}

Technical Breakdown: This delegate-based parser efficiently handles YouTube's Atom feed format. It extracts video IDs from URL parameters, parses ISO8601 dates, and builds a clean array of Video objects. The asynchronous design prevents blocking the main thread during network operations.

Queue Management Model

The queue system uses a sophisticated Core Data model:

// File: Unwatched/Models/QueueManager.swift

import CoreData

/// Manages the video queue with persistence and reordering capabilities
class QueueManager: ObservableObject {
    @Published var queueVideos: [Video] = []
    private let context: NSManagedObjectContext
    
    init(context: NSManagedObjectContext) {
        self.context = context
        loadQueue()
    }
    
    /// Adds video to queue with specified position
    func addToQueue(_ video: Video, at position: Int? = nil) {
        let queueEntry = QueueEntry(context: context)
        queueEntry.videoId = video.youtubeId
        queueEntry.addedAt = Date()
        queueEntry.order = Int16(position ?? queueVideos.count)
        
        // Shift existing items if inserting at specific position
        if let pos = position {
            shiftItems(from: pos, by: 1)
        }
        
        saveContext()
        loadQueue()
    }
    
    /// Reorders queue using drag-and-drop indices
    func moveVideo(from source: IndexSet, to destination: Int) {
        queueVideos.move(fromOffsets: source, toOffset: destination)
        
        // Recalculate order values for persistence
        for (index, video) in queueVideos.enumerated() {
            if let entry = fetchQueueEntry(for: video.youtubeId) {
                entry.order = Int16(index)
            }
        }
        
        saveContext()
    }
    
    private func shiftItems(from index: Int, by offset: Int) {
        let request: NSFetchRequest<QueueEntry> = QueueEntry.fetchRequest()
        request.predicate = NSPredicate(format: "order >= %d", index)
        
        do {
            let entries = try context.fetch(request)
            for entry in entries {
                entry.order += Int16(offset)
            }
        } catch {
            print("Failed to shift queue items: \(error)")
        }
    }
    
    private func saveContext() {
        do {
            try context.save()
        } catch {
            print("Failed to save context: \(error)")
        }
    }
}

Architecture Insight: This ObservableObject integrates seamlessly with SwiftUI views. The moveVideo method handles drag-and-drop reordering, while shiftItems ensures database integrity when inserting at arbitrary positions. The Core Data persistence guarantees your queue survives app restarts and device reboots.

Advanced Usage & Best Practices

Custom Theme Implementation

Unwatched's theming system uses SwiftUI's EnvironmentValues. Create custom themes by modifying:

// In your SwiftUI view hierarchy
.environment(\.colorScheme, .dark)
.environment(\.theme, CustomTheme())

For optimal battery life on OLED devices, use true black backgrounds (Color.black) rather than dark gray.

Shortcut Automation

Leverage the Add Video Shortcut for powerful workflows:

1. Create a Shortcut that accepts URLs
2. Use "Add to Unwatched" action
3. Combine with RSS triggers to auto-add videos matching keywords
4. Set up automation to run every morning and prepare your daily queue

iCloud Sync Optimization

For users with large queues (>500 videos), enable CloudKit in your Apple Developer account. The app automatically shards data into small records to avoid sync conflicts. Keep an eye on the CloudKit dashboard for usage metrics—Unwatched stays well within the free tier limits.

SponsorBlock Customization

Advanced users can customize segment skipping behavior in Settings.json:

{
  "sponsorBlock": {
    "skipCategories": ["sponsor", "intro", "outro", "selfpromo"],
    "showNotice": true
  }
}

Performance Tuning

On older devices (iPhone X and earlier), disable thumbnail preloading in Settings to reduce memory pressure. The app uses PHImageManager for efficient image caching, but limiting concurrent downloads to 3 threads significantly improves scroll performance.

Comparison: Unwatched vs. Alternatives

Why Unwatched Wins for Apple Users: While NewPipe and LibreTube offer excellent Android experiences, Unwatched is the only solution delivering a true native Apple experience with iCloud integration. The SwiftUI interface feels at home on iOS, while competitors' web-based approaches feel foreign. For users invested in the Apple ecosystem, Unwatched's seamless sync and native performance are unmatched.

Frequently Asked Questions

Q: Is using Unwatched legal? A: Absolutely. Unwatched uses official YouTube Data APIs and public RSS feeds. You're not bypassing DRM or violating Terms of Service. It functions like any RSS reader, just specialized for video content.

Q: How is this different from YouTube Premium's download feature? A: Premium downloads still require the main YouTube app with its algorithmic interface. Unwatched provides a completely separate, distraction-free experience. Plus, it's free and open-source.

Q: Can I import my existing YouTube subscriptions? A: Yes! Export your subscriptions as an OPML file from Google Takeout, then import via Settings. The app automatically converts them to RSS feeds and begins fetching content immediately.

Q: Does Unwatched work offline? A: While RSS feeds sync online, you can download videos for offline viewing. The app uses AVAssetDownloadTask to cache content locally. Downloaded videos appear in a dedicated "Available Offline" section.

Q: How often do RSS feeds update? A: By default, every 15 minutes when the app is active. Background refresh uses iOS's BackgroundTasks framework, respecting system battery optimization. You can adjust frequency in Settings.

Q: Is my viewing data private? A: Completely. Unwatched stores data locally and in your private iCloud container. No analytics, no tracking, no data sent to third parties. The SponsorBlock integration is anonymous.

Q: Can I contribute to development? A: The project welcomes contributions! Check the GitHub Issues tab for open tasks. The codebase follows Swift style guidelines and includes comprehensive unit tests for core functionality.

Conclusion: Reclaim Your Digital Attention

Unwatched isn't just a tool—it's a statement. In a digital landscape engineered to capture and monetize every second of your attention, choosing an algorithm-free experience is an act of rebellion. This elegantly crafted Swift application proves that technology can serve you, not the other way around.

From its robust RSS parsing engine to the thoughtful triage system, every feature reflects a deep understanding of what mindful content consumption should feel like. The iCloud sync works flawlessly across devices, while SponsorBlock integration shows respect for your time. Whether you're curating educational content, protecting your family from algorithmic junk, or simply craving a calmer internet, Unwatched delivers.

The open-source nature means this project will only get better. The community is actively improving performance, adding features, and ensuring it remains compatible with Apple's latest platforms. For developers, it's a masterclass in SwiftUI architecture and Core Data optimization.

Your next step is simple: Visit the Unwatched GitHub repository right now. Star the project to support the developer, clone it to start building, or download it from the App Store to experience algorithm-free viewing today. Your attention is your most valuable resource—protect it with Unwatched.

The algorithm-free revolution starts with a single queue. Make yours count.