Why EFI Motorcycles Bog on Throttle Snaps — and Why Your Fuel Tuner Can't Fix It

The EFI throttle bog

Twist the throttle on a modern fuel-injected dirt bike and sometimes it just falls on its face. A flat spot. A hiccup. Riders call it the bog.

It's common, and most of the time the factory deserves the blame. Emissions rules push the fuel map lean at exactly the throttle openings we actually ride — the part-throttle, roll-on zone — so the bike surges, snatches, or goes flat right when you ask for power. You feel it crossing a log, rolling on out of a corner, blipping to rev-match.

So you buy a piggyback fuel tuner to richen it back up. Problem solved.

Except — Tyler, one of the first riders to run our tuner, put it on a completely stock KLX300 with the fuel map set to zero. Adding nothing. And he still felt the bog on throttle snaps. I'd never felt it on my own bike.

If the tuner is adding zero fuel, how is it changing anything at all?

That question turned into a several-week dive, and the answer is something almost nobody talks about: every device that reads your injector signal has a blind spot in exactly the moment you snap the throttle. It's not a bug in one brand. It's physics. Here's what's actually happening — and how we fixed it.

How a piggyback tuner works

A fuel tuner sits between the ECU and the injector. There are only two ways to wire it.

The first is series: you cut the ECU's injector wire, and the tuner re-drives the injector itself. Powerful — it can add and subtract fuel — but now the tuner is in the critical path. If it dies, the bike dies.

The second is parallel: the ECU's wire stays connected, and the tuner fires a second injector driver alongside it. The injector simply takes whichever pulse is longer. The tuner can only add fuel, never subtract — which is fine, because de-restricting a bike almost always means adding fuel.

We chose parallel, on purpose, for one reason. Call it the walk-home test: if the tuner ever dies, gets wet, or you just unplug it, the bike runs exactly as stock and gets you home. The ECU's wire is never cut.

Here's what "series" versus "parallel" actually means on the wiring:

Series — the tuner re-drives the injector. Cut the ECU's wire, put the box in line. If the box dies, the bike dies.

Parallel — the ECU wire stays uncut (thick cyan). The tuner reads the ECU's pulse off that wire (thin cyan) and only adds fuel (dashed green). Box dies, gets wet, or you unplug it = stock bike, gets you home.

That safety comes with a consequence we'll come back to: because the injector takes the longer of the two pulses, the tuner's whole job is to decide how long to hold the injector open. Get that timing wrong and you don't lean out — you over-fuel.

The tuner fires one pulse late

To add the right amount of fuel, the tuner has to do real work: measure the ECU's pulse, work out the RPM and engine load from it, look up the fuel map, and calculate how much longer to hold the injector open.

That math can't finish inside the same pulse. By the time it did, the injector would already be closing — and injectors don't pause. Once the current starts dropping, the little valve is seating, and reopening it costs precious milliseconds while the magnetic coil rebuilds.

So the tuner does what every injector-reading device does: it measures one pulse, does the math in the calm gap before the next one, and fires the result on the next pulse. It's always exactly one pulse late.

Figure 3 — the tuner always reacts one pulse late. Normally invisible — a few thousandths of a second.

That's normally fine. An engine's airflow barely changes from one revolution to the next, so what was correct a moment ago is still correct now. One pulse of stale is nothing.

Until it isn't.

Throttle enrichment: the ECU's hidden trick

There's exactly one moment an engine's airflow changes faster than one pulse can track: when you snap the throttle open.

The ECU knows this. Left uncorrected, the sudden rush of air would lean out the mixture and the bike would hesitate — so the ECU fires a quick burst of extra fuel shots in between the regular pulses. It won't wait for the next engine revolution, because by then the engine would already be gasping.

On the KLX (and most modern fuel-injected bikes) that looks like a rapid 10ms – 1ms – 10ms – 1ms injector pattern: big regular pulses with tiny 1-millisecond shots stuffed in between whenever the throttle moves.

