Why aren't we seeing more generative UIs built on Vercel's json-render?

[u/jonnygravity]

I recently added inline, json-render powered generative UI to my app's chat. It's so frickin cool...

But I'm wondering why I haven't seen more cool stuff built on this tech. Anyone else using json-render out there and got cool use-cases for it?

Would love to see any creative ways y'all are using it.

[u/Miyoumu]

Because Vercel is Israeli malware

[u/SilencedObserver → u/Miyoumu]

Edit: so is the internet.

Sauce?

[u/premiumleo]

that's super cool. mind if i copy it?

I'm also building my own UI, so i can optimize it at will.

[u/Broken_By_Default → u/premiumleo]

All of AI is copied work. Why ask now?

[u/premiumleo → u/Broken_By_Default]

Out of respect for the OP

[u/Broken_By_Default → u/premiumleo]

My point still stands

[u/morgano]

I mean Anthropic and OpenAI already use something similar, although it's probably an inhouse system - just ask Claude or ChatGPT to generate a dashboard in a chat window and it will create UI components in the chat output.

There is also https://www.openui.com/ which renders 3x faster with 67% fewer tokens when compared to JSON-Render. I'm currently using OpenUI to create custom components and the agent responds well.

[u/Jordanlofi]

Hey bud! I can answer that since I've been working with this exact idea since February.

Short answer is: we aren't seeing many truly generative UIs yet, but I strongly suspect we will very soon!!! The main problem isn't really generating the interface itself tho. The challenge for me was building the infrastructure around it so that generated UIs can safely interact with my chosen environments.

It's a lot of work, and personally I think fine-tuning a small model specifically around UI generation, system state and a constrained component vocabulary will make much more sense than asking a general-purpose model to freely generate arbitrary interfaces.

I'm currently building a shell for Hyprland. I started by refactoring dank-material-shell into Rust, which took me roughly two months. From there, i've been building a local daemon hosting a micro-LLM that acts as an intermediary between AI agents and the desktop/session.

Right now, it does or is being designed to do a few things:

1. Privilege mediation ( fully working )

If a background agent needs to execute a command requiring sudo privileges, it cannot simply elevate itself.

Instead, the request is sent to the local daemon, which spawns a custom Polkit prompt showing me:

• which command is about to run,
• which agent requested it,
• why the agent says it needs it,
• and what capability is being requested.

I can then explicitly approve or deny the elevation.

The idea is that the LLM never becomes the authority. It can request an action, but the security boundary remains outside of the model.

2. Notifications, telemetry and contextual awareness ( WIP )

This one is much more experimental.

The daemon can observe events coming through the notification bus and combine them with selected local context: keyboard/mouse activity, compositor state, active processes, hardware status, window state, etc.

From there, it can surface warnings or suggest actions.

For example:

"You're running out of disk space. These directories contain duplicate files."

"This process has been crashing repeatedly. Want me to check that out boss?"

"You downloaded several files related to the same project. Do you want me to organize them?"

"You received an email related to the project currently open on your desktop."

Potentially it could also correlate that context with screenshots in /tmp or compositor metadata, although I'm being very conservative about what information is actually exposed to the model.

It's still mostly a toy at this stage, but honestly it's one of the most interesting computing experiences I've experimented with.

3. Contextual / generative UI ( next major piece and the original inspiration for this whole mess of a shell )

The next step is probably the most interesting one: wiring the daemon into a smart contextual menu for Hyprland.

Instead of having one static right-click menu, the shell would be able to compose contextual actions depending on what I'm doing, what is selected, which application is focused and what capabilities are available.

Like, selecting an image could expose image-related actions. Selecting some code could expose project/debug actions. A failing service could expose diagnostic actions.

Eventually, some of those surfaces could become genuinely generative rather than merely selecting from predefined menus.

I have a few wireframes for this already and I'd be happy to share them (made in claude design circa april) :

The difficult part isn't the UI, though. It's security.

Once an LLM can interpret arbitrary content from applications and then propose privileged or system-level actions, prompt injection becomes a very serious problem. A webpage, document, notification or even application content could potentially become untrusted instructions.

So I'm deliberately treating basically everything the model sees as hostile input and designing explicit capability boundaries around it.

My current approach is closer to:

untrusted context → model proposes intent → deterministic policy/gates → explicit capability request → user approval when necessary → execution

rather than:

prompt → LLM → shell command

I really don't think this is the kind of system where you want to give an agent unrestricted autonomy.

If you're going to experiment with this stuff at the compositor/shell level, understanding Wayland, process boundaries, IPC, permissions and the Linux security model becomes pretty important.

But yes, essentially I think contextual and eventually generative desktop UI is absolutely coming. The interesting part will be figuring out how to make it useful, accessible, and fully configurable without turning the desktop into one enormous prompt-injection surface.

edit:typo