All the applications you love—built and maintained by a community member who understands what you need on Unraid. Love a particular app or plugin? Donate directly to the developer to support their work.
Jellyfin is a Free Software Media System that puts you in control of managing and streaming your media. It is an alternative to the proprietary Emby and Plex, to provide media from a dedicated server to end-user devices via multiple apps. Jellyfin is descended from Emby's 3.5.2 release and ported to the .NET Core framework to enable full cross-platform support. There are no strings attached, no premium licenses or features, and no hidden agendas: just a team who want to build something better and work together to achieve it.
The Plex Media Server enriches your life by organizing all your personal media, presenting it beautifully and streaming it to all of your devices. It's easy to use, it's awesome, and it's free!
The plexpass Media Server enriches your life by organizing all your personal media, presenting it beautifully and streaming it to all of your devices. It's easy to use, it's awesome, and it's free!
dizqueTV is a Plex DVR plugin. It allows you to host your own fake live tv service by dynamically streaming media from your Plex servers(s). Your channels and settings are all managed through the dizqueTV Web UI.
dizqueTV will show up as a HDHomeRun device within Plex. When configuring your Plex Tuner, simply use the generatered ./.dizquetv/xmltv.xml file for EPG data. dizqueTV will automatically refresh your Plex server's EPG data and channel mappings (if specified to do so in settings) when configuring channels via the Web UI. Ensure your FFMPEG path is set correctly via the Web UI, and enjoy!
This is an unRAID Docker template for:
Debrid Media Bridge
"An All-In-One image for the unified deployment of Riven, Zurg, and rclone"
https://hub.docker.com/r/iampuid0/dmb/
!!!!!!!!! ADDITIONAL STEPS REQUIRED DURING INITIAL SETUP !!!!!!!!!
This link has all the information and links you might need: https://github.com/Unlearned6688/unraid-templates/blob/main/template-readmes/dmb-readme.md
During the first setup, directories will be created using root user on the host OS (unRAID).
However, the container uses a non-root user called DMB when running normally.
So, you need to change the owner of the DMB directories to the unRAID default of owner: nobody group:users aka 99:100
Method 1 CLI
1. stop the docker container fully. Wait to see it fully stopped.
2. access the terminal as root user
3. run the command chown -R 99:100 /mnt/user/appdata/DMB
4. run the above command again for any other directories used by DMB eg /mnt/user/DMB (skip if you only have one directory)
5. Restart the container. Check logs. You might need to stop container and run the chown command two times during the first setup only.
Method 2 unRAID GUI
1. stop the docker container fully. Wait to see it fully stopped.
2. login to unRAID GUI as root user
3. Locate your ./appdata/DMB directory (if you setup shares (most people do) then click shares, go into appdata, you'll see DMB there after the first run)
4. click the + sign on the right side of the ./appdata/DMB directory. Change owner. Choose nobody in the drop down menu (it is called just that: nobody) as the owner. Apply the change
5. repeat above steps if you have other directories used by DMB eg /mnt/user/DMB
6. Restart the container. Check logs. You might need to stop container and do the steps twice during the first setup only.
"What are Riven and Zurg? What is all of this stuff?"
Riven is a new, still in development, open source, free, media solution that combines a bunch of ideas into one complete, polished package.
More specifically, in the same vein as plex_debrid before (github repo: itstoggled/plex_debrid - now archived), it allows for end users to input their own (paid) real-debrid API token (real-debrid.com for info) (other "debrids" not supported at the moment) and then access "cached torrents" on the real-debrid servers. Cached torrents allow the user to stream the video file being sought, whether movie or tv show.
Zurg is a specialized rclone mount and filtering program. Basically, it takes a raw rclone mount of all torrents a user has in their debrid library, and it filters them resulting in a huge variety of variables such as file size, bitrate, resolution, etc. (huge list).
This project also leverages the power of rclone to mount the debrid webdav directory into your OS, unRAID in this case, inside of a docker container. When you provide this mount path to your Plex server Plex won't distingtush between local media that you might have and this mounted media. It will stream the media directly from the real-debrid (or other servers if added later by devs) servers to your Plex server where it will be played lag-free assuming your network/server/player can handle it.
PostgreSQL database is also used to store settings and relevant information.
"So, why this image and not the image from the developers of Riven or Zurg?"
You could certainly use those if you wish to setup all the invidivdual components. This AIO image just seeks to simplify and streamline the process.
links for a ton more information if desired or required:
DMB AIO wiki: https://github.com/I-am-PUID-0/DMB/wiki
Riven Wiki: https://rivenmedia.github.io/wiki/
https://github.com/rivenmedia/riven
https://github.com/debridmediamanager/zurg-testing
https://rclone.org/docs/
https://www.postgresql.org/
Floatplane-Downloader - Automagically downloads the latest videos from Floatplane and optionally formats them to be viewed in Plex.
Both downloading videos as they release and archiving the entire backlog is supported
To setup floatplane-downloader, you will have to edit the settings.json file in /mnt/user/appdata/floatplane-downloader/db
https://github.com/Inrixia/Floatplane-Downloader/blob/master/wiki/settings.md
Or you can read through the advanced-env setup to configure it only through container variables: https://github.com/Inrixia/Floatplane-Downloader/blob/master/wiki/advenv.md
Plex Media Server
Enjoy your media on all your devices.
All your movie, TV Show, music, and photo collections at your fingertips, anywhere you go on all the devices you love.
Plex-TVTime is a Plex webhook handler that automatically updates your TVTime watch history. TV episodes are automatically marked as watched once you complete them on Plex.
Plexanisync lets you synchronize your plex library with anilist, plugin from RickDB, Docker-Hub version maintained by Mizz141.
A premade custom_mappings.yaml file is available on github: https://github.com/mizz141/PlexAniSync-Mappings along with additional installation instructions (Highly Recommended)
Yet Another Proxy (YAP) for SmoothStreams.tv Docker Image
Environment variables will take precedence over manual changes to proxysettings.json and will persist across container restarts. This means that if you set the YAP_USERNAME and YAP_PASSWORD for instance when you create the container, these will always be placed in the proxysettings.json file, even if you edit the file manually with a text editor.
For Plex setup see: https://github.com/stokkes/docker-sstvproxy#plex
tautuilli-notification-digest (TND) acts a middleman between Discord and Tautulli for notifying you about recently added media to your plex server.
It collects all of the Recently Added notifications Tautulli would send to a Discord notification agent throughout the day and then compiles them all into **one** notification that is sent on a schedule you configure. It reduces multiple, noisy notifications for active plex server into one digestable message sent once a day.
You will need to make changes to Tautulli before TND is usable on unraid. Refer to the Support Thread or use the Quick Start guide in the project README to get started.
tinyMediaManager is a media management tool written in Java/Swing. It is written to provide metadata for the Kodi Media Center (formerly known as XBMC), MediaPortal and Plex media server. Due to the fact that it is written in Java, tinyMediaManager will run on Windows, Linux and macOS (and possible more OS).
Create live TV channels from media on your Plex servers, and more!
Access your channels by adding the spoofed Tunarr HDHomerun tuner to Plex, Jellyfin, or Emby. Or utilize generated M3U files with any 3rd party IPTV player app.
Tunarr is a fork of dizqueTV.
**Nvidia GPU Use:**
Using the Unraid Nvidia Plugin to install a version of Unraid with the Nvidia Drivers installed and add **--runtime=nvidia** to "extra parameters" (switch on advanced view) and copy your **GPU UUID** to **NVIDIA_VISIBLE_DEVICES.**
**Intel GPU Use:**
Edit your **go** file to include **modprobe i915**, save and reboot, then add **--device=/dev/dri** to **"extra parameters"** (switch on advanced view)
TVH-IPTV-Config - A simple IPTV config frontend for playlist filtering providing a M3U proxy for Plex, Emby, Jellyfin and (of course) Tvheadend.
TVH-IPTV-Config (TIC) attempts to provide a simple IPTV config frontend for a Tvheadend (TVH) backend. In addition to this, it provides HDHomeRun tuner emulation, an HLS playlist proxy/caching and custom channel mapping from multipl playlist sources.
Note: This template is a stand-alone installation of TIC and requires that you, the user, also install and maintain a seperate Tvheadend container. Currently, only TVH v4.3+ is tested and supported, though 4.2.8 may work fine. You will need to ensure you have the 'XMLTV URL grabber' module installed with your TVH server.
If you want to run TIC without managing your own TVH backend, then you should look at using the "tvh-iptv" template which provides an AIO docker container solution.
Features:
Easily import/configure channels from playlists.
Assign and locally cache logos per channel.
Assign EPG sources for each channel.
Configure channel numbers and ordering for channels.
Configure multiple stream sources per channel.
Manage and search through playlists that contain tens of thousands of streams without crashing the UI.
Provide an ffmpeg buffer for your streams so multiple devices playing back the same stream will only use one playlist connection.
Serve an HDHomeRun emulator for each playlist so Plex, Emby, and Jellyfin can connect to it an saturate the number of configured connections per playlist.
Automatically fetch missing metada for your EPG programme schedule like icons, description, etc.
Configure and automatically actively maintain a Tvheadend backend for IPTV without the fuss.
Automatically generate IPTV networks in TVH per playlist configured with a number of connections allowed.
Automatically manage a custom EPG based on channel selection.
Automatically create muxes in TVH for each stream asssociated with a configured channel. Configure muxes with FFmpeg pipes to improve compatibility and provide a local buffer.
Automatically map mux services to channels in TVH.
Automaticlaly configure optimal streaming and timeseries settings.
Automaticlaly configure optimal recording settings.
Much more little tweaks behind the scenes...
How it works:
Tvheadend(https://www.tvheadend.org/), AKA "TVH", is a TV streaming server and recorder supporting, among other things, IPTV input sources.
Tvheadend offers the HTTP (VLC, MPlayer), HTSP (Kodi, Movian) and SAT>IP streaming and there are a bunch of clients out there to use as clients for watching.
The catch is that on its own, Tvheadend can be complicated to setup for IPTV. Once you read through all the documentation and forum posts on how to do it, it works well. But that is a steep learning curve. In addition to this, if you were to just throw a IPTV playlist of thousands of channels at the thing, well... good luck with that mess. To get it working really well, there is a lot of mouse clicking here and there and perhaps the odd ffmpeg pipe to configure on each MUX and... who as time for that!
TIC should make life easy(ish) when setting up IPTV on Tvheadend.
Advanced Configuration:
LIMIT CPU USE:
1) Toggle this Docker Container template editor to "Advanced View".
2) In the "Extra Parameters" field, add "--cpus='1'".
This value depends on the number of cores available to the container. To limit to 50%, set this value to 0.5 * n cores. If you have 2 cores available to this container, "--cpus='.5'" will equal 25% of that available CPU resources. To limit the CPU cores available to the continer, use "CPU Pinning"
LIMIT RAM ALLOCATION:
1) Toggle this Docker Container template editor to "Advanced View".
2) In the "Extra Parameters" field, add "--memory='1g'".
Tvheadend and TIC can use on average around 100Mib - 500 Mib of RAM for various tasks.
Even though limiting RAM is unnecessary as this container should not ever need more that 1GB RAM it is good practice to do so.
