WinOLS Guide (1/10): What It Is and How to Get Started

If you’re serious about ECU tuning, you’ll inevitably encounter WinOLS. Developed by EVC electronic in Germany, WinOLS is the industry-standard software for viewing, analysing, and modifying the calibration data stored inside Engine Control Units. It’s the tool behind virtually every professional chiptuning file service, and the one that separates casual remappers from skilled calibration engineers.

This guide covers everything you need to know to get started — from what the software actually does, to navigating its interface, to creating and editing your first project.

What Is WinOLS?

WinOLS stands for Windows OLS (On-Line Service). At its core, it’s a binary editor purpose-built for automotive ECU calibration files. Unlike a generic hex editor, WinOLS understands that the raw data inside an ECU file represents maps — two-dimensional and three-dimensional lookup tables that the engine control software references thousands of times per second to make decisions about fuel injection, ignition timing, turbo boost, torque delivery, and much more.

WinOLS lets you:

• Import raw binary (.bin) files read from an ECU
• Identify and define the maps within that binary data
• Visualise maps in 2D line graphs, 3D surface plots, or numerical tables
• Edit map values with precision — individually, by selection, by percentage, or by offset
• Compare original and modified files side by side
• Correct checksums so the ECU accepts the modified file
• Export the modified binary for flashing back to the ECU

WinOLS does not read from or flash to the ECU directly. You need a separate hardware tool (KESS, KTAG, Autotuner, CMD Flash, etc.) to extract the original file and write the modified one back. WinOLS is purely the editing and analysis layer in between.

Who Uses WinOLS?

WinOLS is used by three main groups:

• File service operators — companies (like fileservice24.at) that receive original ECU files from customers, modify them, and return the tuned files. WinOLS is their primary workspace.
• Master tuners — professionals who develop their own calibrations for specific vehicles, either for their own dyno shop or for resale to other tuners.
• Advanced enthusiasts — experienced DIY tuners who want full control over their vehicle’s calibration rather than relying on pre-made tunes.

WinOLS is not a push-button tuning solution. There is no “add 50 HP” button. Every modification requires understanding what a map does, how changing its values affects engine behaviour, and what the safe limits are for the hardware. This is what makes it powerful — and why proper training matters.

Licensing and Cost

WinOLS is commercial software with a straightforward licensing model:

The license is perpetual — you own it forever. The annual subscription only adds new features and ECU support. If you let it lapse, WinOLS continues to work with whatever version you last updated to. If you renew later, you pay for each missed year (up to three years back).

Demo version: EVC offers a free demo that lets you open and view ECU files, define maps, and explore the interface. The only restriction is that you cannot export modified files. This is the best way to learn before committing to a license. Download it from evc.de.

Installation and First Launch

WinOLS runs on Windows (7 through 11). Installation is straightforward:

1. Download the installer from evc.de (requires registration)
2. Run the installer and follow the prompts — default settings are fine
3. On first launch, enter your license key or select Demo mode
4. The software creates a local project database in your Documents folder

WinOLS uses a project-based workflow. Every ECU file you open becomes a project stored in the local database. Projects contain the binary data, all defined maps, version history, and any notes you’ve added. This means you can close WinOLS, reopen it days later, and pick up exactly where you left off — all your map definitions are preserved.

Understanding the Interface

The WinOLS interface can look intimidating at first. Here’s what each area does:

The Project List (Left Panel)

Shows all projects in your database. Each project represents one ECU file. You can organise projects into folders, search by vehicle or ECU type, and see at a glance which projects have maps defined.

The Data Window (Centre)

This is where you view and edit the actual ECU data. It has four view modes, switchable via tabs at the bottom or keyboard shortcuts:

