Hey selfhosters!

I’m Priveetee, the creator of TypeType.

TypeType is an open-source, self-hostable video app for YouTube, NicoNico and BiliBili. No ads, no trackers, no sponsors, no recommendation feed. You run it on your server, and your watch data stays there.

Why it exists

I wanted to watch YouTube without ads and sponsors, so I tried Piped in 2024. It worked well for a while, then the bugs added up and the experience no longer fit what I wanted. I considered contributing upstream, but my vision for the app was too different. So I started TypeType instead.

That was a lot of testing, failed attempts and late nights. Today it is a small community project with more than 450+ stars on GitHub, a web app, an Android app and regular releases.

What it does

You get search, trending, channels, comments, playlists and subscriptions across the three services. Your history, subscriptions, playlists, favorites, watch progress and settings live in your own PostgreSQL. Change device, log in, and pick up where you left off.

There is also allow-list filtering. You can choose which channels and playlists are available for the whole instance or for specific users, which helps with family use.

TypeType is an ecosystem, not a YouTube frontend. The stack includes a Kotlin/Ktor server, PostgreSQL, Dragonfly, a media proxy, a token service and a downloader with Garage storage.

Self-hosting

The stack uses Docker and prebuilt images, so there is nothing to compile. The recommended install is one interactive command:

curl -fsSL https://raw.githubusercontent.com/TypeType-Video/TypeType/main/scripts/install-stack.sh | bash

The installer prepares the Compose files, generates the secrets, picks free ports when needed and sets up Garage so downloads work. It asks before pulling images and starting services. If you prefer to review everything first, there is a --download-only option and a manual Compose guide that explains each step.

One detail worth knowing: HOST_PORT_SERVER changes the port on your host, not inside the container. The server and its health check stay on 8080 internally.

Around 2 GB of RAM is comfortable for a small instance, and the first account you create becomes the admin. The app and frontend are MIT, while the server is GPL-3.0 because it uses PipePipeExtractor.

Why NicoNico and BiliBili

YouTube alone would have been simpler, but TypeType is built around PipePipeExtractor, and I spend a lot of time learning how PipePipe and its extractor work. NicoNico and BiliBili are part of what makes PipePipe different from NewPipe. Supporting them is my way of respecting that work and where the project comes from.

The community

TypeType stopped being just my project a while ago. People open issues, send PRs, test beta builds, translate the app and the docs, and share ideas. Some of the best parts of TypeType started that way. Huge thx to everyone involved, this thing is ours :)

Translations are always welcome. I could run them through AI, but I have no way to review the language-specific details, and I’d rather not ship a translation I can’t stand behind. So if you speak a language and want to help, it’s yours. Feedback is welcome too, good or bad.

Links

Quick Start: https://typetype-video.github.io/Docs-TypeType/self-hosting/quick-start
Manual Compose setup: https://typetype-video.github.io/Docs-TypeType/self-hosting/docker-compose
Configuration and ports: https://typetype-video.github.io/Docs-TypeType/self-hosting/configuration
Troubleshooting: https://typetype-video.github.io/Docs-TypeType/self-hosting/troubleshooting
Translations: https://translate.typetype.video/engage/typetype/
Source code: https://github.com/TypeType-Video/TypeType
PipePipeExtractor: https://github.com/TypeType-Video/PipePipeExtractor
Experiment instance: https://experiment.typetype.video/

AI use disclosure

• Implementation: 70% Generated
• Testing: 60% Pair
• Documentation: 60% Pair, the rest by me and the community
• Review: 70% Pair
• Design: 0%
• Deployment: 0%

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.

Source code: https://github.com/TypeType-Video/TypeType

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: https://priveetee.github.io/Docs-PipePipe/developer-guide/introduction.html

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: https://github.com/TypeType-Video/TypeType/blob/dev/AI_TRANSPARENCY.md

Links:

Source code: https://github.com/TypeType-Video/TypeType

1.9.0 release notes: https://github.com/TypeType-Video/TypeType/releases/tag/v1.9.0

Android client: https://github.com/TypeType-Video/TypeType-Android

Playback engine: https://github.com/TypeType-Video/TypeType-Player

Self-hosting docs: https://typetype-video.github.io/Docs-TypeType/self-hosting/introduction

Extractor: https://github.com/InfinityLoop1308/PipePipeExtractor

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: https://translate.typetype.video/engage/typetype/

If you want to follow the project, there’s also a community here on Lemmy: https://lemmy.zip/c/TypeType

Thanks for reading :)