DEV Community: Kernolix Group

How I Built 20 Privacy-First Manifest V3 Chrome Extensions (With Zero Remote Telemetry)

Kernolix Group — Wed, 21 Oct 2026 12:23:52 +0000

Building Chrome extensions in 2026 comes with a completely new set of architectural challenges and opportunities. With Google's complete transition to Manifest V3, developers can no longer rely on background persistence or arbitrary remote code execution.

Rather than seeing this as a limitation, I used Manifest V3 constraints as an opportunity: What if we built an entire suite of 20 production-grade extensions where 100% of the scraping, tracking, and storage happens entirely on the user's machine, with zero external tracking servers?

Here is what I learned building the Plato Chrome Extensions Suite, along with the key engineering decisions behind our flagship tools.

🛠️ The Core Architectural Philosophy

Most browser tools on the market today follow a telemetry-heavy architecture:

The extension injects a content script.
User activity or page contents are shipped to an external backend API.
The server runs heavy parsing and returns results.
Users are charged $30 to $50 per month just to access their own data.

Our philosophy was the exact opposite:

Zero Remote Telemetry: All DOM parsing, price detection, and contact scraping operate inside the tab's sandbox.
Local Persistence: Data is stored locally via chrome.storage.local and exported directly into client-side CSV, JSON, or Markdown.
Service Worker Lifecycle: Managing transient background tasks without memory leaks or dropped event listeners.

🔍 Flagship Implementations & Real-World Code

1. E-Commerce Competitor Price Tracker & Stock Spy

Many price tracking extensions rely on server-side web scraping that frequently breaks due to IP blocking. By running client-side on active product pages:

Dynamic price selector matching for Amazon and marketplace layouts.
Historical price snapshot logging to local indexed records.
Instant alert computation when a genuine price drop or artificial markup is detected.

Mağazadaki versiyon: Amazon & Trendyol Price Tracker on Chrome Web Store

2. LinkedIn B2B Lead Extractor & Profile Scraper

Scraping search results from social networks often risks rate limits or profile warnings. To solve this, we implemented:

Human-Delay Emulation: Exponentially weighted random delays (1200ms - 2800ms) between page navigations.
Client-Side CSV Formatter: Compiles names, titles, and company attributes into CRM-ready CSVs in browser memory using Blob and URL.createObjectURL.

Canlı versiyon: LinkedIn Lead Extractor on Chrome Web Store

3. AliExpress to Shopify One-Click Product Importer

Dropshippers often struggle with manual product data copying:

Traverses image galleries and high-resolution thumbnail URLs.
Normalizes variant pricing tables, color options, and inventory counts.
Exports formatted Shopify-compatible CSVs for immediate catalog import.

Canlı versiyon: AliExpress Importer on Chrome Web Store

4. YouTube Transcript Summarizer & Smart Notes

Extracts closed caption text tracks directly from the YouTube player API client-side, structuring timestamps and key takeaways without needing high-latency server proxies.

Canlı versiyon: YouTube Summarizer on Chrome Web Store

💡 Key Lessons for Extension Developers in 2026

Embrace chrome.storage.local Over Cloud DBs: For privacy-sensitive utilities, users strongly prefer knowing their data never leaves their device.
Handle Service Worker Idle Time: In Manifest V3, background workers can terminate after 30 seconds of inactivity. Always design background message passing with state rehydration.
Keep Dependencies Lean: Avoid heavy frontend frameworks for lightweight extension popups. Vanilla JS and modern CSS deliver instant sub-50ms render times.

All 20 extensions are now live on the Chrome Web Store and listed on Plato Bilişim.

What architectural patterns or Manifest V3 challenges have you faced in your browser projects? Let's discuss in the comments below!

How to Reclaim 100GB of macOS Sequoia Ghost Storage (Without Heavy Cleaners)

Kernolix Group — Sat, 17 Oct 2026 13:14:25 +0000

🧹 Reclaiming 100GB of Ghost Storage on macOS Sequoia: Why We Built Mac Cleaner

Every Mac user and developer running macOS Sequoia on Apple Silicon (M1/M2/M3/M4) eventually encounters the dreaded alert:

⚠️ "Your startup disk is almost full (99%)."

When you open System Settings → General → Storage, you are greeted by a massive grey block labeled "System Data" or "Developer" taking up 120GB+ of space with zero explanation.

Most users turn to legacy cleaners. But as software engineers, we noticed a critical problem: traditional cleaning apps install dozens of permanent background daemons, consume 1.2GB of RAM just idling in the menu bar, run telemetry, and demand aggressive subscription renewals.

