ph-intercept

ph-intercept

Docker app from m00grin's Repository

Real-time DNS dashboard for Pi-hole v6, AdGuard Home, and Technitium DNS.

Requirements

A Pi-hole v6, AdGuard Home, or Technitium DNS server the container can reach over the network.
Overview

Real-time DNS dashboard for Pi-hole v6, AdGuard Home, and Technitium DNS. Every query becomes a ship on screen: allowed queries fly past as friendlies, and blocked ones get shot down by an interceptor. The HUD shows live stats and lets you pause blocking with a timer.

Setup: pick your PROVIDER, then fill in the URL and credentials for that provider only. Leave the other providers' fields blank.

Optional settings (backgrounds, ignored domains and clients, view-only and privacy options for shared screens, 2-player split screen with a second DNS server) are under Show more settings.

ph-intercept

Latest release Build status CodeQL status OpenSSF Best Practices

A Pi-hole, AdGuard Home, and Technitium DNS visualizer and dashboard that runs as a standalone Docker container. Streams live DNS query events from your Pi-hole v6, AdGuard Home, or Technitium DNS server and renders them as pixel-art friendlies and enemies. Blocked queries are destroyed by the ship, allowed queries fly through. Toggle blocking, set timed blocks, update block lists, and switch ships from the HUD.

Designed to be dropped in alongside an existing DNS setup with no extra dependencies. Two instances can run side by side in local 2-player split-screen.

Try the live demo in your browser first, no install needed.

ph-intercept shooting down blocked DNS queries live
Starfield Nebula Outrun
Starfield background Nebula background Outrun background

AdGuard Home user? See the AdGuard setup guide.

Technitium DNS user? See the Technitium setup guide.

Quick Start

1. Get your Pi-hole app password (not your web login password): from the Pi-hole admin panel, go to Settings → Web interface / API → Configure app password.

  • CLI users: Create a .env file in the same directory as your compose.yaml:

    PIHOLE_PASSWORD=your_pihole_app_password
    
  • Portainer users: Skip the .env file. Add PIHOLE_PASSWORD as an environment variable directly in the Portainer stack config.

2. Create a compose.yaml (copy the example below or grab compose.yaml from the repo) and update PIHOLE_URL to your Pi-hole's address:

