Vibe once, securely run everywhere

Quarantined. Immutable. Portable.

QIP components render identically across browser, server, cli, and native.

They are quick for coding agents to create and quick for users to run. You can add them to existing applications or use QIP Router to create websites like this one.

We use WebAssembly for its strong isolation with no filesystem, network, or secrets access. And strict-yet-simple component contracts work cross-platform, bringing determinism so everything renders predictably alike everywhere.

Render anything

du -h modules/text/markdown/commonmark.0.31.2.wasm
# 48K    modules/text/markdown/commonmark.0.31.2.wasm
 
echo "# A Markdown renderer that works identically cross-platform!" \
| qip run modules/text/markdown/commonmark.0.31.2.wasm
# <h1>A Markdown renderer that works identically cross-platform!<h1>

QIP components can convert text, images, or any MIME type. A pipeline can turn Markdown into HTML, URLs into QR codes, SVG into bitmap images, or WARC archives into deployable websites. Missing something? Just prompt it and add it to your component collection.

Browser rendering

You can load the exact same Markdown component and run it in the browser with the <qip-preview> custom HTML element:

<form aria-label="Markdown to HTML">
    <qip-preview>
        <source src="/components/text/markdown/commonmark.0.31.2.wasm" type="application/wasm" />
        <textarea name="input" rows="3" placeholder="Write some Markdown"
        ># A Markdown renderer that works identically cross-platform! Try typing…</textarea>
        <output name="output"></output>
    </qip-preview>
</form>

Interactive components

Interactive QIP Components receive keyboard & pointer events and render out pixels.

See /play for more interactive examples.

Pluggable web router

QIP can also take Markdown files and render a website:

site/
  index.md
  docs/router.md
  _recipes/text/markdown/10-markdown-basic.wasm
  _components/interactive/sudoku.wasm

# Make a HEAD request to the /about page
qip router head ./site /about

# Make a GET request to the /about page
qip router get ./site /about

# Copy a component to syntax highlight bash code
cp syntax-highlight-bash.wasm ./site/_recipes/text/markdown/20-syntax-highlight-bash.wasm

# Run a dev server
qip dev ./site

# Generate an archive of the entire site with view source enabled
qip router warc ./site --view-source

Recipes allow each MIME type to be processed by a series of QIP component steps. Each source file is transformed by the recipe and become a webpage route. The same components can be rendered in the browser via custom HTML elements.

Software today is continuously moving

Modern software depends on libraries, frameworks, and platforms that never stop changing.

Docker can package that world, but it requires lots of moving pieces that require continual patches. We believe a small function to transform some data should not need a whole application environment to run.

Introducing components that are small, isolated, and deterministic across platforms

QIP component are self-contained WebAssembly modules with strict input and output. The output of one then becomes the input of the next, allowing you to compose them together into deterministic pipelines. These will work identically across platforms and will not bitrot due to outdated dependencies.

Quarantined: components run in a sandbox isolated from the host (no filesystem, network, or environment access).
Immutable: components are self-contained with no dependencies required, so once you have a working component it stays working.
Portable: components run identically across platforms using Core WebAssembly.
Agent-friendly: components are small, making them easy to generate, review, benchmark, and replace.
Deterministic: the same component and input are guaranteed to produce the same output no matter where or when you run it.
Composable: components pipe together like Unix tools and run everywhere like React.

All these properties combined give you predictability. Agent-friendly combined with quarantined means you can experiment with the latest AI tools or programming language without concerns of leaking data. Cross-platform combined with determinism gives you confidence it’ll work the same everywhere, making testing faster. Composable together with immutable means a sophisticated pipeline of components you’ve created will just continue working the same as it did last week.

You break things into small pieces amenable to agentic coding, and those pieces run securely protecting you and your users, and work the same over time and across platforms. Components, AI coding, security — you can pick all three.