void render_nav_link(String href, String label) { <> } void render_feature_card(String eyebrow, String title, String body) { <>

} void render_signal(String title, String body) { <>
} void render_link_card(String href, String title, String body, String meta) { <>
} DValue code_example_props(String eyebrow, String title, String summary, String code, String note, String language = "uce") { DValue props; props["eyebrow"] = eyebrow; props["title"] = title; props["summary"] = summary; props["code"] = code; props["note"] = note; props["language"] = language; return(props); } RENDER(Request& context) { String page_title = "UCE: make dynamic websites like it's 2006"; String generated_at = time_format_utc("%Y-%m-%d %H:%M:%S UTC"); String snippet_minimal = "RENDER(Request& context)\n" "{\n" "\tString name = first(context.get[\"name\"].to_string(), \"guest\");\n" "\t<>\n" "\t\t

Hello, .

\n" "\t\t

Rendered at

\n" "\t\n" "}\n"; String snippet_forms = "RENDER(Request& context)\n" "{\n" "\tif(context.post.has(\"email\"))\n" "\t\tcontext.session[\"flash\"] = \"Saved \" + context.post[\"email\"].to_string();\n" "\t<>\n" "\t\t
\n" "\t\t\t\n" "\t\t\t\n" "\t\t
\n" "\t\t\n" "\t\t\t

\n" "\t\t\n" "\t\n" "}\n"; String snippet_components = "COMPONENT(Request& context)\n" "{\n" "\t<>\n" "\t\t
\n" "\t\t\t

\n" "\t\t\t

\n" "\t\t
\n" "\t\n" "}\n\n" "RENDER(Request& context)\n" "{\n" "\tDValue props;\n" "\tprops[\"title\"] = \"Shipping note\";\n" "\tprops[\"body\"] = \"Components are just .uce files with structured props.\";\n" "\t<>\n" "\t\t\n" "\t\n" "}\n"; String snippet_markdown = "RENDER(Request& context)\n" "{\n" "\tString src = \"# Release Notes\\n\\n- fast path\\n- docs\\n- demos\";\n" "\t<>\n" "\t\t
\n" "\t\t\t\n" "\t\t
\n" "\t\n" "}\n"; String snippet_websocket = "RENDER(Request& context)\n" "{\n" "\t<>\n" "\t\t\n" "\t\n" "}\n\n" "WS(Request& context)\n" "{\n" "\tDValue payload = json_decode(context.in);\n" "\tString connection_id = context.params[\"WS_CONNECTION_ID\"];\n" "\tcontext.connection[\"name\"] = payload[\"name\"];\n" "\tpayload[\"connection_id\"] = connection_id;\n" "\tws_send(json_encode(payload));\n" "}\n"; String snippet_nginx = "location ~ \\.uce$ {\n" "\terror_page 418 = @uce_websocket;\n" "\tif ($http_upgrade = \"websocket\") { return 418; }\n" "\tinclude fastcgi_params;\n" "\tfastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;\n" "\tfastcgi_pass unix:/run/uce/fastcgi.sock;\n" "}\n\n" "location @uce_websocket {\n" "\tproxy_http_version 1.1;\n" "\tproxy_set_header Upgrade $http_upgrade;\n" "\tproxy_set_header Connection $connection_upgrade;\n" "\tproxy_pass http://127.0.0.1:8080;\n" "}\n"; <> <?= page_title ?>
UCE Docs
PHP energy, C++ runtime

Make dynamic websites like it's 2006.

UCE is a direct web runtime: files are pages, templates live next to control flow, nginx fronts the whole thing, and a request can compile into a wasm module on first hit. It is built in the image of PHP's non-architecture, but with an explicit request object, component rendering, and a built-in WebSocket broker.

Open the demo area Read the docs Browse the starter
Why UCE

The old web had the right instincts.

Put code where the page lives. Let runtime state die with the request. Keep deployment boring. Treat server-rendered HTML as the default, and add richer behavior only where it pays for itself.

Non-architecture

It is not trying to save you from the web.

What it leans into

Files on disk, explicit request handlers, template tags, reusable partials, request-scoped state, and operationally plain deployment.

What it resists

Mandatory client-side hydration, giant application shells, hidden routing layers, and pretending every website is a desktop app in a trench coat.

What it adds

Built-in components, markdown rendering, current request data in one place, and a broker-backed WebSocket story that stays inside the same runtime.

Code first

Common things in UCE

The examples below are modeled on the current runtime API and the published demo pages. The point is not abstraction depth. The point is that the code stays obvious.

Deployment

Put nginx in front. Keep the runtime focused.

The intended shape

  • nginx serves static files directly from `/var/www/html`
  • ordinary `.uce` page loads go through FastCGI
  • websocket upgrade traffic for `.uce` paths goes to the built-in HTTP listener
  • systemd manages the runtime binary and restart policy

The practical settings

  • `FCGI_SOCKET_PATH=/run/uce/fastcgi.sock` for normal requests
  • `HTTP_PORT=8080` for `.uce` websocket upgrades
  • `scripts/systemd/manage-uce-service.sh` for build and service control
  • published root should be `/var/www/html`, not the repo root
Explore

Go straight to the useful parts.

Reality check

What this is and what it is not

Is UCE production ready?

The runtime is still experimental. The point of this site is to explain the model, show the current surface area, and make it easy to evaluate the demos and docs.

Why compare it to PHP?

Because the design instinct is similar: dynamic pages as files, shallow deployment, and a bias toward solving the request in front of you instead of building an application architecture altar.

What makes it different from old PHP?

The request object is explicit, components and named handlers are first-class, markdown support is built in, and WebSockets use a broker-owned connection model inside the runtime.

}