Moonlight for TCL Google TVs on Android 14.
No freezes, no reboots, no inherited crashes, and the lowest latency the TV's MediaTek chip can deliver:
4K HDR at a steady 60 frames per second, counted at the screen.
English · Русский
Why · Install · Numbers · Features · TV setup · Home Assistant · Build
A build of Artemis, the Moonlight Android fork, tuned for the MediaTek chip
in TCL Google TVs on Android 14 firmware (C8K, C6K, QM6K, QM8K and similar). It streams games and the desktop from
Sunshine or Apollo on your PC. It installs as
its own app (com.limelight.tcl) next to Artemis or Moonlight, so their updates never replace it; settings and PC pairings are per
app. Android 14 and armeabi-v7a only, because that is what these TVs run. The numbers here were measured on a TCL C8K.
Background: moonlight-stream/moonlight-android#1533.
![]() |
![]() |
![]() |
| TCL's Android 14 firmware has a race in its input service that gamepad rumble sets off: the service aborts, the TV shows the boot animation and every app restarts. Moonlight TCL sends rumble through the Bluetooth stack instead, so the pad shakes and the TV stays up. The whole-TV freezes on stream exit or a menu over the video come from older TCL firmware; there Moonlight TCL keeps a second layer above the video by default, so they don't happen. The "volume change after an hour kills the screen" symptom was the rumble crash. | The Settings screen that crashed on open in Artemis, the crash on oversized frames at high bitrates, and the frame-loss handling that could drop 120 frames in a row after one lost packet (three fixes from upstream moonlight-common-c) are all gone. The settings that could not change anything on a TV are gone too: 45 settings in seven categories instead of 85 in ten. |
| Decoded frames go to the screen straight from the decoder's callback: no renderer thread, no blocking waits, each frame copied once. Sound leaves through native AAudio. The video threads run at display priority with Android's performance hints, and the video is the only layer on screen, so the compositor stays on its fast path. The client's own share of the per-frame decode time is under a millisecond; the rest is the MediaTek hardware decoder. | Same TV, same 4K60 HDR stream at 100 Mbps, counted at the TV's compositor: the official Artemis 20.2.6 put all 60 frames on screen in 0 of 48 samples, Moonlight TCL in 44 of 48, using a third less CPU. Both receive the same 60 frames and decode them in the same time; the difference is the path between the decoder and the screen. |
A 2.1 MB APK, all languages included, and 32 MB of RAM on the main screen (Artemis 20.2.6 on the same TV: 12 MB and 81 MB).
No AndroidX, no Material, no OkHttp: every screen is built on the framework's own widgets and the app's own views, the host
is reached through HttpsURLConnection, and most of what is left is the native decoder and streaming library.
One screen before the stream, settings that flip in place, nothing to wait for.
|
PCs as chips, apps as posters, a dark action panel on Menu or Y, two-pane settings like the TV's own. An on-screen keyboard with dictation driven by the gamepad or the remote. A card when a pad joins, runs low or goes on the charger. The interface in 32 languages, right-to-left included. |
- Download the APK from the latest release: one
armeabi-v7aAPK per release. For updates, add Moonlight TCL to Obtainium or find it in Obtainium's own "Add app" search: the app is listed in the Obtainium catalog. Inside the app,Settings → About → Updates via Obtainiumopens Obtainium directly. - Install with a file manager, the Downloader app or
adb install. A new version installs over any earlier Moonlight TCL build. - Pair: open the app, choose your PC, type the PIN into Sunshine or Apollo. Coming from Artemis or Moonlight, pair again: pairings and settings are per app.
- Play. The defaults are already set for a 4K TV: 3840×2160, 60 FPS, HEVC, HDR on, 100 Mbps, frame delivery "Lowest latency". When the app asks once for the Nearby devices (Bluetooth) permission, say yes: that is what lets rumble reach Bluetooth gamepads.
| TV | TCL Google TV on Android 14 firmware: C8K, C6K, QM6K, QM8K and similar. Android 14 and armeabi-v7a only. |
| PC | Sunshine or Apollo. HDR needs a GPU that encodes HEVC Main 10 and an HDR game. |
| Network | Ethernet through a USB gigabit adapter. Wi-Fi adds milliseconds of latency and jitter; on Ethernet the hop to the PC is under a millisecond. The TV's own port is 100 Mbps, too small for a 100 Mbps stream. |
| Gamepad | Any pad the TV sees. Rumble over Bluetooth is verified on Xbox pads; a pad on a USB cable goes through Moonlight's own USB driver. |
Important
Does the TV freeze or go black when you leave the stream or open a menu over it? Update the TV firmware. TCL fixed this in
V655 (C6K, C7K, C8K, C805, X11K and the rest of the T653T01 / 0012T01 platform) and V339 (North American QM8K, QM7K,
Q77K, QM6K: 0012T02). To see your version, open the TV's own settings (not Moonlight's): Settings → System → About → Product Information, a line
like V8-0012T01-LF1V667. If the TV doesn't offer the update itself, full OTA images are here:
T653T01 / 0012T01 (V655 or newer) and
0012T02 (V339 or newer). Pick the one that matches the platform in your firmware line.
On older firmware Moonlight TCL turns on Settings → Advanced → Keep a second layer above the video (only if the TV freezes)
by default. It keeps a tiny transparent surface above the video and removes the video before the stream screen closes, so the
firmware never has to rebuild the picture under a playing video. The picture gets slower. If your TV freezes on firmware this
list doesn't cover, turn it on yourself.
Video above 1080p corrupted (wrong crop, shifted image, green and blue bands at 4K)? Update the TV firmware. TCL fixed
this in V048.000462 for its Realtek platform G15 (0016T01: C6K in Brazil and Asia-Pacific, P8K, P8L, A400M). On older
firmware Moonlight TCL turns Settings → Advanced → TV game mode (recommended) off by default. If the picture is still
corrupted, or you changed that setting yourself before, turn it off by hand.
If the TV still freezes or reboots, open an issue with adb logcat -v threadtime -b all captured around the moment, or after a
reboot the output of adb shell dumpsys dropbox --print system_server_native_crash.
Everything below is from a TCL C8K, firmware V655, HEVC, 60 FPS, wired gigabit network, on a rested TV (why that matters is explained under the tables). The one game figure that was not measured under controlled conditions is marked as such.
Artemis 20.2.6 is the release this fork started from. Same TV, same PC, same settings: 4K60 HEVC HDR, 100 Mbps, frame
delivery "Lowest latency". The source is tools/framerate-test.html in heavy mode on the PC, a page guaranteed to
deliver 60 frames per second; the TV's compositor was asked every two seconds how many frames it had actually put on the screen.
| Test page in heavy mode, 4K60 HDR, 100 Mbps | Artemis 20.2.6 | Moonlight TCL |
|---|---|---|
| Samples with all 60 frames per second on screen | 0 of 48, every sample 50–56 | 44 of 48, the rest 57–59 |
| Frames per second arriving from the network | 60 | 60 |
| Decoder time per frame | 14–15 ms | 14–15 ms |
| App CPU load (4 cores) | 54–62 % | 38–41 % |
At 200 Mbps, where the decoder itself is the limit for both, an earlier run gave 5 of 22 samples at 60 for Artemis against 10 of 22 here. In a game at 100 Mbps the gap was larger, 40–51 frames per second on screen for Artemis against a steady 60 here while spinning the camera in a heavy scene, but the PC's own frame rate was not recorded in those runs, so take that pair as indicative only. Two more differences need no measurement: Artemis sends rumble through the system input stack, the path that reboots this TV, and its Settings screen crashed on open during the test.
How the comparison was run
For this run the Artemis 20.2.6 source was built as the same package as Moonlight TCL (then 20.2.10-tcl3), so both clients shared one pairing and one settings file; they were installed over each other and measured back to back, twice each, on the same host session. The test page's own counter read 60.0 throughout. Each two-second answer from the compositor was scored as either "all 60 per second" or "fewer". The performance overlay was off in both clients: drawing it costs the compositor about 25 ms per frame and ruins the measurement.
The client's own share of the per-frame decode time is under a millisecond; the rest is the MediaTek hardware decoder, and what it costs depends on pixels and bitrate, not on the codec.
| Stream | Decode time per frame |
|---|---|
| 3840×2160 HDR, 100 Mbps | 13 ms |
| 3840×2160 H.264, 100 Mbps | 14–15 ms (no better than HEVC) |
| 2560×1440, 100 Mbps | 7 ms |
| 1920×1080, 100 Mbps | 6 ms |
Frames that actually reach the screen while spinning the camera in a heavy scene, counted at the compositor:
| Bitrate | Decode time | Frames/s on screen |
|---|---|---|
| 60 Mbps | 12 ms | 60 |
| 100 Mbps | 13 ms | 58–60, an occasional single dropped frame |
| 120 Mbps | 14 ms | 60 in some scenes, about 40 in the heaviest |
| You want | Set | What you get |
|---|---|---|
| The default | 100 Mbps | A picture essentially transparent for a real-time encoder; 60 frames per second in nearly every scene. |
| Smoothness in every scene | 60 Mbps | 60 frames per second everywhere, a slightly softer picture. Anything in between behaves accordingly. |
| The last bit of detail | 120 Mbps | Dark HDR scenes at their best; dips to about 40 frames per second in the heaviest moments, the decoder has no headroom left. |
| Latency over sharpness | 2560×1440 | 7 ms of decode instead of 13; the TV scales it to the panel. Stay on HEVC. |
Both apps installed on the same TV and opened to their main screen, no stream running (dumpsys meminfo, proportional set size).
| Moonlight TCL | Artemis 20.2.6 | |
|---|---|---|
| APK | 2.1 MB, armeabi-v7a, all 32 languages |
12.1 MB, universal |
| On the TV's storage | 2 MB (plus the box art cached for your PCs) | 14 MB |
| RAM on the main screen | 32 MB | 81 MB |
| of which the Java heap | 2.5 MB | 42 MB |
| of which code | 3.8 MB | 10 MB |
What else moves the numbers: heat, background apps, and things that turned out not to matter
Heat. After about an hour of continuous 4K HDR the decoder on this TV started returning 45–50 frames per second with either client while still receiving 60, and fifteen minutes of idle brought it back to 60. All figures here are from a rested TV.
Background load. What else runs on the TV matters as much as the client. In one session the frames on screen came in waves, about 40 per second for 20 seconds every 90 seconds, while 60 kept arriving from the network and the socket dropped nothing: Google Assistant's hands-free "Hey Google" detection was using a quarter of a core the whole time, a browser and the TV settings sat in memory, the kernel was stalling on memory reclaim 250 times a second and the SoC ran at 78–80 °C. With hands-free detection switched off and the background apps closed, the same stream held 60 in 86 % of samples instead of 48 %, and the SoC ran two degrees cooler. See Set up the TV.
Things that did not matter on this TV. The display has exactly one mode, 3840×2160 at 60 Hz (the panel's 120/144 Hz exist
only for HDMI inputs), so a 120 FPS stream is shown at 60. Releasing frames with a zero timestamp made no difference to
smoothness or latency. Of the MediaTek decoder's ~113 vendor keys, the latency-named ones were tried one at a time and none
helped (some are ignored, one blanks the screen, game-mode leaves the decode time unchanged and visibly smears the picture),
so none are used.
Stability: what was fixed and what is left out
-
The whole-TV freeze (volume bar, menu, app switch or stream exit over a playing video) is a bug in MediaTek's display composer. While the video is the only layer on screen, the panel runs in a mode synchronized to the video frames. When a second layer appears or the video goes away, that mode changes, the composer's vsync thread waits for a vblank that never comes, and SurfaceFlinger stalls with it. Comparing the firmware images shows the fix: a timeout on that wait with a software vsync fallback, handling of the frame-sync mode change, and separate video and graphics commits in the kernel display driver.
Platform Models Freezes Fixed in T653T01/0012T01C6K, C7K, C8K, C805, X11K, C955 and similar Android 14 builds up to V643 V655 T653T02/0012T02QM8K, QM7K, Q77K, QM6K, 2024 QM8/QM7 (North America) Android 14 builds up to V333 V339 Below those versions
Settings → Advanced → Keep a second layer above the videois on by default: a 2×2 px surface stays above the video, so the sync mode never changes, and the video layer is removed before leaving the stream. The picture gets slower with it. The "volume change after an hour freezes the screen and the app dies" symptom was the rumble crash. -
On TCL's Realtek platform G15 (
0016T01) the TV's game mode corrupts video above 1080p on firmware before V048.000462, so thereSettings → Advanced → TV game modeis off by default. Firmware that can't be read counts as old. Both firmware-based defaults apply only until you change the setting yourself. -
Fixed a Settings-screen crash inherited from Artemis and a crash on oversized frames at high bitrates.
-
Frame-loss recovery as in upstream Moonlight since September 2026: no speculative loss reports while reference-frame invalidation is off (one lost packet could drop up to 120 consecutive frames), a partially dropped IDR frame is handled correctly, and invalidation after a multi-block loss points at the right frames.
-
Phone-only features and the 3D mode are gone, logcat is quiet during a stream, and the settings are down to the ones that can change something on a TV: no touchpad, metered-network, clipboard, floating-button, in-app-language or community-logging options, every title and description rewritten in one plain line.
Video: the proven renderer, straight from the decoder to the screen
- The proven renderer from before Artemis' August 2025 experiments (polling loop, codec-flushing watchdog, undocumented MediaTek keys, forced Balanced pacing), which had made controller response noticeably slower on TCL.
- Decoded frames go to the screen straight from the decoder's callback: no renderer thread in between and no blocking waits.
- Each frame is copied once, from the network buffers directly into the decoder's input buffer, instead of twice through Java.
- The decoder is always asked for every low-latency option it accepts; the video threads run at display priority and are registered with Android's performance hints (ADPF); the app is declared a game.
- The video is the only layer on screen, which keeps the TV's compositor on its fast path.
- Defaults for a 4K TV: 3840×2160, 60 FPS, 100 Mbps, HEVC, HDR on, frame delivery "Lowest latency".
Audio: native AAudio
- Native AAudio low-latency output, no Java between the decoder and the audio driver. Falls back to
AudioTrackon its own, and when the system equalizer is on.
Rumble: through the Bluetooth stack, not the input service that restarts the TV
- TCL's Android 14 firmware has a race in
system_server's input service: a gamepad vibration arrives on a binder thread and is pushed into the event queue that the input reader thread is draining without the lock. Any rumble sent through the Android input stack can hit it; when it does, the system service aborts, the TV shows the boot animation and every app restarts, which looks exactly like a reboot (confirmed from the crash dumps and AOSP source; fixed upstream in Android 15, so only TCL can fix it here). - Moonlight TCL therefore sends rumble to Bluetooth gamepads through the Bluetooth stack's own HID host: the output report
reaches the pad by the same Bluetooth path the kernel's force feedback would take, but
system_serverand its input reader are never involved. It needs the Nearby devices (Bluetooth) permission, which the app asks for once. Rumble is on by default. - Xbox pads are verified on the TV, the 8BitDo Ultimate 2.4G (Bluetooth D-mode) on a C7K; DualShock 4, DualSense, Switch Pro and Joy-Con, other 8BitDo pads, Amazon Luna, Google Stadia, NVIDIA Shield 2017 and GameSir 8K pads are written from the Linux and SDL driver sources and still wait for someone with the hardware (an issue saying whether yours rumbles would settle it). Other Bluetooth pads stay silent on this TV: there is no switch back to the input service, because that path is what restarts the TV. A gamepad on a USB cable is driven by Moonlight's own USB driver and never touches the input stack either.
Gamepads on screen: cards and charge
- A card over the stream when a gamepad joins, when its battery runs low (20 %, then 10 %) and when it goes on the charger: player number, the pad's name as set in the TV's Bluetooth settings, the charge. Player 1 bottom-left, player 2 bottom-right; while the in-game menu is open every pad's charge stays in the corners, and the PC and app lists show the attached pads as small icons with a battery at the top right.
- The TV exposes no gamepad battery itself, so the pad is asked over Bluetooth LE (the standard Battery Service); the Xbox
Wireless Controller has no charging flag anywhere, but a counter in its statistics table grows at every cable plug-in, and
that is where the charger card comes from. The pad never reports the cable coming out, so the state returns to discharging
once the level falls.
Settings → Gamepad → Gamepad cards on screenturns it off.
On-screen keyboard: typing and dictation from the pad or the remote
Game menu → On-screen keyboarddraws a keyboard over the stream and hands the gamepad to it: d-pad or left stick moves, A presses, B closes, X is Backspace, Y is Space, LB/RB switch between the US, Russian and function-key pages, LT is Shift, RT is Enter; the TV remote works the same way with OK and Back.- Latin letters, digits and the special keys reach the PC as real key presses, like a US keyboard plugged into it, so games and shortcuts see them and the PC's own layout decides the character; Russian letters go as text and come out right whatever layout the PC is in.
- Shift, Ctrl and Alt are sticky (tap for the next key, tap again to lock), Win opens the Start menu, and the Fn page has F1–F12, Ins/Del/Home/End/PgUp/PgDn, PrtSc and ready shortcuts: Alt+Tab, Alt+F4, Win+D, Win+R, Win+Tab, Win+E, Ctrl+C/V/Z/A.
- The microphone key (or the View button) dictates through the TV's speech recognizer: Russian on the Russian page, the TV's language otherwise; the text lands on the PC as typed text, and the first use asks for the microphone permission. The TV's own keyboard is not used: it needs a text field and never sees gamepad buttons.
Interface: one screen, two-pane settings, 32 languages
- One screen before the stream, in the style of the TV's own menus: the PCs as chips in the header with a status dot (green online, grey offline, a lock when not paired), the selected PC's apps as posters below, the attached gamepads with their charge in the corner, the active settings profile and the settings behind pill buttons. A PC that is offline, unpaired or still being checked shows a short message with the actions that make sense (wake, pair, delete) instead of the grid. Long press, Menu or the gamepad's Y open the dark action panel for a PC or an app.
- Settings are two-pane like the TV's: categories on the left, the rows on the right, toggles flip in place, choices open the panel, sliders and text values a small dialog; a settings profile is edited on the same screen with the changed rows marked. Left and Back return to the categories.
- "Go to Server Config" opens the Sunshine or Apollo web UI in the in-app browser: the PC's own certificate is accepted, the login is asked for, and Back closes the page.
- The interface comes in 32 languages (English, Russian, Ukrainian, Polish, Czech, Bulgarian, German, Dutch, Danish, Swedish, Norwegian, Finnish, French, Spanish, Italian, Portuguese and Brazilian Portuguese, Romanian, Greek, Turkish, Hungarian, Hebrew, Arabic, Persian, Hindi, Thai, Vietnamese, Indonesian, Japanese, Korean, Simplified and Traditional Chinese), every one complete, right-to-left layouts for Arabic, Hebrew and Persian; the app follows the TV's language or the per-app language picked in Android settings.
- No AndroidX and no OkHttp: every screen is built on the framework's widgets (Activity, ListView, GridView, AlertDialog) and the
app's own Views, the host is reached through
HttpsURLConnection. The APK is 2.1 MB with all languages (37 MB in the first builds); most of what is left is the native decoder and streaming library.
Tools: built-in latency test, frame rate test page
- Built-in latency test (
Settings → Advanced → Latency test mode): opentools/latency-test.htmlfull screen on the PC, press A/B/X/Y in the stream, read button-to-frame latency split into input, host+network and decode+present. - Latency report after the stream (
Settings → Interface) shows the decode time of the session. tools/framerate-test.htmlis a local 60 fps test pattern for the PC (ladder, moving bar, frame counter, heavy mode): every dropped or duplicated frame in the stream is visible on the TV without any overlay.
The TV's own background work costs frames and heat (see Measured, not promised). On a TCL C8K these settings are worth a look; the screenshots are from firmware V655 with the menu switched to English.
Plug in Ethernet through a USB adapter. Wi-Fi latency is far too high for this: every hop costs milliseconds and jitters, and the jitter is what drops frames. On Ethernet the TV reaches the PC in under a millisecond. The TV's built-in port is only 100 Mbps, which does not carry a 100 Mbps stream with its audio and overhead; a USB gigabit Ethernet adapter does. The TV picks it up without drivers and the link negotiates 1000 Mbps. All the numbers in this README were measured on such a link.
Turn off hands-free "Hey Google". Settings → Accounts & Profiles → your account → Google Assistant → Hands-free mic off. With it on, the Assistant's hotword detector used a quarter of a CPU core the whole time the TV was on. The microphone button on the remote keeps working.
Close what you are not using. The TV has 2.4 GB of RAM and swaps to compressed memory; a browser left in the background plus the TV settings screen pushed the kernel into reclaiming memory 250 times a second during a stream. Quit them before streaming (Settings → Apps → the app → Force stop).
Developer options, if you have them enabled. Make sure Don't keep activities is off. It is a debugging aid, not a memory saver: it frees nothing (the process and its heap stay) and only destroys the screen you leave, so every return rebuilds it from scratch; in Moonlight TCL that means polling the PCs and loading the posters again after every trip to Settings or a stream. Memory is freed by Background process limit → "No background processes" or "At most 2 processes", which keeps idle apps out of memory at the price of other apps restarting more often. Nothing else in there helps streaming.
Keep it cool. After an hour of 4K HDR the SoC sits at 76–82 °C and the firmware trims the decoder. Lower panel brightness changed that by about a degree; airflow behind the TV matters more.
Moonlight TCL registers two links that anything able to start apps on the TV can open (Home Assistant's Android TV Remote,
adb). They are not marked browsable, so a web page on the TV can't fire them.
| Link | Does |
|---|---|
moonlight-tcl://open |
Opens the PC list. |
moonlight-tcl://stream?host=<PC name>&app=<app name> |
Starts streaming that app. host must match the PC name exactly, app ignores case. uuid=<PC uuid> and appid=<app id> work instead of the names. |
action: remote.turn_on
target:
entity_id: remote.living_room_tv
data:
activity: moonlight-tcl://stream?host=WIN-PC&app=DesktopA stream link takes the same path as a launcher shortcut, so it shows the same error if the PC or app isn't found. The links come from yuliwilliam/moonlight-tcl.
- JDK 17 and the Android SDK with NDK
27.3.13750724(seeapp/build.gradle). git submodule update --init --recursive(moonlight-common-ccomes from pabragin/moonlight-common-c, branchtcl).- Point Gradle at the SDK with
ANDROID_HOMEorlocal.properties. ./gradlew :app:assembleRelease(not-Pandroid.injected.build.abi: it marks the APKtestOnly, which the TV rejects), thenzipalignandapksigner signthe APK fromapp/build/outputs/apk/release/with your own keystore.
All streaming functionality is the work of the Moonlight and Artemis authors: Cameron Gutman, Diego Waxemberg, Aaron Neyer, Andrew Hennessy, ClassicOldSong and the contributors of both projects. Moonlight started as a project of students at Case Western at MHacks.
Licensed under the GNU GPL v3, see LICENSE.txt.




