The integration layer for your applications

Gluer connects browsers, mobile apps, backends in any language, third-party webhooks and local LLMs through one real-time message bus. No broker to run. No ingress to open. No polling.

Start for free Read the docs

Free tier · no credit card · connect your first worker in under 5 minutes

import gluer from "gluer-js";

// Public frontend key: safe to ship to the browser.
gluer.setup({ project: "4f2c9ab7e1d05c83" });
gluer.connect();

// Call any worker, in any language, anywhere.
const { data } = await gluer.sendMsgSync("orders:create", {
  product_id: 99,
  qty: 1,
});

Why Gluer

Stop writing glue code between your systems

Every new service, client or vendor multiplies the connections you have to build and operate. Gluer replaces that mesh of adapters with one bus that every runtime speaks.

Clients

Web app gluer-js

Mobile app gluer_dart

Webhooks HTTP bridge

CLI / agents any language

Gluer mesh

wss://ws.gluer.io

Auth, routing, sessions, load balancing

Workers

Node service cloud

Python worker on-prem

Local LLM Ollama / vLLM

Legacy system private VPC

HTTP-to-WebSocket bridge

Stripe, Zapier, n8n or a plain cURL call reaches your async workers over HTTP and gets a synchronous JSON answer back.

Workers dial out

A service on a laptop, in a private VPC or behind NAT joins the mesh with an outbound connection. No ingress, no tunnel, no static IP.

Load balancing built in

Register as many workers as you want for a project. Gluer distributes messages across them and drops the ones that go silent.

Session isolation

Every message is scoped to a project and a session, so tenants and users can never address each other's traffic.

Resilient by default

Automatic reconnect with backoff, heartbeats, offline message buffering, subscription restoration and MessagePack framing — in every SDK.

One protocol, every runtime

The same Standard Message Header routes a call from a React page to a Python worker, a Flutter app or an Elixir release.

One protocol, every runtime

A single message header routes calls between a browser, a Node worker, a Python service and a Flutter app. Stop writing a bespoke adapter for every pair of systems.

Real-time by default

Persistent full-duplex connections with automatic reconnect, offline buffering and pub/sub — plus an HTTP bridge so webhooks and cURL get synchronous answers from async workers.

Reach anything, anywhere

Workers connect outbound, so services on a laptop, in a private VPC or behind NAT become reachable from production without opening a port or standing up a tunnel.

Managed, not another server

Connection pooling, load balancing across workers, session isolation and observability come with the platform. You ship features instead of operating a broker.

Use cases

One layer, many problems it removes

Teams reach for Gluer whenever two systems need to talk and neither wants to own the plumbing.

Product teams

Real-time product features

Live dashboards, presence, collaborative editing, notifications and chat without standing up a socket tier or polling your API.

Integrations

Vendor and webhook plumbing

Receive Stripe, GitHub or CRM webhooks on the HTTP bridge and answer them from a worker that already has your business logic.

Enterprise

Reach private and on-prem systems

Expose an ERP, a warehouse machine or a customer's on-prem database to your SaaS through an outbound worker instead of a VPN.

AI teams

AI features without shipping data out

Route prompts to a model running on your own hardware and stream tokens back to the browser over the same connection.

Local development against production clients

Run a worker on your laptop and let the deployed frontend call it. Debug real traffic without deploying or tunnelling.

Platform

Gradual migrations

Put Gluer in front of a monolith and move actions to new services one at a time — clients keep calling the same action name.

Protocol

One header does the routing

Gluer messages are MessagePack frames carrying a Standard Message Header — a single string that tells the mesh who is calling, which project they belong to and what should run.

direction : session : project : plugin : action

{
  "smh": ">:ws-8f21c4:4f2c9ab7e1d05c83:orders:create",
  "uuid": "0f6c1f2e-6b7a-4f0a-9d1e-2a4f8f4b1c33",
  "data": { "product_id": 99, "qty": 1 }
}

Workers reply by flipping the direction to < and keeping the uuid, which is how a synchronous caller — including an HTTP request — gets its answer back.

> < + -

Direction

Request, response, subscribe or unsubscribe.

ws-8f21…

Session

Who the message belongs to. Scopes every reply to one client.

4f2c9ab7…

Project

Your project key. Traffic never crosses project boundaries.

orders

Plugin

Logical group of actions exposed by a worker.

create

Action

The function the worker runs.

Endpoints

You don't host Gluer — you connect to it

