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

> Learn how to set up YTLite on iOS. Follow this guide to fork the repository, enable GitHub Actions, and sideload the app for an enhanced YouTube experience.

- Repository: [Dan/YTLite](https://github.com/dayanch96/YTLite)
- Tags: getting-started
- Published: 2026-04-22

---

**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`](https://github.com/dayanch96/YTLite/blob/main/.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`](https://github.com/dayanch96/YTLite/blob/main/YTLUserDefaults.h):

```objc
// 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:

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

```

Changing preferences at runtime:

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

```

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

```objc
%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`](https://github.com/dayanch96/YTLite/blob/main/YTLUserDefaults.h). The UI reads these values to populate the settings pane found under **Settings → YouTube** within the modified app.