We wanted a native, zero-bloat solution built specifically for the Apple Silicon era. Here is why we built Mac Cleaner: Disk & Storage (v2.0.0) and how you can reclaim tens of gigabytes safely.

🎬 Watch the 4K Architecture Showcase & Live Scan

Here is a complete walkthrough of the liquid-glass interface and sub-second disk traversal in action:

Prefer a quick 10-second breakdown? Watch our viral demo: YouTube Shorts Walkthrough

🔍 Where Does the "Ghost Storage" Actually Go?

If you inspect your Mac's APFS container via terminal (du -sh *), you will find the biggest offenders:

1. Xcode DerivedData & Simulator Caches (20GB - 80GB)

Every build in Xcode dumps intermediate objects into:

~/Library/Developer/Xcode/DerivedData
~/Library/Developer/CoreSimulator/Caches

If you work on multiple projects or update macOS, orphaned simulator runtimes linger forever.

2. Hidden Package Manager & NPM/SPM Caches (15GB - 40GB)

CocoaPods, Swift Package Manager, Homebrew, and Docker build layers leave gigabytes of unreferenced blobs inside ~/Library/Caches.

3. Duplicate Media & Video Clones (10GB - 50GB)

High-resolution 4K ProRes videos, duplicate screenshots, and multiple AirDrop downloads silently consume flash storage.

⚡️ What Makes Mac Cleaner: Disk & Storage Different?

Unlike bloated legacy utilities, Mac Cleaner was engineered around four core tenets:

100% On-Device & Private: Zero network telemetry. Every file index, SHA-256 hash calculation, and purge operation runs strictly locally within Apple's App Sandbox.
Apple Silicon & Swift 6 Native: Leverages POSIX kernel APIs and Grand Central Dispatch to traverse 500,000+ files in under 6 seconds without triggering fans or high CPU spikes.
2027 Liquid Glass Interface: Designed to feel like a first-party Apple utility with pearl-white Light Mode and deep space-blue Dark Mode.
Actionable Apple Intelligence: Live memory gauges, RAM pressure monitoring, and 1-click diagnostic shortcuts.

📊 Storage Reclaim Benchmark

Component	Legacy Cleaners	Mac Cleaner: Disk & Storage
Idle Memory (RAM)	~850 MB – 1.4 GB	0 MB (No Daemons)
Background Processes	3 – 5 Root Daemons	0 (Sandboxed)
DerivedData & SPM Purge	Paid Add-on	Included
Privacy / Telemetry	Third-party analytics	100% Local / Zero Tracking
SHA-256 Duplicate Scan	Clunky / Slow	Sub-second Multithreaded

📲 Download on the Mac App Store

Mac Cleaner: Disk & Storage is officially available worldwide on the Mac App Store:

👉 Download Mac Cleaner: Disk & Storage on the Mac App Store

🌐 Official Product Portal: https://macsweep.app

Try it on your Mac and share your benchmark results below! What is the largest phantom folder you've cleared from your Mac?

Building VoiceJot: Low-Latency On-Device Speech Transcription and AI Meeting Minutes in Swift

Kernolix Group — Tue, 06 Oct 2026 07:19:00 +0000

The Bottleneck: Managing Voice Memos

Voice memos are the most natural way to capture ideas during client meetings, team standups, and college lectures. However, finding actionable information inside raw 30-minute audio recordings is a huge productivity drain.

To solve this, we engineered VoiceJot: Voice to Text, a privacy-first iOS application that combines Apple's native speech recognition with real-time neural formatting and structured AI summaries.

Architectural Highlights

1. AVAudioEngine & SFSpeechRecognizer Pipeline

VoiceJot taps raw PCM audio buffers at 44.1 kHz using an AVAudioNodeTap:

Partial results are streamed in real time to give users an instant visual typewriter animation.
Works across 50+ languages with automatic punctuation and capitalization restoration.
Supports direct audio demuxing from WhatsApp voice messages and video clips via AVAssetReader.

let recognitionRequest = SFSpeechAudioBufferRecognitionRequest()
recognitionRequest.shouldReportPartialResults = true
recognitionRequest.addsPunctuation = true

inputNode.installTap(onBus: 0, bufferSize: 1024, format: recordingFormat) { buffer, _ in
    recognitionRequest.append(buffer)
}

2. Structured Executive Summaries

Instead of dumping raw unformatted text walls, VoiceJot parses transcripts into:

Executive Overview: 2-3 sentence core meeting synthesis.
Key Discussion Points: Bulleted major arguments.
Action Items (To-Do): Direct delegated tasks with deadlines.