services:
  ph-intercept:
    image: ghcr.io/m00grin/ph-intercept:latest
    hostname: ph-intercept
    container_name: ph-intercept
    restart: unless-stopped
    deploy:
      resources:
        limits:
          memory: 128m
          cpus: "1"
          pids: 20

    environment:
      # REQUIRED: Pi-hole v6 API endpoint
      # Example: "http://192.168.1.2:80/api"
      PIHOLE_URL: "http://CHANGE.ME:PORT/api"

      # CLI users: Create a .env file in the same dir as this compose file with:
      #  PIHOLE_PASSWORD=your_pihole_app_password
      # Portainer Web users: Add the environment variable: PIHOLE_PASSWORD=your_pihole_app_password
      PIHOLE_PASSWORD: ${PIHOLE_PASSWORD}

      # Optional: where ESC navigates to (like your homelab dashboard or homepage)
      # Accepts http://, https://, protocol-relative (//), relative paths, and custom app schemes
      # Leave blank ("") to disable ESC entirely
      RETURN_URL: ""

      # Background. These set the DEFAULT; each user can also switch the background live
      # from the in-app settings menu, and their choice is remembered per-browser.
      # Style: starfield | nebula | outrun | dark
      BG_MODE: starfield

      # Sky region shown for the starfield:
      #   summer_triangle | orion | scorpius | southern_cross
      SKY_PRESET: summer_triangle

      # Optional custom background image: a URL, or /bg/your-filename.jpg (mounted volume).
      # When set, it becomes the default and enables the in-app "CUSTOM" option so it can be
      # picked any time. Leave blank to disable it (CUSTOM shows greyed out in the menu).
      BG_IMAGE: ""

      # SSL certificate verification. Set to "false" if Pi-hole uses HTTPS
      #  with a self-signed certificate. Leave as "true" for HTTP or valid HTTPS.
      PIHOLE_VERIFY_SSL: "true"

      # Optional: comma-separated regex patterns. Matching domains spawn no ships. Case-insensitive.
      # PIHOLE_IGNORE_DOMAINS: .*\.local$,.*\.internal$

      # Optional: "true" makes the page view-only. The server refuses the blocking
      # toggle, filter update and 2-player mode switch; the HUD controls go inert.
      # READ_ONLY: "true"

      # Optional: "true" drops the client name/IP from every query on the server,
      # so it never reaches the browser. Also hides the in-app CLIENT toggle.
      # HIDE_CLIENT: "true"

      # Optional: comma-separated regex patterns matched against the client name or IP.
      # Queries from matching clients spawn no ships. Case-insensitive.
      # PIHOLE_IGNORE_CLIENTS: ^uptime-kuma$,^192\.168\.1\.99$

      # Optional: "true" replaces every domain with an opaque per-start token on the
      # server. Repeat queries still group; domain labels and the DOMAIN toggle go away.
      # HIDE_DOMAIN: "true"

      # 2-player local mode: set the URL (and password if the second Pi-hole has one)
      # to enable a second Pi-hole ship on the right half
      # PIHOLE2_URL: "http://192.168.1.3:8053/api"
      # PIHOLE2_PASSWORD: ${PIHOLE2_PASSWORD}
      # PIHOLE2_VERIFY_SSL: "true"

    volumes:
      # Portainer Web users: This will resolve to /data/compose/<stack-id>/bg/
      - ./bg:/app/static/bg
      # Persists 2-player mode state across container restarts
      - data:/app/data

    cap_drop:
      - ALL

    security_opt:
      - "no-new-privileges:true"

    read_only: true

    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

    ports:
      # Host port : container port. Change the left side if 4653 is taken
      - "4653:4653"

    # Optional: point DNS at your Pi-hole (if used for DNS resolution) or resolver directly (like Unbound)
    # dns:
    #   - your.dns.dockernet.ip

    # Optional: only needed if you use static IPs on a custom Docker network
    # Uncomment both networks blocks if you need this
    # networks:
    #   intercept_net:
    #     ipv4_address: this.container.dockernet.ip

# networks:
#   intercept_net:
#     external: true

volumes:
  data:

3. Start the container:

docker compose up -d

Open http://your-host:4653.


Image Tags

Tag What it is
:latest Latest stable release.
:X.Y.Z Pinned release (e.g. 1.5.8).
:develop GHCR only. Built automatically on every push to the develop branch. May be unstable. Good for trying out what I'm working on.

Other Ways to Get It

Registries

GitHub is where the work happens and where every image is built. Each release is published, unchanged, to every registry below, so the digest is identical everywhere. Pull from whichever you prefer.

Registry Image Notes
GitHub (GHCR) ghcr.io/m00grin/ph-intercept Home. Also carries :develop.
Docker Hub docker.io/m00grin/ph-intercept Release tags.
Codeberg codeberg.org/m00grin/ph-intercept :latest and the last few releases.
GitLab registry.gitlab.com/m00grin/ph-intercept Release tags.

Use the tags from Image Tags.

Build from source

Prefer to build it yourself? Clone a release tag, check that I signed it, and build. The image builds natively for whatever architecture your machine is, with no buildx needed.