Three ways in, one routing layer. Clients use the public frontend key; workers authenticate with the private backend key that never leaves your servers.

Actor	Endpoint	Transport	Key	Used by
Clients	wss://ws.gluer.io/ws/:project/:session	WebSocket	Frontend key	Browsers, React Native, Flutter, desktop and IoT devices.
Workers	wss://ws.gluer.io/server/:project/:id	WebSocket	Backend key	Your Node.js, Python, Go, Elixir or on-prem services, dialling out.
Integrations	https://ws.gluer.io/api/:project/:plugin/:action	HTTPS POST	Frontend key	Webhooks, cron jobs and any external system that speaks HTTP.

Clients also fall back to https://api.gluer.io/api automatically when a socket can't be opened, so a blocked network degrades to HTTP instead of failing.

Quickstart

Three steps to a connected stack

No infrastructure to provision. Create a project, connect a client and a worker, and you have a bidirectional path between them.

Connect your client

Install the SDK, point it at your project's frontend key and start calling actions. Reconnects, buffering and subscriptions are handled for you.

import gluer from "gluer-js";

gluer.setup({ project: "4f2c9ab7e1d05c83" });
gluer.connect();

// RPC-style call, resolved when a worker answers.
const { data } = await gluer.sendMsgSync("orders:create", { id: 500 });

// Or subscribe to a channel and react to pushes.
gluer.subscribe("orders", (msg) => render(msg.data));

Expose a worker

Register plain functions and dial out with your backend key. The worker can live in your cloud, on a laptop or inside a customer's network.

import * as gluer from "gluer-nodejs";

gluer.register_plugin("orders", "create", async ({ id }) => {
  const order = await db.orders.find(id);
  return { status: "confirmed", order };
});

gluer.connect(process.env.GLUER_BACKEND_KEY);

Bridge anything over HTTP

Point a Stripe webhook, a Zapier step or a cron job at the REST bridge. Gluer forwards it to a worker and returns the worker's JSON synchronously.

curl -X POST https://ws.gluer.io/api/4f2c9ab7e1d05c83/billing/payment_success \
  -H "Content-Type: application/json" \
  -d '{ "amount": 5000, "customer": "cus_123" }'

# → { "status": "ok", "invoice": "in_998" }

Create a project Full getting started guide

LLM gateway

Put Gluer between your apps and your models

Local models are cheap, private and fast — but they live on machines your users can't reach. Gluer makes a model on your laptop, your GPU box or your customer's VPC callable from any client, with the same protocol as the rest of your stack.

worker · runs next to the model

import * as gluer from "gluer-nodejs";

// Any OpenAI-compatible endpoint works the same way:
// Ollama, llama.cpp server, vLLM, LM Studio, or a hosted provider.
const OLLAMA = process.env.OLLAMA_URL ?? "http://localhost:11434";

const llm = {
  async generate({ prompt, model = "llama3.1" }) {
    const res = await fetch(`${OLLAMA}/api/generate`, {
      method: "POST",
      body: JSON.stringify({ model, prompt, stream: false }),
    });

    const { response } = await res.json();
    return { model, completion: response };
  },
};

gluer.register_object("llm", llm);

// Private backend key, never shipped to clients.
gluer.connect(process.env.GLUER_BACKEND_KEY);

client · browser, mobile or webhook

import gluer from "gluer-js";

gluer.setup({ project: "4f2c9ab7e1d05c83" });
gluer.connect();

// The browser has no idea the model runs on a Mac Mini in the office.
const { data } = await gluer.sendMsgSync("llm:generate", {
  prompt: "Summarise this ticket in one sentence",
  model: "llama3.1",
});

render(data.completion);

Your model stays where it is

The worker dials out to Gluer, so Ollama, llama.cpp, vLLM or LM Studio never needs a public address and prompts never leave your network.

Same call for local and hosted

Clients call llm:generate. Behind it you can run a local model, a hosted provider, or both with a fallback — without touching client code.

Streaming to the browser

Publish tokens on a channel and every subscribed client renders them as they arrive, over the connection it already has open.

Tools and agents get a safe door

Give an agent one audited action instead of network access to your internal services, with per-project keys and session scoping.

Works with Ollama, llama.cpp, vLLM, LM Studio and any OpenAI-compatible endpoint.

See the pattern

Integrations

Everything talks to Gluer, so it talks to everything

Gluer is transport-agnostic on purpose: if a system can open a socket or send a POST, it can join the mesh — no per-vendor connector to wait for.

Inbound