Availability & Resources

App Store Link: https://apps.apple.com/app/id6799866105
Target OS: iOS 16.0+ Universal

How are you integrating on-device speech transcription in your mobile apps? Let's discuss in the comments below!

Building Shrink Video: Hardware-Accelerated 4K Video Compression on iOS with VideoToolbox

Kernolix Group — Tue, 06 Oct 2026 07:18:18 +0000

The Challenge: Mobile 4K Video Bloat

Modern iPhones shoot stunning 4K 60fps video, but sending clips via messaging apps is a constant headache:

WhatsApp: 16MB file limit (expanded to 64MB under specific document attachments).
Discord: 25MB standard upload limit.
Email: 20MB-25MB hard attachment ceilings.

Most third-party video compressor apps on iOS suffer from two critical architectural flaws:

They upload user videos to remote cloud servers (severe privacy invasion and slow upload latency).
They use crude "Low / Medium / High" presets that crush bitrate and render pixelated artifacts.

To solve this, we engineered Shrink Video: Compressor entirely on-device using Apple's low-level VideoToolbox framework and AVFoundation.

Technical Architecture

1. Zero-Cloud Hardware Re-Encoding

By leveraging Apple Silicon's dedicated media engine via VTCompressionSession and AVAssetWriter:

Videos never leave the iPhone RAM.
Compression runs 100% offline in Airplane Mode.
Native hardware HEVC (H.265) achieves up to 80% file size reduction while retaining crisp edge detail.

2. Deterministic Bitrate Target Slider

Instead of guessing quality presets, users drag a target size slider (e.g., exactly 15.5 MB for WhatsApp). The app calculates the exact video bitrate target:

let audioBitrate: Double = 128_000 // 128 kbps AAC
let targetSizeBytes: Double = targetMB * 1024 * 1024
let totalSeconds = CMTimeGetSeconds(asset.duration)

let availableVideoBytes = targetSizeBytes - ((audioBitrate / 8) * totalSeconds)
let targetVideoBitrate = max(500_000, (availableVideoBytes * 8) / totalSeconds)

3. Smart Downscaling Pipeline

Downscaling from 4K (3840x2160) to 1080p or 720p runs through Metal-accelerated bilinear filtering to preserve high-frequency texture information.

Results & App Store Availability

Processing Speed: 60-second 4K clip compressed to 18MB in under 6 seconds on iPhone 15 Pro.
App Store Link: https://apps.apple.com/app/id6799865864
Target OS: iOS 16.0+

Have you implemented custom VideoToolbox pipelines in Swift? Let's discuss transcoding trade-offs in the comments!

Building a High-Performance Safari Content Blocker on iOS with Declarative WebKit Rules

Kernolix Group — Tue, 06 Oct 2026 02:30:19 +0000

Introduction: The State of Ad Blocking on iOS

When developing ad-blocking solutions on iOS, developers face a major architectural choice between:

Declarative WebKit Content Blockers (SFContentBlockerManager)
Local VPN Packet Tunnels (NEPacketTunnelProvider)

While local VPN proxies can inspect all device traffic, they introduce severe downsides: significant battery consumption, latency spikes, and severe privacy concerns because user network packets pass through an active background tunnel.

To provide a private, seamless experience, we engineered AdBlocker Pro: Block Ads using Apple's declarative WebKit Content Blocker API.

Declarative Architecture vs VPN Tunnels

1. Zero-Knowledge On-Device Execution

With SFContentBlockerManager, the iOS host application compiles a declarative JSON ruleset and hands it off directly to the WebKit subsystem:

The app never sees URLs, tabs, or DNS queries.
Rule matching runs directly inside Apple's native C++ WebKit pipeline.
If the host app crashes or is terminated, blocking remains 100% active.

2. Overcoming Rule Limits with Modular Content Extensions

WebKit enforces strict limits per content blocker extension. AdBlocker Pro solves this through modular classification:

Advertising Trackers: Google DoubleClick, Criteo, Taboola, Outbrain.
Privacy Telemetry: Fingerprinting scripts, cross-site beacons.
Cosmetic Filters & Cookie Banners: CSS selectors hiding modal dialogs and GDPR consent walls.

Rules are dynamically packaged into App Group shared storage and compiled into WebKit via:

SFContentBlockerManager.reloadContentBlocker(withIdentifier: extensionIdentifier) { error in
    if let error = error {
        print("Rule compilation error: \(error.localizedDescription)")
    } else {
        print("WebKit rules compiled successfully.")
    }
}

3. Native SwiftUI Performance

