Reimagining the internet, where users own the infrastructure.

fn main() {
    let port = phage::get_port(8080);
    phage::http::listen(port).expect("failed to listen");

    loop {
        if let Some(req) = phage::http::accept() {
            let body = format!("Hello! You requested: {}", req.path);
            phage::http::respond(200, "text/plain", body.as_bytes());
        }
    }
}

package main

//go:wasmimport env phage_http_listen
func phageHttpListen(port int32) int32

//go:wasmimport env phage_http_respond
func phageHttpRespond(
    status int32,
    ctypePtr *byte, ctypeLen int32,
    bodyPtr *byte, bodyLen int32,
) int32

func main() {
    phageHttpListen(8080)
    body := []byte("Hello from Go on SkyPhage!")
    ctype := []byte("text/plain")
    phageHttpRespond(200,
        &ctype[0], int32(len(ctype)),
        &body[0], int32(len(body)))
}

// Compiled to WASM with the Javy toolchain.
// The runtime passes the request on stdin and reads the response from stdout.
const request = JSON.parse(readInput());

const response = {
    status: 200,
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
        message: "Hello from JavaScript on SkyPhage!",
        path: request.path,
        timestamp: new Date().toISOString(),
    }),
};

writeOutput(JSON.stringify(response));

import json

def handle_request(request):
    """Handle an incoming HTTP request."""
    path = request.get("path", "/")
    method = request.get("method", "GET")

    if path == "/":
        return {
            "status": 200,
            "content_type": "application/json",
            "body": json.dumps({
                "message": "Hello from Python on SkyPhage!",
                "method": method,
            }),
        }
    return {"status": 404, "content_type": "text/plain", "body": "Not found"}