Your Phone Just Got a Driving Instructor, a Guardian Angel, and a Battery Therapist — Meet Tracelet 3.3.0

Background geolocation that stopped just watching you move and started understanding how you move — all on‑device, no cloud, still open‑source.

Let’s be honest about background geolocation for a second.

For years the deal was simple and slightly boring: your app wanted to know where a phone was. A dot on a map. Latitude, longitude, “congrats, the device is at the coffee shop again.” Useful! But about as insightful as a security camera pointed at a wall.

Tracelet 3.3.0 looked at that dot and said: “Cool. But… how is it getting there? Is it walking? Driving like it’s late for a flight? Did it just… crash?”

This release is the moment Tracelet went from “I know where you are” to “I know what you’re doing, I can tell when something’s wrong, and I’ll do it without nuking your battery.”

And the best part for us developers: it’s all running on the device, in a shared Rust core, with no cloud calls and no ‘enterprise tier sales call.’ Everything new is opt‑in and off by default — turn on only what you need, and existing tracking behaves exactly as before.

Grab a coffee. Tour time.

Beginner-friendly part: what even is this?

If you’re new: Tracelet is an open‑source background geolocation engine for Flutter (iOS + Android). It’s the thing that keeps tracking even when your app is minimized, killed, or the phone rebooted — the genuinely hard part of mobile location that makes developers cry.

Delivery apps, fleet tracking, field‑service, rideshare, personal‑safety apps. The “where’s my driver / worker / package” category.

3.3.0 adds four superpowers on top of that. None require shipping raw sensor data to a server. Your accelerometer stays your business. (Want the official docs while you read? Here: https://tracelet.ikolvi.com/en/core/driving-safety)

🚗 Driving Telematics — “Your Car Is Now Judging You”

You know that friend who brakes like every traffic light personally offended them? Tracelet can detect that now.

It turns the raw GPS stream into actual driving behavior events:

• Harsh braking (“we get it, the light was red”)
• Harsh acceleration (“this is a Corolla, not a Ferrari”)
• Harsh cornering (“Tokyo Drift was a movie, not a tutorial”)
• Speeding (configurable, with a grace tolerance so a 2‑second blip doesn’t snitch)

Each event ships a severity score from 0 to 1:

Tracelet.onDrivingEvent((event) {
  print('${event.kind} — severity ${event.severity}');
});
// harsh_braking — severity 0.82
// speeding — severity 0.40

It even works on the web, because it’s GPS‑derived.

💥 Crash & Fall Detection — the one that gives me chills

Jokes paused, because this one matters.

Tracelet 3.3.0 detects a crash (a hard impact while moving) or, optionally, a personal fall. The part I love as an engineer: it’s corroborated — a big jolt alone is never enough. Dropping your phone on pavement shouldn’t dial 911. It cross‑checks impact against speed and motion before believing you.

Then it does the most human thing software can do: it asks if you’re okay first.

Tracelet.onImpact((event) async {
  if (event.isPotential) {
    // Show a big "Are you OK?" countdown screen.
    await Tracelet.cancelImpact(event.id);   // "I'm fine"
    // await Tracelet.confirmImpact(event.id); // "Get help now"
  } else {
    // Nobody cancelled in time → start your SOS flow.
  }
});

Honest and important: Tracelet gives you the trigger and the cancel window. It does not call emergency services itself — you build that flow, the UX, and the legal copy. That’s deliberate: you should control what happens when the stakes are human safety.

🚶 Transport-Mode Classifier — walking, cycling, or driving?

Your phone now knows the difference between strolling, running for the bus, cycling, driving, or standing perfectly still pretending you didn’t see your ex across the street.

It fuses accelerometer + GPS with hysteresis (fancy word for “won’t flicker between ‘walking’ and ‘running’ every half second like an indecisive fitness tracker”).

Tracelet.onModeChange((event) {
  print('Now: ${event.mode} (confidence ${event.confidence})');
});

Delivery apps love it: “driver left the van, now walking to the door” becomes automatic. No buttons.

🔋 Motion-Gated Wakelock — the Battery Therapist (Android)

A deeply unsexy feature your users will silently thank you for.

Aggressive Android OEMs sometimes need a wakelock to keep background tracking alive. But holding one while the phone sits motionless all night? That’s just draining battery to watch nothing happen.

3.3.0 drops the wakelock when stationary and re‑asserts it the moment you move — gated on the hardware significant‑motion sensor, so it’s basically free:

Config(android: AndroidConfig(releaseWakelockWhenStationary: true));

Nobody writes a 5‑star review about battery they didn’t lose. They sure write 1‑star ones about battery they did.

🩺 Bonus: Tracelet Doctor writes its own bug reports

The built‑in diagnostic overlay (tracelet_doctor) now has one‑tap Copy / Share Bug Report — bundling health + config + recent logs + telematics into a paste‑ready report, with secrets automatically redacted. When a user says "it's broken," they hand you a full diagnosis instead of "idk it just stopped."

So… what’s the catchiest feature?

Crash & fall detection. Telematics is fun, the classifier is clever, the wakelock is responsible — but crash detection makes someone stop scrolling and go “wait, my app can do that?” It reframes the category from logistics to people. That’s not a feature bullet, it’s a story.

How the world sees it

Invisibly — that’s the point. Nobody sees a Rust core. They see a rideshare app that checks on you after a hard stop, a delivery that updates itself when the courier starts walking, a field‑worker app that quietly has someone’s back on a night shift, and a phone that isn’t dead at 4 PM. Good infrastructure is felt, not seen.

How drivers see it

Two angles at once:

1. “My phone is judging my driving.” Yep — and most people drive a little better when a score exists (same reason we slow past a speed camera). Done right, that’s a good nudge.
2. “My phone has my back.” The same sensors that catch bad habits detect the crash you didn’t see coming. The judgment and the guardian angel are the same feature stack.

The best drivers will forget it’s there. The unlucky ones will be very glad it was.

The fine print that’s actually a flex

• On‑device & deterministic — shared Rust core, same results on Android and iOS, no network.
• Opt‑in, default‑off — turn on only what you need.
• Side‑channel — events ride alongside your normal location stream; they never change locations, odometer, or sync.
• Open‑source — all of it.
• You own safety‑critical UX — Tracelet hands you the trigger; you build the SOS.

Try it without crashing a car (please)

You don’t have to drive recklessly — or crash — to build against this. The example app and APIs let you simulate driving events, impacts, and modes in code, so you can test your “Are you OK?” screen on a couch instead of a highway.

TL;DR

Tracelet 3.3.0 taught background geolocation to understand behavior, detect danger, classify movement, and respect battery — all on‑device, open‑source, opt‑in. Your dot on the map grew up: it got a job, a conscience, and a really good sense of when something’s wrong.

Drive safe. Your phone’s watching. (In the good way.) 🚗💨

👉 Read the full Driving & Safety guide: https://tracelet.ikolvi.com/en/core/driving-safety

⭐ Open‑source — stars, issues, and PRs welcome. 📚 Docs: tracelet.ikolvi.com

tracelet #driving #crash #safety #flutter #background #tracking