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

Use the workflow_dispatch trigger on main.yml or 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 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

Located at .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

Located at .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

Located at .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 and 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 only)
• tweak_url — Direct .deb URL (for 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 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) 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:

# 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 via the workflow_call directive:

# 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, 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:

   # 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:

# 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:

   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 when you need to test a tweak version not yet released, or a fork with custom modifications.

Example: Testing a Pull Request Build

# 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:

# 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 and ytp_beta.yml:

   enable_newtweak:
     description: "Add NewTweak (description)"
     type: boolean
     default: false

2. Pass to helper in the build-tweaks job:

   with:
     enable_newtweak: ${{ github.event.inputs.enable_newtweak }}

3. Implement in _build_tweaks.yml:

   on:
     workflow_call:
       inputs:
         enable_newtweak:
           type: boolean
           required: false

   And add the conditional clone/build:

   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 for stable releases (uses tweak_version), ytp_beta.yml for testing (uses tweak_url)
• Shared helper — _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 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 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 and ytp_beta.yml, pass it to _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.

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