How to Set Up YTLite on iOS: Complete Build and Installation Guide

To set up YTLite on iOS, fork the dayanch96/YTLite repository, enable GitHub Actions, run the "Create YouTube Plus app" workflow with a direct URL to a decrypted YouTube IPA, and sideload the resulting artifact using AltStore, Sideloadly, or a package manager on a jailbroken device.

YTLite (formerly YouTube Plus) is a jailbreak tweak that injects optional features into the official iOS YouTube app by hooking native classes at runtime. According to the source code in YTLite.x, the tweak uses CaptainHook-style syntax to modify YouTube behavior while persisting user preferences through the YTLUserDefaults wrapper. This guide covers the complete setup process from repository fork to final configuration.

Prerequisites

Before building YTLite, ensure you have the following:

• A jailbroken iOS device or a device capable of sideloading unsigned apps (iOS 16+ with AltStore or similar)
• Xcode 15 or later for local builds, or a GitHub account to use the provided CI workflow
• A decrypted YouTube IPA (App Store version stripped of FairPlay DRM) hosted on a file service that provides direct download links
• GitHub Actions permissions set to "Read and Write" in your forked repository (required for artifact uploads)

The tweak compiles as a Dynamic Framework and must be injected into an unencrypted binary because CaptainHook can only patch binaries that are not DRM-protected.

Fork the Repository and Enable Actions

First, create your own copy of the repository to run the build workflow:

1. Navigate to the dayanch96/YTLite repository and click Fork.
2. In your forked repository, go to Settings → Actions → General.
3. Under Workflow permissions, select Read and write permissions to allow the workflow to upload the compiled IPA artifact.

This configuration is required because the GitHub Actions workflow defined in .github/workflows/ytp_beta.yml needs write access to store the final YTLite-App.ipa file.

Prepare the Decrypted YouTube IPA

YTLite requires a decrypted YouTube IPA to function. You must obtain a decrypted version of the official YouTube app (stripped of FairPlay DRM) and upload it to a file hosting service that provides a direct download URL.

Upload the .ipa file to a host like filebin.net or Dropbox, ensuring the link points directly to the file without HTML redirects. Test the URL in a browser—it should initiate an immediate download of the .ipa file when accessed.

Build YTLite Using GitHub Actions

The repository provides an automated workflow that compiles the tweak and embeds it into your decrypted IPA:

1. In your forked repository, click the Actions tab.
2. Select the Create YouTube Plus app workflow (or the [BETA] Build YouTube Plus app workflow for beta features).
3. Click Run workflow and configure the following inputs:
   • Decrypted IPA URL: Paste the direct download link from the previous step
   • Tweak version: Specify the release tag (defaults to latest)
   • Bundle ID and Display Name (optional): Customize the app identifier and name
4. Submit the workflow run.

The workflow will compile YTLite.x into a dynamic bundle, inject it into the YouTube IPA, and sign the output with a temporary provisioning profile. When complete, download the artifact named YTLite-App.ipa from the workflow run summary.

Sideload the YTLite-Enabled IPA

Install the modified YouTube app using one of these methods:

• AltStore: Connect your device, open AltStore on macOS or iOS, navigate to My Apps, click the + button, and select the downloaded YTLite-App.ipa.
• Sideloadly: Drag the IPA onto the Sideloadly window, enter your Apple ID credentials, and click Start to sign and install.
• Cydia (Jailbroken): Copy the IPA to your device and install using Cydia Installer or dpkg -i via command line.

After installation, launch the YouTube app. The tweak automatically adds a YouTube Settings entry in the app's settings menu where all configuration options appear.

Configure YTLite Features and Settings

All user preferences are stored via YTLUserDefaults, which wraps NSUserDefaults to provide typed accessors. The settings UI presents toggles under logical groups like Player settings and Interface customization.

To interact with preferences programmatically using the helpers defined in YTLUserDefaults.h:

// Read a boolean preference
BOOL hideShorts = ytlBool(@"hideShorts");

// Set a preference value programmatically
ytlSetBool(YES, @"noAds");

Values persisted through ytlSetBool immediately affect hooked methods in YTLite.x that check these flags at runtime. Most hooks read configuration on-the-fly, so changes apply without restarting the app.

Updating or Removing YTLite

To update YTLite to the latest version, repeat the workflow execution steps with a fresh decrypted YouTube IPA. The GitHub Actions pipeline always produces the latest binary from the repository source.

To remove the tweak, delete the YouTube app bundle from your home screen or through Settings → General → iPhone Storage. On jailbroken devices, uninstall via your package manager.

Developer Reference: Working with YTLUserDefaults

If you are extending YTLite or building complementary tweaks, you can interface with the preference system directly.

Reading preferences with default fallbacks:

// Check if Shorts should be hidden
BOOL hideShorts = ytlBool(@"hideShorts");

Changing preferences at runtime:

// Enable "Shorts Only" mode
ytlSetBool(YES, @"shortsOnlyMode");

Adding custom hooks requires editing YTLite.x and following the existing CaptainHook pattern:

%hook YTPlayerViewController
- (void)loadWithPlayerTransition:(id)arg1 playbackConfig:(id)arg2 {
    %orig;
    if (ytlBool(@"force2xSpeed")) {
        [self setPlaybackRate:2.0];
    }
}
%end

After modifying YTLite.x, rebuild the tweak using the CI workflow or locally via Xcode.

Summary

• YTLite modifies the iOS YouTube app by hooking native classes in YTLite.x using CaptainHook syntax.
• Installation requires a decrypted YouTube IPA and uses a GitHub Actions workflow to compile and inject the tweak.
• Preferences persist through YTLUserDefaults functions (ytlBool, ytlSetBool) and appear in the YouTube Settings UI.
• The resulting IPA can be sideloaded via AltStore/Sideloadly or installed on jailbroken devices.
• Updates are performed by re-running the workflow with the latest repository code.

Frequently Asked Questions

What is YTLite and is it safe to use?

YTLite is an open-source jailbreak tweak formerly known as YouTube Plus that enhances the official iOS YouTube app with optional features like ad blocking and interface customization. Because it hooks into system classes using runtime modification via YTLite.x, you should only install it from the official dayanch96/YTLite repository to ensure you are running audited code.

Do I need a jailbroken device to use YTLite?

No, YTLite works on both jailbroken and non-jailbroken devices. Non-jailbroken users can sideload the patched IPA using tools like AltStore or Sideloadly, while jailbroken users can install the tweak directly into the YouTube app using a package manager.

How do I update YTLite to the latest version?

To update, download a fresh decrypted YouTube IPA and re-run the "Create YouTube Plus app" GitHub Actions workflow in your forked repository. Download the new artifact and reinstall it over the existing app, or delete the old version first to avoid conflicts.

Where are YTLite preferences stored?

Preferences are stored in standard iOS user defaults through the YTLUserDefaults wrapper, specifically using functions like ytlBool() and ytlSetBool() defined in YTLUserDefaults.h. The UI reads these values to populate the settings pane found under Settings → YouTube within the modified app.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}