Figure 4 — not noise. The ECU's throttle enrichment: extra fuel shots the instant you twist the grip.

This is throttle enrichment (sometimes called tip-in enrichment). I spent a while thinking those tiny shots were electrical noise. They're not. When I logged every injector pulse, they lined up exactly with throttle movement. The ECU is doing something deliberate, fast, and invisible to the rider.

And it's about to cause a problem.

The RPM guessing game

Here's the first thing those enrichment shots break.

The tuner works out engine RPM from the gap between injector pulses — the ECU fires once every two crank revolutions, so the gap tells you the revs. But the enrichment shots make that gap look tiny. A tuner that isn't ready for this reads "5,000 RPM just jumped to 15,000 in an instant" — physically impossible — and pulls fuel from a totally wrong cell of the map. The engine is at 5,000; the tuner thinks it's at redline.

Figure 5 — the enrichment shots fake an RPM spike. The guard holds the real value.

I hit this years ago, and the fix is a physics sanity-check: hold onto the last believable RPM, and reject any jump the rotating engine mass couldn't physically make in that time. No crankshaft goes from 5,000 to 15,000 in a few milliseconds. The check refuses to believe it, holds the real RPM, and the map reads correctly.

It works. It shipped. It's the reason the fuel map tunes cleanly.

So RPM is handled. We're done, right?

The twist: the tuner over-fuels when you snap it

Here's the catch.

That physics sanity-check protects the RPM reading by freezing on the last good pulse for the whole enrichment burst. But the tuner's output doesn't know that. So while the ECU is firing a tiny 1-millisecond enrichment shot, the tuner is still holding the injector open for the last good 10-millisecond pulse alongside it.

And remember the rule from parallel wiring: the injector takes the longer of the two pulses.

Figure 6 — the longer pulse wins: each 1 ms enrichment shot gets stretched to the tuner's frozen width (~10 ms). The injector still closes between shots — this is per-squirt over-fuel, not a continuous pour. (Only if shots land closer than that width do they merge into a block — rare in the real data.)

So each tiny 1 ms enrichment shot gets stretched out to the tuner's frozen value — roughly 10 ms at high load. Two squirts that should've metered 2 milliseconds land closer to 20. That's the over-fuel bog — and note what it isn't: the engine isn't drowning in one continuous pour. The injector usually still closes between shots (the gaps are big enough). It's every individual enrichment squirt landing ~10× too fat, snap after snap, that you feel.

And it can only ever be rich — too much fuel — never lean. A parallel tuner physically cannot subtract fuel. That's actually what told me where to look: Tyler's bike couldn't be going lean, so the bog had to be rich, and that pointed straight at the enrichment burst. It also solves the zero-map puzzle: "zero" never meant "fire nothing" — it meant "add nothing on top of the regular pulse." The tuner still fires the last regular width on every edge, so a 1 ms enrichment shot still drew the full-width pulse alongside it. Adding zero still over-fueled.

It's also not every blip. Snap the throttle right out of a closed-throttle decel and the tuner's held value is already small, so the ECU's shot covers it — almost no extra fuel. The nasty bog is high load into a snap: the held value is a big pulse, and every tiny shot gets stretched out to that big width — ~10× too fat, squirt after squirt. That's why Tyler felt it pinning the throttle under load, not on every wrist twitch.

Why every tuner struggles with this

This isn't a bug in one brand. It's a timing problem baked into how every injector-reading device has to work.

The ECU fires those enrichment shots with no warning. Reacting to them inside the same pulse is bounded by physics — the math, the coil, the valve. For decades the only answer was to predict at the start of the pulse, fire in parallel, and live with exactly this over-fuel.

The obvious fixes are all wrong:

That last row is the real answer — and it's why this problem sat unsolved for decades. The danger is how you'd add fuel at the end. The obvious way is to time the pulse in software — but that's the third row, and it's an engine-safety minefield. If the microcontroller gets momentarily busy handling a Bluetooth packet to your phone at the wrong millisecond, a software-timed pulse can stutter — and in an engine, "stutter" means a pulse stuck open or snapped shut mid-stroke. That's a catastrophic engine-safety risk, not a tuning hiccup. Old tuner hardware had no circuit that could safely time a pulse off the moment the injector closes. So nobody did. Everyone predicted at the start, fired in parallel, and lived with this.

