# Go2TV: pushing local files and torrents to a TV over DLNA and Chromecast

> Go2TV is a single-binary Go application that casts video, audio and images from a computer or phone to DLNA Smart TVs, Chromecast devices and UPnP receiver apps, optionally transcoding through FFmpeg. The unusual part is torrent casting, where a magnet link plays while it downloads.

**alexballas/go2tv** — Cast media files to Smart TVs and Chromecast devices.

- Repository: https://github.com/alexballas/go2tv
- Stars: 1,136 · Forks: 82
- Language: Go
- License: MIT
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/alexballas-go2tv

## It removes the USB stick and the media server from the workflow

The problem Go2TV solves is mundane and constant. A file sits on your laptop, the TV cannot see it, and the usual answers are to copy it onto a USB drive or to stand up a media server that exposes your whole library. Go2TV takes a third route: it discovers the device on your network and pushes one file at a time to it.

The audience is therefore people with local files and a network-connected display, and the project's own framing is deliberately narrower than a streaming app. There is no catalogue of streaming services to browse. You pick a file, pick a device, and press play.

That narrowness is the feature. No server to configure, no port forwarding, no library indexing, no directory layout for the TV to understand. The cost is that every file is a deliberate action, so a household that wants a permanent media centre built around Go2TV will find it tiring. The application ships in three shapes, a graphical interface, a command line, and a web interface in server mode, so the same tool can be a desktop utility or something you drive from a phone browser.

## Two casting stacks live in the same binary

Based on the repository layout, the tree separates the two protocols the tool speaks. The castprotocol/ directory covers Chromecast, devices/ holds device handling and discovery, and soapcalls/ holds the SOAP exchanges that DLNA media renderers expect. The httphandlers/ package serves the web interface in server mode, rtmp/ carries the RTMP server used to feed live streams, and metadata/ deals with media information.

Discovery is handled by two libraries, go-ssdp for SSDP and hashicorp/mdns for multicast DNS, which matches the two device families the project supports: DLNA/UPnP TVs such as Samsung, LG and Sony, and Chromecast including Chromecast with Google TV. The CLI reflects this design directly, because the target is addressed by a URL that the device discovery step hands you.

Third-party receiver applications are supported as well, with BubbleUPnP and GMediaRender named as examples. That is a meaningful difference from vendor casting: the receiver app becomes the thing on the TV, and Go2TV simply speaks to it.

## FFmpeg is the compatibility layer, and it is optional

Many TVs accept only a narrow set of containers and codecs. Go2TV handles that by shelling out to FFmpeg when a file is incompatible, converting on the fly. The project is explicit that this is opt-in: FFmpeg has to be installed, and Go2TV uses it automatically when it is needed.

The encoding choice is worth knowing. When transcoding is enabled, Go2TV probes the available GPU H.264 encoders first and falls back to libx264 if hardware encoding is unavailable or fails at startup. A machine with a usable GPU encoder therefore transcodes on the GPU, and a machine without one quietly takes the slower software path rather than failing.

The same dependency powers several other features. External SRT, VTT, ASS and SSA subtitle files are supported, along with embedded MKV subtitles, and seeking works by position in the video. The RTMP server lets you cast a live stream from OBS directly to a Chromecast, and the experimental Cast Desktop feature turns a desktop into a live stream for DLNA or Chromecast targets. Both of those last two are gated behind the same requirement, so installing FFmpeg is what turns Go2TV from a file caster into a stream caster.

## Torrent casting plays a file that is still downloading

Torrent support is the feature that distinguishes Go2TV from the ordinary push-a-file tools, and the module list shows the machinery behind it, a dependency on the anacrolix torrent library.

The flow is simple in the interface and involved underneath. In the graphical interface you click Torrent…, paste a magnet link or open a .torrent file, and choose Use file. Casting starts immediately rather than after the download completes. When the player seeks to a position that has not arrived yet, Go2TV fetches the missing ranges on demand, and the same seekable source is what FFmpeg reads when transcoding is active.

The lifecycle is well specified, which matters for a feature that writes to disk. Cancel download stops playback and removes the temporary cache, and loading another torrent or quitting removes it as well. On Android the download continues in the background even after you press Stop, and the same flow accepts provider-backed .torrent documents as well as magnets, with torrent files shareable from other apps.

The honest caveat is that this pulls a full torrent client into a media caster, so the binary carries a stack you may never use.

## Installing and the first cast, from a cask to a command line

On macOS the documented path is a Homebrew cask, and on Linux it is a Flathub application.

```bash
brew install --cask go2tv
```

```bash
flatpak install flathub app.go2tv.go2tv
```

The Flatpak build bundles FFmpeg automatically. Otherwise, download the latest release from the releases page and run the single executable: go2tv.exe for the Windows GUI, go2tv-lite.exe for the Windows CLI, go2tv for Linux, and the macOS zip for Intel or Apple Silicon. The Android build is an .apk with bundled FFmpeg, arm64 only, and it needs Android 9.0 or newer.

The command line is the quickest way to see whether your TV is reachable. Listing devices first, then pushing a file to the address that was discovered:

```bash
go2tv -l
go2tv -v movie.mp4 -t http://192.168.1.100:8060/
```

Adding a subtitle file and enabling transcoding works the same way, and the remote URL flag points Go2TV at a file served over HTTP rather than one on disk.

```bash
go2tv -v movie.mkv -s movie.srt -tc -t http://192.168.1.100:8060/
go2tv -u https://example.com/movie.mp4 -t http://192.168.1.50:8009
```

