The workflow
Eight steps, in the order you actually do them.
FTT never talks to your ECU. It reads a datalog you already have, bins it into the breakpoints you already use, and gives you a correction you can argue with before any of it reaches your tune.
- 01
Set the breakpoints to match the ECU
You type in the axis values your ECU actually uses. Nothing is auto-binned, and that is deliberate: a bin edge sitting between two ECU breakpoints quietly averages two cells of your tune into one number, and nothing on screen would tell you it happened.
- 02
Load the log
Load the CSV your logging software exports. FTT reads the header row; you map its columns to channels once, and choose which channel positions each axis — RPM against MAP, TPS, or whatever the engine is logging. Load several logs and they append into one timeline.
- 03
Set the filters
A row filter is a condition you write against any logged channel — abs([delta_tps]) > 5 drops throttle transients, a temperature threshold in the log's own units drops a cold engine. Then two filters inside each cell: sigma rejection (K = 2.0 by default), so one bad sample can't drag an average, and a minimum sample count (5 by default), below which a cell reads empty rather than trusted.
- 04
Read the grid
Every row that survives lands in exactly one cell, and the grid updates the moment a filter changes — there is no recompute step. Each map is a layer of the same grid: the average lambda in a cell, the hits behind it, the error against your target, or any formula you define. Switch between them without losing your place.
- 05
Shape the correction
The correction is a map you define with a formula — the logged error turned into a change against your base fuel, written in terms you can read. With an inverse formula, editing the corrected map writes back through to the base map, so the two stay tied. Nothing has been written to your tune at this point. It is a table on your screen until you copy it out.
- 06
Fill, interpolate and smooth
Select a region. H and V interpolate a ramp across it. Smooth blends each cell with its neighbours at a strength you set, and can ignore empty cells so gaps don't drag good data down. Smart Fill estimates empty cells from nearby cells that have data, and leaves a hole with nothing near it empty rather than invent a number. Every tool writes to the map you choose, and one undo history covers all of it.
- 07
Check the change against the data
The Tune Quality Report compares the tune before and after your edits, load row by load row: how much you added against how much the data asked for, and where those disagree. Numbers only — the decision stays yours. Save it as text, CSV or PDF for the customer file.
- 08
Get the numbers back into the tune
Select the finished region and copy. It lands on the clipboard tab-separated, in the same shape as the grid, which is what a tuning table paste expects. The project itself — axes, maps, filters and channel mappings — saves as one XML file on your own disk.
Before and after
A log, a table, a map.
The same pull at three points in the workflow. The middle panel is the log binned into your breakpoints, and nothing in the last panel reaches your tune until you copy it out.
What the log looks like
Logged lambda against target, every row, unbinned. This is the shape of the problem: tens of thousands of points, a large share of them recorded while the throttle was still moving.
Screenshot pending
The scatter view — logged lambda against target, before any binning.
What it becomes
Averaged into your breakpoints, with the hit count under every value. The %Change table is another layer of this same grid — same axes, same cells.
Small figures are hit counts. Cells under the minimum sample threshold stay unshaded — no data is not the same as on target.
What you keep
After interpolation across the thin corners and a smoothing pass. Every changed cell is one you chose to change.
Screenshot pending
The working map after interpolation and smoothing.
Which ECUs this works with.
Listed by model number, with what we read from each and what we haven't got to yet.