WinOLS automation bot, included free

What the bot actually does

• DTC removal. Fault codes handled automatically against calibrations that already exist, rather than opened and edited by hand one file at a time.
• Solution application. It applies solutions from the sources you already trust: your own tested WinOLS project database, or established third-party solution software you licence separately — FixWave and Swiftec among them. We do not supply, resell or bundle that software, and you keep your own licence for it.
• Matching, not inventing. A new read comes in, the bot finds the closest match in a library of proven, human-made calibrations and copies those known-good values into the new version. AI may assist the matching when a database hit isn't perfect — it never writes a calibration value, and it never has free rein. No two files are ever quite the same; the judgement stays with the tuner.

Every automated result should still be checked by a tuner before it goes near a real vehicle. The bot is supplied as-is and experimental, and you need your own WinOLS licence with the OLS530 LUA option — see our software terms. We would rather say that here than in a footnote.

What it costs, and what the alternative costs

It is included in the RemapDash portal price. There is no bot tier, no per-file charge for it, and no separate machine to rent. The portal is £74.50 a month for your first six months, then £129 — and the price we print is the price you pay.

For comparison, a like-for-like competitor charges £4,500 setup plus £350 a month, plus VAT.

What is LUA scripting in WinOLS?

OLS530 — "LUA for WinOLS" is an official plugin from EVC electronic that lets you remote-control WinOLS with scripts written in Lua, a small, fast scripting language. Scripts can run two ways: applied on demand to the project you have open, or running permanently in the background, watching for and processing incoming files. EVC's own WinOLS Online Checksum Search is written in LUA — so the plugin is battle-tested inside the product itself.

Through the LUA API a script can do most of what an operator can do at the keyboard: search your project database for matching past projects, open projects, read and write project and version properties, read and write bytes, import and export files and maps, compare files, work with map packs, and search and apply checksums. In short: the repetitive, mechanical half of file work.

What does the WinOLS LUA plugin cost?

The plugin itself has published pricing: EVC lists OLS530 at €1,178.10 including 19% German VAT (about €990 net — resellers such as Tuning-shop.com quote €990 excluding VAT). That is on top of a full WinOLS licence, which is quoted individually by EVC and its resellers rather than published. So before you have written a single line of script, LUA automation is a four-figure investment — and then the real cost starts: the programming time to build, test and maintain scripts against your own workflow.

That is why automation platforms in this industry charge what they charge. Some portal vendors sell WinOLS automation as a premium product costing thousands, typically running on a separate dedicated PC that you supply and keep running. The automation is real — but it has been priced like a luxury.

What can LUA automation actually do?

Applied to a real file service, scripted WinOLS covers jobs like these:

• Find what you already know. Search your project database for past projects matching an incoming read — by producer, ECU number, software version — before a human even opens the file.
• Process incoming files automatically. EVC's own application example: apply changes to each incoming file depending on its Bosch number, and send the result onward.
• Carry proven changes across. Import your verified modifications from a matching past project onto a new read of the same ECU family.
• Keep the paperwork straight. Fill in vehicle and version properties, export originals and modified files with consistent naming, keep the project library clean.
• Handle checksums as a checked step. Search which checksum families apply, and treat correction as a deliberate, verified action — not an afterthought.

Notice what every one of those has in common: the script is moving your data around — your projects, your definitions, your verified modifications. Nothing is being invented.

Where the calibrations come from — your library, not a model

This is the part people miss, so it's worth being blunt about it. A LUA script has no opinion on how an engine should be tuned. It has no model, no training data, no notion of what a "good" map looks like. It is plumbing. Everything it applies has to come from a source you already trust, and in practice there are two:

• Your own tested file database. Every job you've ever completed and verified lives in your WinOLS project library — original, version, and the exact changes you made, on a car that ran. When a matching read comes in, the script finds that proven work and applies it. The calibration was authored by a human tuner and validated on a real vehicle; the script just saved you from doing the same thing by hand for the four-hundredth time.
• Established third-party solution software. These are commercial, purpose-built solution providers with their own developed, tested definitions for the ECUs they support — they are not language models guessing at values. A script can drive them as part of your workflow in exactly the same way it drives WinOLS: hand over a file, take back a result produced by software that was built, by engineers, for that specific job.

In both cases the knowledge predates the automation. Nothing is generated on the spot. Automation is only ever as good as the library behind it — which is why a mature, well-kept WinOLS project database is the most valuable thing in a tuning business, and why automation is a multiplier for shops that have one rather than a shortcut for shops that don't.

Library-based automation is not "AI tuning"

A lot of software is currently being marketed as "AI tuning". The phrase gets applied to two completely different things, and conflating them is how people end up with damaged engines:

