Joxit vs Docker Registry Browser vs Registry Frontend: Best Docker Registry UI 2026

If you run a private Docker registry, managing images through the raw REST API or CLI gets tedious fast. A web-based Docker Registry UI gives you visual tag management, image browsing, deletion controls, and multi-registry support — all from your browser.

In this guide, we compare the three most popular open-source Docker Registry UIs: Joxit Docker Registry UI, Docker Registry Browser by klausmeyer, and docker-registry-frontend by kwk. We’ll cover features, deployment options, and provide ready-to-use Docker Compose configs so you can get started immediately.

Why Self-Host a Docker Registry UI?

Running your own Docker registry is common for organizations that need to:

• Control image distribution — keep proprietary images within your network
• Reduce pull latency — local registry is faster than Docker Hub
• Meet compliance requirements — some industries require all artifacts to be stored internally
• Cache upstream images — proxy registries reduce external dependency and bandwidth

But managing a registry without a UI means relying on the docker registry CLI tools, raw API calls with curl, or third-party tools. A self-hosted web UI solves this by providing:

• Visual tag listing and filtering
• Image deletion with confirmation
• Multi-registry switching
• Pull command copy-paste
• Architecture and layer inspection

For related reading, see our Harbor vs Distribution vs Zot container registry comparison and Docker registry proxy and caching guide.

Joxit Docker Registry UI

GitHub: Joxit/docker-registry-ui · Stars: 3,410 · Language: Riot.js · Last Updated: January 2026

Joxit is the most popular and feature-complete Docker Registry UI. It’s a single-page application built with Riot.js and served through Nginx. The project supports both Docker Registry v2 and v3.

Key Features

• Multi-registry support — switch between registries dynamically from the UI
• Single-registry mode — lock the UI to one registry with SINGLE_REGISTRY=true
• Image deletion — delete single or multiple tags at once
• Multi-architecture support — view manifests for different architectures
• Dockerfile viewing — see the Dockerfile content for each image
• Search and filter — filter images and tags with the search bar
• Smart tagging — numeric tag sorting, hover-to-show SHA256
• Helm chart available — deploy on Kubernetes via Artifact Hub

Docker Compose Deployment

Here’s a production-ready Docker Compose setup that runs Joxit UI alongside a private registry:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

