vyla-entertainment/documentation
2
0
Fork 0
mirror of https://gitlab.com/vyla-entertainment/documentation.git synced 2026-11-15 06:57:21 -05:00
Code Issues Packages Projects Releases Wiki Activity

huge rewrite

Browse Source
This commit is contained in:
alwaysmesmerizingyou
2026-11-14 18:21:12 -08:00
parent f465d1ec0d
commit 2cec85a8f3
69 changed files with 11479 additions and 1576 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
products/go.md
View File

@@ -1,17 +1,106 @@
# Vyla Go
# Vyla Go (Android Mobile)
<p class="page-description">The Android control center for running the Vyla media stack locally.</p>
<p class="page-description">The native Android mobile client for the Vyla ecosystem, combining hardware-accelerated shaders, automated runtime management, and mobile streaming.</p>
<img class="vyla-banner" src="/src/assets/images/android/site_preview.png" alt="A collage of films and shows available through a Vyla experience" loading="lazy" fetchpriority="low" />
<img class="vyla-banner" src="/src/assets/images/android/site_preview.webp" alt="Vyla Go mobile streaming application interface" loading="lazy" decoding="async" fetchpriority="low" />
**Vyla Go** is the Android application in the Vyla ecosystem. It prepares and runs the local services that power your media experience, then opens the interface in a secure embedded window. It is designed for people who want Vyla on their Android device without managing a separate server process or service lifecycle by hand.
## Overview
**Vyla Go** brings the power of the Vyla media ecosystem directly to Android smartphones and tablets. Built using **Tauri v2 Mobile**, Vyla Go delivers a fluid, responsive touch experience backed by native hardware acceleration and custom WebGL shaders.
Designed for mobile reliability on varying cellular and Wi-Fi networks, Vyla Go automatically coordinates local resource extraction, service fallbacks, and remote update fetching without requiring constant manual APK re-installations.
---
## Downloads
Vyla Go is available for Android. Get the latest version below:
Official APK packages are published on the [Vyla Go GitLab Releases](https://gitlab.com/vyla-entertainment/go/-/releases):
| Platform | Download |
| --- | --- |
| Android | [Download: v0.0.0 (.apk)](https://gitlab.com/vyla-entertainment/go/-/releases) |
| Package | Target Architectures | Compatibility | Download Link |
| :--- | :--- | :--- | :--- |
| **Universal APK** | `arm64-v8a`, `armeabi-v7a`, `x86_64` | Android 7.0+ (API 24+) | [Download Universal APK](https://gitlab.com/vyla-entertainment/go/-/releases) |
| **ARM64 APK** | `aarch64` | Modern 64-bit Android Devices | [Download ARM64 APK](https://gitlab.com/vyla-entertainment/go/-/releases) |
Clicking the download button will retrieve the latest `.apk` package for your device.
---
## Key Features
- **Tauri v2 Mobile Architecture**: Native Rust-backed Android application layer with secure Chromium WebView rendering.
- **Hardware-Accelerated WebGL Shaders**: Real-time dynamic glassmorphism, responsive ambient backdrops, and fluid gesture navigation.
- **Automated Resource Management**: Downloads and unpacks core service updates directly from official release channels, keeping scraper definitions up to date.
- **Low-Latency Mobile Playback**: Supports HLS and direct stream resolution with adaptive mobile bitrate handling.
---
## Building from Source
### Prerequisites
Before compiling Vyla Go, ensure your development environment has:
- **Node.js**: v20 or newer
- **Rust & Cargo**: Latest stable toolchain
- **Android Studio**: Android SDK & NDK (v29+)
- **Cross-Compilation Targets**:
```bash
rustup target add aarch64-linux-android x86_64-linux-android
```
### Build Commands
```bash
# 1. Install project dependencies
npm install
# 2. Package the runtime update payload
npm run build:payload
# 3. Compile the release APKs
npm run build:apk
```
The compiled release packages are output to:
```
src-tauri/gen/android/app/build/outputs/apk/universal/release/app-universal-release.apk
```
---
## Developer & Debugging Guide (ADB)
The Vyla Go repository provides complete ADB integration for debugging, log collection, and direct device installation:
### Streaming Device Logs
Monitor the application logs in real time via ADB:
```powershell
# Stream live application logs tagged VylaGo
& "$env:LOCALAPPDATA\Android\Sdk\platform-tools\adb.exe" logcat -s VylaGo
# Clear the log buffer and stream fresh output
& "$env:LOCALAPPDATA\Android\Sdk\platform-tools\adb.exe" logcat -c
& "$env:LOCALAPPDATA\Android\Sdk\platform-tools\adb.exe" logcat -s VylaGo
```
### Crash Diagnostics
Inspect unhandled exceptions, native SIGSEGV errors, and runtime failures:
```powershell
& "$env:LOCALAPPDATA\Android\Sdk\platform-tools\adb.exe" logcat -d | Select-String "VylaGo|AndroidRuntime|FATAL"
```
### Direct Device Installation
Install your newly built APK directly to a connected USB or Wi-Fi debug device:
```powershell
& "$env:LOCALAPPDATA\Android\Sdk\platform-tools\adb.exe" install -r "src-tauri\gen\android\app\build\outputs\apk\universal\release\app-universal-release.apk"
```
### Resetting App State
To completely terminate and purge cached app state:
```powershell
& "$env:LOCALAPPDATA\Android\Sdk\platform-tools\adb.exe" shell am force-stop com.vyla.go
& "$env:LOCALAPPDATA\Android\Sdk\platform-tools\adb.exe" shell pm clear com.vyla.go
```
### Fixing Emulator DNS Timeouts
When running Android emulators that fail to reach remote release endpoints:
```powershell
& "$env:LOCALAPPDATA\Android\Sdk\platform-tools\adb.exe" shell settings put global private_dns_mode off
```

149
products/home.md
View File

@@ -1,73 +1,156 @@
# Vyla Home
# Vyla Home (Desktop)
<p class="page-description">The desktop control center for running the Vyla media stack locally.</p>
<p class="page-description">The native desktop control center and player runtime for Windows, macOS, and Linux built on Tauri v2 and an embedded Node.js sidecar.</p>
<img class="vyla-banner" src="/src/assets/images/desktop/site_preview.png" alt="Vyla Home desktop application preview" loading="lazy" fetchpriority="low" />
<img class="vyla-banner" src="/src/assets/images/desktop/site_preview.webp" alt="Vyla Home desktop application preview displaying streaming interface" loading="lazy" decoding="async" fetchpriority="low" />
## Vyla Home
## Overview
**Vyla Home** is the desktop application in the Vyla ecosystem. It prepares and runs the local services that power your media experience, then opens the interface in a secure embedded window. It is designed for people who want Vyla without managing a separate server process, reverse proxy, or service lifecycle by hand.
**Vyla Home** is the flagship desktop application of the Vyla ecosystem. Engineered for performance and privacy, Vyla Home packages the entire Vyla streaming runtime into a lightweight native shell using **Tauri v2** and an embedded Node.js sidecar process.
Instead of running heavy web browsers with excessive RAM overhead, Vyla Home leverages system-native WebViews (WebView2 on Windows, WebKit on macOS/Linux), ensuring instant boot times, hardware-accelerated video decoding, and tiny background resource footprints.
---
## Downloads
Vyla Home is available for Windows, macOS, and Linux. Get the latest version below:
Official binary releases are published directly to the [Vyla Home GitLab Releases](https://gitlab.com/vyla-entertainment/home/-/releases):
| Platform | Download |
| --- | --- |
| Windows | [Download: v0.0.0 (.exe)](https://gitlab.com/vyla-entertainment/home/-/releases) |
| macOS | [Download: v0.0.0 (.dmg)](https://gitlab.com/vyla-entertainment/home/-/releases) |
| Linux | [Build from source](#linux-setup) |
| Platform | Package Format | Architecture | Download Link |
| :--- | :--- | :--- | :--- |
| **Windows** | Setup Installer (`.exe`) / Portable | x86_64 (64-bit) | [Download for Windows (.exe)](https://gitlab.com/vyla-entertainment/home/-/releases) |
| **macOS** | Disk Image (`.dmg`) | Universal (Apple Silicon & Intel) | [Download for macOS (.dmg)](https://gitlab.com/vyla-entertainment/home/-/releases) |
| **Linux** | Source Build / Flatpak (in progress) | x86_64, aarch64 | [Build from Source](#linux-build-guide) |
Clicking the download button will retrieve the latest installer for Windows or macOS.
:::callout-info
When launching Vyla Home for the first time, the application will automatically perform a self-check, initialize local caches, and establish secure RPC connections.
:::
## Linux Setup
---
For Linux, you'll need to build Vyla Home from source. Follow these steps to install on Fedora:
## Architectural Implementation
**Step 1: Install dependencies**
Vyla Home operates via a dual-process architecture:
| Process Layer | Tech Stack | Responsibilities & Capabilities |
| :--- | :--- | :--- |
| **Tauri Main Process** | Rust | Manages native OS window lifecycle, system tray icons, native menus, and hosts the secure WebView renderer. |
| **Inter-Process Channel** | Stdio IPC | Bi-directional JSON-RPC stream communicating over standard input and standard output (`stdin` / `stdout`). |
| **Node.js Sidecar Process** | Node.js (`main.js`) | Orchestrates `ServiceManager` for local/remote fallback, verifies update cryptographic signatures via `UpdateClient`, manages Discord Rich Presence, and handles local cached data. |
### File Locations & Directory Structure
Vyla Home stores its configuration, cryptographic keys, cached catalogs, and logs in standard operating system directories:
| OS | Default Storage Path |
| :--- | :--- |
| **Windows** | `%APPDATA%\vyla-home\vyla-home-files\` |
| **macOS** | `~/Library/Application Support/vyla-home/vyla-home-files/` |
| **Linux** | `~/.local/share/vyla-home/vyla-home-files/` |
### Diagnostics & Logs
If you encounter runtime issues, inspect the sidecar debug log:
- **Windows**: `%APPDATA%\vyla-home\vyla-home-files\logs\node-debug.log`
- **macOS/Linux**: `<AppDataDir>/logs/node-debug.log`
---
## Windows Troubleshooting: WebView2 Runtime
On Windows systems, Vyla Home utilizes Microsoft's Evergreen WebView2 runtime. If your installation encounters a `WebView2 runtime initialization error`:
1. Ensure the Microsoft Edge WebView2 Evergreen Runtime is installed from [Microsoft's official site](https://developer.microsoft.com/en-us/microsoft-edge/webview2/).
2. For portable or standalone deployments, verify that `WebView2Loader.dll` exists in the `bin/` directory adjacent to the binary:
```bash
sudo dnf install webkit2gtk4.1-devel curl wget openssl-devel libappindicator-gtk3-devel librsvg2-devel
sudo dnf install gcc gcc-c++ make automake autoconf
vyla-home\bin\WebView2Loader.dll
```
**Step 2: Install Node.js and NPM**
---
## Linux Build Guide
To build and run Vyla Home natively on Linux distributions (such as Fedora, Ubuntu, Debian, or Arch):
### 1. Install System Dependencies
:::code-group
<!-- tab: Fedora / RHEL -->
```bash
sudo dnf install nodejs npm
sudo dnf install -y \
webkit2gtk4.1-devel curl wget openssl-devel \
libappindicator-gtk3-devel librsvg2-devel \
gcc gcc-c++ make automake autoconf nodejs npm
```
**Step 3: Install Rust**
<!-- tab: Ubuntu / Debian -->
```bash
sudo apt-get update && sudo apt-get install -y \
libwebkit2gtk-4.1-dev build-essential curl wget \
libssl-dev libayatana-appindicator3-dev librsvg2-dev \
nodejs npm
```
<!-- tab: Arch Linux -->
```bash
sudo pacman -Syu --needed \
webkit2gtk-4.1 base-devel curl wget openssl \
libappindicator-gtk3 librsvg nodejs npm
```
:::
### 2. Install Rust Toolchain
```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source "$HOME/.cargo/env"
```
**Step 4: Clone the Git repository**
### 3. Clone and Build
```bash
# Clone the repository
git clone https://gitlab.com/vyla-entertainment/home.git vyla-home
cd vyla-home
```
**Step 5: Install more dependencies**
```bash
# Install Node dependencies
npm install
# Package runtime payload
npm run build:payload
# Launch in developer mode
npm run dev
# Or compile production binary
npm run build
```
**Step 6: Build the Fedora package (.rpm)**
---
## Developer Workflows
The Vyla Home repository includes specialized scripts for continuous development and release management:
```bash
cargo update --manifest-path src-tauri/Cargo.toml
npx tauri build --bundles rpm,appimage
# Start the full application in development mode with hot reload
npm run dev
```
**Step 7: Final installation**
```bash
sudo dnf install src-tauri/target/release/bundle/rpm/*.rpm
# Package the local application payload into update-payload.zip
npm run build:payload
```
*Thank you @krishi279 for supplying the Linux setup instructions on Discord ❤️.*
```bash
# Test the UI shell with a simulated test harness
npm run dev -- -- --env VYLA_TEST_UI=1
```
```bash
# Compile and package a full production installer release
npm run release:full
```
### Resolving File Locks (OS Error 32)
If a hung process locks the binary during development on Windows:
```powershell
Stop-Process -Name "vyla-home", "node", "cargo" -Force -ErrorAction SilentlyContinue
```

188
products/player.md
View File

@@ -1,37 +1,177 @@
# Build a player
# Building a Custom Player
<p class="page-description">Design a resilient Vyla playback experience around your own product and infrastructure.</p>
<p class="page-description">Architectural principles, format handling, and engineering guidelines for building resilient video players backed by Vyla infrastructure.</p>
## Your player, your rules
## Overview
Vyla supplies the integration layer; your application owns the player experience. That includes design, authentication, title discovery, parental controls, analytics, playback policy, and fallback behavior.
In the Vyla ecosystem, you are never locked into an official frontend. Vyla provides the discovery, resolution, and proxy layers; your application owns the player experience. Whether you are building a custom web portal, desktop client, or mobile app, this guide covers the core engineering patterns required for a robust player.
For a local managed experience, Vyla Home starts its bundled player service. For a custom product, choose one of two boundaries:
---
| Integration | Best for |
| --- | --- |
| **SDK directly** | Node.js products that already have a backend and want complete control |
| **Stream API** | browser or mobile clients that need an HTTP/SSE source feed |
## Integration Boundaries
## Build for changing conditions
Choose your integration point based on your architecture:
Provider results vary by title and network. A dependable player should:
| Architecture | Integration Point | Data Flow | Best For |
| :--- | :--- | :--- | :--- |
| **Node.js Backend** | **Vyla SDK Directly** | `sdk.getStream()` in-process | Applications with full backend control, custom authentication, and server-side session tracking. |
| **Browser / Mobile** | **Stream API Gateway** | SSE `/movie` or `/tv` over HTTP | Web applications, smart TV frontends, or lightweight mobile clients requiring an HTTP/SSE source feed. |
1. Begin playback as soon as it has a usable candidate.
2. Keep later candidates as fallbacks.
3. Keep subtitles independent from first playback.
4. Report a helpful unavailable state when no candidates resolve.
5. Destroy playback and abort in-flight work when the viewer changes titles.
---
The SDK returns provider results directly; Stream API emits `meta`, `source`, and `done` events. Both models benefit from the same fallback strategy.
## Playback Formats: HLS vs Direct Video
## Playback formats
Resolved candidate streams come in two primary container types:
Candidates may be HLS manifests or direct media files. Let the result metadata and your player capabilities guide how a candidate is loaded; do not assume every URL has the same format or availability. HLS-capable web players normally use HLS.js where native HLS is unavailable, while direct media can be assigned to a video element.
1. **HLS Streams (`type: "hls"`)**:
- Master M3U8 playlists containing multiple bitrate/resolution variants.
- Proxied through Stream API (`/api?url=...`), which automatically rewrites chunk URLs and AES-128 encryption key URIs.
- Requires native HLS support (Safari on macOS/iOS) or a JavaScript HLS MSE library such as [HLS.js](https://github.com/video-dev/hls.js/) in modern browsers.
2. **Direct Media Files (`type: "mp4"`)**:
- Progressive MP4 or MKV streams.
- Proxied with HTTP Range header forwarding (`206 Partial Content`), allowing smooth scrubbing and seeking.
- Directly assignable to the HTML5 `<video>` element `src` attribute.
## Continue building
---
- Embed provider resolution with [SDK quickstart](/sdk/vyla-sdk/quickstart).
- Learn the optional HTTP event contract in [Paths and playback events](/stream-api/reference/paths).
- Use the [client integration guide](/guides/integrations) for a browser-oriented example.
- Review [error handling](/guides/error-handling) before shipping a player.
## Resilient Player Architecture
Upstream streaming hosts are dynamic: network latencies fluctuate, upstream proxies fail, and geo-restrictions vary. A production-ready Vyla player must adhere to five design rules:
### 1. Start on the First Candidate
Never wait for all providers to finish. Stream API emits verified sources over Server-Sent Events (SSE). The moment the first `source` event arrives (typically within 3 to 8 seconds):
- Initialize your player immediately.
- Store any subsequent incoming `source` events in a priority fallback array.
### 2. Maintain a Fallback Priority Array
If the active stream stalls, encounters an unrecoverable network error, or buffer-underruns:
- Catch the error event (e.g. `Hls.Events.ERROR` with fatal flag).
- Pop the next candidate from your fallback queue.
- Re-attach the media source without disrupting the user's viewing session.
### 3. Decouple Subtitles from Video Playback
Subtitles are retrieved independently from the video stream. Never block initial video buffering waiting for subtitle tracks to download. Load the video stream immediately and inject subtitle tracks (`<track kind="subtitles">`) asynchronously once resolved.
### 4. Implement a Client-Side Timeout
Always set a client-side watchdog timer (typically 15 to 20 seconds). If no viable candidate emits a valid video stream before the timer expires, render an informative empty state allowing the user to retry or switch servers.
### 5. Clean Up on Title Switch
When a viewer selects a new movie or episode:
- Call `eventSource.close()` on the active SSE connection.
- Invoke `hls.destroy()` or `video.removeAttribute('src')`.
- Clear pending retry timers and abort in-flight fetch requests.
---
## Reference Implementation: Minimal Web Player
Below is a complete, copyable implementation using native HTML5 and HLS.js:
```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<title>Vyla Custom Player</title>
<script src="https://cdn.jsdelivr.net/npm/hls.js@latest"></script>
<style>
video { width: 100%; max-width: 960px; height: auto; background: #000; border-radius: 8px; }
.status { font-family: sans-serif; margin-top: 8px; color: #666; }
</style>
</head>
<body>
<video id="vyla-video" controls playsinline></video>
<div id="status" class="status">Connecting to Stream API...</div>
<script>
const API_BASE = "https://your-stream-api.example.com";
const TMDB_ID = 155;
const video = document.getElementById("vyla-video");
const statusEl = document.getElementById("status");
const fallbackSources = [];
let isPlaying = false;
let hlsInstance = null;
const eventSource = new EventSource(`${API_BASE}/movie?id=${TMDB_ID}`);
eventSource.onmessage = (event) => {
const data = JSON.parse(event.data);
if (data.type === "meta") {
statusEl.textContent = `Found: ${data.meta.title} (${data.meta.year})`;
if (data.subtitles) loadSubtitles(data.subtitles);
}
else if (data.type === "source") {
if (!isPlaying) {
playCandidate(data);
} else {
fallbackSources.push(data);
}
}
else if (data.type === "done") {
eventSource.close();
if (!isPlaying && fallbackSources.length === 0) {
statusEl.textContent = "No compatible streaming sources found.";
}
}
};
eventSource.onerror = () => {
eventSource.close();
if (!isPlaying) statusEl.textContent = "Error connecting to Stream API.";
};
function playCandidate(candidate) {
isPlaying = true;
statusEl.textContent = `Streaming from provider: ${candidate.source} (${candidate.quality})`;
if (candidate.type === "hls") {
if (Hls.isSupported()) {
if (hlsInstance) hlsInstance.destroy();
hlsInstance = new Hls({ maxBufferLength: 30 });
hlsInstance.loadSource(candidate.url);
hlsInstance.attachMedia(video);
hlsInstance.on(Hls.Events.MANIFEST_PARSED, () => video.play());
hlsInstance.on(Hls.Events.ERROR, (event, errorData) => {
if (errorData.fatal) {
console.warn("HLS fatal error encountered. Switching to fallback candidate...");
hlsInstance.destroy();
isPlaying = false;
if (fallbackSources.length > 0) playCandidate(fallbackSources.shift());
}
});
} else if (video.canPlayType("application/vnd.apple.mpegurl")) {
video.src = candidate.url;
video.play();
}
} else {
video.src = candidate.url;
video.play();
}
}
function loadSubtitles(subtitles) {
subtitles.forEach((sub) => {
const track = document.createElement("track");
track.kind = "subtitles";
track.label = sub.label;
track.srclang = sub.label.slice(0, 2).toLowerCase();
track.src = sub.file;
video.appendChild(track);
});
}
</script>
</body>
</html>
```
---
### Next Steps
- Explore the complete [Client Integration Guide](/guides/integrations) for React, Vue, and ExoPlayer examples.
- Review error classification in the [Error Handling Guide](/guides/error-handling).
- Review the SSE event protocol in [Paths & Playback Events](/stream-api/reference/paths).

87
products/tv.md
View File

@@ -1,17 +1,86 @@
# Vyla TV
# Vyla TV (Android TV)
<p class="page-description">The Android TV application for running the Vyla media experience on your television.</p>
<p class="page-description">The native 10-foot Leanback streaming experience for Android TV and Google TV, built with Jetpack Compose and ExoPlayer.</p>
<img class="vyla-banner" src="/src/assets/images/android-tv/site-preview.png" alt="A collage of films and shows available through a Vyla experience" loading="lazy" fetchpriority="low" />
<img class="vyla-banner" src="/src/assets/images/android-tv/site-preview.webp" alt="Vyla TV application Leanback interface on television display" loading="lazy" decoding="async" fetchpriority="low" />
**Vyla TV** is an Android TV streaming app built with Jetpack Compose and ExoPlayer that lets you browse and watch movies and TV shows from TMDB.
## Overview
**Vyla TV** is the living-room client in the Vyla ecosystem. Built entirely as a native Android application using modern **Jetpack Compose for TV** and Google's high-performance **ExoPlayer (Media3)** engine, Vyla TV brings the decentralized media experience to large displays.
Every interface component in Vyla TV is designed specifically for remote control navigation, ensuring seamless D-pad focus management, rapid title browsing, and cinema-grade playback.
---
## Downloads
Vyla TV is available for Android TV. Get the latest version below:
Official TV APK builds are published to the [Vyla TV GitLab Releases](https://gitlab.com/vyla-entertainment/TV/-/releases):
| Platform | Download |
| --- | --- |
| Android TV | [Download: v0.0.0 (.apk)](https://gitlab.com/vyla-entertainment/TV/-/releases) |
| Platform | Format | Recommended Target Devices | Download Link |
| :--- | :--- | :--- | :--- |
| **Android TV / Google TV** | `.apk` | Sony Bravia, Chromecast with Google TV, NVIDIA Shield TV, Xiaomi Mi Box | [Download Vyla TV APK](https://gitlab.com/vyla-entertainment/TV/-/releases) |
| **Amazon Fire TV** | `.apk` | Fire TV Stick 4K / Max, Fire TV Cube | [Download Vyla TV APK](https://gitlab.com/vyla-entertainment/TV/-/releases) |
Clicking the download button will retrieve the latest `.apk` package for your Android TV device.
---
## TV Experience & Features
- **D-Pad Directional Navigation**: Engineered from the ground up for directional remotes. No mouse pointers, virtual cursors, or awkward touch adaptations.
- **ExoPlayer Media3 Engine**: Hardware-accelerated video decoding with direct support for adaptive HLS (m3u8), MP4, and MKV streams.
- **Playback Control Matrix**:
- Variable playback speeds (0.5x, 0.75x, 1.0x, 1.25x, 1.5x, 2.0x).
- Multi-track subtitle selector with custom sync adjustment and font sizing.
- Multi-stream source switcher to toggle between upstream providers without leaving the player.
- **Catalog & Library**:
- TMDB catalog integration with detailed cast, plot synopses, and genre filters.
- "Watch Later" watchlist and persistent "Favorites" library stored locally on device.
- Instant resume tracking with automatic timestamp memory.
---
## Sideloading on Android TV / Fire TV
If your device does not have a direct browser installer:
1. Install **Downloader by AFTVnews** from the Google Play Store or Amazon Appstore.
2. In your TV's settings, navigate to **Settings > System > Developer Options** (or **Device & Software > Developer Options**) and enable **Install Unknown Apps** for Downloader.
3. Open Downloader and enter the direct APK URL from our releases:
```bash
https://gitlab.com/vyla-entertainment/TV/-/releases
```
4. Download the latest `.apk` and select **Install**.
---
## Building from Source
### Prerequisites
- Node.js 20+
- Java Development Kit (JDK 17 or JDK 21)
- Android SDK with Android TV API 26+
### Build Steps
```bash
# Clone the repository
git clone https://gitlab.com/vyla-entertainment/TV.git vyla-tv
cd vyla-tv
# Install JavaScript asset bundling tools
npm install
# Build JS resolver bundle and compile debug APK via Gradle
npm run dev
```
The resulting package will be generated at:
```
android/app/build/outputs/apk/debug/vyla.apk
```
### Developing in Android Studio
To inspect Kotlin source code or UI composables directly:
1. Launch Android Studio.
2. Choose **Open an Existing Project** and select the `android/` subfolder inside the TV repository.
3. Allow Gradle to sync and build targets.