Still on the Way
So Glad to Have Met You
We are glad you found us. Maybe we are just passing by at RobustMQ, brushing past each other. Maybe we will travel together for a while. Maybe we will be companions for a very long time.
RobustMQ wants to invite you to sign your name for us — this signature will always be displayed on our official website. Because we want to know that you once looked at us seriously. Maybe one day in the distant future, you will suddenly remember that you once left us a signature, and we will have already traveled far.
@socutes @huichungka @Ayanokoji-li @patwrall @flyswimmer @satori1995 @WaterWhisperer @NuclEnergy @hzbnb @qiu121 @linyihai @chenxi2015 @codenohup @dwsio @Yinwei-Yu @reigadegr @yongruifang @ytharic @realonbebeto @cadeYDL @jamesfeng2009 @CsongSY @wanliofficial
How to Sign Your Name
If you are not sure how to submit a pull request, see Pull Request Example for a walkthrough.
It's a simple step:
- Fork our project
- Open both docs/zh/OverView/SignYourName.md and docs/en/OverView/SignYourName.md, and add your GitHub username.
- Submit a PR:
PR title: 'docs: @yourname Nice to meet you'
PR description: 'relate #1380'- Wait for us to merge
Who We Are
Just a few programmers who wanted to see if they could make something great.
Honestly, We're Still on the Way
We don't overpromise. We are still on the road, still exploring.
What RobustMQ wants to do is ambitious — the data communication infrastructure for the AI era, unifying MQTT, Kafka, NATS, and AMQP, covering the full data flow from edge devices to cloud clusters. This vision is real, not marketing language.
But we have to be honest: today's RobustMQ has a near-complete MQTT core, Kafka is still in development, and NATS and AMQP have demo validation done and are waiting to be pushed forward. We are showing you the destination we want to reach, not claiming we are already there. We are still walking, one step at a time.
Infrastructure software cannot be built on packaging — only on accumulation. When users choose a communication infrastructure, they are betting on its reliability over the next five or ten years. We want to build real trust from day one, not cover the distance with a pretty vision.
Head Up, Head Down
There are two ways to fail in infrastructure software: keep your head down and eventually walk in the wrong direction; or keep your head up dreaming and never write much code.
We choose both.
Head up — we never stop thinking about the future. What kind of protocol support does AI Agent communication need? What new demands does edge computing place on messaging systems? How can multi-protocol unification avoid architectural compromise? These are questions we constantly think about, even before we are ready to implement the answers.
Head down — right now we are focused on MQTT. Not because MQTT is the destination, but because doing one thing extremely well matters more than doing ten things at once. MQTT is where we refine our architecture, validate our ideas, and build our engineering capabilities. Every interface design, every code abstraction, every performance decision is preparation for multi-protocol expansion later.
For three years we have gone back and forth between these two: think through the direction, write good code, think again, write again. Slow, but steady.
Slow Is Fast
This is not self-consolation. It is an engineering philosophy we genuinely believe.
Over three years we have torn down architectures, refactored core modules, and rejected designs we thought we had figured out. That is not failure — it is the necessary path. Every teardown makes the architecture cleaner; every refactor makes the code more solid. We are not afraid to admit we took detours, because the detours are part of the refinement.
Quality defects in infrastructure software get amplified. An architectural compromise may become an unavoidable technical debt three years later. A performance shortcut may become a bottleneck at scale. A tight coupling may turn adding a new protocol into a full rewrite.
We would rather go slower now: think the architecture through, design the interfaces cleanly, write code that any engineer can read. In such a system, adding features has linear cost, not exponential cost.
So we do not try to do everything. Each phase, we do the one most important thing, finish it well, and then move on. Not because we lack ambition, but because we have seen too many projects die from trying to do too much.
Open Source Is a Belief, Not a Strategy
We chose open source not because it is the popular business model right now, but because we genuinely believe great infrastructure software should belong to the whole community.
Open source means transparency. Anyone can see every architectural decision, every code tradeoff, every known deficiency. That transparency is pressure on us, but also a constraint — no cutting corners, no fooling ourselves, no "ship it and fix it later."
Open source also means not building in isolation. We learn from Kafka, NATS, EMQX, and other excellent projects. We get ideas from community discussions and correct our direction from user feedback. Standing on the shoulders of those who came before is not a weakness — it is the pragmatic attitude engineers should have.
Technology is our belief, and application is our pursuit. What we want to build is infrastructure software that engineers can actually use and rely on — not a paper, not a demo, but a system running in production.
We Are Not Afraid of Failure
RobustMQ is not a commercial project. No funding pressure, no quarterly targets, no KPIs that must be delivered by a certain date. We are doing this simply because we want to.
That gives us a different relationship with failure.
Failure here is not loss — it is information. A design getting torn down means we found a better direction. A feature that turns out to be the wrong approach halfway through — stopping early is more valuable than pushing through. We will not keep walking the wrong road just because we already invested time, and we will not hide problems to avoid admitting mistakes.
Doing something you want to do is itself the meaning. The result matters, but so does the process — every line of code, every architectural decision, every conversation with the community is part of it. We enjoy the process. We are not just waiting for the destination.
If someday RobustMQ does not make it, we will not feel that time was wasted. What is truly wasted is the thing you wanted to do but never started.
What We Are Building Is Worth Doing Slowly
In this domain, Kafka took ten years to become the de facto standard for data pipelines. MQTT took twenty years to establish an unshakeable position in IoT. There are no shortcuts in infrastructure software.
What RobustMQ wants to do — unifying AI Agent communication, IoT device ingestion, edge data sync, and real-time stream processing on a single infrastructure — is hard enough, and worth enough.
We do not know how far RobustMQ will ultimately go. But we know: something worth doing deserves to be done seriously.
Dare to dream. Build it slowly.