- Published on
If you've ever looked at your BMW's instrument cluster and thought "there's clearly a spot for a speed limit sign here, why isn't it showing anything?" you're not imagining things. A lot of F-series and G-series BMWs have the Speed Limit Info (SLI) function baked into the software from the factory, it's just never switched on. No camera, no activation, nothing. This is exactly the gap an SLI emulator fills, and I want to walk you through how it actually works, which cars it fits, and the real coding values I've used to get it running properly.
Quick heads-up before we start
An SLI emulator is not the same thing as BMW's proper traffic sign recognition system with a KAFAS camera. The real deal reads actual road signs in real time and cross-checks them against map data. An emulator, on the other hand, feeds the car speed information from a separate module either map-based or pulled from its own database and the coding tells your cluster, HUD and head unit to actually display it. That's a useful assist, but it's not a substitute for paying attention to the signs on the road. Treat it as a helpful nudge, not gospel.
OEM SLI vs. an emulator — what's the actual difference?
Here's the short version:
- Factory SLI: Uses the KAFAS camera plus navigation and vehicle data, needs the right hardware, activation and usually an FSC code.
- SLI emulator: A bolt-on module that hands the car speed data directly, paired with coding in the cluster (and HUD/head unit if fitted).
- Coding with no data source at all: You'll just get a blank field or three dashes, because there's nothing feeding the system.
That last point trips people up constantly. If you code everything correctly and still see three dashes, it almost always means the car has no active data source — whether that's a missing FSC, an inactive KAFAS function, or an emulator that isn't talking to the car properly.
Which BMWs does this actually work on?
This applies mainly across the F-series and G-series lineup, including the 1 Series (F20/F21), 2 Series (F22/F23/F45/F46), 3 Series (F30/F31/F34/F35), 4 Series (F32/F33/F36), 5 Series (F10/F11/F07 and G30/G31), the F/G-series X models, and in some cases the i3 and MINI F-series depending on the emulator and software version. Every car is a little different in terms of which control unit handles it and what the CAFD parameters look like, so always double check against your specific vehicle before assuming a value will exist.
What you'll need before you start
- A suitable SLI emulator built for BMW F/G-series
- The emulator properly installed
- E-Sys or another reliable coding tool
- A proper ENET cable
- Stable power to the car (a battery charger, not just idle voltage)
- A backup of your original coding data
- Some prior experience with FDL coding — this isn't a great first-ever coding project
Back up your original CAFD/NCD files before touching anything. Always.
A word on the coding values below
These are the values the community and most emulator manufacturers commonly use — they can shift slightly depending on your exact vehicle, software version, and equipment. Not every parameter shows up on every car, and that's fine. If something's missing, don't force it into existence; just move on.
Coding the F-Series (KOMBI / BKOMBI)
On F-series cars, this lives in the instrument cluster control unit — labeled KOMBI or BKOMBI depending on the model.
ANZEIGE_NPI = aktiv KI_PIA_SPEED_LIMIT = aktiv SPEED_LIMIT = aktiv SPEED_LIMIT_GENERATION = sli_gen_2_npi RCOG_TRSG_APPL = aktiv RCOG_TRSG_TIMEOUT = aktiv
These flip on the speed limit readout plus the additional-info/NPI display in the cluster.
Coding the G-Series (DKOMBI)
G-series cars store this in the digital cluster, or DKOMBI. Depending on your software version, not every line below will be available.
ADDITIONAL_SIGN_ENABLE = aktiv ANZEIGE_NPI = aktiv CB_TACHOZEIGERBAND = aktiv CB_SLI_NPI = aktiv PIA_SLI_NPI = aktiv RCOG_TRSG_APPL = aktiv RCOG_TRSG_TIMEOUT = aktiv SLI_PERMANENT_ENABLE = aktiv SPEED_LIMIT_ENABLE = sli TACHOZEIGERBAND_ENABLE = aktiv NO_PASSING_ENABLE = aktiv SPEED_LIMIT_UNIT_ENABLE = Wert_02
Quick note on SPEED_LIMIT_UNIT_ENABLE: Wert_02 shows the unit (km/h or mph), while Wert_00 hides it. Depending on your CAFD, you might see Wert_0 instead of Wert_00 — just match whatever notation your own file uses.
Coding the Head-Up Display
If your car has a HUD, these values need checking too — but only after the cluster display is confirmed working.
HUD_NPI_ENABLE = aktiv HUD_PIA_SPEED_LIM = aktiv HUD_SPEED_LIMIT_ENABLE = aktiv HUD_SLI_ENABLE = aktiv PIA_HUD_SLI = aktiv PIA_HUD_SLI_NPI = aktiv PIA_HUD_SLI_PORTIERUNG = aktiv PIA_HUD_VSLI = aktiv HUD_PIA_SLI = aktiv HUD_PIA_NPI = aktiv
Not every car will have all of these — that's normal, just skip what's missing.
Coding the Head Unit (NBT / NBT EVO)
For the info to also show up in iDrive, code the head unit:
SPEEDLIMIT_INFO = aktiv SLI_NAVI_DISPLAY = nicht_aktiv
SPEEDLIMIT_INFO = aktiv makes the speed limit info visible in the iDrive menu. SLI_NAVI_DISPLAY = nicht_aktiv is commonly used with emulator setups so the display isn't purely dependent on the factory nav/SLI logic — though this value isn't present on every car.
Step-by-step with E-Sys
- Connect the car to a stable power supply.
- Plug in your ENET cable.
- Open E-Sys and connect to the vehicle.
- Read the FA/VO — SVT is the better option here.
- Read out the relevant control units: KOMBI/BKOMBI/DKOMBI, HUD (if fitted), and HU_NBT/HU_NBT2/HU_MGU.
- Back up the original coding data.
- Open FDL coding and locate the SLI values.
- Make your changes and write them.
- Power the car down and let it sleep for a few minutes.
- Check the iDrive menu, the instrument cluster, and the HUD if applicable.
- Take it for a short test drive and compare the display against real signs.
What a successful result looks like
Once everything's coded correctly, you should see the detected or provided speed limit in the cluster, along with additional signage, overtaking restrictions, HUD display (if equipped), and a corresponding iDrive menu entry.
The classic problem: three dashes instead of a speed
This is the most common headache people run into. Usual suspects:
- Emulator not wired in correctly
- Wrong DIP switch or country setting on the emulator
- Wrong F-series/G-series selection on the emulator
- km/h vs. mph mismatch
- Incomplete cluster coding
- Head unit coding missed
- HUD coding missed
- No actual SLI data source
- Wrong vehicle profile selected in the emulator
- Emulator not compatible with your software version
Most emulators need DIP switches configured before first use — typically F-series/G-series, region (Europe/USA), units, and sign display style. Always follow the exact instructions for your specific emulator model here.
Cluster works, HUD doesn't
If the cluster is showing speed limits fine but the HUD stays blank, go back through the HUD-specific values:
HUD_NPI_ENABLE, HUD_PIA_SPEED_LIM, HUD_SPEED_LIMIT_ENABLE, HUD_SLI_ENABLE, PIA_HUD_SLI, PIA_HUD_SLI_NPI, PIA_HUD_VSLI, HUD_PIA_SLI, and HUD_PIA_NPI.
Keep in mind some HUD generations simply can't display every piece of info, depending on model year and software.
Missing iDrive menu item
Check SPEEDLIMIT_INFO = aktiv on NBT/NBT EVO cars. If it's set correctly and the menu still isn't appearing, you may be dealing with a newer head unit generation (MGU) where the parameter names differ.
Don't expect perfection
An emulator's display is only as reliable as its data source. It can be wrong because of outdated maps, construction zones, temporary limits, variable signage, new signs that haven't hit the database yet, a misread country/unit setting, or unsupported additional signs. Bottom line: treat it as a helpful assist, never as a legal reference. Actual road signs and traffic law always take priority.
Before you buy or install anything
Check whether your car is F-series or G-series, which cluster it has, whether it's got a HUD, which head unit is fitted, whether the emulator you're eyeing actually supports your car, whether it handles km/h and European sign styles properly, and whether other owners with the same model have had good results. If the emulator relies on navigation data, make sure that data is current. After coding, always do a short test drive comparing the display to real signs on the road.
Retrofitting speed limit display via an SLI emulator is very achievable on most BMW F and G series cars, but three things need to line up: the emulator has to actually suit your vehicle, the cluster coding has to be complete, and depending on your equipment, the head unit and HUD may need their own coding pass on top.
For F-series, the values that matter most are
ANZEIGE_NPI, KI_PIA_SPEED_LIMIT, SPEED_LIMIT, SPEED_LIMIT_GENERATION, RCOG_TRSG_APPL, and RCOG_TRSG_TIMEOUT. For G-series, add SLI_PERMANENT_ENABLE, SPEED_LIMIT_ENABLE, TACHOZEIGERBAND_ENABLE, NO_PASSING_ENABLE, and SPEED_LIMIT_UNIT_ENABLE to that list.
And if you've got a HUD, don't skip its coding without it, the info usually only shows up in the cluster, not in your line of sight where it's most useful.
At the end of the day, it's a genuinely handy upgrade for cars that never got the feature from the factory. Just remember it's an assistant, not a replacement for actually watching the road.