Have you ever wished you could turn your local network into a smart routing system? Instead of remembering IP addresses and ports, what if you could use simple, memorable URLs that trigger workflows, redirect to services, or even search your notes?

That’s exactly what dy.lan does. It’s a self-hosted URL router with a plugin architecture that transforms your local network into a powerful automation platform. Built by Ralf Hülsmann, a Ruby rookie from Sevelen, Germany, dy.lan (pronounced “Dylan”) is a lightweight HTTP router designed specifically for local networks.

The Basic Concept

At its core, dy.lan acts as a central entry point that translates URLs into actions. Instead of remembering 192.168.1.73:8384 for Syncthing, you can access http://sync.lan. Instead of writing complex scripts, you can use http://dy.lan/n/meeting to search your Apple Notes.

The project solves several common problems:

  • Infrastructure abstraction: When a service moves to a new IP or port, you update one config line instead of hunting down bookmarks and scripts
  • Workflow shortcuts: Turn URLs into actions with pattern-based routing
  • Clean local services: Route HTTP traffic without the complexity of full reverse proxies like Traefik or nginx for simple use cases
  • Extensibility: YAML configs for simple redirects, Ruby plugins for custom logic

Plugin Architecture and Extensibility

What makes dy.lan powerful is its plugin system. The architecture is built around numbered plugins (00-, 10-, 20-…) that follow a first-match-wins priority system. Each plugin can:

  • Match URLs using regex patterns with capture groups
  • Filter by domain/host
  • Execute custom Ruby logic
  • Handle timeouts (default 500ms, configurable per plugin)
  • Auto-disable after 5 errors (circuit breaker pattern)

Plugins are hot-reloadable for YAML configs (after domain-match), and the system is resilient — syntax errors and loops won’t crash the server.

The project includes 8 example plugins covering everything from simple redirects to API integrations, monitoring dashboards, and cron jobs. You can extend it with any feature you can implement in Ruby.

Real-World Examples

Here are some practical ways dy.lan can be used:

Google Search Shortcut

# config/redirects.yaml
redirects:
  - pattern: '^/g/(.+)$'
    target: 'https://google.com/search?q=${1}'

Access http://dy.lan/g/ruby and it redirects to a Google search for “ruby”. Simple, memorable, and no coding required.

DEVONthink Search For more complex workflows, you can use a Ruby plugin:

class DevonthinkPlugin < Dylan::Plugin
  pattern %r{^/(\d{8})}

  def call(host, path, request)
    alias_id = path.match(pattern)[1]
    Dylan::Response.redirect("x-devonthink-item://#{alias_id}")
  end
end

Now http://dy.lan/12345678 opens the document with that alias in DEVONthink.

Apple Notes Search

class NotesPlugin < Dylan::Plugin
  pattern %r{^/n/(.+)}

  def call(host, path, request)
    query = path.match(pattern)[1]
    Dylan::Response.redirect("shortcuts://run-shortcut?name=search_notes&input=#{query}")
  end
end

Access http://dy.lan/n/example to search your Apple Notes for “example” via Shortcuts.

Deployment Options

One of the great things about dy.lan is its flexibility. It can run on your Mac for local development or on a Synology NAS for 24/7 operation.

On Your Mac:

git clone https://github.com/rhsev/dy.lan
cd dy.lan
docker-compose -f docker-compose.mac.yml up -d

On Synology: The project includes docker-compose.synology.yml for easy deployment on NAS devices. With macvlan networking, you can give dy.lan its own dedicated IP address, avoiding conflicts with other reverse proxies.

The performance is impressive: 6,000 requests per second on a Mac mini M4, and 2,500 requests per second on a Synology DS224+ (compared to ~200 req/s for YOURLS on similar hardware). All while using just 20-30 MB of RAM.

Technical Highlights

Built with Ruby 4.0’s async/fiber-based concurrency, dy.lan uses non-blocking I/O so slow plugins don’t block fast ones. It’s a pure Ruby implementation with no Rails, no middleware, and no database. Configuration is done through YAML files and Ruby plugins, with a browser-based dashboard for stats and container management.

The system includes modern Ruby syntax (using it parameter in core code while keeping plugins explicit), configurable timeouts, circuit breakers, and domain filtering per plugin. It’s designed to be simple, transparent, and easy to extend.

Getting Started

If you want to try dy.lan yourself, check out the GitHub repository. The project is shared as-is, built to solve specific friction in personal automation workflows. Ralf has been developing and sharing this with me for a while, and I’m glad he decided to make it public so others can benefit.

Whether you need simple URL redirects, workflow automation, or a lightweight reverse proxy for local services, dy.lan provides a clean and extensible solution.