So what's left?

The fix: add fuel at the end, not the start

Instead of starting its pulse when the injector opens — where it competes with the ECU's width and over-fuels — the tuner starts its pulse the instant the injector closes. So it only ever extends the tail.

The math flips. It stops being "the longer pulse wins" and becomes simple addition: the injector is open for the ECU's pulse, plus a small tail. That tail is sized from the real pulse that just happened, so a 1-millisecond enrichment shot gets a sub-millisecond tail — physically incapable of over-fueling — and it's capped by a hard duty ceiling (90%), so it never pushes past the injector's safe margin.

Figure 8a — don't compete with the ECU's width. Just add a little at the end.

And it isn't software doing the timing — it's a dedicated timer hard-wired into the chip, tripped the instant the injector closes. As reliable as an analog circuit: even if the microcontroller gets distracted sending data to your phone, the fuel pulse can't stutter, stick open, or snap shut mid-stroke. No software in the path.

There's a beautiful physical detail here. The instant the ECU lets go, the injector wants to snap shut — but the tuner's driver chip has a built-in clamp that catches the voltage spike from that release instantly, holding the injector open just long enough for the tail circuit to kick in. We're talking millionths of a second — about seventeen times inside the window where the injector valve would actually seat and close. No relays, no software, no measurable delay.

Does it actually work on a real bike? Yes. Below is the same part-throttle roll-on off my KLX355 — same ECU pulses in both panels, only what the tuner adds differs.

Figure 8b — real on-bike data, one throttle moment. Cyan = ECU command. Red = over-fuel (old). Green = enrichment tail (new).

Figure 8c — the raw injector on/off signal. Old: each pulse widened — the enrichment shots stretched far past what the ECU commanded (worst one in this window: ~16 ms; the frozen width tracks the last main pulse, so it's bigger under hard load than the toy's 10 ms). New: short tails, closes clean between pulses.

On this ride, 99.4 percent of pulses delivered exactly the intended extra fuel, down to the microsecond. The few that delivered less were the safety cap doing its job on purpose — never a silent cut.

It's not literally zero over-fuel, and I won't pretend it is. There's a tiny, harmless residue — a few percent — from the tuner measuring a split-second late, plus one unavoidably-long shot at the very start of each snap before the fix kicks in. Bounded to a small tail — never the held-open over-fuel. I'd rather tell you that than claim magic.

How we even saw it: logging every combustion

None of this gets solved by guessing at a dyno.

The tuner records every single injector event — when it opened, how long, whether it trusted that pulse, and exactly how much extra fuel it added. You dump that log to your phone over Bluetooth, then open it on a laptop: every event laid out, throttle position and RPM and pulse widths on one screen. When Tyler reported the bog, he sent me his log. I didn't speculate — I read off the held-open pulse, to the microsecond.

That's the difference between "I think it's running rich" and "here's the over-fuel, right here, on this combustion event."

The real flex: fixed over the air

Tyler didn't mail his bike back.

I built the fix, shipped a 0.31.0 update, and he installs it from his phone — the same way the fuel maps, the logger, and everything else update. A fuel tuner used to be a sealed box you lived with, flaws and all. This one gets better after you own it.

Rider reports the symptom. The log proves it. The firmware ships. The phone delivers it. That loop — open, logged, fixable — is the actual product.

Thanks to Tyler for the logs that caught this, to Ross for decoding the factory ECU, and to the Discord for pushing on every bog. Built in the open, fixed in the open.

If your EFI bike bogs on throttle snaps — stock or tuned — that's not always the map's fault, and it's not always the tuner's either. Sometimes it's both. If you want to see what your injectors are actually doing, the tuner logs every pulse.