In server mode, a web interface lets you browse media roots and control casting from any browser on the network. Its assets are built with Tailwind CSS and esbuild, and the build is scripted in the repository's package.json.

```bash
npm run build:webui:css
npm run build:webui:js
npm run build:webui
```

## A media server versus a direct push

The alternative to Go2TV is not another caster so much as a different architecture: a UPnP or DLNA media server, and the receiver apps such as BubbleUPnP and GMediaRender are named in the project as supported targets. A server publishes a directory tree and lets the renderer pull what it wants. Go2TV does the opposite: it opens a channel to the device and serves a single file, converting it if the device refuses the format.

The difference shows up in everyday use. With a server, the TV keeps a catalogue, remembers where you stopped, and can browse while you are away. With Go2TV, each file is a session you start, and the catalogue lives in your file manager instead of on the TV. What Go2TV adds in exchange is format flexibility through FFmpeg, the ability to serve a file from a magnet link, and no server process to keep alive on a machine that is not otherwise on.

For a single laptop and a single TV, the direct push is less machinery. For a house with several people browsing a shared library, the server model wins on ergonomics even though Go2TV is the better tool for a one-off file.

## Where Go2TV stops working

The device list is the boundary. DLNA and UPnP televisions, Chromecast devices, and receiver applications are the documented targets, and the project does not describe support for AirPlay or for the proprietary casting stacks of other TV ecosystems. Everything happens on the local network, so a device on a different VLAN, or a guest network that isolates clients, will simply not be discovered.

Format support is a second limit. Without FFmpeg installed, a file the TV cannot decode is a file the TV will not play, and the project treats transcoding as an optional add-on rather than a bundled feature. Even with it, the constraints of the output format and of the receiving device still apply.

Smaller edges are worth listing. Gapless playback is supported for DLNA devices, which implies it is not a guarantee for Chromecast targets. Cast Desktop is labelled experimental. The Android package is arm64 only and requires Android 9.0 or newer. And since the build runs on a module path of go2tv.app/go2tv/v2 requiring Go 1.26.0, building from source means matching that toolchain.

## MIT licence, steady releases and a version scheme that matters on Android

Go2TV is MIT licensed, so reading it, modifying it and shipping your own build carries no copyleft obligation, which makes it a comfortable dependency for a self-hosted setup or a bundled appliance.

The project is not archived and the last push was on 2026-10-18, with v2.7.0 released on 2026-10-09 following v2.6.1 on 2026-09-16 and v2.6.0 on 2026-09-14. Releases are frequent enough that the release notes are the place to check for behaviour changes rather than the repository as a whole.

The build system carries one subtlety worth knowing. The Makefile derives a numeric application code from version.txt, and the comment explains why: Android refuses to install a build whose code is lower than the one already on the device, so the code has to rise with every release and a development build has to stay below the release it leads to. The same file drives the AppImage packaging, and a Dockerfile builds from golang:1.26 with make and make install, producing a container whose entrypoint is go2tv.

```dockerfile
FROM golang:1.26
WORKDIR /usr/local/src/go2tv/
COPY . .
RUN make
RUN make install
ENTRYPOINT [ "go2tv" ]
```

## Conclusion

Go2TV is a good fit if your TV is DLNA or Chromecast, your media sits on a laptop rather than on a NAS the TV can browse, and you would rather push one file at a time than publish a library. It is the wrong tool for a shared household library that every device should browse, and for formats your TV refuses when FFmpeg is not installed. Verify three things before committing: that your device appears in the discovery list of go2tv -l, that FFmpeg is on your PATH if the container is unusual, and that the version you install matches the release notes you read, since the project ships per-architecture zips and an AppImage built from the same tree.

## FAQ

### How do I install Go2TV on macOS or Linux?

On macOS install the Homebrew cask with brew install --cask go2tv, and on Linux install the Flathub application with flatpak install flathub app.go2tv.go2tv. You can also download a per-architecture zip from the releases page and run the single executable without any installation step.

### Does Go2TV need FFmpeg installed?

No, but without it files your TV cannot decode natively will not play, since transcoding is what FFmpeg provides. When transcoding is enabled Go2TV probes available GPU H.264 encoders first and falls back to libx264, and the Flatpak and Android builds bundle FFmpeg already.

### Can Go2TV cast a torrent or magnet link?

Yes. You paste a magnet link or open a .torrent file, choose the file to use, and casting starts while the download is still running, with missing ranges fetched on demand when you seek. Cancel download stops playback and removes the temporary cache.

### How do I find the device to cast to from the command line?

Run go2tv -l to list the devices discovered on your network, then pass the address you want with the -t flag, for example go2tv -v movie.mp4 -t http://192.168.1.100:8060/. The -u flag serves a remote file over HTTP instead of a local one.

### Which devices can Go2TV cast to?

The documented targets are DLNA and UPnP televisions such as Samsung, LG and Sony models, Chromecast devices including Chromecast with Google TV, and media receiver apps such as BubbleUPnP and GMediaRender. The project does not describe support for AirPlay or other vendor-specific casting protocols, and discovery only works across the same local network.

## Sources

- [alexballas/go2tv on GitHub](https://github.com/alexballas/go2tv)
- [Issues](https://github.com/alexballas/go2tv/issues)
- [License: MIT](https://github.com/alexballas/go2tv/blob/main/LICENSE)
- [README](https://github.com/alexballas/go2tv/blob/main/README.md)
- [Releases](https://github.com/alexballas/go2tv/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/alexballas-go2tv