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.

Universal

Every resource and action has a predictable, web-native address.

Composable

If it has a URL, it can be embedded, linked, and integrated with anything else on the web.

AI-Native

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.

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.