get started
start
Imagine having a portable HTML file that not only displays information but is malleable and shareable.
No complicated server setups, no extra dependencies, just a lightweight HTML file that you can open, modify, and view from anywhere.
Hyperclay hosts these powerful HTML files so you can create personal, malleable software easily.
I build several dozen web things a year
When I’m in flow, coding a website feels like writing a story
But it’s better than a story, because I can interact with it as I’m coding
Most of the things I build transform some data into a more useful format
For example,
Static websites are the obvious place to host these simple tools
But static websites fall short in one annoying way: changes to them are ephemeral
This is frustrating because the problems I want to help solve are not ephemeral
With physical objects, ephemerality is shocking — changes are supposed to persist
But there's no obvious digital counterpart to physical objects
Static websites are great, but changes users make to them reset
To get digital objects to act more intuitively, we need to build a whole persistence layer around them
In practice, this means a server with a database, API, templates, and user accounts
That’s a lot of effort to mimic what we take for granted with physical objects
This is frustrating because I want to focus on making the actual thing, not the persistence layer
I'm like a writer who wants to create experiences for readers, but I have to keep fixing typewriters
It would be a great to ignore all the noise of modern web dev and just build the experience I want
What I need is a primitive concept that's so obvious it feels like a single, shapeable object
Let’s take an example: a personal dev log I can update over time
There’s a surprising amount of work in getting this simple digital object online
Updating it can be a cumbersome process too, when it should be natural and instant
The best workflow I can imagine is the ease-of-use of a local desktop app you open and edit, but its changes are persisted online
If only my UI had the power to permanently update itself
When I’m done updating it, people can view it
It would be a better digital object: malleable, shareable, cloneable, persistent
Think about how many digital objects are designed specifically for this workflow:
This is the lifecycle of:
What kind of thing could encapsulate this workflow in a single, small package?
Of course! Most web apps already use HTML, with a few extra steps in the middle
What if we cut out the middle steps?
We’d be left with a simple, easy-to-think-about stack:
HTML becomes the all-in-one database / API / UI, flattening all levels of the stack into one layer
It's a lot less to worry about:
We’d get a full web app with the same amount of code that a static website requires
It’s easy to think about!
It's a new primitive: a single, shapeable object
Introducing Hyperclay, a place to host self-modifying HTML files (e.g. HTML apps)
Hyperclay gobbles up ordinary HTML pages and makes it so changes made to them persist
Here’s how simple your online, editable, shareable journaling app could be:
Or you could build a way to track the extra hours you worked this week:
For something more complex, see my personal dev log:
(To persist changes, request access to Hyperclay)
The types of HTML documents Hyperclay makes possible unify UI, state, and behavior into one
But best of all, shaping these HTML documents feels like shaping something real, like a physical object
Not in the mood to go down endless rabbit holes just to build a simple idea that pops into your head?
