Open-source · Language-agnostic standard

Polyglot Queues,
Simplified.

A high-performance, agnostic queue standard that lets Laravel, Go, Python, Java, .NET and Node.js speak one strict JSON schema — no PHP serialize() lock-in, no broker glue.

Zero broker overhead Redis & RabbitMQ Built-in trace_id
message_flow.topology live route
producers consumers PHP Python Go Node.js Java .NET BabelQueue PHP Python Go Node.js Java .NET
The Ecosystem

One standard. Six native SDKs.

Install the driver for your stack and start producing or consuming the same schema in minutes. Each core ships a framework adapter — no bridge services, no translation layer.

PHP v1.0.0

PHP

Packagist

AdaptersLaravel · Symfony

$ composer require babelqueue/php-sdk
Py v1.0.0

Python

PyPI

AdaptersCelery · Django

$ pip install babelqueue
Go v1.0.0

Go

pkg.go.dev

AdaptersRedis · RabbitMQ

$ go get github.com/babelqueue/babelqueue-go
JS v1.0.0

Node.js

npm

AdaptersBullMQ · NestJS

$ npm install @babelqueue/core
Jv v1.0.0

Java

Maven Central

AdaptersSpring Boot

$ implementation("com.babelqueue:babelqueue-core:1.0.0")
C# v1.0.0

.NET

NuGet

AdaptersMassTransit

$ dotnet add package BabelQueue.Core
Quickstart

Shipping a polyglot message in three steps.

Here it is in Laravel — every SDK follows the same shape. The envelope on the wire is identical, so a Go, Python or .NET service consumes it natively.

1

Install

Add the driver for your stack.

$ composer require babelqueue/laravel
2

Produce

Publish by URN — no class is shared across languages.

BabelQueue::publish(
    'urn:babel:orders:created',
    ['order_id' => 1042],
);
3

Consume — anywhere

Map the URN to a handler, in this or any other language.

// config/babelqueue.php
'urn:babel:orders:created'
    => OnOrderCreated::class,
The Polyglot Proof

One language produces. Another consumes. Same bytes.

Pick any producer and consumer pair. BabelQueue emits the exact same strict JSON envelope, and the other language decodes it natively — only meta.lang reflects who produced it.

Polyglot Proof schema validated
Producer producer.laravel.php
1use BabelQueue\Facades\BabelQueue;
2
3BabelQueue::publish('urn:babel:orders:created', [
4 'order_id' => 1042,
5 'amount' => 99.90,
6]);
Wire envelope identical bytes
{
  "job" "urn:babel:orders:created"
  "trace_id" "7b3f9c2a-e41d-4f88-9b2a-1c0d5e6f7a8b"
  "data"
    "order_id" 1042
    "amount" 99.90
  
  "meta"
    "id" "f1e2d3c4-b5a6-4789-90ab-cdef01234567"
    "queue" "default"
    "lang" "php"
    "schema_version" 1
    "created_at" 1749132727000
  
  "attempts" 0
}
Consumer consumer.go
1env, _ := babelqueue.Decode(body)
2
3// env.Job == "urn:babel:orders:created"
4order := env.Data["order_id"]
Key Features

Built for distributed teams that ship fast.

The opinionated defaults you actually want in production — typed, traceable, and broker-agnostic from day one.

Agnostic Serialization

Strongly-typed, pure JSON envelopes replace fragile PHP serialize() — readable, portable and validated against a strict schema.

Distributed Tracing

Every message carries a built-in trace_id, so a failure three services deep is one query away — across any language boundary.

Broker Agnostic

First-class support for Redis and RabbitMQ. Swap backends with a config line — your producers and consumers never change.

Zero Overhead

No sidecar, no proxy, no broker plugin. BabelQueue talks straight to native drivers — adding nothing between your app and the queue.

How it compares

Polyglot queues without the rewrite.

The other paths to cross-language messaging mean new infrastructure or losing your framework's ergonomics. BabelQueue changes only the serialization.

BabelQueue PHP serialize() Kafka / gRPC rewrite Hand-rolled bridge
Keep your Redis / RabbitMQ broker
No new infrastructure or sidecar ~
Consumed natively in any language
Drop-in — reuse your framework's worker
Built-in cross-service trace_id ~
Zero heavy dependencies ~
FAQ

Questions, answered.

The things teams ask before adopting BabelQueue. Still curious? The full standard is in the wire contract.

Do I have to replace my message broker?

No. BabelQueue runs on the Redis or RabbitMQ you already operate — it changes the serialization, not the transport. There is no new broker, sidecar or proxy to deploy.

Will it change my existing (non-BabelQueue) jobs?

No. Standard framework jobs and workers stay exactly as they are. Only connections you opt into as polyglot use the canonical envelope, so adoption is incremental.

Which languages and frameworks are supported?

All six SDKs are released at 1.0: PHP (Laravel & Symfony), Python (Celery & Django), Go (Redis & RabbitMQ transports), Node.js (BullMQ & NestJS), Java (Spring Boot) and .NET (MassTransit) — each a framework-agnostic core plus a framework adapter.

Is the wire format stable?

Yes. The envelope is frozen at schema_version 1: fields are never added, renamed, removed or retyped without a deliberate version bump. A v1 producer stays readable by every v1 consumer, in any language, indefinitely.

How is a message identified across languages?

By a URN (urn:babel:<context>:<event>) carried in the envelope, never a class name — so a Go or Python consumer routes on a stable string without sharing any type with the producer.

Is there a performance cost?

Negligible. The codec adds well under 2% over the plain-JSON serialization a publisher already pays, measured against a conservative broker round-trip — and it talks straight to native drivers, with nothing in between.

How do I trace a message across services?

Every message carries a trace_id, generated by the first producer and preserved unchanged across every hop and language — so an end-to-end trace is one query away, no manual plumbing.

Ship one schema across every service.

Free, open-source, and production-ready. Drop in a driver and your polyglot queue just works.