• Hex view — raw hexadecimal data, byte by byte. Useful for pattern recognition and understanding file structure. Press T to switch to text/hex view.
• 2D view — a line graph showing data values along a horizontal axis. Excellent for spotting maps visually — they appear as structured patterns (curves, steps, ramps) against the noise of non-map data. Press Shift+F to toggle 2D.
• 3D view — a three-dimensional surface plot of the currently selected map. This is the classic “tuning mountain” view where you can see fuel, boost, or torque tables as landscapes. The X and Y axes represent the map’s input parameters (typically RPM and load), and the Z axis shows the output value.
• Table view — the numerical grid where you do precision editing. Rows and columns correspond to the map’s axes, and each cell contains the actual value the ECU uses.

The Map List (Right Panel or Bottom Panel)

Once maps are defined (either manually or via import), they appear here as a list. Double-clicking a map jumps directly to it in the data window. Each map entry shows its name, address, dimensions, and data type.

The Toolbar

Quick access to common operations: open/save, import/export, view mode toggles, zoom, map properties, checksum correction, and search functions.

Creating Your First Project

Here’s the step-by-step process for opening an ECU file and starting to work with it:

Step 1: Import the Binary File

Go to File → Open new project and import BIN (or press Ctrl+N). Browse to your .bin file and select it. WinOLS will ask you to set the data format:

• Data width: 8-bit or 16-bit. Most modern ECUs use 16-bit data. If you’re unsure, try 16-bit first — the 2D view will look more structured if you’ve chosen correctly.
• Byte order: LoHi (Intel/little-endian) or HiLo (Motorola/big-endian). Bosch ECUs with Infineon Tricore processors use HiLo. Continental/Siemens ECUs often use LoHi. Getting this wrong inverts all your values — if the 2D view looks like random noise, try switching the byte order.

Step 2: Set View Parameters

Double-click the data window to open the Properties dialog. Here you configure:

• Data organisation (number of columns in hex view)
• Value display format (decimal, hexadecimal, or engineering notation)
• Zoom level for 2D/3D views

Set the column count to match common map widths for your ECU type. For example, Bosch EDC17 maps commonly use 16 or 17 columns. A correct column width makes maps appear as neat rectangular blocks in the hex view.

Step 3: Explore in 2D View

Switch to 2D view and slowly scroll through the file. You’re looking for structured patterns — areas where the data forms recognisable shapes rather than random noise. These patterns are maps. A boost pressure map might look like a rising curve that plateaus. An injection quantity map might show a structured staircase pattern.

This visual exploration is the foundation of manual map finding. With experience, you’ll recognise common map shapes at a glance.

Step 4: Define a Map

When you find a pattern that looks like a map:

1. Position your cursor at the start of the suspected map
2. Right-click and choose Start of map, or press M
3. Move to the end of the map and press W to mark the end
4. WinOLS creates a map entry. Open its Properties to set the name, dimensions (rows x columns), axis definitions, and scaling

Naming maps clearly is essential. Use descriptive names like “Boost pressure target — main” or “Injection quantity limit — smoke” rather than generic labels.

Step 5: Save Your Project

WinOLS auto-saves to its project database, but it’s good practice to create explicit save points. Use Version → Create new version before making any edits. This lets you compare your modifications against the original at any time and roll back if needed.

Data Types and Byte Order — Getting It Right

Understanding data representation is critical in WinOLS. Every value in an ECU file is stored as raw bytes, and how you interpret those bytes determines whether the data makes sense:

Quick test: If you open a file and the 2D view shows smooth, structured patterns with recognisable shapes, your data type and byte order are correct. If it looks like random noise or jagged spikes, try switching between HiLo/LoHi or 8-bit/16-bit.

Importing Map Definitions (The Fast Track)

Defining every map manually in a file with hundreds of maps would take days. This is where Damos files, A2L files, and Mappacks come in:

• Damos / A2L files — these are OEM development files that contain the complete map structure: names, addresses, dimensions, axis definitions, units, and scaling formulas. Importing a matching Damos file into WinOLS instantly identifies and labels every map in the ECU file. A2L is the standardised format (ASAM MCD-2 MC); Damos is the Bosch-specific equivalent. These files are difficult to obtain but provide the highest quality map definitions.
• Mappacks — pre-built collections of map definitions created by tuners and shared (or sold) within the community. A mappack for a specific ECU type (e.g., Bosch EDC17C46) identifies the most important tuning-relevant maps. Import via File → Import → Mappack. Mappacks are more accessible than Damos files but may not cover every map.

