PHP-first UI framework

Build UIs in PHP
JavaScript-native.

Build modern, reactive UIs in PHP, and let Thorm generate the HTML, CSS, and JavaScript you need—cleanly and consistently.

Get Started View Examples

SSR•CSR•Hybrid•Pluggable

Thorm (PHP) → renders in

SSRCSRHybrid

PHP


<?php 
// PHP authoring (concept)
$cnt = state(0);

$app = div([], [
    h1([], [ text(concat('Count: ', read($cnt))) ]),
    button(
        [ on('click', inc($cnt, 1)) ], 
        [ text('Inc') ]
    ),
    show(eq(mod(read($cnt), 2), 0),
        p([], [ text('Even!') ])
    )
]);

Why Thorm

Build modern web UI with one language: PHP

Thorm is designed for teams that want to ship polished, interactive websites without turning every project into a JavaScript framework decision. Many apps can be built end-to-end in PHP, and when you do need JavaScript, Thorm keeps it structured and contained.

One-skill team workflow

Frontend UI and backend logic can be owned by PHP developers—fewer handoffs, faster delivery.

Lower training & hiring friction

Reduce ramp-up time and dependency on niche frontend stacks. PHP stays the primary skill.

Less framework churn

Stop rebuilding your UI layer around the latest JavaScript trends. Keep a stable, consistent approach.

JavaScript only when you need it

Many sites work great with SSR + progressive enhancement. Interactivity can stay optional and scoped.

SEO & performance by default

Server-rendered pages load fast and index well—without extra client-side complexity.

Predictable delivery

Fewer moving parts means fewer deployment surprises, simpler debugging, and more consistent releases.

The Promise:

A PHP developer can build and ship a professional website without becoming a JavaScript framework specialist.
JavaScript is still there when needed—just not running the show.

Features

Everything you need for modern, reactive UI — in one backend workflow

Thorm focuses on a small, learnable set of primitives and a clean runtime model. Build interactive interfaces without living in JavaScript, and easily switch between SSR or CSR based on SEO and UX needs.

Fine-grained reactivity

Core

Atoms + expressions + batching give predictable updates and minimal DOM writes. Your UI stays responsive without “state spaghetti.”

PHP DSL → IR-driven runtime

Architecture

Author UI in PHP, compile to a stable IR, and let the runtime handle evaluation, patching, and lifecycles. Clean separation, easier tooling, fewer hacks.

Components & slots

Compose pages from reusable building blocks with props and named/default slots. Live prop/slot reactivity works without remounting.

Effects & actions

Behavior

Declarative triggers (mount/watch/interval/timeout/event/visible) and actions (http/navigate/redirect/delay/set/inc…) for predictable behavior and fewer one-off scripts.

Routing + navigation

App

SPA router with params/query context, link primitives, and programmatic navigation. Great for interactive areas like community and demos.

HTTP + form binding

Data

Fetch primitives with parse modes and reactive status/headers, plus <code>bind()</code> helpers for text/number/checkbox inputs (optional debounce).

Examples

See it in action

Explore interactive examples built with Thorm. Start with the live experience, and switch to server-rendered output when SEO or shareability matters.

Browse all examples

Trust & principles

What you can count on

Thorm is built for backend developers who want modern, reactive UI without living in JavaScript.
It's early, it's evolving — and we're being honest about that.

One-language workflow

Build UI with backend code and a consistent component model. Fewer handoffs, faster iteration.

JavaScript stays optional

Many apps won't require custom JavaScript at all. When you need it, keep it contained and intentional.

SSR ↔ CSR per route

Choose rendering mode based on the job: SEO-heavy pages server-rendered, interactive areas client-rendered.

Switching should be a small config change, not a rewrite.

Registry-based runtime today

Thorm is organized around a registry approach now, so the runtime stays structured and predictable.

Manifest-driven plugins are on the roadmap — not “done”, not “promised”, just the direction we're building toward.

Freedom to use your JS code

We are not limiting you to Thorm JS runtime, you can bring and use custom JavaScript or your preferred libraries. Click the 🎉 button.

Easy to use, hard to master

You can start with a small set of primitives and ship quickly.

As you grow, you'll find deeper patterns for composition, behavior, and architecture.

Status: Developer Preview

Breaking changes are expected — hopefully for the better.
The best way to evaluate Thorm is to run the examples and read the docs.
If something feels awkward, it's probably a design edge we still need to smooth out.

Get Started Examples Roadmap

Note: we're considering a “three-level dependency limit” for plugins (max depth 3), but that idea hasn't been fully tested yet.

Roadmap

Where Thorm is going

Here's what we're actively shaping next — focused on workflow, stability, and making modern UI approachable for backend teams.

View the full roadmap

SSR ↔ CSR ergonomics

Make route-level rendering choice effortless — and explore automatic switching via a simple mode flag.

Manifest-driven plugins

Today: registry-based runtime. Next: manifests, clear boundaries, and safe extension points.

Docs + guided learning

More examples, a real tutorial path, and a documented “build this website with Thorm” series.

More host languages

After the PHP foundation stabilizes, explore Python and TypeScript targets with the same philosophy.

No hype, just direction

The roadmap is a plan, not a promise. We'll iterate based on what feels most useful in real projects.

Follow updates

Stay in the loop

Thorm is moving fast. If you want release notes, new examples, and roadmap milestones, join the newsletter (low volume, no spam).

Prefer discussion over email? Join the community

Ready

Ready to build with Thorm?

Start with the Getting Started guide, explore interactive examples, and follow the roadmap as we stabilize.