Compatibiliteitslaag: hoe software bruggen slaat tussen oud en nieuw
Stel je voor dat je een Nederlandstalige brief wilt versturen naar iemand die alleen Japans leest. Je hebt twee opties: de ontvanger leert Nederlands, of er komt een vertaler tussen die de boodschap omzet zonder dat afzender en ontvanger elkaars taal hoeven te kennen. Een compatibiliteitslaag is precies zo'n vertaler, maar dan in software. Het is een stuk programmacode dat tussen twee systemen in gaat zitten die niet rechtstreeks met elkaar overweg kunnen, en die voortdurend "vertaalt" zodat ze toch samenwerken.
Je komt dit principe overal tegen zonder het te beseffen. Een oude Windows-game die op een Mac draait, een stekkeradapter die een Europese stekker in een Amerikaans stopcontact past, of een kunstmatige-intelligentiemodel dat getraind is in het ene programma maar gebruikt wordt in een ander: steeds is er een tussenlaag die de kloof overbrugt. In de technologiewereld is dit een onopvallend maar cruciaal stukje infrastructuur, want zonder zulke lagen zou elke nieuwe generatie hardware of software vrijwel bij nul moeten beginnen.
Wat is het precies?
Om compatibiliteitslagen te begrijpen, helpt het om eerst te weten wat een API is: een Application Programming Interface, oftewel een vaste set afspraken waarmee programma's met elkaar of met een besturingssysteem communiceren. Vergelijk het met een menukaart in een restaurant: je hoeft niet te weten hoe de keuken werkt, je bestelt via vaste opties. Software "bestelt" op dezelfde manier functies bij het systeem eronder, bijvoorbeeld "open dit venster" of "lees dit bestand".
Het probleem ontstaat wanneer een programma is geschreven voor de ene menukaart (bijvoorbeeld die van Windows), maar draait op een systeem met een heel andere menukaart (bijvoorbeeld Linux of een nieuwe chipfamilie). Een compatibiliteitslaag vangt de bestellingen van het programma op, herschrijft ze naar de menukaart van het doelsysteem, en stuurt het antwoord weer terug in een vorm die het originele programma begrijpt. Het programma zelf hoeft niet aangepast te worden en "merkt" in principe niets van de vertaling.
Dit is iets anders dan volledige emulatie, waarbij een compleet ander systeem inclusief processor wordt nagebootst in software (traag, maar zeer precies), en ook anders dan virtualisatie, waarbij een hele computer binnen een computer wordt gesimuleerd met eigen geheugen en besturingssysteem. Een compatibiliteitslaag is meestal lichter: hij vertaalt alleen de aanroepen (de "bestellingen") en laat de rest, zoals de processor, gewoon zijn eigen werk doen. Dat maakt het doorgaans sneller dan emulatie, al is de grens tussen de technieken in de praktijk niet altijd scherp en worden ze soms gecombineerd.
Wat wil men ermee bereiken?
De belangrijkste drijfveer is hergebruik. Software bouwen kost tijd en geld, en bedrijven en gebruikers willen niet telkens opnieuw beginnen zodra er een nieuwe chip, besturingssysteem of platform verschijnt. Een compatibiliteitslaag maakt het mogelijk om oude investeringen mee te nemen naar een nieuwe omgeving.
Een tweede doel is het soepel laten verlopen van grote technologische overgangen. Wanneer een fabrikant overstapt op een nieuw type processor, willen gebruikers niet dat al hun programma's ineens stoppen met werken. Een compatibiliteitslaag geeft ontwikkelaars tijd om hun software geleidelijk aan te passen, terwijl gebruikers ondertussen gewoon kunnen doorwerken.
Daarnaast speelt interoperabiliteit een steeds grotere rol, vooral rond kunstmatige intelligentie. AI-modellen worden getraind in verschillende programma's ("frameworks"), en bedrijven willen niet vastzitten aan één ervan. Dat risico heet vendor lock-in: de situatie waarin je zo afhankelijk bent van één leverancier of platform dat overstappen extreem duur of praktisch onmogelijk wordt. Compatibiliteitslagen verlagen die afhankelijkheid, omdat ze het makkelijker maken om tussen platformen te wisselen.
Voorbeelden uit de praktijk
Wine is een van de bekendste compatibiliteitslagen. Het project, dat begin jaren negentig van start ging, vertaalt aanroepen die bedoeld zijn voor Windows rechtstreeks naar aanroepen die Linux en andere Unix-achtige systemen begrijpen. Er wordt dus geen complete Windows-computer nagebootst; Wine "praat" simpelweg de taal van Windows-programma's tegen het onderliggende Linux-systeem. Het bedrijf CodeWeavers bouwt hierop het commerciële product CrossOver, dat Wine gebruiksvriendelijker maakt voor consumenten en bedrijven.
Apple gebruikte de techniek Rosetta in 2006 om gebruikers te helpen bij de overstap van PowerPC-chips naar Intel-processoren: programma's geschreven voor de oude chips bleven werken dankzij automatische vertaling. Toen Apple in 2020 zelf overstapte van Intel-chips naar zijn eigen ARM-gebaseerde Apple Silicon-chips (de M-serie), verscheen de opvolger Rosetta 2, die dezelfde rol vervulde voor die nieuwe overgang.
Microsoft ontwikkelde WSL, de Windows Subsystem for Linux, waarmee ontwikkelaars Linux-programma's rechtstreeks binnen Windows kunnen draaien. De eerste versie verscheen halverwege de jaren 2010 en vertaalde Linux-systeemaanroepen naar Windows; de latere versie WSL2 koos voor een andere aanpak en draait een echte, lichtgewicht Linux-kernel in een snelle virtuele omgeving.
In de wereld van kunstmatige intelligentie is ONNX (Open Neural Network Exchange) een belangrijk voorbeeld. Dit initiatief, gestart door Microsoft en Facebook (nu Meta), is geen vertaler tussen besturingssystemen maar een gemeenschappelijk uitwisselingsformaat voor AI-modellen. Een model getraind in het ene framework, zoals PyTorch, kan via ONNX worden omgezet zodat het ook in een ander framework of op andere hardware kan draaien.
WebAssembly (vaak afgekort tot WASM) tot slot is een open standaard waarmee code, geschreven in talen als C++ of Rust, snel en veilig in webbrowsers kan draaien, en inmiddels ook daarbuiten. Het werd ontwikkeld in samenwerking tussen de grote browserbouwers en fungeert als een soort universele tussenlaag die websoftware niet langer afhankelijk maakt van één specifieke programmeertaal.
Hoe ver is de techniek?
Compatibiliteitslagen zijn geen nieuwe uitvinding; het principe bestaat al decennia en is in de kern volwassen techniek. Toch is perfecte compatibiliteit zelden haalbaar. Elke vertaalslag kost rekenkracht en tijd, waardoor vertaalde programma's meestal iets trager draaien dan software die native (rechtstreeks, zonder tussenlaag) is geschreven voor het doelsysteem. Ontwikkelaars proberen dat verlies te beperken, bijvoorbeeld door delen van de vertaling alvast te doen bij installatie in plaats van steeds opnieuw tijdens het gebruik, maar helemaal wegwerken lukt zelden.
Daarnaast blijven er altijd "edge cases" over: uitzonderlijke situaties waarin het brongedrag zo specifiek of ongedocumenteerd is dat de vertaling net niet klopt, met kleine bugs of vreemd gedrag tot gevolg. Dit is een voortdurend kat-en-muisspel: naarmate bronsystemen veranderen, moeten compatibiliteitslagen worden bijgewerkt om nieuwe functies te blijven ondersteunen.
Het snelst groeiende terrein op dit moment is niet besturingssysteem-compatibiliteit, maar interoperabiliteit tussen AI-frameworks en tussen cloud- en edge-omgevingen (kleine apparaten zoals telefoons of sensoren die zelf AI-berekeningen doen). Naarmate er meer concurrerende AI-hardware en -software op de markt komt, groeit de vraag naar standaarden en tussenlagen die voorkomen dat modellen aan één leverancier vastzitten.
Wie werken eraan?
Bij besturingssysteem-compatibiliteit zijn CodeWeavers (rond Wine en CrossOver) en Apple (rond Rosetta) belangrijke namen, naast Microsoft, dat zowel WSL als, samen met partners, ONNX ondersteunt. WebAssembly wordt niet door één bedrijf gedragen maar door een coalitie van grote browserbouwers, waaronder Mozilla, Google, Microsoft en Apple, die de standaard gezamenlijk ontwikkelen binnen open internetstandaardenorganisaties. Rond ONNX is een brede open source-gemeenschap actief, met bijdragen van meerdere grote technologiebedrijven en onderzoeksgroepen die profiteren van een gedeeld, neutraal uitwisselingsformaat. Verder zijn er talloze kleinere open source-projecten en bedrijven die compatibiliteitslagen bouwen voor specifieke niches, van gameconsole-emulatie tot bedrijfssoftware die nog op verouderde systemen draait.