Set Up Redlib as a Self-Hosted Reddit Front End

Browse Reddit Without the Noise

Reddit’s official website and app have grown heavier with every passing year – more ads, more tracking, more JavaScript bloat, and an API pricing structure that killed off most third-party clients. Redlib is an open-source, privacy-respecting front end for Reddit that strips all of that away. It fetches Reddit content without loading Reddit’s ad scripts, without requiring an account, and without sending your browsing habits back to any analytics platform. The result is a fast, clean interface that looks and works better than the original for anyone who just wants to read posts and threads.

Self-hosting Redlib means you run your own instance on your own hardware or a VPS, giving you full control over who can access it and how it behaves. This guide walks through the entire setup process using Docker, which keeps things clean and avoids dependency conflicts. The whole process takes under 30 minutes if you have a Linux server ready to go.

What You Need Before Starting

The requirements are minimal. You need a server running Linux – Ubuntu 22.04 or Debian 12 work well – with Docker and Docker Compose installed. If you are running this on a home server, a Raspberry Pi 4 or any x86 machine with at least 512MB of RAM handles Redlib without any strain. A VPS from any provider works just as well, and a $5-per-month tier is more than enough. You also need a domain name if you want to expose the instance publicly with HTTPS, though running it locally on a private network is perfectly valid too.

Make sure Docker is installed and your user has permission to run Docker commands without sudo. If you set up a reverse proxy like Nginx or Caddy on this server before, those skills carry over directly here. Caddy is worth recommending specifically because it handles SSL certificate provisioning automatically, which cuts out several manual steps compared to Nginx with Certbot.

Installing Redlib with Docker Compose

Create a directory for the project and move into it. A clean location like /opt/redlib keeps things organized and easy to find later.

mkdir /opt/redlib && cd /opt/redlib

Create a file called docker-compose.yml in that directory. Redlib publishes an official Docker image under quay.io/redlib/redlib, and that is what the compose file should reference. Below is a working configuration that runs Redlib on port 8080 internally:


version: "3"
services:
  redlib:
    image: quay.io/redlib/redlib:latest
    restart: unless-stopped
    ports:
      - "127.0.0.1:8080:8080"
    environment:
      - REDLIB_DEFAULT_THEME=black
      - REDLIB_DEFAULT_FRONT_PAGE=default
      - REDLIB_DEFAULT_LAYOUT=card
      - REDLIB_DEFAULT_SHOW_NSFW=false
      - REDLIB_DEFAULT_BLUR_NSFW=true
      - REDLIB_DEFAULT_HIDE_HLS_NOTIFICATION=true


Binding the port to 127.0.0.1:8080 rather than 0.0.0.0:8080 is intentional. It prevents the container from being directly accessible from the internet and forces all traffic through your reverse proxy, which is where HTTPS termination and access control happen. Once the file is saved, start the container with docker compose up -d and confirm it is running with docker compose ps. The Redlib interface will be accessible at http://localhost:8080 from the server itself at this point.

Setting Up a Reverse Proxy with Caddy

If Caddy is not already installed, add it via the official repository for your distribution. On Ubuntu, the Caddy team maintains an APT repository that keeps the binary up to date. Once installed, the configuration file lives at /etc/caddy/Caddyfile.

Replace the default content of that file with the following, substituting your actual domain name:


reddit.yourdomain.com {
  reverse_proxy localhost:8080
}


That is the entire Caddy configuration needed. Caddy automatically provisions a TLS certificate via Let’s Encrypt when it detects a valid public domain pointing to your server’s IP address. Run systemctl reload caddy and wait about 30 seconds. Your Redlib instance should now be reachable over HTTPS at your domain. If your DNS record is not yet propagated, the certificate provisioning will fail silently and retry – check journalctl -u caddy for status messages.

Configuring Redlib Defaults and Access Control

The environment variables in your compose file control default behavior for every visitor who has not changed their personal settings. REDLIB_DEFAULT_THEME accepts values like system, light, dark, black, and several others. REDLIB_DEFAULT_LAYOUT accepts card, clean, and compact. Users can override all of these from the settings page, but the defaults shape the first impression.

Two additional environment variables deserve attention for anyone running a private instance. Setting REDLIB_ROBOTS_DISABLE_INDEXING=true adds a robots.txt that discourages search engine crawling, which keeps your instance off public lists of Redlib instances. Setting REDLIB_DEFAULT_SUBSCRIPTIONS to a pipe-separated list of subreddit names pre-populates the front page for new visitors with those communities – useful if you are running this for a small group with shared interests.

For access control, Redlib does not have built-in authentication. If you want to restrict who can reach the instance, the cleanest approach is to add basic authentication at the Caddy layer. In the Caddyfile, add a basicauth block with a hashed password generated by running caddy hash-password. Alternatively, if you already run a self-hosted identity layer or a VPN like WireGuard, placing Redlib behind that network boundary is the simplest approach and requires no changes to Redlib’s configuration at all.

Keeping the Instance Updated

Redlib updates fairly often, partly because Reddit occasionally changes internal endpoints or rate-limiting behavior that breaks older versions. Keeping the image current matters more here than with a typical self-hosted app. The update process is two commands from inside the /opt/redlib directory:


docker compose pull
docker compose up -d


The first command downloads the latest image, and the second restarts the container using it. Downtime is typically under five seconds. For anyone who wants to automate this, a weekly cron job running those two commands handles it without any manual intervention. Set it with crontab -e and schedule it for a low-traffic window. Watch the Redlib GitHub repository for release notes if Reddit makes a significant change that breaks things between scheduled updates – that is usually where fixes appear first.