tag=$(git ls-remote --tags --refs --sort=-v:refname https://github.com/m00grin/ph-intercept.git 'v*' | head -n1 | sed 's|.*refs/tags/||')
git clone --depth 1 --branch "$tag" https://github.com/m00grin/ph-intercept.git
cd ph-intercept

echo '* ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIMdnYVfo4t2Ag1LkmaQ5nKiN66g23hyHHfWRlsaV93tZ' > /tmp/ph-intercept-signers
git -c gpg.ssh.allowedSignersFile=/tmp/ph-intercept-signers tag -v "$tag"

docker build -t ph-intercept .

tag -v should report a good signature with key SHA256:34Xm5zcAM5p/n6QZD3nJ7p/bbzp21Mh3/e8sHkGk+co. The first line picks the newest release. To build a specific one, set tag yourself, for example tag=v1.5.8.

Then use the Quick Start compose file, replacing its image: line with image: ph-intercept. Compose uses the image you just built, so there is nothing to pull. Then run docker compose up -d.


Entities

Each DNS query spawns an entity. Tier scales with how many times that domain has queried while the entity is still on screen:

Allowed queries: friendly ships traveling across the screen. Cache-answered queries move faster than upstream-answered ones.

Friendly ships for allowed queries, including a heavy transport and a capital ship
Tier Condition Shape Color
1 First query Rounded shuttle · Delta wing · X-wing Green · Blue · Lime
2 Queried again while on screen Heavy transport Cyan
3+ Three or more queries while on screen Capital ship Gold

Blocked queries: enemies the ship targets and destroys. A domain blocked again while still on screen mutates its sprite to the next tier in place.

Targeted enemies for blocked queries: crab (tier 1), heavy drone (tier 2), boss (tier 3)
Tier Condition Shape Color
1 First block Crab invader · Squid Red
2 Blocked twice Heavy drone Orange
3+ Three or more Boss Purple

Ship weapon color tracks tier: green for tier 1, cyan for tier 2, gold for tier 3+.


The ship

The ship targets and destroys blocked entities autonomously. At five on-screen threats a support drone launches and flanks; at ten a second drone deploys. Drones are recalled when the threat count drops.

Seven ships are selectable from the HUD, shown in an 8-slot 4×2 grid: Protector (NSEA Protector, default), Falcon (Millennium Falcon), Swordfish (Swordfish II), Enterprise (NCC-1701), Serenity (Firefly), Normandy (Mass Effect), and PES (Planet Express Ship). Switching ships triggers a warp-out/warp-in transition that pushes nearby entities aside.

Ship selector

The HUD

A strip across the bottom, divided into four panels:

INTERCEPT: blocking status and toggle. Click to open a menu with timed-disable options (10 sec, 30 sec, 5 min) or a full disable. A countdown shows during a timed block; it survives navigation and syncs if blocking changes remotely.

STATS: total queries, blocked, allowed, and block percentage. Updated live.

GRAVITY: gravity list size. The arrow triggers a list update and confirms when done.

SHIPS: active ship name. Click to open the ship selector.

HUD strip: intercept, stats, gravity, ship

A hamburger button at the left edge of the HUD opens the Settings panel, which includes:

  • Friendlies, Client, Domain: show or hide friendly entities, the requesting client label, and the domain label
  • CRT filter: a scanline overlay
  • Auto-hide: slides the HUD away until you hover it
  • Background: switch style and sky region live
  • Pi-hole: link to the Pi-hole admin panel

Display settings are saved to localStorage and restored on next load.


The background

Four modes are available via BG_MODE:

starfield (default): Renders a real section of the night sky from an accurate star catalog (~12,200 stars to magnitude 6.8, color-coded by spectral type). Positions use equatorial coordinates; what you see is where the stars actually are. The sky region is set by SKY_PRESET.

Starfield background (Orion preset)

Star data is from the HYG Database by David Nash (astronexus.com), combining Hipparcos (ESA) and the Yale Bright Star Catalogue, and is licensed under CC BY-SA 4.0.

Planets: Mars, Jupiter, Saturn (with ring), and the Moon are computed from real orbital elements and appear at their actual sky positions, updated hourly.

Transients: occasional satellite passes and meteors, including the ISS.

nebula: A procedurally generated nebula. Overlapping color lobes with value noise, dust lanes, and a synthetic star layer. Fully GPU-rendered, no catalog data.

outrun: A retro synthwave scene. A banded sun setting on the horizon over a scrolling neon perspective grid, with a starry sky. Pairs especially well with the CRT filter.

dark: Plain black background. No canvas rendering overhead.

BG_IMAGE: A custom image (URL or a /bg/your-file.jpg mounted into the container).

The env vars set the default background. Each user can also switch it live from the in-app settings menu (Background), including sky presets and, when BG_IMAGE is set, a CUSTOM option. That choice is remembered per browser and never changes anyone else's default.

Portainer: drop image files into /data/compose/<stack-id>/bg/ on the Portainer host (where the ./bg bind mount resolves).


Configuration

All configuration is via environment variables in compose.yaml.

Upgrading? Pull the latest compose.yaml to see all current options. Anything you don't set uses its default, so an older compose keeps working.

Required

Variable Description
PIHOLE_PASSWORD Pi-hole app password. CLI: set in a .env file. Portainer: add as an environment variable in the stack. Get it from Settings → Web interface / API → Configure app password.
PIHOLE_URL Pi-hole v6 API base URL, e.g. http://192.168.1.x:8053/api

Optional

Variable Default Description
RETURN_URL "" URL that ESC navigates to. Accepts http://, https://, protocol-relative (//), relative paths, and custom app schemes. Leave blank to disable ESC.
BG_MODE starfield Default background: starfield · nebula · outrun · dark. Switchable live in-app.
SKY_PRESET summer_triangle Default sky region: summer_triangle · orion · scorpius · southern_cross. Switchable live in-app.
BG_IMAGE "" Custom image URL or /bg/filename.jpg. When set, it's the default and enables the in-app CUSTOM option; blank leaves CUSTOM disabled.
READ_ONLY false Set to true for a wall display or a page others can open: the server refuses every request that changes something (blocking toggle, filter update, 2-player mode) with HTTP 403, and the HUD leaves those controls inert. Status and stats stay visible.
HIDE_CLIENT false Set to true to drop the client name or IP from every query before it is sent to the browser. The in-app CLIENT toggle is hidden.
HIDE_DOMAIN false Set to true to replace every domain with an opaque token before it is sent to the browser (HMAC-SHA256 with a random key generated at each start, so tokens can't be looked up from a list of common domains). Repeat queries still group into tiers; domain labels, the letter fragments on a kill and the in-app DOMAIN toggle are left out.
PIHOLE_VERIFY_SSL true Set to false if Pi-hole uses HTTPS with a self-signed certificate.
PIHOLE_IGNORE_DOMAINS (unset) Comma-separated regex patterns. Domains that match spawn no ships. Case-insensitive; escape literal dots (\.local$). Example: .*\.local$,.*\.internal$
PIHOLE_IGNORE_CLIENTS (unset) Comma-separated regex patterns, matched against the client name and IP. Queries from matching clients spawn no ships. Case-insensitive; escape literal dots (^192\.168\.1\.99$). Example: ^uptime-kuma$,^10\.0\.0\.5$
PIHOLE2_URL (unset) Second Pi-hole v6 API base URL. Setting a valid URL activates local 2-player split-screen mode. See below.
PIHOLE2_PASSWORD "" App password for the second Pi-hole. Omit if it has none.
PIHOLE2_VERIFY_SSL true Set to false if the second Pi-hole uses HTTPS with a self-signed certificate.

Local 2-Player Mode

Two DNS instances can run side by side in split-screen. Player 1's ship occupies the left half of the canvas, Player 2's ship the right. Each instance streams its own events, stats, and controls.

Add the second Pi-hole to your compose.yaml environment block:

PIHOLE2_URL: "http://192.168.1.3:8053/api"
PIHOLE2_PASSWORD: ${PIHOLE2_PASSWORD}

And add the password to your .env file:

PIHOLE2_PASSWORD=your_second_pihole_password

PIHOLE2_PASSWORD can be omitted if the second Pi-hole has no app password set. Setting a valid PIHOLE2_URL is all that is required to make the mode available; turn it on from the in-game 2-player panel. On/off state is saved to the data volume, so it survives container restarts.

AdGuard Home? The second instance mirrors your primary provider, so an AdGuard setup pairs with a second AdGuard Home via ADGUARD2_URL / ADGUARD2_USERNAME / ADGUARD2_PASSWORD. See the AdGuard 2-player setup.

Technitium DNS? Pairs with a second Technitium via TECHNITIUM2_URL and TECHNITIUM2_TOKEN (or user + password). See the Technitium 2-player setup.


Requirements

  • Pi-hole v6 (v5 is not compatible)
  • Docker with Compose
  • Network route from the container to your Pi-hole
  • Architecture: linux/amd64 · linux/arm64 · linux/arm/v7 · linux/arm/v6 · linux/386 · linux/riscv64 · linux/ppc64le

The container listens on port 4653. The compose file includes an optional static IP block for existing Docker networks.

Curious what everyone runs it on? I'm asking in a quick poll instead of collecting any data.


Troubleshooting

If something's off, check the logs first:

docker logs ph-intercept 2>&1 | grep -v '^INFO:'

On a healthy setup that prints nothing. Otherwise ph-intercept logs one line when a problem starts, and one line when it clears:

Log line What to check
Pi-hole: could not reach http://... Check PIHOLE_URL The URL and port, and that the container can reach your Pi-hole over the network.
Pi-hole: unexpected HTTP 404 reply from .../auth. Check PIHOLE_URL points at the Pi-hole v6 API (ends in /api) PIHOLE_URL must end in /api, not /admin.
Pi-hole: login rejected (password incorrect). Check PIHOLE_PASSWORD Use an app password from Settings → Web interface / API → Configure app password.
Pi-hole: login refused by rate limiting (...), retrying Pi-hole throttles logins after a few quick attempts. It clears on its own within a few seconds.
PROVIDER='...' is not recognised ... PROVIDER must be pihole, adguard, or technitium (or leave it out for Pi-hole).

In 2-player mode the second Pi-hole logs the same lines as Pi-hole 2, pointing at the PIHOLE2_* variables.


Privacy

ph-intercept only talks to your own Pi-hole instance(s). It never phones home, has no analytics, and collects nothing. Your display settings (ship, background, toggles) are saved in your browser's local storage and never leave it. Requests from other websites to the blocking controls are refused, so a page you visit can't toggle your DNS server through ph-intercept.

Shared screens: on a wall display or a page other people can open, READ_ONLY stops anyone from changing your DNS server, and HIDE_CLIENT and HIDE_DOMAIN keep client names and domains out of the browser. See Optional settings.


Testing

I may have gone a little overboard.

ph-intercept is developed against a suite of about 700 tests that I run locally before every release. The suite lives on my machine, not in this repository. CI builds the images and scans them (CodeQL and Trivy). The tests cover these layers:

  • DNS providers: async unit tests for the Pi-hole, AdGuard Home, and Technitium clients: every auth path, session handling, query classification, the broadcast queue, and the live query pollers
  • API and config: every route, security headers, cache-control rules, input validation, environment parsing, and the READ_ONLY, HIDE_CLIENT, and HIDE_DOMAIN modes
  • 2-player mode: routes, state persistence, and the races between two instances
  • Browser: Playwright tests in Chromium, Firefox, and WebKit for page load, canvas sizing, SSE connection and reconnect, settings persistence, blocked storage, sprite recovery, and bfcache reentry
  • Devices: emulated device profiles and viewports, including Raspberry Pi touchscreens, Fire tablets, iPads, Android tablets, HiDPI displays, 4K, ultrawides, and orientation changes
  • Pixels: a canvas baseline that hashes rendered scenes, so a drawing regression can't hide behind passing behavior tests
  • Docs and listings: checks that the READMEs, example composes, and the Unraid template stay in step

Categories

Download Statistics

964
Total Downloads

Related apps

Explore more like this

Explore all

Links

Details

Repository
m00grin/ph-intercept:latest
Last Updated2026-11-14
First Seen2026-11-15

Runtime arguments

Web UI
http://[IP]:[PORT:4653]/
Network
bridge
Shell
sh
Privileged
false
Extra Params
--cap-drop=ALL --security-opt=no-new-privileges --memory=128m --pids-limit=20

Template configuration

Web UI portPorttcp

Port for the dashboard. Change it if 4653 is already in use on your server.

Target
4653
Default
4653
Value
4653
DNS providerVariable

Which DNS server to watch. Fill in only that provider's fields below.

Target
PROVIDER
Default
pihole|adguard|technitium
Value
pihole
Pi-hole: API URLVariable

Pi-hole v6 API base URL, e.g. http://192.168.1.x:80/api (v5 is not supported).

Target
PIHOLE_URL
Pi-hole: app passwordVariable

Pi-hole app password, from Settings, Web interface / API, Configure app password.

Target
PIHOLE_PASSWORD
AdGuard Home: control URLVariable

AdGuard Home control API base URL, e.g. http://192.168.1.x:3000/control

Target
ADGUARD_URL
AdGuard Home: usernameVariable

AdGuard Home username or email address.

Target
ADGUARD_USERNAME
AdGuard Home: passwordVariable

AdGuard Home password.

Target
ADGUARD_PASSWORD
Technitium: console URLVariable

Technitium web console address, e.g. http://192.168.1.x:5380

Target
TECHNITIUM_URL
Technitium: API tokenVariable

Permanent API token from the Technitium console (recommended). Or leave blank and use the username and password under Show more settings.

Target
TECHNITIUM_TOKEN
Technitium: usernameVariable

Console username, only if you are not using an API token.

Target
TECHNITIUM_USER
Technitium: passwordVariable

Console password, only if you are not using an API token.

Target
TECHNITIUM_PASSWORD
Technitium: 2FA codeVariable

Only if the console account has 2FA enabled. Not needed with an API token.

Target
TECHNITIUM_TOTP
Technitium: query log appVariable

Installed name of the Technitium query-log app. Change only if you renamed it.

Target
TECHNITIUM_QUERY_LOG_APP
Default
Query Logs (Sqlite)
Value
Query Logs (Sqlite)
Technitium: query log classVariable

Class path of the Technitium query-log app. Change only if you renamed it.

Target
TECHNITIUM_QUERY_LOG_CLASS
Default
QueryLogsSqlite.App
Value
QueryLogsSqlite.App
Default backgroundVariable

Starting background. Viewers can switch it live in the app.

Target
BG_MODE
Default
starfield|nebula|outrun|dark
Value
starfield
Sky regionVariable

Constellations shown in the starfield background.

Target
SKY_PRESET
Default
summer_triangle|orion|scorpius|southern_cross
Value
summer_triangle
Custom background imageVariable

Image URL, or /bg/your-file.jpg for a file in the backgrounds folder below. Leave blank to disable.

Target
BG_IMAGE
Backgrounds folderPathro

Folder for custom background images, used with the Custom background image setting.

Target
/app/static/bg
Default
/mnt/user/appdata/ph-intercept/bg
Value
/mnt/user/appdata/ph-intercept/bg
ESC return URLVariable

Where pressing ESC takes you, e.g. your homelab dashboard. Leave blank to disable ESC.

Target
RETURN_URL
View-only modeVariable

Set to true for a wall display or a page others can open: the server refuses the blocking toggle, filter updates, and 2-player mode changes, and the HUD leaves those controls inert. Stats stay visible.

Target
READ_ONLY
Default
false|true
Value
false
Hide client namesVariable

Set to true to drop the client name or IP from every query before it reaches the browser. The in-app CLIENT toggle is hidden.

Target
HIDE_CLIENT
Default
false|true
Value
false
Hide domainsVariable

Set to true to replace every domain with an opaque token before it reaches the browser (new random key at each start). Repeat queries still group; domain labels and the DOMAIN toggle are left out.

Target
HIDE_DOMAIN
Default
false|true
Value
false
Pi-hole: verify SSLVariable

Set to false if Pi-hole uses HTTPS with a self-signed certificate.

Target
PIHOLE_VERIFY_SSL
Default
true|false
Value
true
AdGuard Home: verify SSLVariable

Set to false if AdGuard Home uses HTTPS with a self-signed certificate.

Target
ADGUARD_VERIFY_SSL
Default
true|false
Value
true
Technitium: verify SSLVariable

Set to false if Technitium uses HTTPS with a self-signed certificate.

Target
TECHNITIUM_VERIFY_SSL
Default
true|false
Value
true
Pi-hole: ignored domainsVariable

Comma-separated regex patterns; matching domains spawn no ships. Example: .*\.local$,.*\.internal$

Target
PIHOLE_IGNORE_DOMAINS
Pi-hole: ignored clientsVariable

Comma-separated regex patterns matched against the client name and IP; queries from matching clients spawn no ships. Example: ^uptime-kuma$,^10\.0\.0\.5$

Target
PIHOLE_IGNORE_CLIENTS
AdGuard Home: ignored domainsVariable

Comma-separated regex patterns; matching domains spawn no ships. Example: .*\.local$,.*\.internal$

Target
ADGUARD_IGNORE_DOMAINS
AdGuard Home: ignored clientsVariable

Comma-separated regex patterns matched against the client name and IP; queries from matching clients spawn no ships. Example: ^uptime-kuma$,^10\.0\.0\.5$

Target
ADGUARD_IGNORE_CLIENTS
Technitium: ignored domainsVariable

Comma-separated regex patterns; matching domains spawn no ships. Example: .*\.local$,.*\.internal$

Target
TECHNITIUM_IGNORE_DOMAINS
Technitium: ignored clientsVariable

Comma-separated regex patterns matched against the client IP (Technitium logs no client name); queries from matching clients spawn no ships. Example: ^192\.168\.1\.99$

Target
TECHNITIUM_IGNORE_CLIENTS
2-player: second Pi-hole URLVariable

Second Pi-hole v6 API URL for split-screen 2-player mode. Leave blank to disable.

Target
PIHOLE2_URL
2-player: second Pi-hole passwordVariable

App password for the second Pi-hole, if it has one.

Target
PIHOLE2_PASSWORD
2-player: second Pi-hole verify SSLVariable

Set to false if the second Pi-hole uses HTTPS with a self-signed certificate.

Target
PIHOLE2_VERIFY_SSL
Default
true|false
Value
true
2-player: second AdGuard URLVariable

Second AdGuard Home control URL for split-screen 2-player mode. Leave blank to disable.

Target
ADGUARD2_URL
2-player: second AdGuard usernameVariable

Username for the second AdGuard Home.

Target
ADGUARD2_USERNAME
2-player: second AdGuard passwordVariable

Password for the second AdGuard Home.

Target
ADGUARD2_PASSWORD
2-player: second AdGuard verify SSLVariable

Set to false if the second AdGuard Home uses HTTPS with a self-signed certificate.

Target
ADGUARD2_VERIFY_SSL
Default
true|false
Value
true
2-player: second Technitium URLVariable

Second Technitium console URL for split-screen 2-player mode. Leave blank to disable.

Target
TECHNITIUM2_URL
2-player: second Technitium tokenVariable

API token for the second Technitium server (recommended).

Target
TECHNITIUM2_TOKEN
2-player: second Technitium usernameVariable

Console username for the second Technitium server, only if you are not using an API token.

Target
TECHNITIUM2_USER
2-player: second Technitium passwordVariable

Console password for the second Technitium server, only if you are not using an API token.

Target
TECHNITIUM2_PASSWORD
2-player: second Technitium 2FA codeVariable

Only if the second server's console account has 2FA enabled. Not needed with an API token.

Target
TECHNITIUM2_TOTP
2-player: second Technitium verify SSLVariable

Set to false if the second Technitium server uses HTTPS with a self-signed certificate.

Target
TECHNITIUM2_VERIFY_SSL
Default
true|false
Value
true