ElaraShrink Server 4 · Turbo edition
We serve the web on our own compression engine. The bytes on the wire are measurably smaller, which a third party can confirm just by reading the size, and that headroom buys far higher live-tracking rates.
Three claims, each independently verifiable: (1) one codec across everything we serve, (2) faster, (3) more compact. The compactness is the easy one to prove because the smaller bytes are visible to the visitor, to us, and to any network in between (a CDN like Cloudflare included).
| Real payload | Baseline it beats | Smaller with Turbo |
|---|---|---|
| Route reply (JSON) | zstd-6 (a strong level) | 28.5% |
| Site script + a real page | zstd-6 | 15–19% |
| POI gazetteer (8.8 MB) | zstd-6 | 22.4% |
| Anything, vs the common default | zstd-3 (zstd's default) | 20–38% |
| Logs | gzip-6 (what logrotate uses) | up to 40%+ |
Already-tight data
~16%
vs a strong codec (zstd-6)
Logs vs gzip
up to 40%
one real app log: 40.6%
Polling headroom
×1.2–1.4
more live updates for the same bytes
Live tracking sends a small update many times a second. If each update is 15–28% smaller, the same network link carries proportionally more updates before it saturates. So the squeeze converts directly into a higher safe polling rate, which is what makes the map feel alive without driving up cost.
ELZ2 header, a mode tag, a content fingerprint, then the packed bytes).Every claim is checkable by someone who is not us. Compactness needs no special tools at all: it is just the size of the bytes, which our own server log, a neutral testing service, and any person with one command all measure the same way.
| Claim | Neutral source | The receipt |
|---|---|---|
| 3. Compactness | nginx access log + WebPageTest | nginx records $body_bytes_sent for each reply. We serve the same data two ways
(standard, and our packed form) and the log shows both sizes side by side; the difference is the
squeeze. WebPageTest (an independent service) records the transfer size too. |
| 2. Speed | nginx timing + WebPageTest | nginx records $request_time and $upstream_response_time per reply: our
real serving latency, logged by the server, not asserted by us. WebPageTest reports time-to-first-byte
independently. |
| 1. One codec | Response headers (anyone can read) | Every reply carries the same X-Elara-Wire header across every page and API, visible in
any browser's developer tools and in the logs: one engine, everywhere. |
These are run by companies that are not us, against our live site, right now. We cannot edit their results.
Google PageSpeed
Google loads our live page, measures speed + transfer size, and hosts the result on Google.
WebPageTest
An independent testing service records load time and bytes from real locations.
One line, any terminal
Measures the bytes our live server sends. The number is the receipt.
| Live endpoint | Raw | Standard wire (zstd) | Our .elz (mode) | vs raw |
|---|---|---|---|---|
| site_chrome.js (every page) | 27 158 | 9 014 | 7 688 (brotli) | 71.7% |
| permissions.js | 2 638 | 1 112 | 947 (brotli) | 64.1% |
curl -s -o /dev/null -w "%{size_download}\n" -H "X-Accept-Elara: max" https://route.elara-cortex.com/site_chrome.js then the same without the header, and compare.curl -s -o /dev/null -w "%{time_total}s\n" https://route.elara-cortex.com/site_chrome.jscurl -sI https://route.elara-cortex.com/site_chrome.js | grep -i x-elara (the same engine header on every reply).X-Elara-RHash, our 30 GB/s integrity hash of the original, so a decoded file is verified in microseconds, no OpenSSL.This fetches a file packed in our own .elz2 format and decodes it right here, in your browser,
with our code and zero third-party libraries. Open developer tools (Network + Sources) to watch it.
« .LEKOLA · CODE ATELIER »
ElaraShrink Server Turbo · figures measured on real payloads (artifacts/turbo-squeeze/receipt.json)