Skip to content

Beta: these docs are still being updated. The next full update is on 18 November at 8 PM UTC. Docs in beta. Full update 18 Nov, 8 PM UTC.

Hoody.com

A Hoody computer is a full Debian 13 Linux machine with systemd, its own filesystem, its own network stack and its own process tree. It boots, runs services and keeps its state, and it can hold terminals, desktops, databases and browsers. It is a machine you work in, operated over HTTP.

A computer runs on a server: flat-rate bare metal rented from the marketplace, which is hardware you control, a paid subserver, or a shared free-tier server to start.

Each of its services is a URL reachable from any network. Until the computer or its project sets proxy permissions, anyone who has a URL can open it: before sharing anything sensitive, set them to require a password, token or sign-in.

PartWhat you get
Operating systemDebian 13 (Trixie) with the full apt package manager
Initsystemd: service management, not a single entrypoint process
FilesystemIts own, persistent and writable, with the full Linux directory layout (FHS)
NetworkIts own network stack: own IP, own DNS, own routing table
ProcessesIts own process tree
Hoody KitWith the Kit enabled, the default: the Kit services, each a URL live from the moment the computer starts, with no setup or deployment step

One request creates a computer with the Kit and its developer tools (every option).

In the Hub, open Computers and press Get a computer. Check the server and project, and leave Hoody kit and Developer kit on under More options; both are on by default. Then press Get computer.

Terminal window
# Create a computer: a full Linux computer
hoody computers create --project "$PROJECT_ID" \
--server-id "$SERVER_ID" \
--name "dev-environment" \
--hoody-kit \
--dev-kit
# Once it is running, the Kit services are live

How does a computer differ from Docker or a VM?

Section titled “How does a computer differ from Docker or a VM?”

A Docker container is a build artifact: lightweight, stateless and disposable, made to ship software. A Hoody computer is a full machine, persistent by default, reached by URL from any network. Docker comes with its developer tools; Podman or anything else installs as usual.

A virtual machine is also a full computer, but it assumes you SSH in, configure it by hand and manage each machine on its own. A Hoody computer takes HTTP as its primary interface. Row by row: Docker and VM comparisons.

A Kit-enabled computer, the default, runs the Hoody Kit: services that expose Linux capabilities as HTTP endpoints, such as a terminal, a desktop, files, SQLite, a browser and the Hoody Agent. They are its primary interface, each at https://{projectId}-{computerId}-{service}[-{instance}].{server}.computers.hoody.com (anatomy). The Kit lists every service; URL labels.

The tabs show different calls to the same services.

Terminal window
# Run a command in the computer
hoody terminal commands run -c "$COMPUTER_ID" \
--command "sudo apt update && sudo apt install -y nodejs"
# Read a file
hoody files get /home/user/app.js -c "$COMPUTER_ID"
# Query an existing /hoody/databases/app.db that has a users table
hoody db transactions run -c "$COMPUTER_ID" \
--db /hoody/databases/app.db \
--transaction '[{"query":"SELECT * FROM users"}]'

Each computer’s files, processes and network are its own. Computers cannot see each other’s files, there are no shared volumes by default, and what runs in one computer is invisible to the next. To share a directory, set up a storage share explicitly. A computer that already holds project-scoped ramdisk also shares /ramdisk/project with its project’s computers on the same server (details).

Computers do not share an internal network. They communicate over HTTP URLs through Hoody Proxy, the same way any two computers on the internet do (how URLs reach computers). The separation is always on and does not depend on application code (details).

For instance-aware services, the instance number in the URL (-1, -2, -3) selects a parallel session in the same computer, for different users or agents:

https://{projectId}-{computerId}-terminal-1.node-us.computers.hoody.com # Developer's shell
https://{projectId}-{computerId}-terminal-2.node-us.computers.hoody.com # Build process
https://{projectId}-{computerId}-terminal-3.node-us.computers.hoody.com # AI agent's session
https://{projectId}-{computerId}-display-1.node-us.computers.hoody.com # Main desktop
https://{projectId}-{computerId}-display-2.node-us.computers.hoody.com # A second, separate display
https://{projectId}-{computerId}-sqlite-1.node-us.computers.hoody.com # SQLite service
https://{projectId}-{computerId}-sqlite-2.node-us.computers.hoody.com # Same SQLite service; the instance segment does not select a database
# Both reach the same files; pick the database with ?db=app or ?db=analytics

SQLite instead selects the database with the db query parameter; other services also ignore the number.

A URL gives everyone the same address. To keep several viewers on one display, share it with ?sharing=true&steal=false; otherwise a new connection takes over (display sharing).

Computers have no per-unit cost. Once a server exists, you can create as many as its capacity and limits allow: 3 on a free-tier server, the plan’s limit on a paid subserver.

Each computer uses some of its server’s resources, so check capacity before you create staging environments or a computer per feature or per AI agent.

The CLI tab creates ten test runners one after another; the other tabs create four named computers in parallel. The server needs room for them.

Terminal window
# Spawn 10 computers for parallel testing
for i in $(seq 1 10); do
hoody computers create --project "$PROJECT_ID" \
--server-id "$SERVER_ID" \
--name "test-runner-$i" \
--hoody-kit
done
# Each gets the Kit services, each isolated

A computer is not disposable: its disk files survive restarts until you restore a snapshot or delete it. /ramdisk is temporary storage: its contents survive computer restarts but are lost when the server reboots. You can stop it (running programs end) and start it again, pause it (memory is kept), snapshot it, restore a snapshot, copy it to another server or project, and delete it for good, its snapshots included. What each stage does, and how.

At every stage, the computer’s identity is its set of URLs. They appear when you create the computer and disappear when you delete it.

Elsewhere the unit varies by layer (server, VM, pod, process, function). In Hoody it is the computer, so there is one abstraction and one URL pattern to learn:

  • A service runs in a computer.
  • An AI gets access through the computer’s URLs.
  • A risky experiment goes in its own computer, away from everything else.
  • Rolling back means restoring a computer snapshot.
  • Sharing an environment means sharing a computer URL.

URL labels, comparisons and lifecycle stages: the Computers reference.