Hey everyone!
I’d like to introduce TypeType, because I don’t think many people here have seen it yet.
TypeType is an open-source, self-hostable video app for YouTube, NicoNico and BiliBili. You run one private instance, then use it from the web app or from the native Android client. Your accounts, subscriptions, history, playlists, favorites, watch progress and settings stay on the instance you control, instead of living only inside the platforms.
IF YOU DONT WANT TO READ ALL THE POST (and that’s alright no worries), HERE IS A TLDR !
TL;DR: TypeType is an open-source, self-hostable video app for YouTube, NicoNico and BiliBili, with a web app and a native Android client. It’s built on PipePipeExtractor with its own MSE/SABR playback engine. You can import and export your data with a dozen other apps, no lock-in. 1.9.0 is out, focused on playback reliability. Contributions are welcome, in code, translations or testing.
Some background, because TypeType didn’t come out of nowhere
If you’ve been around open-source YouTube tooling for a while, you probably know the family tree. NewPipe is the libre Android streaming front-end, and NewPipeExtractor is the library that does the extraction behind it. PipePipe is a hard fork of NewPipe started in early 2022, and it also handles other services, including NicoNico and BiliBili, with its own extractor, PipePipeExtractor.
Then there’s the self-hosted side. Piped and Invidious are the two big alternative frontends, both AGPL, one built around Vue with its own backend, the other written in Crystal. LibreTube is an Android client that supports YouTube content, and it can use Piped for optional account sync. Those projects are the ones that showed a lot of people that running your own YouTube frontend was even possible.
Before TypeType, I had spent years around PipePipe, and that’s really where the project comes from.
The SABR part
My main work this year was on SABR, the protocol YouTube moved to after cutting the older methods used to fetch streams. I started with a proof of concept, the support landed in PipePipeExtractor, and then came the harder parts: live streams, cold start, session recovery, memory growth from segment buffers. I also maintain the PipePipe wiki and wrote the SABR guide there.
That work is really why TypeType exists in its current form. Once the extraction and the session logic are yours, you can build an app that owns the entire chain, instead of relying on someone else’s frontend.
What TypeType is in practice
On the web side you get multi-service search, personal libraries, downloads, comments, subtitles, SponsorBlock, administration, and SABR playback in the browser. The Android client adds background audio, Picture in Picture, audio-only playback, native playback controls and notifications, and it works from Android 6.0 without Google Play Services. The web app and the Android app share the same account and the same library, because they talk to the same instance.
One thing I’m quietly proud of is the portability. It works in both directions. You can import and export across TypeType, PipePipe, NewPipe, Invidious, Piped, LibreTube, ViewTube, Materialious, youtube-local, Flow, SkyTube, Grayjay, YouTube Takeout and even OPML, and that covers subscriptions, history, playlists, favorites, watch progress, settings and more.
And to be clear, there’s no competition here. I genuinely don’t care if you leave and use something else. The point is that your data is yours, so you can come from another project without starting over, and leave with it too if you want.
How it works
TypeType is several services rather than one big blob.
The core is a Kotlin/Ktor server. It wraps PipePipeExtractor for the extraction side: streams, manifests, search, suggestions, trending, comments and channels. It also owns the user data, accounts, subscriptions, playlists, favorites, progress, imports and administration, stored in PostgreSQL with Dragonfly as cache.
Next to it, a TypeScript token service handles the YouTube specifics: visitor data, BotGuard challenges, Proof-of-Origin tokens, player signature decoding, and the WEB and MWEB SABR session metadata. Player decoding stays on our own service path, we don’t rely on third-party decoder endpoints.
For downloads, there’s a separate Go service. It takes jobs from the server, downloads the selected streams with concurrent HTTP Range requests or SABR segments, and muxes audio and video without re-encoding, then publishes the artifact to local or S3-compatible storage. No yt-dlp wrapper under the hood.
On the client side, a React and TypeScript web app handles the interface and the library, and playback goes through our own MSE engine, TypeType-Player. It’s written in TypeScript, has no runtime dependencies, and is published on npm and JSR as @typetype/mse.
So the chain is: client asks the server, the server extracts through PipePipeExtractor, the token service supplies what YouTube requires, and the player turns the resulting session into audio and video.
What we built on top
The extraction engine does the hard part, and I credit it every time, because TypeType would not exist without it. But the project is a lot more than a wrapper now: SABR playback sessions with recovery and bounded buffers, opaque media handles, a custom MSE engine, multi-service search, personal libraries, RSS feeds, profiles, notification delivery, downloads and muxing, portability across a dozen apps, OIDC and instance administration.
Around it there are separate repositories: the React web client, the MSE/SABR playback engine, the Go downloader, and the token service. Licenses vary per component: the server is GPLv3 because of the PipePipeExtractor integration, the downloader is GPL-3.0-or-later, and the rest is MIT.
1.9.0 is out
Most of this release is about making playback more dependable rather than adding new screens. YouTube web playback is now SABR-only, and recoverable live requests stay inside the active playback session instead of leaving playback stuck. There’s also work on Takeout imports, subscription groups on desktop, and the self-hosting documentation.
Honestly, the part I’m the most proud of is that this is not a one-person project anymore. Several people sent PRs for this release, on subscription groups, playback and character encoding. That’s still new to me and it makes me really happy :)
And the community around TypeType is something I did not expect. There are amazing people who test builds, report bugs with real details, help with translations, answer each other, and just hang around. It’s warm, it’s genuinely helpful, and I will never thank them enough.
We also published an AI transparency statement, explaining how AI is used in the project and what we expect from contributions.
Links:
Contributions are welcome, whatever part of the stack interests you: Kotlin/Ktor on the server, the React web client, the TypeScript playback engine, the Go downloader, or the Android app.
And you don’t even need to write code. Translations are handled on Weblate, so if you want to help translate TypeType into your language, you can do it right there.
If you want to follow the project, there’s also a community here on Lemmy.
Thanks for reading :)