SmartTwitchTV: a Twitch client built as a web app plus an APK

The gap the official Twitch app leaves on a television

The reason the project exists is stated in one sentence in the README: it is a web application designed to give access to Twitch features on Smart TVs, because the official Twitch app is not available for most devices. The intention behind it is a web app that works on all modern browsers and can be easily ported to any operating system that can run a web app. That portability goal is the design constraint that explains the rest of the repository. The author is explicit that the app has no affiliation with Twitch, that it is a user made app, and that it is only possible because Twitch provides the APIs that allow it to show Twitch content, with the developer documentation and the registration process both linked. The two things you inherit by using it are therefore clear: a third party application with no support commitment from the platform, and a dependency on the documented Twitch API surface that the project keeps up with as that surface changes. The audience is a viewer, not a developer, but the project is also a working example of a hybrid app structure, which is the part most worth understanding before deciding whether to run it.

Two halves: the web app and the Android APK

The application is split into two parts, and the split is the architecture. The web app is a web page containing the user interface and most of the app logic, and it is published at the fgl27 GitHub Pages address, where the README links to it as the access point. The APK holds two main views. One is the WebView, the view that loads the web app page. The other is the PlayerActivity, described as the main app activity and the activity that holds the app players and the web UI, and the APK additionally handles the Android specific interactions the app needs to make everything work. So the split of responsibility is: the web app owns the interface, the routing, and the Twitch API calls, while the native side owns the video player, the remote control key events, and the device integration that a browser cannot offer. The repository layout mirrors this, with an app directory for the web code, an apk directory for the Android project, a release directory for what is published, and separate jsonreferences and screenshot directories. It is a design worth borrowing for any hybrid project: the part that changes often stays in the web layer where it can be updated without shipping a new binary.

The OS interface and the JavascriptInterface bridge

The two halves talk to each other through what the README calls an OS interface, and this is the mechanism to understand if you ever want to modify the app. The web app calls the native side through the functions in app/specific/OSInterface.js. Each of those functions has a mirror function on the Java side, and those Java functions are annotated with JavascriptInterface in PlayerActivity, which uses a class named public class WebAppInterface to hold all of them. The direction back is the other way round: the APK calls into the web app with a loadUrl of javascript:smartTwitchTV.FUN_NAME(), where the function name has to be one of the functions exposed by the app API in release/api.js.

WebView.loadUrl("javascript:smartTwitchTV.FUN_NAME()")

The README is candid that this looks complicated until you have seen it, and it is right that the process is technically simple. A JavaScript function calls into Java, Java can call back into a JavaScript function, and both sides keep their own half of the logic. The cost of that simplicity is coupling: the two sides have to agree on names, and a function renamed on one side breaks the other silently until something on screen stops working. It is also the reason the project keeps the web app and the APK in step, which is why the release directory and the app directory are updated together.

Where the pieces come from, and how the web app is served

There is no package to install for the web app. It is a page served from a GitHub Pages address, and the README links to the release index.html as the entry point, so the fastest way to see the application is to open that page in a browser. The APK is the part you install on a television, and the README has a Download section for it, along with sections on how to build the web app for JavaScript, HTML and CSS and how to build the APK. The repository carries the build tooling for that web layer in package.json, and the dependency list is small and tells you the approach.

  "dependencies": {
    "crass": "^0.12.3",
    "firebase": "^12.8.0",
    "html-minifier": "^4.0.0",
    "jshint": "^2.13.6",
    "prettier": "^3.8.1",
    "shelljs": "^0.10.0",
    "uglify-js": "^3.19.3"
  }

Styles are written in CSS and minified with crass, the HTML is minified with html-minifier and the scripts with uglify-js, jshint and prettier cover linting and formatting, and shelljs drives the build from the command line. Firebase is present, and the repository has firebase.json and a.firebaserc, so hosting the built web app is part of the flow. The separation into two repositories is explained in the README: the smarttv-twitch repository was the original, and separate repositories make it easier to use GitHub Pages and keep the commit history separated.

The Tizen sibling and the fork lineage

The project is a fork, and the README is straightforward about the ancestry. It was initially forked from the tizen branch of CazuzaCzz's SmartTwitchTV, which was itself forked from nikitakatchik's SmartTwitchTV. The author kept the original name and commit history but stopped calling it a fork, because the number of changes made it a new application in practice, built from scratch with a focus on performance and on covering the available Twitch features. The reason for the fork was practical: the earlier repositories did not support the author's television model and did not have all the Twitch features, and at that point the app was a Samsung Tizen project. That lineage still shapes the repository. The original project runs on Samsung Tizen OS, which the README describes as very limited, and because of that the Android version became the main project. The consequence is stated directly: not all features of the Android project can be ported to the Samsung one, although features are ported from the Android version to the Tizen version from time to time. So the two projects are siblings rather than mirrors, and a reader has to know which platform a feature applies to.

One maintainer, GPL-3.0, and a version number that keeps climbing

The README states the constraint that matters most for anyone depending on this project: only one person works on it, the work is done for free in spare time, and as a result improvements are slow. That is the single largest factor in whether you should install it, and it is worth weighing against the alternative of a browser and the official site, which is free and always current. The release history shows the same pattern from the outside. The tagged builds are numbered as 379 with a version string of 3.0.379 dated 2026-03-17, 377 from 2025-06-14, and 375 from 2025-05-27, and the last push to the repository was on 2026-06-06. The licence is GPL-3.0, which matters if you plan to redistribute a modified build, because a derived APK carries the copyleft obligations, while running the published build yourself is not the issue. The repository also carries a SECURITY.md and a changelog section, and the README asks people with doubts to open an issue, which is the right place to raise a problem with a single maintainer.

Editorial conclusion

SmartTwitchTV fits a household with an Android TV or Tizen television that has no official Twitch app, and fits a developer who wants to understand the WebView and JavaScript bridge pattern that keeps most of an app's logic in web code. It does not fit a team that needs a maintained vendor behind it, since the README states that one person maintains the project in spare time, and it does not fit a user on a desktop who expects a normal browser experience, since the official Twitch site already covers that case. Before you install it, register your own application with Twitch and supply the credentials, because the app has to be registered to access the API, and check that the version you install is newer than the last tagged build, 379, from 2026-03-17.

Frequently asked questions

Official sources

1. fgl27/SmartTwitchTV on GitHub
2. Issues
3. License: GPL-3.0
4. README
5. Releases