GitHub Vita Lite - Wolff's Store
Code / README | Releases | Issues
WolffsRoom/YouTubeOnVita

README.md

25646 bytes · Original / download

Logo YouTube On PSVita

_Unofficial client for PS Vita_ **The real YouTube on TV experience, brought to PlayStation Vita through Cobalt.** [![Status](https://img.shields.io/badge/STATUS-WORK%20IN%20PROGRESS-f0ad4e?style=for-the-badge)](#project-status) [![Platform](https://img.shields.io/badge/PLATFORM-PS%20VITA-006fcd?style=for-the-badge&logo=playstation&logoColor=white)](#overview) [![Engine](https://img.shields.io/badge/ENGINE-COBALT%20%2B%20STARBOARD-455a64?style=for-the-badge)](#how-it-works) [![Build](https://img.shields.io/badge/BUILD-v0.28%20EXPERIMENTAL-ea4335?style=for-the-badge)](#project-status) *An independent homebrew project by [WolffsRoom](https://github.com/WolffsRoom).*
*Not affiliated with Google, YouTube, or Sony.*

[!IMPORTANT] YouTubeOnVita is experimental and not ready for a public stable release. The official YouTube on TV interface runs inside Cobalt on Vita3K and on a physical PS Vita, and video playback with audio works in Vita3K. Performance, sound quality and hardware video playback are still being validated.

This is not a custom YouTube lookalike. The objective is to execute the actual YouTube on TV web application on the Vita, not to reproduce its appearance with a separate handmade UI.


Overview - [What Is YouTubeOnVita?](#overview) - [Project Status](#project-status) - [Features and Compatibility](#features-and-compatibility) - [Controls](#controls) - [Screenshots and Demonstrations](#screenshots-and-demonstrations)
Development - [How It Works](#how-it-works) - [Technical Milestones](#technical-milestones) - [Video and Audio](#video-and-audio) - [Known Issues and Limitations](#known-issues-and-limitations) - [Building and Testing](#building-and-testing) - [Project Structure](#project-structure) - [Development History](#development-history) - [Roadmap](#roadmap) - [Credits and Disclaimer](#credits-and-disclaimer)

Overview

YouTubeOnVita is an ongoing project to bring the actual YouTube on TV application to the PlayStation Vita. Rather than developing a third-party interface that merely resembles YouTube, the project adapts Google Cobalt, its Starboard platform layer, and the console's native services so that the TV application itself can run on Vita hardware.

The goal is a console-style experience comparable in concept to YouTube on smart TVs, PlayStation consoles, and Nintendo Switch: browse YouTube, navigate with physical controls or touch, sign in where supported, and watch videos directly on the Vita's 960 × 544 display.

The original handmade UI prototype (legacy/native-mock-v001/) was retained as an early experiment, not as the basis of the final client.

Project Status

![Current development state](https://img.shields.io/badge/DEVELOPMENT-ACTIVE-orange?style=flat-square) ![Latest local milestone](https://img.shields.io/badge/LOCAL%20MILESTONE-v0.28-blue?style=flat-square) ![Hardware verification](https://img.shields.io/badge/REAL%20HARDWARE-PARTIAL%20TESTING-yellow?style=flat-square)

Development snapshot: November 17, 2026. The details below describe results observed in the development tree, mainly through Vita3K; they do not imply that a release with those features has been published.

Component Current state Notes
Cobalt Evergreen / Starboard Running Official ARM32 Cobalt runtime starts and processes events through the Vita port, in Vita3K and on hardware.
YouTube on TV interface Running Genuine TV frontend, onboarding, menus, thumbnails, search and category screens.
Networking and HTTPS Working TLS connections and YouTube resources.
D-pad and buttons Working Navigation, selection and player controls.
Front touchscreen Working on hardware Tap = click, swipe = D-pad steps, two-finger tap = Back.
Player controls Working in Vita3K Overlay, pause/resume, captions (CC), next-video shelf. Playback speed other than 1x is not supported.
H.264 video playback Working in Vita3K 240p to 720p (up to 60 fps advertised), zero-copy frames; hardware playback under validation.
AAC audio playback Working in Vita3K Hardware sound quality still under validation.
Sign-in persistence Fixed in v0.25 Cobalt's storage record is now written; needs more hardware confirmation.
Microphone input Basic capture tested Voice search end-to-end not confirmed.
Physical Vita performance Improving v0.25-v0.26 removed busy-waiting threads and a kernel-object leak that froze the app.
Public stable VPK Not available Current builds are development/testing packages.

[!NOTE] The site and features exposed by YouTube are controlled by Google's service. Some TV interfaces and account flows may depend on device compatibility, identification or certification. YouTubeOnVita is not a certified YouTube device or official Google client. Service-side changes may affect operation at any time.


Features and Compatibility

Implemented or demonstrated

Planned or not yet verified end-to-end

Controls

YouTubeOnVita forwards the PS Vita's native inputs to Starboard. The YouTube TV application decides how to interpret them in each screen.

Vita control Input sent to Cobalt Typical use
D-pad Directional gamepad keys Navigate menus, rows and focus
Cross (×) Gamepad primary button Select / confirm
Circle (○) Gamepad secondary button Back / dismiss, where supported
Square (□) Gamepad button 3 Application-dependent
Triangle (△) Gamepad button 4 Application-dependent
L / R Gamepad shoulder buttons Application-dependent
Start / Select Gamepad auxiliary buttons Application-dependent
Front touchscreen: tap Pointer click Select the element under the finger
Front touchscreen: swipe D-pad steps (72 px each) Scroll rows and menus; content follows the finger
Front touchscreen: two fingers Circle (Back) Go back

Note: These are mappings, not a guarantee that every button already has a dedicated YouTube function. Analog-stick behavior is not implemented.

Screenshots and Demonstrations

The current development build has produced real frames from the Cobalt-rendered YouTube TV interface in Vita3K, including onboarding, category navigation and video playback.

A normal Windows screen capture of Vita3K's OpenGL window previously showed a white image even while the guest had rendered content. Development captures therefore use an OpenGL SwapBuffers/glReadPixels capture path to inspect the actual framebuffer. This fixes the recording method; it should not be mistaken for a PS Vita graphics fix.

[!NOTE] Screenshots and GIFs from the actual project will be added here after they are reviewed. This README intentionally contains no mockups, simulated YouTube screenshots, or nonexistent media links.


How It Works

Cobalt is not Chromium. It is a Google-developed runtime for HTML5-based applications on televisions, streaming devices and game consoles. It uses technologies such as the V8 JavaScript engine and Skia, but it is not a full desktop browser with tabs and a general-purpose Chromium feature set.

The Vita port provides the Starboard implementation required to connect Cobalt to the console's operating system and hardware.

                YouTube on TV web application
                  (HTML / CSS / JavaScript)
                             |
                      Cobalt Evergreen
                   (V8 / Skia / web runtime)
                             |
                       Starboard 15
                        PS Vita port
            +----------------+----------------+
            |                |                |
        VitaGL / GXM    Network / TLS   Input / Files
            |                |                |
         SceGxm         Vita network     SceCtrl / Touch
            |
        SbPlayer / native media
            |
       SceAvcdec + SceAudiodec
            |
                     PlayStation Vita

Native runtime and loader

The project includes an experimental ARM32 loader for the matching Cobalt Evergreen 5.50.2 / Starboard 15 binary. It performs segment loading, relocation, external symbol resolution, executable-memory protection, C++ static initialization and dispatch of Cobalt's native event entry point.

This is more than a static webpage wrapper: Cobalt runs application code and communicates with native Vita interfaces through Starboard. It is also not a port of the entire Chromium browser.

Graphics

The graphics implementation connects Cobalt's EGL/GLES expectations to VitaGL and the Vita graphics stack. It supplies the EGL interfaces required by the browser, translates missing GLES behavior where possible, and manages shader compilation and caching. The port has been tested rendering YouTube interface elements, thumbnails and video frames in Vita3K.

Identity and service compatibility

During development, a console-compatible device identity was used to evaluate whether YouTube would serve the TV interface. The project does not contain Google's certification keys or claim to be an officially certified device. Service compatibility is not guaranteed; device restrictions, login policies and video availability may change independently of this project.


Technical Milestones

The following tests describe separate capabilities. They are not all equivalent to a fully working client.

Milestone Result / evidence
ARM32 Cobalt ELF loading Dynamic relocations and 74 static C++ constructors validated in Vita3K.
Starboard backend Native filesystem, networking, event scheduling, synchronization, input and platform services tested.
EGL / GLES bridge Browser's EGL display, surface, context, shader compilation and presentation implemented.
Browser startup SbEventHandle(Start) returns, followed by event-loop processing.
Official frontend YouTube TV onboarding, menu focus, thumbnail rows and category screens rendered in Vita3K.
Touch input Front-screen taps demonstrated on the onboarding screen.
Local H.264 baseline test 60 hardware-decoded frames extracted from a synthetic MP4 test video.
Integrated YouTube playback Experimental SbPlayer validated with H.264/AAC content in Vita3K.
v0.22 AAC fix The audio clock advanced to 19.06 s, end-of-stream was reported, and autoplay advanced to the next video in the recorded test.
Automated regression Latest documented run: 193/193 Starboard tests passing.

The tests and their reports can be found locally in experiments/cobalt/vita/ and the scripts in tools/. Results may differ on actual hardware.

Video and Audio

Video

Cobalt's media pipeline provides encoded elementary samples, not a ready-to-play MP4 file. SbPlayer therefore interfaces with the Vita decoders directly:

YouTube media stream / Cobalt MSE
                |
      SbPlayerWriteSamples
                |
       SceAvcdec (H.264)
                |
        Planar YUV420 video
                |
   GXM linear textures (zero copy)
                |
       Cobalt video surface

The media policy advertises H.264 Baseline/Main/High from 240p to 720p, up to 60 FPS. The Vita's AVC decoder accepts at most 1280 × 720 pixels for game applications; 1080p needs the non-game decoder entry points and is only offered when the system accepts them and memory allows. Invalid probe attributes sent by YouTube (unknown EOTF, tunnel mode, absurd bitrates) are refused, as in the reference Starboard implementation. VP9, AV1, Opus and DRM-protected playback are not implemented.

Audio

AAC-LC samples are decoded through SceAudiodec and sent to the Vita audio output system. v0.22 fixed a double-ADTS-header issue (Cobalt already delivers ADTS frames) that left the decoder silent and stalled the audio-driven clock. The interface sound sink pre-buffers ~85 ms before playing and after running dry, instead of alternating data with silence.

Audio behavior on physical Vita hardware requires further validation. Earlier tests reported distortion and underruns during high CPU usage; improvements to buffering and feeder scheduling have been made, but they do not yet establish stable playback on every device.

Microphone

Basic microphone capture has been implemented via sceAudioIn (mono, 16 kHz). The input path was tested separately; voice search from the official YouTube UI has not been validated end-to-end.


Known Issues and Limitations

[!WARNING] Development builds may freeze, exit unexpectedly, consume substantial memory, or produce distorted audio. They are intended for debugging and should not be presented as stable YouTube installations.

Building and Testing

For developers only. This is not yet an end-user installation guide. A full build requires VitaSDK, Docker, the appropriate Cobalt Evergreen source/binary and supporting assets available in the local development environment. Not all third-party or service-owned runtime components can be redistributed with a public repository.

Prerequisites

Local build

From the local project root, in PowerShell:

# Build the current experimental Cobalt target and supporting tests.
docker run --rm `
  -v "${PWD}:/src" `
  -w /src `
  -e VITASDK=/usr/local/vitasdk `
  vitasdk/vitasdk:latest `
  sh -lc 'cmake -S . -B build-starboard15 -DYTV_BUILD_SW_H264_PROBE=OFF && cmake --build build-starboard15 -j8'

With the currently configured local build, the experimental Cobalt package is produced at:

build-starboard15/CobaltNativeBootstrapTest.vpk

Released test packages are copied to current/ (YouTubeVita_vX.YY.vpk), with older ones in current/anteriores/. VPKs are not committed to the repository.

Third-party sources (kubridge, so_util, vitaGL at the pinned commit, MinHook) are git submodules: clone with git clone --recursive or run git submodule update --init. The Cobalt Evergreen binary (libcobalt.so, .crx) and the Cobalt source reference (experiments/cobalt/upstream-25) are not committed.

The development title ID is YTVCB0001. The title name, version and filename are development identifiers; they are not a public release contract. The CMakeLists.txt currently also includes multiple isolated graphics, networking, relocation and decoder test targets.

Run tests in Vita3K

.\tools\test_starboard_vita3k.ps1
.\tools\test_relocations_vita3k.ps1
.\tools\test_avplayer_vita3k.ps1

# Requires the experimental title to have been installed in Vita3K first.
.\tools\test_cobalt_boot_vita3k.ps1 -Seconds 90

The boot runner records diagnostic logs in timestamped tools/capture/cobalt-boot-*/ directories and supports optional frame and audio capture. Check its actual parameters and dependencies before use. It is intended to manage only the test session it starts.

Device logs and diagnostics

The Vita-side diagnostic directory is:

ux0:data/youtubevita/

Relevant files include cobalt_boot.log, starboard15.log, decoder/player logs, and optional developer configuration files. The project also provides startup tracing, event/input scripts, performance profiling and image/audio capture utilities. Some instrumentation is enabled only in explicit diagnostic builds.


Project Structure

YouTubeVita/                         Local source workspace name
├── assets/
│   ├── livearea/                   LiveArea resources (bg0, startup gate, icon)
│   └── shader_cache_seed/          Precompiled VitaGL shaders
├── experiments/cobalt/
│   ├── evergreen/                  Official Evergreen package research/staging
│   ├── upstream-25/                Cobalt source reference
│   └── vita/
│       ├── port_*.cpp              Starboard Vita implementations
│       ├── platform15.cpp          Platform services and logging
│       ├── import_lookup.cpp       Cobalt import resolution
│       ├── relocate_elf.c          ARM ELF bootstrap and diagnostics
│       └── COBALT_BOOT_STATUS_2026-11-17b.md
├── third_party/                    Third-party source/build dependencies
├── tools/                          Tests, capture and staging utilities
├── legacy/native-mock-v001/        Archived handwritten UI prototype
├── build-starboard15/             Local build output (not committed)
├── current/                        Released test VPKs (not committed)
└── CMakeLists.txt

The eventual repository/release layout may be simplified. Build artifacts, captured sessions, licensed binaries and local toolchains should not automatically be committed to the public repository.

Development History

Version / milestone Highlights
v0.01 — Prototype Early handmade UI experiment, later archived in favor of the real YouTube on TV frontend.
Starboard foundation ARM ELF loader, native filesystem/network, event loop, graphics, audio and memory interfaces.
Cobalt bootstrap Official runtime constructors and SbEventHandle(Start) operational in Vita3K.
Real UI milestone YouTube TV onboarding and navigation rendered through Cobalt; OpenGL framebuffer capture validated.
v0.18 — Navigation Physical controls and real category/menu navigation in Vita3K.
v0.19 — Hardware feedback Touch input, audio feeder changes, extended-memory mode and performance improvements following early PS Vita tests.
v0.20 — Runtime optimizations V8 JIT enabled, cache management, updated playback/audio buffering and profiling.
v0.21 — Native media SbPlayer H.264/AAC integration, microphone capture and precompiled shader cache.
v0.22 — AAC fix Fix for AAC ADTS handling; media clock, end-of-stream and autoplay validated in Vita3K.
v0.23 — Resolutions and touch Zero-copy video, decoder capacity tiers up to 720p (1080p via the non-game decoder when allowed), touch gestures, stricter codec policy.
v0.24 — Hardware crash fix Threads that use pthread primitives are created through pthreads (a raw kernel thread crashed inside pthread-embedded).
v0.25 — CPU and sign-in Native wait primitives (no 500 µs polling), microsecond epoll timeouts with a loopback wake socket, storage record names fixed (sign-in persisted), audio pre-buffering.
v0.26 — Freeze fix Futex-style mutex/condition variables with a fixed parking lot (no kernel object per lock); video decoder initialised within the game limit.
v0.27–v0.28 — LiveArea New LiveArea assets; packaging no longer leaks files from other test VPKs; valid "a1" template with bg0/startup.

Dates, names and version numbers above describe local development milestones, not a public release history.

Roadmap


Credits and Disclaimer

Development: WolffsRoom

This project builds on work by the developers and contributors of:

Additional third-party notices and applicable licenses must be kept alongside the respective components. See the project's LICENSES.md and individual dependency licenses. Do not infer a license for the entire repository from the presence of third-party code; upstream components retain their own licenses, and redistribution of proprietary binaries or branded resources requires the relevant rights.

YouTube, the YouTube logo, Google, PlayStation, and PS Vita are trademarks of their respective owners. YouTubeOnVita is an unofficial, independent homebrew project, with no affiliation, sponsorship, approval, or certification by Google/YouTube or Sony Interactive Entertainment.

Use this project responsibly and in accordance with the applicable service terms, software licenses and local law.


**YouTubeOnVita** *Unofficial client for PS Vita* *Real TV frontend. Native Vita integration. Work in progress.*