Boosthis drops into JavaScript / TypeScript, Python, Java, Go, PHP, C# / .NET, Ruby, Dart (Flutter), Swift, Kotlin (Android), Rust or Elixir — in phone apps, browser pages, back-end servers, Bun and edge functions — measures what is actually slow in your own app, and hands your AI assistant the real numbers plus a proven fix for each problem it finds. It never reads your source code and never sends a full web address: route and screen names are normalised before anything is uploaded.
The languages you write
…and the places that code runs
Try Boosthis free for 7 days. Everything on the plan switches on straight away — project keys, your AI connection, all of it. We charge SAR 1.00 to check the card works and hand it straight back, and take nothing else today. On day 7 the card is charged for the plan you pick, and the plan continues monthly. Cancel any time before day 7 — one click, and you pay nothing at all. One free trial per account and per card. You choose your plan when you create your account, before your first project key is issued — see the plans.
What we support
Two different questions, kept apart on purpose. What you write is a language: JavaScript / TypeScript, Python, Java, Go, PHP, C# / .NET, Ruby, Dart (Flutter), Swift, Kotlin (Android), Rust and Elixir. Where it runs is a place — phone apps, browser pages, back-end servers, Bun and edge functions — and the same JavaScript can run in every one of them. That is why fifteen toolkits cover twelve languages, and why there are sixteen separate things you can install.
The iOS and Android apps people install — React Native, Flutter, Swift (Apple) and Android (Kotlin). Here Boosthis reads how long the first screen takes to appear, how long until it answers a tap, how long that tap then waits, and how steady the screen stays afterwards.
Anything a person opens in a browser tab — Web (browser). Here Boosthis reads INP — how long a page takes to respond after someone clicks — and the rest of the Core Web Vitals, page by page.
The services your app calls — Node.js / Express, Python, Java, Go, PHP, C# / .NET, Ruby, Rust and Elixir. Here Boosthis reads how long each route takes to answer, and what the runtime was busy doing while it took that long.
The same back-end kit, on Bun's own engine instead of Node's. Here Boosthis reads the same per-route timings as a Node.js server, minus the few readings Bun's engine does not expose.
Code that runs at the edge, close to whoever asked for it. It runs on Cloudflare Workers, Deno Deploy, Deno, Supabase Edge Functions, Vercel Edge Functions and Netlify Edge Functions. Here Boosthis reads how long each request spends inside the isolate — which is as much as something that stops existing between requests can know.
Three things are genuinely identical everywhere: the scoring model and its shared budgets, the strict PII guard on everything a kit sends, and the AI tool surface your assistant reads. How much a runtime can measure is not identical — a browser has no garbage collector to inspect, Rust has no runtime to ask, an edge isolate is gone between requests — so the fullest kits take 75 readings and the newest take 9. The plans page lists what each runtime can measure, row by row and generated from the kits themselves; find yours there before you choose a plan.
Drop useBoosthis("ScreenName") into any screen for
instant, on-device performance ratings — every screen measured, and
regressions caught early. A built-in dashboard tab shows the full
meter page inside your own app, and your AI assistant can read the
same numbers.
Call startWebVitals() once at page load for real
browser Web Vitals per page — INP for how quickly the page answers a
click, plus the rest of the Core Web Vitals — rated against the same
shared budgets. Catches the browser-specific problems that hurt real
visitors, with a concrete fix for each.
Add the boosthis() Express middleware — or
attach() on any other Node server — and optionally
mount(app) for the live /_boosthis/ page.
Catches the runtime-specific problems that actually slow Node services
down, with a concrete fix for each.
Bun runs the back-end kit's own files on Bun's engine instead of
Node's — the same boosthis() middleware, the same
/_boosthis/ page, and its own recipe on your Setup page.
It registers under its own name so your dashboard can say plainly
which readings Bun's engine does not expose, rather than showing them
as blanks on a Node project.
Add @track_perf("route") to any function. One extra
line — boosthis.mount(app) — mounts a live dashboard at
/_boosthis/ on your existing Flask or FastAPI port. Run
boosthis serve without a web app for the same dashboard
at localhost:7787. Catches the problems that actually
slow Python services down, with a concrete fix for each.
Wrap any com.sun.net.httpserver handler with
BoosthisHandler, or any framework route with the generic
Wrap helper, for per-route ratings against the same
shared budgets. Catches the problems that actually slow JVM services
down — with a concrete fix for each, zero dependencies, JDK stdlib
only.
Wrap any http.Handler with
boosthis.Middleware for per-route ratings against the
same shared budgets. Catches the problems that actually slow Go
services down — with a concrete fix for each, zero dependencies, pure
stdlib.
One line — \Boosthis\Boosthis::start() in your front
controller, or the ready-made Laravel / PSR-15 middleware — rates
every route against the same shared budgets. Catches what actually
slows PHP-FPM sites down, from OPcache and memory limits to realpath
cache pressure, with a concrete fix for each and no extensions
required.
One line — app.UseBoosthis() in your ASP.NET Core
pipeline, or Boosthis.Start() anywhere else — rates every
route against the same shared budgets. Catches what actually slows
.NET services down, from GC pauses and heap headroom to thread-pool
starvation, with a concrete fix for each and not one NuGet package to
install.
One line — Boosthis.start, or the ready-made Rails
Railtie / Rack middleware — rates every route against the same shared
budgets. Catches what actually slows Rails and Rack apps down, from GC
pressure and memory headroom to slow outbound calls, with a concrete
fix for each.
Two lines — BoosthisFlutter.start and
BoosthisFlutter.run in main() — rate every
screen against the same shared budgets, straight from the engine's own
frame timings. Catches what actually slows Flutter apps down, from
raster-vs-build jank and frozen frames to image-cache weight and
memory growth.
One line — BoosthisApple.start at launch — rates every
screen of a native iOS, iPadOS, macOS, tvOS or visionOS app against
the same shared budgets, straight from the app's own run loop and
MetricKit. Catches what actually slows native Apple apps down, from
unresponsive hangs and scroll hitches to memory headroom before
jetsam.
One line at launch rates every screen of a native Android app against the same shared budgets, straight from the app's own frame timing and the ART runtime. Catches what actually slows Android apps down, from frozen frames and app hangs to GC pauses, thermal throttling and cold-start cost.
One layer — boosthis::middleware for axum or
actix-web — rates every route against the same shared budgets. Catches
what actually slows tokio services down, from blocking calls on an
async worker to task backlog and connection churn, with a core that
pulls in nothing but std.
One plug — Boosthis.Plug in your Phoenix endpoint —
rates every route against the same shared budgets, and reads what only
the BEAM can tell you: scheduler utilisation, run-queue backlog,
reductions, per-process message queues and ETS growth. Zero
dependencies — it runs on OTP alone.
Wrap a Cloudflare Worker or a standard request handler to measure reliability, access pressure, cookie safety and cold starts where the host allows it. It needs neither Node.js nor a filesystem. It adds no page and no bubble to the function on purpose — its numbers appear on your Boosthis dashboard instead.
Scoring model
Every runtime is rated against the same shared budgets and distilled into a single 0–100 score, so you can compare performance across RN screens, Python routes, and Node.js handlers side-by-side — no per-tool guesswork.
Measuring and rating happen where your code runs. Nothing is uploaded
until you turn telemetry on for a project; after that the kit sends the
timings, the issue labels and the screen or route name — normalised, so
it is a label like /orders/:id and never a real address.
How it works
Detection runs entirely on-device; clear fix guidance is delivered inside your dashboard and AI tools exactly when an issue is detected.
React Native: useBoosthis("ScreenName").
Python: @track_perf("route").
Node.js: app.use(boosthis()).
One line per screen or route, and your project key connects it.
Each kit takes the measurements its own place can actually take — INP and the Core Web Vitals in a browser, first-screen and tap timings in a phone app, per-route timings on a server — rates them against the same shared budgets, and detects known problems as it goes. What each place measures is listed above.
Connect your AI assistant to give it read-only access to the full live meter page, per-screen diagnosis, session summary and fix suggestions — for the projects you connect, and nothing else. How to connect your AI.
We help you find and fix your project's performance issues — clear guidance, delivered right in your dashboard and AI tools. Your source code, request and response bodies, cookies and session data are never collected, and a project uploads nothing at all until you turn its telemetry on. What it uploads then is what your dashboard, your alerts and your monthly review are made of.
What you get
Finding the slow thing is half the job. This is what Boosthis does with it afterwards.
Every problem a kit reports is tied to a fix in the Boosthis library: what causes it, what to change, and how to tell it worked. Your AI assistant reads the same library, so it can apply the fix instead of inventing one.
When something throws where a kit can see it, the crash is filed with your project — through the same privacy guard as every other payload. The kit never takes your app down with it: a failure inside Boosthis can only ever silence Boosthis.
Boosthis watches your projects between visits and emails you when a screen or route turns bad, when a fixed one comes back, or when a project that was reporting goes quiet. Muting an alert silences the email, never the measurement — and the page says how much a mute is hiding.
Once a month, a written summary per project: what got faster, what got slower, and what was not measured at all. A month with no data is reported as a month with no data, never drawn as a good one.
On the plans that include it, one request can be followed from the screen a person tapped, through the services behind it, and back — so a slow screen is blamed on the part that was actually slow. Available in 14 of 15 runtimes.
Every project has a dashboard with its meters, its issues and its history; every kit can serve the same page inside your own app. Our own uptime is on the status page, whether it is good news or not.
Pricing
Billed in Saudi Riyal (SAR) — choose monthly or yearly below, where a year costs 10 months — and the price you see is the final amount charged — inclusive of any applicable taxes, with no hidden fees. Major cards are accepted, and if you pay from abroad your bank converts automatically. You choose your plan when you create your account, before your first project key is issued.
Try Boosthis free for 7 days. Everything on the plan switches on straight away — project keys, your AI connection, all of it. We charge SAR 1.00 to check the card works and hand it straight back, and take nothing else today. On day 7 the card is charged for the plan you pick, and the plan continues monthly. You get an email when the trial starts, and another a few days before that charge. Cancel any time before day 7 — one click, and you pay nothing at all. One free trial per account and per card.
Your first project, fully instrumented.
Full toolkit: tracing, full telemetry, unlimited AI connections.
For when more than one person is responsible for the same project.
For running many projects at once, with nothing left to count.
Plans renew automatically — monthly plans each month, yearly plans each year — until cancelled. Cancel anytime: you keep your plan until the end of the period you have paid for, and a lapsed plan never deletes your data. Fees are prepaid for the period you chose and non-refundable except where the law requires — full details in the Refund & Cancellation Policy.
Privacy
Boosthis was designed so that nothing sensitive can leave your app, even if you misconfigure it. Measuring and rating happen inside your own process, and a project uploads nothing until you turn its telemetry on. When you do, three things go to your dashboard: the timings, the issue labels, and the normalised name of the screen or route they belong to. Your source code, request and response bodies, cookies and session data are never collected — the kit has no access to them.