Every phone is a sensor.
Every second is a life.
NE-PULSE turns everyday smartphones and low-cost microcontrollers into a decentralized earthquake sensing network — detecting structural motion in real time and giving cities precious seconds of warning before the destructive shaking arrives.
How the warning actually works
Two waves travel out from every earthquake. One is fast and harmless. The other is slower and destructive. The gap between them is your warning.
- 1. Rupture begins
A fault slips underground. The fast, harmless P-wave radiates outward first.
- 2. Sensors detect, network warns
Phones and microcontrollers feel the P-wave and report it. The network confirms a genuine rupture and broadcasts a warning — at network speed, far faster than any seismic wave.
- 3. Cities receive seconds of warning
Each city already knows exactly how many seconds it has before the destructive wave arrives, based on its distance from the epicenter.
- 4. The destructive S-wave arrives
Slower, but far more damaging. By the time it reaches a city, that city has already had its warning.
The backend, demystified
Checking whether ten different phones are all reporting shaking from the same neighborhood, at the same instant, sounds like it should require slow, complicated geographic math. It doesn't have to.
Instead of running heavy, non-linear geometric boundary computations against raw GPS coordinates, every reading's lat/lng is indexed instantly into a discrete, hierarchical hexagonal cell key via Uber's H3 library (github.com/uber/h3-go) — with an automatic pure-Go equirectangular-grid fallback when a C toolchain isn't available at build time. Two phones in the same cell are, by definition, close together.
Routing a new reading to its cell is a single hash-map lookup keyed on its H3 index — never an iterative comparison against every other active device's coordinates, the approach that would otherwise force scan time to grow with total device count. Confirming coincidence within that cell then checks only its own small, fixed-capacity buffer of recent readings, bounded regardless of how many devices are online system-wide.
The ingestion pipeline is written in Go: goroutines and channel-based handoff move every reading from the gRPC hot path to background workers with zero application-level mutexes — each worker owns its own consumer state exclusively, coordinating only through a buffered channel and atomic counters, so no incoming reading ever blocks on lock contention.
Follow one reading, live
Trace a single sensor reading from the first tremor to a warning on someone's screen.
A phone or microcontroller's accelerometer picks up the first sign of motion — milliseconds after the fault slips.
No coordinate math. It lands in one of millions of pre-computed hexagonal cells, instantly comparable to its neighbors.
One shaking phone could be someone dropping it. Multiple devices in the same zone, at the same instant, is a rupture.
At network speed — faster than any seismic wave — every downstream system hears about it at once.
Command dashboards and phones alike show exactly how many seconds remain before the destructive wave arrives.
See it in action
A live look at the sensor network in motion and the real-time seismic trace that drives every detection.
Edge devices detect motion and shoot a data pulse upward the instant it happens — no polling, no delay, straight into the live command view.