# How to Customize YouTube Shorts with YTLite: Complete Guide to Shorts Tweaks

> Customize YouTube Shorts with YTLite on iOS! Explore 15+ toggles for playback, UI, and feed behavior. Get the complete guide to Shorts tweaks and enhance your viewing experience.

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

---

**YTLite provides 15+ dedicated toggles to control YouTube Shorts playback, UI elements, and feed behavior on iOS, all accessible through the Shorts section in its Settings UI.**

If you want granular control over how YouTube Shorts work on your jailbroken iOS device, YTLite offers one of the most comprehensive tweak suites available. The open-source project at `dayanch96/YTLite` exposes every Shorts customization through a clean settings interface backed by robust method hooking in the core implementation.

## Shorts-Only Mode: Lock YouTube to Shorts Playback

The **Shorts-only mode** transforms your entire YouTube experience into a dedicated Shorts player. When enabled, the app restricts navigation to Shorts content exclusively.

Enable this mode in `Settings.x` through the toggle:

```objc
[self switchWithTitle:@"ShortsOnlyMode" localizerKey:@"SHORTS_ONLY_MODE" defaultValue:NO selector:@selector(toggleShortsOnlyMode:)]

```

*[Source: Settings.x lines 42-44](https://github.com/dayanch96/YTLite/blob/main/Settings.x#L42-L44)*

### Emergency Exit: Two-Finger Long-Press

YTLite builds in a safety mechanism. If you need to escape Shorts-only mode without digging through settings, perform a **two-finger long-press** on any Shorts player for 0.5 seconds.

The handler lives in `YTLite.x`:

```objc
- (void)turnShortsOnlyModeOff:(UILongPressGestureRecognizer *)gesture {
    if (gesture.state == UIGestureRecognizerStateBegan) {
        ytlSetBool(NO, @"shortsOnlyMode");
        // Notify user via banner
    }
}

```

*[Source: YTLite.x lines 49-56](https://github.com/dayanch96/YTLite/blob/main/YTLite.x#L49-L56)*

## Auto-Skip Shorts: Hands-Free Playback

Enable **auto-skip Shorts** to eliminate the tap requirement between videos. When active, YouTube automatically advances to the next Short when the current one ends.

Toggle this in `Settings.x`:

```objc
[self switchWithTitle:@"AutoSkipShorts" localizerKey:@"AUTO_SKIP_SHORTS" defaultValue:NO selector:@selector(toggleAutoSkipShorts:)]

```

*[Source: Settings.x lines 43-44](https://github.com/dayanch96/YTLite/blob/main/Settings.x#L43-L44)*

The actual skip logic delegates to YouTube's native player controls; YTLite simply enables the underlying auto-advance flag through the stored boolean.

## Hide Shorts from Feeds: Clean Home and Subscriptions

The **Hide Shorts** option removes Shorts rows from your Home feed, Subscriptions tab, and other browse surfaces while preserving regular video content.

Enable this feed-level filter:

```objc
[self switchWithTitle:@"HideShorts" localizerKey:@"HIDE_SHORTS" defaultValue:NO selector:@selector(toggleHideShorts:)]

```

*[Source: Settings.x lines 44-45](https://github.com/dayanch96/YTLite/blob/main/Settings.x#L44-L45)*

The implementation hooks into YouTube's feed rendering pipeline, inspecting content types and suppressing items marked as Shorts before they reach the UI layer.

## Shorts Progress Bar: Visual Playback Indicator

Add a **progress bar to Shorts** to see exactly where you are in a video. This mimics the standard YouTube player experience that's normally hidden in the Shorts interface.

Enable this overlay:

```objc
[self switchWithTitle:@"ShortsProgress" localizerKey:@"SHORTS_PROGRESS" defaultValue:NO selector:@selector(toggleShortsProgress:)]

```

*[Source: Settings.x lines 45-46](https://github.com/dayanch96/YTLite/blob/main/Settings.x#L45-L46)*

The rendering logic in `YTLite.x` manages overlay visibility through an `isOverlayShown` flag:

```objc
static BOOL isOverlayShown = NO;

// Later in the hook:
self.playbackOverlay.alpha = isOverlayShown ? 1.0 : 0.0;

```

*[Source: YTLite.x lines 3-6, 38-40](https://github.com/dayanch96/YTLite/blob/main/YTLite.x#L3-L6)*

## Pinch-to-Fullscreen Shorts: Gesture Expansion

**Pinch-to-fullscreen Shorts** lets you expand any Short to true fullscreen with a pinch gesture, then pinch back to restore the normal overlay layout.

This gesture hook lives in `YTLite.x`:

```objc
%hook YTPlayerView
- (void)didPinch:(UIPinchGestureRecognizer *)gesture {
    %orig;
    if (ytlBool(@"pinchToFullscreenShorts") &&
        [self.playerViewDelegate.parentViewController isKindOfClass:NSClassFromString(@"YTShortsPlayerViewController")]) {
        // Expand or collapse overlay based on pinch scale
        // Implementation details in YTLite.x lines 15-28
    }
}
%end

```

*[Source: YTLite.x lines 9-30](https://github.com/dayanch96/YTLite/blob/main/YTLite.x#L9-L30)*

The toggle for this behavior appears in `Settings.x` at line 46 as `pinchToFullscreenShorts`.

## Convert Shorts to Regular Videos

The **Shorts to regular video** option transforms Shorts links into standard YouTube video playback. This gives you the full player interface with playback speed controls, quality selection, and standard timeline scrubbing.

Enable this conversion:

```objc
[self switchWithTitle:@"ShortsToRegular" localizerKey:@"SHORTS_TO_REGULAR" defaultValue:NO selector:@selector(toggleShortsToRegular:)]

```

*[Source: Settings.x lines 46-48](https://github.com/dayanch96/YTLite/blob/main/Settings.x#L46-L48)*

The implementation hooks URL navigation, intercepting `/shorts/` URLs and rewriting them to `/watch?v=` format before the player loads.

## Granular UI Element Hiding

YTLite provides **individual toggles for every Shorts UI component**, letting you strip the interface down to pure video content.

Each element has its own switch in `Settings.x` (lines 49-64):

| UI Element | Settings Key | Line Reference |
|------------|-----------|--------------|
| YouTube logo overlay | `HideShortsLogo` | 49 |
| Search button | `HideShortsSearch` | 50 |
| Camera/upload button | `HideShortsCamera` | 51 |
| More options (⋮) | `HideShortsMore` | 52 |
| Like button | `HideShortsLike` | 53 |
| Dislike button | `HideShortsDislike` | 54 |
| Comments button | `HideShortsComments` | 55 |
| Share button | `HideShortsShare` | 56 |
| Remix button | `HideShortsRemix` | 57 |
| Channel subscription | `HideShortsSubscribe` | 58 |
| Video title | `HideShortsTitle` | 59 |
| Description | `HideShortsDescription` | 60 |
| Channel avatar | `HideShortsAvatar` | 61 |
| Audio track info | `HideShortsAudioTrack` | 64 |

The corresponding hooks in `YTLite.x` read these boolean values and hide views by setting `alpha = 0` or removing them from the view hierarchy entirely.

## Programmatic Control: Using YTLite's Preference API

For developers building companion tweaks or automation scripts, YTLite exposes a clean **preference API** through `YTLUserDefaults.m`.

Read a Shorts setting:

```objc
BOOL shortsOnly = ytlBool(@"shortsOnlyMode");
BOOL autoSkip = ytlBool(@"autoSkipShorts");
BOOL progressBar = ytlBool(@"shortsProgress");

```

Write a Shorts setting:

```objc
// Enable Shorts-only mode programmatically
ytlSetBool(YES, @"shortsOnlyMode");

// Disable auto-skip
ytlSetBool(NO, @"autoSkipShorts");

// Show progress bar
ytlSetBool(YES, @"shortsProgress");

```

*[Source: YTLUserDefaults.m](https://github.com/dayanch96/YTLite/blob/main/Utils/YTLUserDefaults.m)*

## Summary

YTLite provides **comprehensive YouTube Shorts customization** through:

- **Playback modes**: Shorts-only lock with gesture exit, auto-skip, and regular-video conversion
- **Visual enhancements**: Progress bar overlay and pinch-to-fullscreen gestures
- **Feed management**: Hide all Shorts from Home and Subscriptions
- **Surgical UI hiding**: 16 individual toggles for buttons, text, and overlays
- **Programmable API**: `ytlBool`/`ytlSetBool` for external automation

All settings persist through `YTLUserDefaults` and apply instantly via CaptainHook method swizzling in `YTLite.x` and `Settings.x`.

## Frequently Asked Questions

### Does YTLite require a jailbroken device to customize Shorts?

Yes, YTLite is a **tweak for jailbroken iOS devices** that modifies the YouTube app through dynamic code injection. It requires a compatible jailbreak with substrate or substitute support to hook into YouTube's native classes.

### Can I use YTLite's Shorts features on the YouTube app from the App Store?

No, you cannot apply YTLite to a stock App Store YouTube installation. The tweak must be **injected into a decrypted YouTube IPA** or installed through a package manager like Cydia, Sileo, or Zebra on a jailbroken device where the YouTube app can be modified at runtime.

### Will enabling Shorts-only mode break other YouTube features?

Shorts-only mode **restricts navigation to Shorts content only**, but it does not damage the underlying app. The two-finger long-press gesture provides an immediate escape hatch, or you can disable the mode through Settings. Regular video functionality returns fully once the toggle is off.

### How do I contribute new Shorts customization features to YTLite?

YTLite is open-source under the MIT license. To add new Shorts features, fork the repository, implement your hooks in `YTLite.x` following the existing `%hook` patterns, add corresponding UI toggles in `Settings.x`, and submit a pull request. The project uses CaptainHook for method swizzling and standard iOS preference APIs for persistence.