# How to Use YTLite GitHub Actions for Building Custom YouTube Plus IPAs

> Build custom YouTube Plus IPAs with YTLite GitHub Actions. Automate tweak compilation, IPA injection, and release publishing for your personalized YouTube experience.

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

---

**Use the `workflow_dispatch` trigger on [`main.yml`](https://github.com/dayanch96/YTLite/blob/main/main.yml) or [`ytp_beta.yml`](https://github.com/dayanch96/YTLite/blob/main/ytp_beta.yml) to compile selected tweaks into `.deb` packages, inject them into a decrypted YouTube IPA using Cyan, and publish a draft release—all automatically.**

The [dayanch96/YTLite](https://github.com/dayanch96/YTLite) repository provides fully automated GitHub Actions workflows that transform a stock YouTube IPA into a customized "YouTube Plus" build with your choice of community tweaks. Whether you need a stable release or want to test bleeding-edge features, understanding how to use YTLite GitHub Actions for building saves hours of manual compilation.

## The Three Core Workflow Files

YTLite's automation is split across three YAML files in `.github/workflows/`. Understanding each role helps you choose the right trigger for your needs.

### Production Builds: [`main.yml`](https://github.com/dayanch96/YTLite/blob/main/main.yml)

Located at [`.github/workflows/main.yml`](https://github.com/dayanch96/YTLite/blob/main/.github/workflows/main.yml), this workflow creates stable releases using versioned YTLite tweaks.

**Key characteristics:**
- Trigger: `workflow_dispatch` (manual button press)
- Input: `tweak_version` (e.g., `"5.2"`) to fetch a specific release
- Output: Draft release named `YouTubePlus v<tweak_version> (run-<run_number>)`

### Beta Builds: [`ytp_beta.yml`](https://github.com/dayanch96/YTLite/blob/main/ytp_beta.yml)

Located at [`.github/workflows/ytp_beta.yml`](https://github.com/dayanch96/YTLite/blob/main/.github/workflows/ytp_beta.yml), this workflow tests unreleased or custom tweak builds.

**Key characteristics:**
- Trigger: `workflow_dispatch` (manual button press)
- Input: `tweak_url` (direct `.deb` download link) instead of version
- Output: Draft release with `YouTubePlus_Beta.ipa` asset

### Shared Helper: [`_build_tweaks.yml`](https://github.com/dayanch96/YTLite/blob/main/_build_tweaks.yml)

Located at [`.github/workflows/_build_tweaks.yml`](https://github.com/dayanch96/YTLite/blob/main/.github/workflows/_build_tweaks.yml), this reusable workflow compiles all selected tweaks. You never trigger this directly—it runs automatically via `workflow_call` from the two workflows above.

## Available Build Inputs and Tweak Flags

Both [`main.yml`](https://github.com/dayanch96/YTLite/blob/main/main.yml) and [`ytp_beta.yml`](https://github.com/dayanch96/YTLite/blob/main/ytp_beta.yml) expose identical Boolean flags for enabling community tweaks. Each flag controls whether its corresponding repository gets cloned and compiled.

| Input Flag | Tweak | Function |
|------------|-------|----------|
| `enable_youpip` | **YouPiP** | Picture-in-picture support and enhanced ad blocking |
| `enable_ytuhd` | **YTUHD** | 4K/HD video quality unlock |
| `enable_yq` | **YouQuality** | Video quality selector enhancement |
| `enable_ryd` | **Return YouTube Dislikes** | Restore dislike counts |
| `enable_ytabc` | **YTABConfig** | Additional configuration UI |
| `enable_demc` | **DontEatMyContent** | Content blocking and filtering |

Beyond tweak flags, these string inputs control the build:

- **`ipa_url`** — Direct URL to a decrypted YouTube IPA (required)
- **`tweak_version`** — YTLite version to fetch (for [`main.yml`](https://github.com/dayanch96/YTLite/blob/main/main.yml) only)
- **`tweak_url`** — Direct `.deb` URL (for [`ytp_beta.yml`](https://github.com/dayanch96/YTLite/blob/main/ytp_beta.yml) only)
- **`display_name`** — Custom app name (default: "YouTube Plus")
- **`bundle_id`** — Custom bundle identifier (default: "com.google.ios.youtube")
- **`info_note`** — Release notes shown on the draft release page

## Step-by-Step: Running a Production Build

Follow these steps to build a stable YouTube Plus IPA using the [`main.yml`](https://github.com/dayanch96/YTLite/blob/main/main.yml) workflow.

### Step 1: Navigate to the Actions Tab

Open the YTLite repository on GitHub and click **Actions** at the top. Find **"Build YouTube Plus"** (the name associated with [`main.yml`](https://github.com/dayanch96/YTLite/blob/main/main.yml)) in the left sidebar.

### Step 2: Run the Workflow

Click **"Run workflow"** button. A form appears with all input options.

### Step 3: Configure Your Build

Fill in the required and desired fields:

```yaml

# Required

ipa_url: "https://your-storage.com/YouTube_19.21.3.ipa"

# Version to use (matches GitHub releases of YTLite)

tweak_version: "5.2"

# Enable desired tweaks

enable_youpip: true
enable_ytuhd: true
enable_yq: false
enable_ryd: true
enable_ytabc: false
enable_demc: false

# Customization

display_name: "YouTube Plus"
bundle_id: "com.custom.youtube"
info_note: "Built with YouPiP, YTUHD, and Return YouTube Dislikes"

```

### Step 4: Submit and Monitor

Click **"Run workflow"** to start. The run appears in the list—click it to watch real-time logs.

## Build Process Internals

Understanding what happens behind the scenes helps debug failures and customize workflows.

### Job 1: Build Tweaks

The `build-tweaks` job executes first, invoking [`_build_tweaks.yml`](https://github.com/dayanch96/YTLite/blob/main/_build_tweaks.yml) via the `workflow_call` directive:

```yaml

# From main.yml

jobs:
  build-tweaks:
    uses: ./.github/workflows/_build_tweaks.yml
    with:
      enable_youpip: ${{ github.event.inputs.enable_youpip }}
      # ... other flags

```

Inside [`_build_tweaks.yml`](https://github.com/dayanch96/YTLite/blob/main/_build_tweaks.yml), the helper performs these steps:

1. **Install build tools** — `make`, `ldid`, `dpkg` via `apt-get`
2. **Cache Theos** — The iOS build framework is cached under `~/theos` for speed
3. **Clone selectively** — Each tweak repository only when its flag is `true`:
   ```bash
   # Example from the workflow logic

   if [ "${{ inputs.enable_youpip }}" = "true" ]; then
     git clone https://github.com/PoomSmart/YouPiP.git
     cd YouPiP && make clean package DEBUG=0 FINALPACKAGE=1
   fi
   ```

4. **Produce packages** — Each `make` invocation creates a `.deb` in `packages/`
5. **Upload artifacts** — All `.deb` files plus the "Open YouTube" Safari extension upload as `built-debs`

The helper also supports shortcut paths for pre-built tweaks:

| Input | Behavior |
|-------|----------|
| `tweak_version` | Downloads `com.dvntm.ytlite_<version>_iphoneos-arm.deb` from YTLite releases |
| `tweak_url` | Downloads directly from the provided URL |

### Job 2: Package IPA

The `package` job depends on `build-tweaks` and performs final assembly:

```yaml

# From main.yml

jobs:
  package:
    needs: build-tweaks
    runs-on: ubuntu-latest
    steps:
      - name: Download built tweaks
        uses: actions/download-artifact@v4
        with:
          name: built-debs
          path: ./debs

```

Key packaging steps:

1. **Security hardening** — `levibostian/action-hide-sensitive-inputs` masks secret-like strings in logs
2. **IPA validation** — Checks MIME type of downloaded IPA (must be `application/octet-stream` or `application/zip`)
3. **Install Cyan** — `pipx install git+https://github.com/asdfzxcvbn/Cyan.git` provides the injection tool
4. **Construct tweak list** — Builds space-separated string: `ytplus.deb` + any additional `.deb` files
5. **Inject and repackage** — The critical Cyan command:
   ```bash
   cyan -i youtube.ipa -o YouTubePlus.ipa \
        -uwef $tweaks \
        -n "${{ inputs.display_name }}" \
        -b ${{ inputs.bundle_id }}
   ```

   Flags: `-i` input IPA, `-o` output, `-uwef` unsigned with entitlements and frameworks, `-n` display name, `-b` bundle ID
6. **Publish release** — `softprops/action-gh-release@v3` creates a draft release with the IPA attached

## Running a Beta Build with Custom Tweak URL

Use [`ytp_beta.yml`](https://github.com/dayanch96/YTLite/blob/main/ytp_beta.yml) when you need to test a tweak version not yet released, or a fork with custom modifications.

### Example: Testing a Pull Request Build

```yaml

# Workflow dispatch inputs for ytp_beta.yml

ipa_url: "https://your-storage.com/YouTube_19.25.4.ipa"
tweak_url: "https://github.com/dayanch96/YTLite/releases/download/pr-123/com.dvntm.ytlite_5.3-beta_iphoneos-arm.deb"
enable_youpip: true
enable_ytuhd: true
enable_yq: true
enable_ryd: true
enable_ytabc: true
enable_demc: true
display_name: "YouTube Plus PR-123"
bundle_id: "com.test.youtube.beta"
info_note: "Testing PR #123 with all tweaks enabled"

```

The `tweak_url` takes precedence over `tweak_version` in the beta workflow, downloading directly from your specified location.

### Concurrency Control

Both workflows prevent conflicting builds through concurrency configuration:

```yaml

# From main.yml and ytp_beta.yml

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

```

This ensures that if you trigger a new build before the previous finishes, the older run is automatically cancelled—preventing resource waste and conflicting release drafts.

## Extending the Workflows

The modular design makes adding new tweaks straightforward. To include a new community tweak:

1. **Add input flag** to [`main.yml`](https://github.com/dayanch96/YTLite/blob/main/main.yml) and [`ytp_beta.yml`](https://github.com/dayanch96/YTLite/blob/main/ytp_beta.yml):
   ```yaml
   enable_newtweak:
     description: "Add NewTweak (description)"
     type: boolean
     default: false
   ```

2. **Pass to helper** in the `build-tweaks` job:
   ```yaml
   with:
     enable_newtweak: ${{ github.event.inputs.enable_newtweak }}
   ```

3. **Implement in [`_build_tweaks.yml`](https://github.com/dayanch96/YTLite/blob/main/_build_tweaks.yml)**:
   ```yaml
   on:
     workflow_call:
       inputs:
         enable_newtweak:
           type: boolean
           required: false
   ```

   And add the conditional clone/build:
   ```bash
   if [ "${{ inputs.enable_newtweak }}" = "true" ]; then
     git clone https://github.com/Author/NewTweak.git
     cd NewTweak
     make clean package DEBUG=0 FINALPACKAGE=1
     mv packages/*.deb ../debs/
   fi
   ```

4. **Handle artifact** — The packaging job automatically picks up any `.deb` in the `built-debs` artifact, so no changes needed there.

## Summary

- **Two top-level workflows** — [`main.yml`](https://github.com/dayanch96/YTLite/blob/main/main.yml) for stable releases (uses `tweak_version`), [`ytp_beta.yml`](https://github.com/dayanch96/YTLite/blob/main/ytp_beta.yml) for testing (uses `tweak_url`)
- **Shared helper** — [`_build_tweaks.yml`](https://github.com/dayanch96/YTLite/blob/main/_build_tweaks.yml) compiles enabled tweaks into `.deb` packages via Theos `make`
- **Modular inputs** — Boolean flags control which tweaks get cloned and built; string inputs customize IPA source, naming, and metadata
- **Cyan injection** — The packaging step uses `cyan -i -o -uwef -n -b` to inject all `.deb` files into the base IPA
- **Draft releases** — Finished IPAs publish as draft releases for review before going public
- **Concurrency control** — `cancel-in-progress: true` prevents resource conflicts from rapid re-triggers

## Frequently Asked Questions

### How do I get a decrypted YouTube IPA for the `ipa_url` input?

You need a decrypted (not encrypted/App Store) IPA from a device you own or a trusted source. Common methods include using tools like **Azule**, **pyzule**, or **bfdecrypt** on a jailbroken iOS device. The YTLite workflows validate the MIME type (`application/octet-stream` or `application/zip`) but do not decrypt IPAs themselves.

### Can I build with all tweaks enabled at once?

Yes. Set all Boolean inputs to `true` when triggering the workflow. The [`_build_tweaks.yml`](https://github.com/dayanch96/YTLite/blob/main/_build_tweaks.yml) helper will clone and compile each enabled repository in parallel where possible. Note that some tweaks may conflict; test thoroughly before distributing combined builds.

### What happens if a tweak fails to compile?

The [`_build_tweaks.yml`](https://github.com/dayanch96/YTLite/blob/main/_build_tweaks.yml) workflow runs `make clean package DEBUG=0 FINALPACKAGE=1` for each enabled tweak. If compilation fails, the entire job fails and the packaging step never runs. Check the Git Actions logs for the specific error—common issues include missing dependencies in the tweak's `Makefile` or Theos compatibility problems.

### How do I update an existing workflow with new tweak flags?

Follow the extension pattern: add the Boolean input to [`main.yml`](https://github.com/dayanch96/YTLite/blob/main/main.yml) and [`ytp_beta.yml`](https://github.com/dayanch96/YTLite/blob/main/ytp_beta.yml), pass it to [`_build_tweaks.yml`](https://github.com/dayanch96/YTLite/blob/main/_build_tweaks.yml), then add the conditional `git clone` and `make` block in the helper. No changes are needed to the packaging job since it automatically processes all `.deb` files in the `built-debs` artifact.