• Library-based automation (what LUA does): a new read comes in, a script finds the closest match in a database of proven, human-made calibrations — your own past work, or output from developed third-party solution software — and applies those known-good changes. Deterministic: the same input produces the same output, every time. The knowledge is real and pre-existing; automation just retrieves and applies it faster than a human can.
• Generative "AI tuning" from scratch: a model produces calibration values for maps it has never seen validated, on an ECU it doesn't understand, with no ground truth behind the numbers. Probabilistic: it will always produce an answer, and it cannot tell you how confident it should be. Whether that answer is safe on a specific engine, with specific hardware, fuel and mileage, is exactly the thing it cannot know.

One is a filing clerk with a very fast pair of hands. The other is a stranger with an opinion. Everything in the rest of this page is about the second one — none of it applies to LUA scripting.

The dangers of generative AI tuning (not LUA)

An engine calibration is not a picture or a paragraph. When a generative model gets an image slightly wrong, you get a strange hand. When calibration values are slightly wrong, you get excess EGT, overboost, torque-limit conflicts, injector duty beyond safe limits, or a DPF/EGR strategy fighting itself — faults that may only surface under load, weeks later, on a customer's car. The specific problems:

• No ground truth. A generated map has never been dyno-proven. Plausible-looking numbers and safe numbers are not the same thing.
• Confidently wrong. Generative systems don't flag uncertainty. The output looks as tidy on a bad day as a good one.
• The wrong file is invisible until it isn't. A bad calibration can idle fine and drive normally right up to the operating point where it doesn't.
• Your name on the failure. When an automated file damages an engine, the customer doesn't blame the model. They blame the tuner who flashed it.
• Checksums and structure. Editing a binary safely also means correct checksum handling for that ECU family — a solved problem in WinOLS, an unsolved one in a text model.

Five ways an AI-generated file goes wrong

These are the failure modes experienced tuners will recognise. They are written as illustrative scenarios, not as accounts of specific named incidents — but every mechanism described is a real, well-understood way that an unvalidated calibration destroys hardware and reputations.

• The car that drove away perfectly. A generated file idles smoothly, pulls cleanly on a five-minute road test, and the customer leaves happy. The problem lives in a high-load, high-temperature corner of the map that a gentle test drive never reaches. Three weeks later, towing up a long gradient on a hot day, exhaust gas temperatures sit somewhere they were never meant to be — and turbine or piston damage arrives with no warning light ahead of it. Nothing in the road test could have caught it.
• The limiter that wasn't lifted with it. Fuelling or boost demand gets raised without the corresponding torque-limiter, smoke-limiter or protection maps being moved coherently. The result is an ECU fighting its own request: boost cut on load, limp mode at the worst moment, or a driveline shock as the torque model and reality diverge. The customer describes it as "bucking" and blames the last person who touched the car.
• The DPF that never regenerates again. A diesel's post-injection and regeneration strategy is a system, not a table. Change fuelling and timing without understanding how the aftertreatment strategy responds, and the filter loads faster than it clears. The bill arrives months later as a blocked DPF — and it is a large one.
• The checksum that half-passed. A file written with checksums that don't match the ECU family can produce anything from a stored fault to a non-starting vehicle — and the worst version is the one that flashes successfully and misbehaves later. On some ECUs a failed write leaves a bricked module and a recovery job that costs more than the remap earned.
• The file you can't explain. Something goes wrong and the customer, an insurer, or a warranty assessor asks what was changed and why. "The software decided" is not an answer any of them accept. With a proven library you can point at the original, the version, the specific maps altered, and the vehicle it was validated on. With a generated file, there's nothing to point at.

The pattern in all five: the damage is delayed, expensive, and lands on the tuner. Nobody notices the bad file on the day. They notice it when the engine is out.

None of this means automation is dangerous. It means unvalidated generation is dangerous. Automation that retrieves and applies your own proven work — with a tuner checking the output before it goes near a car — is how professional shops actually scale. That rule applies to our LUA bot too: every automated result should be checked by a qualified tuner before it is flashed to a real vehicle. We put that in writing in our software terms rather than in small print.

Frequently asked questions

Go deeper

• What is WinOLS? — the editor explained: projects, maps, checksums, DAMOS.
• DAMOS & A2L files explained — where definitions come from and how to judge their quality.
• What WinOLS actually costs — how the tiered licensing works and how to budget for it.
• WinOLS alternatives — editors, automation platforms and file services, honestly compared.
• Software terms & automation disclaimer — the plain-English rules our automation ships with.

WinOLS, OLS530 and DAMOS are products and trademarks of EVC electronic GmbH. Prices quoted from evc.de and reseller listings as of August 2026 — verify current pricing with EVC or an authorised reseller. RemapDash is an independent portal-software provider, written by professional tuners who use WinOLS and its LUA plugin daily; this guide is educational and is not affiliated with or endorsed by EVC.