← RCWeb Apps

AI app development without backend drag

RCWeb: A Sandbox for AI-Built Collaborative Apps

RCWeb gives an AI model a deliberately small place to build something surprisingly social: a browser app that can coordinate phones, displays, laptops, kiosks, and other browsers in real time.

The sandbox Models & context Isolation & security Development loop

AI-Generated and AI-Powered Are Different

That distinction matters. RCWeb captures the productivity of AI-generated software without forcing every user interaction through probabilistic inference. When runtime AI is useful, it can be added at a narrow, explicit boundary while ordinary code continues to own routing, validation, state, rate limits, and failure handling.

The Sandbox: Four Stable Layers

The RCWeb server is deliberately generic. It does not need to understand a score, a brush stroke, a slide, a player, or a prompt. It connects browsers and forwards commands; each browser page interprets the small message vocabulary defined by its app.

One Transport, Unlimited App Vocabularies

Apps normally expose a small global callback API and use rc.sendFunctionCall to invoke it on selected peers. The server routes the call without knowing what it means:

var wall = {
    addIdea: function (senderId, text) {
        // Validate the remote arguments, update state, then render.
    }
};

rc.onConnected = function () {
    rc.sendFunctionCall("idea-wall", "wall.addIdea", rc.client, "Build together");
};

rc.connect();

A quiz can define submitAnswer, a game can define jump, and a presentation can define showSlide. All three use the same server contract. A new app can invent its own message vocabulary without requesting or deploying a server-side API change.

Collaboration Is a Primitive, Not a Feature Request

Many conventional prototypes begin as single-user pages and acquire collaboration later through a database, accounts, polling, conflict rules, and bespoke APIs. In RCWeb, the first prototype already knows how to find and address other browsers.

Why Coding Models Thrive Here

Context Has a Natural Boundary

A model rarely needs the whole RCWeb repository. A focused task can be described by the communications guide, the four or five files belonging to one app, and one nearby example with the same collaboration pattern. This is a high-signal context packet: the model can often see the complete behavior it is changing rather than guessing through framework layers, generated code, package internals, and distant services.

Model Choice Stays Open

RCWeb does not couple source code to a particular AI vendor. OpenAI GPT, Google Gemini, Anthropic Claude, and other capable coding models can work on the same plain-text files. A model can start an app, another can review its protocol, and a later model can repair a visual defect without translating the project into a proprietary agent format.

The catalogue has been shaped by more than 1.5 billion development tokens across multiple generations of AI coding models. That history is valuable not merely as volume, but as repeated evidence: tightly bounded apps, explicit conventions, and browser feedback allow models to improve real interactive software over many iterations.

Short Feedback Loops Produce Better Code

There is no app compilation step and no development server to rebuild. A model can edit a file, refresh two browsers in a valid test room, inspect desktop and phone layouts, reproduce a reconnect, and correct the result. Failures are visible in the receiving page's console and remain close to the code that caused them. The loop is quick enough that visual and multi-client verification can be part of development rather than a final ceremony.

Isolation, Security, and Honest Trust Boundaries

RCWeb is a productive sandbox for small collaborative apps because it separates application experimentation from the server process. It is not a claim that arbitrary participants may safely execute arbitrary code together. The boundaries are clear enough for models and humans to reason about explicitly.

What the Browser Sandbox Contributes

RCWeb Apps inherit ordinary browser protections around the local operating system, device capabilities, and user permissions. Camera, microphone, sensors, clipboard, storage, and cross-origin network access remain subject to browser rules. Those protections complement RCWeb's app and room boundaries; they do not replace input validation or access control where an app needs it.

Runtime AI Without Letting the Model Run the System

An AI-powered RCWeb App can send a carefully selected prompt or media item to a model and share the result with the room. The robust pattern is a deterministic shell around a probabilistic capability:

This architecture also protects context budgets. A runtime model need not receive every WebSocket event or the server's internal state. The app can construct the smallest context needed for one useful decision, while the browser keeps immediate interaction responsive and deterministic.

A Development Loop Designed for Iteration

The Few RCWeb Rules Worth Keeping in Every Model's Context

• Load /assets/core/comms.js, define remote APIs and hooks, then call rc.connect().
• Wait for rc.onConnected() before using room, client, and WebSocket values supplied by setup.
• Keep remote callbacks globally reachable and validate their arguments at the boundary.
• Prefer targeted rc.sendFunctionCall messages to raw constructed JavaScript.
• Synchronise state for late joiners and reconnecting symmetric peers.
• Debounce high-frequency typing, pointer, sensor, and game-control traffic.
• Use conservative ES5-compatible JavaScript and broadly supported CSS for older displays.
• Test the shared experience at phone, portrait display, and landscape display sizes where relevant.

The Right Scale for AI-Native Software

RCWeb is not trying to turn every enterprise backend into generated browser code. It is optimised for something more focused and often more delightful: a small collaborative communication app with a clear audience, a small state model, and an immediate shared result.