services:
  registry:
    image: registry:2
    restart: always
    volumes:
      - registry-data:/var/lib/registry
    environment:
      - REGISTRY_HTTP_ADDR=0.0.0.0:5000
      - REGISTRY_STORAGE_DELETE_ENABLED=true
      - REGISTRY_HTTP_HEADERS_Access-Control-Allow-Origin=[http://localhost:8080]
      - REGISTRY_HTTP_HEADERS_Access-Control-Allow-Methods=[HEAD,GET,OPTIONS,DELETE]
      - REGISTRY_HTTP_HEADERS_Access-Control-Allow-Credentials=[true]
      - REGISTRY_HTTP_HEADERS_Access-Control-Allow-Headers=[Authorization,Accept,Cache-Control]
      - REGISTRY_HTTP_HEADERS_Access-Control-Expose-Headers=[Docker-Content-Digest]
    ports:
      - "5000:5000"

  registry-ui:
    image: joxit/docker-registry-ui:latest
    restart: always
    environment:
      - SINGLE_REGISTRY=true
      - REGISTRY_URL=http://registry:5000
      - DELETE_IMAGES=true
      - REGISTRY_TITLE=My Private Registry
      - NGINX_PROXY_PASS_URL=http://registry:5000
      - SHOW_CONTENT_DIGEST=true
    ports:
      - "8080:80"
    depends_on:
      - registry

volumes:
  registry-data:

Key configuration notes:

• NGINX_PROXY_PASS_URL routes UI requests through the same domain, avoiding CORS issues entirely
• SINGLE_REGISTRY=true locks the UI to one registry (recommended for most setups)
• The CORS headers on the registry are required when NGINX_PROXY_PASS_URL is not used
• SHOW_CONTENT_DIGEST=true displays SHA256 digests next to each tag

Reverse Proxy Setup

When deploying behind Traefik or Nginx, Joxit works as a simple static site:

1
2
3
4
5
6

# Traefik labels for Joxit
labels:
  - "traefik.http.routers.registry-ui.rule=Host(`registry.example.com`)"
  - "traefik.http.routers.registry-ui.entrypoints=websecure"
  - "traefik.http.routers.registry-ui.tls.certresolver=letsencrypt"
  - "traefik.http.services.registry-ui.loadbalancer.server.port=80"

Docker Registry Browser (klausmeyer)

GitHub: klausmeyer/docker-registry-browser · Stars: 686 · Language: Ruby on Rails · Last Updated: April 2026

Docker Registry Browser is a Ruby on Rails application that provides a clean web interface for Docker Registry v2. It’s actively maintained and includes a built-in Docker Compose setup that runs both the browser and a registry backend.

Key Features

• Ruby on Rails backend — server-side rendering, no JavaScript framework dependency
• Image deletion — toggle deletion with ENABLE_DELETE_IMAGES=true
• Simple authentication — supports basic auth out of the box
• Pull URL override — set PUBLIC_REGISTRY_URL to show the correct pull command
• Active maintenance — pushed as recently as April 2026
• Docker Compose included — ships with a ready-to-use compose file

Docker Compose Deployment

The project includes an official docker-compose.yml that runs both the browser frontend and a registry backend:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

services:
  frontend:
    build: .
    restart: always
    environment:
      - "SECRET_KEY_BASE=change-me-to-a-random-string"
      - "DOCKER_REGISTRY_URL=http://backend:5555"
      - "ENABLE_DELETE_IMAGES=true"
      - "PUBLIC_REGISTRY_URL=localhost:5555"
    ports:
      - "8080:8080"

  backend:
    image: registry:2
    restart: always
    environment:
      - "REGISTRY_HTTP_ADDR=0.0.0.0:5555"
      - "REGISTRY_STORAGE_DELETE_ENABLED=true"
    ports:
      - "5555:5555"

To use a pre-built image instead of building from source:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

services:
  frontend:
    image: klausmeyer/docker-registry-browser:latest
    restart: always
    environment:
      - "SECRET_KEY_BASE=change-me-to-a-random-string"
      - "DOCKER_REGISTRY_URL=http://backend:5555"
      - "ENABLE_DELETE_IMAGES=true"
      - "PUBLIC_REGISTRY_URL=registry.example.com:5555"
    ports:
      - "8080:8080"

  backend:
    image: registry:2
    restart: always
    environment:
      - "REGISTRY_HTTP_ADDR=0.0.0.0:5555"
      - "REGISTRY_STORAGE_DELETE_ENABLED=true"
    ports:
      - "5555:5555"

Key configuration notes:

• SECRET_KEY_BASE is required for Rails session encryption — generate one with openssl rand -hex 64
• DOCKER_REGISTRY_URL is the internal URL the browser uses to talk to the registry
• PUBLIC_REGISTRY_URL is what users see in pull commands — set this to your external hostname
• The Rails app runs on port 8080 by default

docker-registry-frontend (kwk)

GitHub: kwk/docker-registry-frontend · Stars: 1,689 · Language: JavaScript · Last Updated: May 2023

The docker-registry-frontend is a pure web-based solution built with Angular.js and served through Apache. While the project hasn’t seen updates since 2023, it remains a stable and functional option for basic registry browsing.

Key Features

• Apache-based — served through Apache HTTP Server with SSL support
• SSL built-in — mount your own certificates for HTTPS
• Registry proxy mode — can act as a front for the registry itself
• Custom hostname override — set ENV_REGISTRY_PROXY_FQDN for correct pull commands
• Simple deployment — single container with environment variable configuration

Docker Deployment

1
2
3
4
5
6

docker run \
  -d \
  -e ENV_DOCKER_REGISTRY_HOST=registry.example.com \
  -e ENV_DOCKER_REGISTRY_PORT=5000 \
  -p 8080:80 \
  konradkleine/docker-registry-frontend

For SSL-enabled deployment:

1
2
3
4
5
6
7
8
9

docker run \
  -d \
  -e ENV_DOCKER_REGISTRY_HOST=registry.example.com \
  -e ENV_DOCKER_REGISTRY_PORT=5000 \
  -e ENV_USE_SSL=yes \
  -v $PWD/server.crt:/etc/apache2/server.crt:ro \
  -v $PWD/server.key:/etc/apache2/server.key:ro \
  -p 443:443 \
  konradkleine/docker-registry-frontend

Key configuration notes:

• ENV_DOCKER_REGISTRY_HOST and ENV_DOCKER_REGISTRY_PORT point to your registry
• ENV_REGISTRY_PROXY_FQDN overrides the hostname shown in pull commands
• ENV_USE_SSL=yes enables HTTPS with your own certificates
• The project has not been updated since May 2023, so consider this for stable, low-maintenance setups

Feature Comparison

Which One Should You Choose?

Choose Joxit Docker Registry UI if:

• You need the most feature-complete solution
• Multi-registry management is important
• You want Dockerfile viewing and multi-arch support
• You’re deploying on Kubernetes (Helm chart available)
• You need active maintenance and regular updates

Choose Docker Registry Browser if:

• You prefer server-side rendering (Ruby on Rails)
• You want a simple, self-contained deployment
• You need the official Docker Compose setup that includes both frontend and backend
• You value recent maintenance activity (April 2026)

Choose docker-registry-frontend if:

• You need built-in SSL without a reverse proxy
• You want a stable, unchanging deployment
• Your use case is simple registry browsing without advanced features
• You already run Apache and want to integrate with existing infrastructure

Deployment Architecture

For production deployments, the recommended architecture places the UI behind a reverse proxy with TLS termination:

1
2

Internet → Nginx/Traefik (TLS) → Registry UI → Docker Registry (internal)
                                              → Registry Storage (filesystem/S3)

The Joxit UI with NGINX_PROXY_PASS_URL is the simplest architecture because the UI’s Nginx instance proxies requests to the registry, eliminating CORS configuration entirely. Both the registry and UI share the same external hostname, differentiated only by path.

For those also managing container workloads, see our guide on container management dashboards like Portainer and Dockge for a complete self-hosted container platform.

FAQ

What is a Docker Registry UI?

A Docker Registry UI is a web-based interface that allows you to browse, search, and manage Docker images stored in a private Docker Registry (compatible with the Docker Distribution API v2). Instead of using CLI commands or raw API calls, you can manage images through a browser.

Do I need a Docker Registry UI if I use Harbor?

Harbor is a full-featured container registry with its own built-in web UI, authentication, vulnerability scanning, and replication. If you use Harbor, you don’t need a separate UI. The tools in this comparison are designed for use with the base Docker Distribution registry (registry:2), which has no built-in web interface.

Can these UIs handle authentication?

Joxit supports basic authentication through the browser’s native auth dialog. Docker Registry Browser supports basic auth configuration. The docker-registry-frontend has no built-in authentication — you should place it behind a reverse proxy with auth (like Nginx with htpasswd) if access control is needed.

How do I fix CORS errors with the registry UI?

CORS errors occur when the UI and registry are on different domains. The simplest fix is to use Joxit’s NGINX_PROXY_PASS_URL option, which routes all requests through the UI’s Nginx instance, making the browser think everything comes from the same origin. Alternatively, configure CORS headers on the registry itself using REGISTRY_HTTP_HEADERS_* environment variables.

Can I delete images through the UI?

Yes, all three UIs support image deletion, but with an important caveat: deleting an image through the UI only removes the reference (tag), not the underlying blobs. To reclaim disk space, you must run the registry’s garbage collector: docker exec registry registry garbage-collect /etc/docker/registry/config.yml.

Which UI is best for Kubernetes deployments?

Joxit Docker Registry UI is the clear winner for Kubernetes — it provides an official Helm chart at helm.joxit.dev and is available on Artifact Hub. The other two tools would require custom Deployment and Service manifests.

Is docker-registry-frontend still safe to use?

The project hasn’t been updated since May 2023. While it remains functional for basic browsing, the Angular.js version it uses is no longer maintained. For new deployments, Joxit or Docker Registry Browser are recommended due to their active maintenance and modern technology stacks.