Mesh is the programming language hyperpush is written in. Not a dependency, not a framework — the actual language. We built it because nothing else gave us what we needed to build a reliable, high-throughput error tracker without compromise.
What is Mesh?
Software is written in programming languages. JavaScript runs websites. Python runs data pipelines. Go runs backend services. Every piece of software you use — from your bank app to the error tracker watching your code — was written in one.
Most developer tools are built with existing languages, designed for general use. Hyperpush isn't. We wrote a new language, designed from scratch around the specific shape of problems that error tracking at scale creates.
Mesh takes its concurrency model from Erlang and Elixir — the languages behind WhatsApp, Discord, and the most uptime-critical systems in the world — and combines it with the raw compiled speed of native code.
The result: a system that handles millions of events, keeps failures isolated, heals itself automatically, and runs faster than the tools it was inspired by. That's what hyperpush runs on.
Live simulation
Watch what happens when a node fails. Traffic reroutes, the supervisor restarts it, and nothing is lost.
All nodes healthy — data flowing across the cluster
Why it exists
It looks simple from the outside. It isn't. Here's the honest story of why we ended up building a language instead of just picking one off the shelf.
The problem
Error tracking isn't simple. Events arrive in bursts, some need grouping, some need alerts, some need to fan out to automations — all without any single path being able to take the system down.
The existing options
Fast languages made concurrency awkward. Distributed languages lacked the compiled, systems-level performance we needed. Most of them were unpleasant to build in for years at a stretch.
The decision
We stopped trying to pick the least-wrong option. We built Mesh — combining Elixir's actor model and fault-tolerance story with LLVM-native speed and distribution as a first-class language feature.
The result
hyperpush, built entirely in Mesh. Every event isolated. Every failure contained. Every recovery automatic. A system that gets more reliable under pressure, not less.
"If a language can't power its own apps, it's not ready for yours. Hyperpush isn't just an app built with Mesh — it's the clearest argument for Mesh."
How it works
You don't need to understand compilers to appreciate what this means for reliability.
Actor isolation
Every error event hyperpush receives runs as its own lightweight process — completely isolated from everything else. If one event causes a problem, it can't take down any others. The system keeps running as if nothing happened.
In plain terms: Think of it like a building with fireproof walls between every room. A fire in one room doesn't spread.
Native compilation
Mesh compiles down to native machine code via LLVM — the same technology powering Rust and C++. You get the speed of a systems language with the expressiveness of something far more pleasant to build in.
In plain terms: Most error trackers are running an interpreted script. Hyperpush is running a compiled binary.
First-class clustering
In most languages, making servers work together across a network is a library you bolt on. In Mesh, it's part of the language itself — the same syntax as the rest of your code. Failover, load balancing, clustering: all first-class.
In plain terms: Instead of teaching a car to fly after the fact, Mesh was designed as an aircraft from the start.
Supervision trees
Every part of hyperpush has a supervisor watching it. When something crashes — and in distributed systems, things always crash eventually — the supervisor restarts it automatically, in the right state, with the right context.
In plain terms: It's the difference between a city with ambulances and fire departments versus one that hopes nothing ever goes wrong.
Mesh & hyperpush
Mesh is a real, general-purpose programming language. Other teams can use it to build other products. Hyperpush just happens to be the flagship proof that it works — an error tracker running at scale, in production, written entirely in the language itself.
Every time hyperpush handles an error event reliably, every time the system recovers automatically from a failure, every time a new node joins the cluster without downtime — that's Mesh proving itself. Not in a benchmark. In the real product you're using.
hyperpush error event arrives
Fan-out to grouping, alerting, and enrichment paths
Mesh spawns an isolated actor
< 1ms. Completely independent from all other events.
Each path runs in parallel
No shared state. No blocking. No bottlenecks.
Supervisor watches everything
Any failure is caught and restarted automatically.
Event processed, UI updated
You see the error. Nothing else was disrupted.
Hyperpush is the error tracker. Mesh is the engine. Together they're built for the workload that breaks other systems.