# Everything is a URL

**Page:** vision/everything-is-a-url

[Download Raw Markdown](./vision/everything-is-a-url.md)

---

# Everything is a URL

What if you could `<iframe>` a Linux desktop into your Notion doc?

What if you could `curl` your entire filesystem from a CI/CD pipeline?

What if every script you wrote instantly became a secure, shareable API endpoint?

What if you could give an AI a single URL to grant it access to a terminal, a file system, and a web browser, all at once?

In the legacy world, these are complex engineering challenges. In Hoody, they are the default. This is possible because of one foundational principle: **Everything is a URL.**


	
		Every resource and action has a predictable, web-native address.
	
	
		If it has a URL, it can be embedded, linked, and integrated with anything else on the web.
	
	
		URLs are the native language of AI. Give an agent a URL, and it instantly understands how to interact.
	


## The Universal Resource Locator

In Hoody, we've extended the concept of the URL beyond just web pages. It is a universal identifier for every resource in your computational environment. This isn't an abstraction layer; it's a fundamental architectural shift.

Your terminal, your GUI applications, your files, your background services—they are no longer abstract concepts trapped inside an OS. They are resources with a stable, secure, and web-accessible address.

This is the anatomy of a Hoody URL:

`https://{projectId}-{containerId}-{service}-{instance}.{node}.containers.hoody.icu`

| Part | Example | Description |
| :--- | :--- | :--- |
| `projectId` | `c0d7f...` | The unique ID of the Project this resource belongs to. |
| `containerId` | `a1b2c...` | The unique ID of the Container running the resource. |
| `service` | `terminal`, `display`, `pipe`, `exec`... | One of 18 services — every service has its own URL. |
| `instance` | `1`, `2`, `3`... | The specific instance (multiple terminals, displays, pipes — all at once). |
| `node` | `node-us-1` | The bare metal server where the container runs — a server you own. |

Every one of those URLs is automatically HTTPS with HTTP/2 and HTTP/3 (QUIC). No certificate to configure. No port to memorize. No reverse proxy to set up. You will never think about TLS again in your life.

## From Legacy Commands to a Single URL

This unified structure means you no longer need a dozen different clients and protocols to interact with your systems. All you need is a browser or an HTTP client.

| Goal | Legacy Method | The Hoody Way (Just a URL) |
| :--- | :--- | :--- |
| **Access a Shell** | `ssh user@192.168.1.100` | `https://...-terminal-1...` |
| **View a Desktop** | `vnc://192.168.1.100:5901` | `https://...-display-1...` |
| **Browse Files** | `sftp://user@192.168.1.100`| `https://...-files...` |
| **Access a Web App** | `http://192.168.1.100:8080`| `https://...-http-8080...` |
| **Run a Script** | `python /path/to/script.py` | `POST https://...-exec-1.../script-name`|
| **Stream Data** | `mkfifo /tmp/pipe && cat` | `https://...-pipe-1...` |

## The Scale of What This Enables

Every process, on a server you own, is an HTTPS endpoint with HTTP/2 and HTTP/3. Every one composable, embeddable, shareable, AI-controllable.

**hoody-display** turns any GUI application into a URL. Embed a running desktop in an iframe. Watch an AI-driven browser session from your phone. Run 10 isolated displays side by side, each a different app, each a different URL.

**hoody-pipe** turns named pipes into HTTP streams. Share your screen across the internet as a URL. Transfer files between devices with no client software — just `curl`. Fan out one data stream to 256 receivers simultaneously. It's `mkfifo`, but over HTTPS, from anywhere on Earth.

**hoody-exec** turns scripts into API endpoints. Write a `.ts` or `.js` file to the exec scripts directory and it's instantly callable at a URL. No framework, no deployment, no server configuration.

**hoody-curl** turns any REST call into a GET URL. Wrap a complex POST request into a single GET endpoint that you can put in a QR code, an email link, an iframe. The composability is infinite.

And because everything runs on bare metal servers you actually own — not shared cloud infrastructure — your data stays yours. Years of privacy-first engineering at Hoody went into making sure of that.


Can your tool make an HTTP request? Then it can already control every one of 18 services in any Hoody container. That's 18 services × unlimited instances × unlimited containers. The scale of this is genuinely insane.


---

> Give ChatGPT a URL — it controls your terminal. Give Claude Code a URL — it deploys your app. Give a webhook a URL — it triggers a workflow across three continents. Give your smart glasses a URL — they show you what your AI agent is doing right now. Give a stranger a URL — they see exactly what you want them to see, nothing more.
>
> **The URL is not a reference to the thing. The URL IS the thing.**
>
> That's the difference. That's why everything else we built works.