Anything that can send an HTTP request reaches your workers through the bridge.

Stripe & payment webhooks
GitHub / GitLab events
Zapier, n8n, Make
CRM and helpdesk callbacks
cURL and cron jobs

Runtimes & agents

Agent frameworks and tool servers use Gluer as their transport to private systems.

Hermes workflows
OpenClaw automations
MCP-style tool servers
Background job runners
Custom CLI agents

Models

Local or hosted inference behind a single action name.

Ollama
llama.cpp / vLLM
LM Studio
OpenAI-compatible APIs
Embedding & rerank workers

Need a specific integration pattern? The protocol is public — or see the guides.

SDKs

Speak Gluer from anywhere in your stack

Official SDKs wrap the protocol with reconnects, offline buffering and pub/sub. The wire format is public, so any runtime with a socket can join.

JavaScript

Browser · React · Svelte · Vue

npm i gluer-js

Node.js

Workers · APIs · queues

npm i gluer-nodejs

Dart

Flutter · mobile · desktop

dart pub add gluer_dart

Elixir / Erlang

OTP releases · Phoenix

websocket_client + msgpax

Python

ML pipelines · scripts

websockets + msgpack

Any language

Go · Java · .NET · Rust

WebSocket or HTTP POST

Built on Elixir and the BEAM

The mesh runs on the Erlang virtual machine that has carried telecom switching for decades: millions of lightweight processes, supervised and isolated.

MessagePack on the wire

Compact binary framing keeps payloads small on mobile networks, with JSON accepted on the HTTP bridge.

Runs locally too

A single-binary CLI runs the same mesh on your machine or on-premise, so development and air-gapped deployments use identical code.

Self-hosted

Run the same mesh on your machine

One binary, no dependencies. Develop offline, run integration tests in CI, or deploy the mesh inside an air-gapped network — the protocol and SDKs are identical to the hosted platform.

Linux

Ubuntu, Debian, Fedora and friends

x64ARM64

Download

Run it

chmod +x gluer_cli_linux && PORT=8080 ./gluer_cli_linux

macOS

macOS 11 and later

IntelApple Silicon

Download

Run it

chmod +x gluer_cli_macos && PORT=8080 ./gluer_cli_macos

Windows

Windows 10 and Windows 11

x64

Download

Run it

.\gluer_cli_windows.exe

Point any SDK at your local mesh with gluer.setup({ url: "ws://localhost:8080" }) — see the install guide.

FAQ

Questions we get asked

Short answers. The docs go deeper.

What is Gluer?

Gluer is a managed integration layer that connects frontends, backends, third-party services and LLMs through a single real-time message bus. Clients speak WebSockets or plain HTTP, and Gluer routes every message to the worker that can handle it — regardless of language, cloud or network.

How is Gluer different from a message broker like Kafka or RabbitMQ?

Brokers are infrastructure you host and operate, and they only talk to your backend. Gluer is fully managed and reaches all the way to the browser, the mobile app and the CLI: the same message header routes a request from a React page to a Python worker running on a laptop behind NAT, with an HTTP bridge for webhooks.

Do I need to host anything to use Gluer?

No. Gluer runs as a managed mesh at wss://ws.gluer.io. You create a project, get a public key for clients and a private key for workers, and connect. A single-binary CLI is available if you want to run the mesh locally for development or on-premise.

Which languages and frameworks does Gluer support?

Official SDKs cover JavaScript in the browser, Node.js and Dart/Flutter, with Python, Go, Java, .NET and Elixir workers supported through the same protocol. Any language that can open a WebSocket or send an HTTP POST can join the mesh.

Can Gluer connect my application to a local LLM?

Yes. A worker running next to Ollama, llama.cpp or vLLM connects to Gluer with your private key and exposes inference as a normal action. Your frontend calls it like any other endpoint, so prompts and model output never leave your machine or VPC while the browser still gets streamed responses.

How does Gluer handle security?

Projects are isolated by keypair, client keys are public by design and scoped to browser traffic, worker keys are private and never shipped to clients, origins can be allow-listed per project, and every message is scoped to a session. Passwords are hashed with bcrypt, one-time login codes are single-use and short-lived, and traffic is TLS-only.

Is Gluer free to start?

Yes. You can create an account, create a project and connect workers on the free tier without a credit card.

Connect your first two systems today

Create a project, drop the SDK into your app, and point a worker at it. Free while you build, no credit card, no infrastructure to provision.

Start for free Read the docs