Build anything the room can play.

Every experience has the same three parts. You decide what each one looks like; Omnigate carries the data between them, live, for up to 2,000 phones per computer.

1. Inputs

   Phone

   Guests scan the QR and send votes, taps, sliders, text, photos or drawings — from the browser, no app.

   →
2. Computes + flow

   Server

   Omnigate checks every input, counts and ranks it in real time, and moves the show along: by the operator, a timer or a condition.

   →
3. Scenes

   Screen

   Big screens, side screens and LED walls receive the live data and turn it into the show.

Each part of an experience declares the inputs it accepts. Omnigate builds the phone screen for them — or you write your own phone page with the phone SDK and send anything you like.

• choicePick one or several options
• buttonA single tap — count, react, buzz in
• holdPress and hold — duration counts
• shakeShake the phone — motion as input
• sliderA value on a scale — ratings, stars, 1–10
• numberA number with limits — guesses, estimates
• textWords or short answers, moderated
• photoPhotos, approved before they show
• drawingDraw on the phone, show on the wall
• teamJoin a team — races, battles
• pointTap a spot on an image or map
• emojiEmoji reactions, live
• dataYour own shape: any JSON, checked by the server

Your own phone page

A plain HTML page in your pack. The SDK handles the connection, reconnects, the current view, uploads (resize and consent included) and haptics.

<!-- phone/index.html, inside your pack -->
<script src="/sdk/phone.js"></script>
<script>
  omnigate.on('init', (info) => setLanguage(info.lang));   // language, direction, brand, nickname
  omnigate.on('view', (view) => draw(view));                 // what this phone should show now

  pick.onclick = async () => {
    const ack = await omnigate.send({ color: 'coral', size: 4 });  // any value your schema allows
    if (ack.ok) omnigate.haptic(30);
  };
  const ack = await omnigate.upload(selfieBlob);             // photo / drawing: resized, consent, approval
</script>

You describe what to calculate; Omnigate does it live and publishes the results to every screen. No backend to write, nothing to scale.

experience.json — a segment

One file describes the inputs, the computes, the scenes and the flow. The server checks it on upload.

{
  "id": "bubbles",
  "inputs": [
    { "id": "pick", "kind": "data", "per": "latest",
      "config": { "schema": {
        "color": { "type": "enum", "values": ["coral", "sky", "lime"] },
        "size":  { "type": "number", "min": 1, "max": 5, "integer": true } } } },
    { "id": "rate", "kind": "slider", "per": "latest", "config": { "min": 1, "max": 5 } }
  ],
  "computes": [
    { "id": "all",    "kind": "latest",  "from": "pick", "params": { "n": 100 }, "publish": "bubbles" },
    { "id": "colors", "kind": "groupBy", "from": "pick", "by": "option", "field": "color", "publish": "colors" },
    { "id": "stars",  "kind": "avg",     "from": "rate", "publish": "rating" }
  ],
  "scenes": {
    "main":  { "kind": "omni", "ref": "stage/bubbles.omni", "fallback": "idle" },
    "phone": { "kind": "html", "ref": "phone/index.html" }
  }
}

Every computed value reaches the screen as one live data object, Gate. Pick how you draw it:

Screen SDK (HTML)

<!-- stage/index.html — Canvas, Three.js, Unity WebGL… -->
<script src="/sdk/stage.js"></script>
<script>
  omnigate.on('scene', (msg) => {
    const g = msg.data.Gate;              // live data: state, participants, join, brand, your computes
    title.textContent = g.content.question;
    drawBubbles(g.bubbles);               // published by your "latest" compute
  });
  omnigate.on('event', (name) => {        // GateOpen · GateClose · GateReveal · GateReset…
    if (name === 'GateReveal') celebrate();
  });
</script>

The Gate object (excerpt)

state

idle · open · closed · reveal

participants

connected phones

join.code · join.url · join.short

what the QR and the screen show

brand.primary · brand.accent

the event colours

content

what the organiser filled in

segment.index · segment.count

round and number of rounds

timer.endsInMs

time left to answer

<publish paths>

your computes, e.g. race.distance, quiz.leaderboard

An experience pack is a zip: the experience.json, your phone page, your screen scenes and translations. Upload it in the console; every upload becomes a version, and going live pins the version the event uses — what you rehearsed is what plays.

my-pack.zip
├── experience.json
├── phone/index.html
├── stage/bubbles.omni
├── stage/side.html
└── locales/tr.json

Everything the console does goes through the same API: create events, set the flow, go live, end, and pull the report — as JSON or CSV — into your CRM, data warehouse or dashboards.

curl -X POST https://<your-omnigate>/v1/events \
  -H "Authorization: Bearer $PANEL_KEY" -H "Content-Type: application/json" \
  -d '{ "title": "Launch 2026", "language": "en", "brand": { "primary": "#14123a", "accent": "#ff5a3c" } }'

curl https://<your-omnigate>/v1/events/evt_42/report.csv?lang=en \
  -H "Authorization: Bearer $PANEL_KEY" -o results.csv

Enterprise: on your own servers, in your country, with your identity provider.

Omnigate speaks the Model Context Protocol. Connect it to Claude or any MCP-capable assistant and prepare events in plain language — the assistant uses the same API, with the same checks.

• “Set up a launch for 300 people: a welcome poll, a three-question quiz and a team race. Our colours are navy and coral.”

  → creates the event, fills the flow, applies the brand

• “Go live.”

  → checks the flow and the license, then goes live

• “Send me the results as a spreadsheet.”

  → pulls the report and exports CSV

Tools

list_experiences create_event set_flow set_brand go_live end_event get_report upload_pack

Available to pilot and agency customers on request. Request access