Dynamic rule toggles with instant App Group synchronization.
Real-time whitelist management with zero latency.
Ultra-low memory footprint (~12 MB RAM).

App Store Availability & Resources

App Store Link: https://apps.apple.com/app/id6760575398
Support & Docs: https://adblocker-pro-support.vercel.app/
Target OS: iOS 16.0+ / iPadOS 16.0+

Have you built Safari WebKit extensions or content blockers on iOS? Let's discuss performance tips and rule compilation strategies in the comments!

Building SaveClip: A High-Performance 4K Video Archiver for iOS with Zero Login

Kernolix Group — Tue, 06 Oct 2026 02:29:40 +0000

Why We Built SaveClip: The Modern Media Archiving Problem

Mobile users constantly save and curate short-form video content—from educational clips and cooking recipes to travel footage across TikTok, Instagram Reels, and YouTube Shorts. However, most web downloaders are plagued with invasive ad networks, intrusive redirect pop-ups, and questionable third-party proxy servers that compromise privacy or require social media logins.

To solve this, we engineered SaveClip, a lightweight, native iOS utility that parses, downloads, and archives public social media videos directly to the iOS Camera Roll in native 4K/HDR quality with zero login required.

Key Architectural Decisions

1. Privacy-First Zero-Login Architecture

Traditional archivers request session tokens or embed web view logins. SaveClip takes a strict privacy stance:

Operates strictly on public URL payloads.
URLs are normalized and validated locally on device before dispatching background download tasks.

2. High-Throughput Media Pipeline with AVFoundation and URLSession

Powered by background URLSession configurations, allowing uninterrupted downloads even when switching apps.
Direct Camera Roll export via PHPhotoLibrary, preserving original color space, metadata tags, and spatial audio bitrates.
Native parsing allows the user to select between 1080p Full HD, 4K UHD, and compressed lightweight versions.

3. Native SwiftUI and Swift Concurrency

Fully asynchronous networking using modern Swift concurrency and @MainActor state management.
Dynamic responsive UI built with pure SwiftUI, eliminating UIKit bridge overhead.

App Store Availability & Stack

App Store Link: https://apps.apple.com/app/id6759523131
Frameworks: SwiftUI, AVFoundation, Photos, Combine, URLSession
App Store Status: Globally Live (READY_FOR_SALE)

Feedback, questions on AVFoundation streaming pipelines, and architecture ideas are warmly welcomed!

Building SayHi: An Ephemeral Proximity Discovery iOS App with SwiftUI & MapKit

Kernolix Group — Sat, 03 Oct 2026 23:19:33 +0000

Introduction: Why Another Nearby Discovery App?

Traditional social networks are optimized for permanent connections and algorithmic feeds, while modern dating apps rely heavily on endless swipe decks. When you travel to a new city, work out of a local cafe, or attend a tech conference, you often don't want a heavy social network—you just want to know who is nearby, what vibe they share, and have a zero-friction way to break the ice.

This was the motivation behind SayHi: Wave Nearby, a native iOS application built entirely in Swift and SwiftUI.

Key Architectural Decisions

1. Interactive Proximity on MapKit without Performance Bottlenecks

Using MapKit's latest SwiftUI declarative Map APIs in iOS 17 and iOS 18:

Clustered Annotations: Dynamic annotation clustering ensures that in dense urban areas, rendering 100+ avatar pins does not trigger main-thread hitches.
Dynamic Camera Framing: Seamless camera easing between localized neighborhood zoom and regional discovery.

2. Privacy-Preserving Fuzzed Coordinates

User privacy is paramount when building location-aware software:

No Precise GPS Over The Wire: Exact latitude and longitude coordinates are never stored or broadcast.
Sector Randomization: Coordinates are quantized and fuzzed into randomized grid sectors (~200m radius), computing approximate proximity without revealing exact buildings or residences.

3. The Wave Mechanism: Casual, Low-Pressure Interaction

Instead of cold messaging or forced matching:

Users tap to send a Wave!
A wave triggers a fluid, hardware-accelerated spring animation using SwiftUI's PhaseAnimator.
When both users wave at each other, an ephemeral chat opens up.

4. Vibe-Based Intent Filters

Users can toggle explicit intentions in real time:

Grab Coffee
Explore the City
Workout / Gym Partner
Casual Conversation

Try It on iOS

SayHi is currently live worldwide on the App Store:

Download on App Store: SayHi: Wave Nearby
Tech Stack: 100% Swift, SwiftUI, MapKit, CoreLocation, Combine/Async-Await.

Would love to hear feedback from the developer community on location clustering, privacy design, and SwiftUI ergonomics!