Products

xDNS Gateway

foundation

A DNS-to-runtime gateway that serves arbitrary software systems from bucket-backed storage through programmable CDN and edge routing.

Core idea

A bucket is the durable substrate. DNS and the CDN edge are the programmable delivery layer on top. The browser receives a normal web application, but the backing system can remain storage-native and portable.

This means a hostname can point to a gateway, the gateway can resolve a manifest or storage root, and the platform can serve either static objects or request-time compute without binding the application to one framework or hosting vendor.

Request path

1. Browser requests https://app.example.com/dashboard

2. DNS points app.example.com to the xDNS Gateway edge

3. CDN / edge terminates TLS and forwards Host + Path to the gateway runtime

4. Gateway resolves app.example.com -> xgate manifest

5. Manifest resolves /dashboard -> static fallback or compute route

6. Gateway fetches from bucket storage and/or runs request compute

7. Browser receives HTML, JS, CSS, JSON, and streamed responses as normal web traffic

System layers

Layer	Role	Examples
DNS	Maps the hostname to the gateway entrypoint.	CNAME, A, AAAA, TXT discovery records
CDN / Edge	Terminates TLS, routes by host + path, runs request compute.	Cloudflare edge, Workers, cache, redirects, auth
Bucket / Object Store	Stores static assets, manifests, bundles, snapshots, and app state.	Storj, S3, R2, MinIO, IPFS later
Browser Client	Loads the app shell, assets, API responses, and client runtime.	SPAs, React apps, dashboards, docs, browser-native clients

Bucket-backed app model

The bucket can hold more than static files. It can also hold manifests, deployment bundles, JSON state, workflow snapshots, cached API payloads, and versioned app artifacts. The edge layer decides how to expose those objects to the browser.

bucket/
  apps/myapp/
    xgate.json
    public/index.html
    public/assets/app.js
    public/assets/app.css
    state/session-cache/*.json
    bundles/api-v1/*
    snapshots/release-2026-04-30/*

Smallest useful compute primitive

The universal primitive is not Next.js or Nitro. It is a standard web Request to Response handler with object-storage access.

type GatewayHandler = (
  request: Request,
  context: {
    host: string
    storage: ObjectStorage
    env: Record<string, string>
  }
) => Promise<Response>

Everything above that layer is optional: Hono, Nitro, Next.js, custom SSR, or pure static export.

Manifest shape

{
  "xgate": "v1",
  "origin": {
    "type": "http",
    "baseUrl": "https://storage.example.net/apps/myapp"
  },
  "routes": [
    {
      "match": "/assets/**",
      "type": "static",
      "source": "public/assets/"
    },
    {
      "match": "/api/**",
      "type": "compute",
      "entry": "builtin:echo"
    },
    {
      "match": "/**",
      "type": "static",
      "source": "public/",
      "fallback": "index.html"
    }
  ]
}

What this unlocks

· Static sites and docs delivered from object storage with custom domains.
· React apps and browser clients served from buckets with SPA fallback routing.
· Lightweight API and edge compute routes without requiring a monolithic app server.
· Portable software packaging across Storj, S3, R2, and future decentralized backends.
· A clean separation between durable object substrate and programmable delivery runtime.