After importing, always verify that the maps look correct — axis values should make physical sense (RPM ranges from 0–7000, not 60000–65535), and map values should be within realistic ranges for the parameter they represent.

Essential Keyboard Shortcuts

Learning these shortcuts will dramatically speed up your workflow:

The Comparison Feature

One of WinOLS’s most powerful learning tools is the comparison function. If you have both a stock file and a modified file for the same ECU, you can open them as two versions of the same project. WinOLS highlights every byte that differs between them.

This is invaluable for learning because:

• You can see exactly which maps a professional tuner modified
• You can measure the magnitude of changes (e.g., “boost was increased by 15% in this region”)
• You learn which maps matter for which type of tuning (Stage 1 vs DPF-off vs pop-and-bang)

To compare: open a project, go to Version → Import version from BIN, and load the second file. Then press Ctrl+D to toggle difference highlighting. Changed bytes appear in colour, making it easy to scroll through the entire file and find every modification.

Checksum Correction

Every ECU file contains checksums — mathematical verification values calculated from the calibration data. When you modify any map value, the original checksum no longer matches. If you flash the file without correcting the checksum, the ECU will detect the mismatch and either reject the file, enter a limp mode, or display a check engine light.

WinOLS includes built-in checksum correction for hundreds of ECU types. After editing, go to Misc → Checksum correction (or use the toolbar button). WinOLS automatically recalculates and patches the correct checksum values. For ECU types not natively supported, third-party checksum plugins are available.

Always correct checksums as the very last step, after all map editing is complete. If you correct the checksum and then make another edit, you’ll need to run the correction again.

Your First Editing Workflow

Here’s a realistic beginner workflow from start to finish:

1. Read the original ECU file using your flash tool (KESS, Autotuner, etc.)
2. Create a new project in WinOLS and import the .bin file
3. Import a mappack or Damos for your ECU type to identify maps automatically
4. Create a new version (snapshot) before any changes
5. Identify the maps you need to modify for your tuning goal (e.g., boost and injection for Stage 1)
6. Edit conservatively — small changes first, test on the vehicle, then iterate
7. Correct the checksum
8. Export the modified .bin file
9. Flash the modified file to the ECU
10. Test drive and data-log to verify the changes

Common Mistakes Beginners Make

• Wrong byte order — data looks like noise. Switch between HiLo and LoHi.
• Wrong data width — maps look fragmented or doubled. Try toggling between 8-bit and 16-bit.
• No backup of the original — always keep an unmodified copy of the stock file in a safe location. If something goes wrong, you need it to restore the ECU.
• Editing too aggressively — adding 30% fuel on the first attempt is how engines get damaged. Start with 5–10% changes and verify on the vehicle.
• Skipping checksum correction — the ECU will reject the file or go into emergency mode.
• Trusting mappacks blindly — always verify that imported map definitions look correct. A mislabelled map can lead to editing the wrong parameter.
• Not using version control — WinOLS lets you create snapshots. Use them liberally so you can always compare against your starting point.

Next in the Series

WinOLS Guide (2/10): Finding Maps — Damos, A2L, Mappacks & Manual Search will cover the most important skill in WinOLS: identifying what each block of data in an ECU file actually does. We’ll walk through importing OEM definition files, using mappacks, and the manual search techniques that experienced tuners rely on when no definitions are available. Stay tuned.

The best way to learn is to download the WinOLS demo, open a file you have access to, and start exploring. Compare a stock file against a known tuned file to see what was changed. Join tuning forums and study how experienced tuners approach different ECU types. The learning curve is steep, but the capability you gain is unmatched.

If you don’t have the time or expertise to tune files yourself, that’s exactly what a file service is for. Upload your original ECU file to fileservice24.at, select your tuning options, and receive your professionally modified file in about 60 seconds — no WinOLS license required.