Hermes: wat is het, mogelijkheden en optimalisatie voor React Native

Auteur: IT Sectr Gepubliceerd: 2026-06-04 Leestijd: 9 min

Hermes — is een open-source JavaScript-engine, speciaal ontwikkeld voor React Native en geoptimaliseerd voor mobiele apparaten. In tegenstelling tot JavaScriptCore compileert Hermes JS-code vooraf naar bytecode in de buildfase, wat zorgt voor een snelle start van de applicatie. Volgens Meta, Hermes Docs, 2024 wordt Hermes standaard gebruikt in React Native vanaf versie 0.70.

Belangrijkste punten

  • Hermes — JavaScript-engine van Meta, geoptimaliseerd voor React Native.
  • Bytecode — JS-code wordt vooraf gecompileerd in de buildfase van de applicatie.
  • Startsnelheid — afwezigheid van JIT-compilatie verkort de starttijd met 50%.
  • Geheugen — Hermes verbruikt 30–40% minder geheugen dan JSC.
  • Standaard — gebruikt in React Native 0.70+ voor alle nieuwe projecten.

Wat is Hermes?

Hermes — is een compacte JavaScript-engine, gemaakt door het Meta-team speciaal voor React Native. Het werd aangekondigd in 2019 als alternatief voor JavaScriptCore (JSC), dat standaard werd gebruikt in React Native. Het belangrijkste doel van Hermes is om de snelst mogelijke start van applicaties op mobiele apparaten te garanderen, vooral op Android met beperkte bronnen.

De belangrijkste eigenschap van Hermes is voorafgaande compilatie (AOT — Ahead-of-Time). In tegenstelling tot traditionele JS-engines die code tijdens runtime compileren (JIT — Just-in-Time), compileert Hermes JavaScript naar bytecode al in de buildfase van de applicatie. Dit betekent dat er op het apparaat geen compilatie plaatsvindt — de bytecode wordt onmiddellijk uitgevoerd door de virtuele machine van Hermes.

Hermes is geen universele JS-engine — het is uitsluitend geoptimaliseerd voor React Native-scenario's. Het mist functionaliteiten die niet nodig zijn in mobiele ontwikkeling: eval, generatoren, sommige ES6-functies. Dit maakt de engine compacter en sneller. Volgens Meta is de grootte van Hermes ongeveer 200–300 KB in gecomprimeerde vorm, wat aanzienlijk kleiner is dan JSC (ongeveer 2–3 MB).

Hermes architectuur en bytecode

De architectuur van Hermes verschilt van traditionele JS-engines door het ontbreken van een JIT-compiler. In plaats daarvan gebruikt Hermes een efficiënte virtuele machine (VM) die vooraf gecompileerde bytecode uitvoert. Het afzien van JIT biedt drie belangrijke voordelen: voorspelbare prestaties, lager geheugengebruik en kortere starttijd.

Hermes bytecode is een compacte representatie van JavaScript-code, geoptimaliseerd voor snelle uitvoering. In de buildfase (via Metro) worden JavaScript-bestanden gecompileerd naar .hbc (Hermes Bytecode) bestanden. De applicatie laadt deze bestanden en de Hermes VM voert ze uit zonder verdere compilatie. Het buildproces is geïntegreerd in Metro via de plugin hermes-transformer.

Fasen van codeprocessing

Het verwerkingsproces van JavaScript in Hermes bestaat uit drie fasen: Parse — syntactische analyse van de broncode, CompileExecute

— uitvoering van bytecode door de virtuele machine. De eerste twee fasen worden uitgevoerd in de buildfase, de derde — op het apparaat. Dit verschilt fundamenteel van JSC, waar alle drie fasen op het apparaat worden uitgevoerd.
bash
# Hermes bytecode-compilatie tijdens build
hermes -emit-binary -out index.hbc index.js

# Controleer grootte van gegenereerde bytecode
ls -lh index.hbc

# Toon bytecode-statistieken
hermes -dump-bytecode index.hbc

# Optimaliseer bytecode voor productie
hermes -O index.js -emit-binary -O target.hbc

Na compilatie worden alle .hbc-bestanden samen met native code verpakt in APK of IPA. Bij het starten van de applicatie laadt de Hermes VM de bytecode en begint vrijwel onmiddellijk met uitvoeren — er is geen JIT-opwarmtijd nodig, zoals typisch is voor V8 en JSC.

Hermes vs JSC: vergelijking

De vergelijking van Hermes en JavaScriptCore (JSC) helpt te begrijpen wanneer welke engine te kiezen. JSC — een volwaardige JS-engine van Apple, gebruikt in Safari. Hermes — een gespecialiseerde engine voor React Native. De keuze tussen hen hangt af van de prioriteiten van het project.

KenmerkHermesJavaScriptCore
CompilatieAOT (in buildfase)JIT (op apparaat)
Starttijd50–100 ms200–400 ms
Geheugengebruik30–40% minderBasisniveau
Grootte~250 KB (gecomprimeerd)~2 MB (gecomprimeerd)
ES6+ ondersteuningBeperktVolledig

Hermes wint in startsnelheid en geheugengebruik, maar verliest van JSC in uitvoeringsprestaties van complexe berekeningen. JIT-compilatie van JSC optimaliseert hete code-gedeelten tijdens runtime, wat een voordeel geeft bij CPU-intensieve bewerkingen. Voor een typische React Native-applicatie, waar UI-updates en navigatie de belangrijkste belasting vormen, biedt Hermes een betere gebruikerservaring door de snelle start.

Hermes optimalisaties voor React Native

Hermes bevat verschillende optimalisaties die specifiek zijn voor React Native. De belangrijkste is integratie met JSI (JavaScript Interface). Hermes ondersteunt JSI native, wat het mogelijk maakt de nieuwe architectuur van React Native (Fabric + Turbo Module) te gebruiken zonder extra lagen. Dit maakt Hermes en de nieuwe architectuur een ideaal paar voor maximale prestaties.

Geheugenbeheer

Hermes gebruikt een garbage collector met een generatiestrategie (generational GC), geoptimaliseerd voor mobiele apparaten. In tegenstelling tot JSC, waar garbage collection merkbare pauzes in de UI (jank) kan veroorzaken, voert Hermes GC uit in kleine porties tussen frames, waardoor de impact op de gebruikerservaring wordt geminimaliseerd. Volgens Meta zijn GC-pauzes in Hermes 2–3 keer korter dan in JSC in typische React Native-scenario's.

Lazy loading en constanten

Hermes ondersteunt lazy loading van modules — een JavaScript-module wordt alleen gecompileerd wanneer deze echt nodig is. Dit vermindert de grootte van de bytecode en versnelt het opstarten. Bovendien berekent Hermes constante expressies in de compilatiefase, waarbij functieaanroepen waar mogelijk worden vervangen door constante waarden.

js
// Voorbeeld van Hermes-specifieke optimalisaties

// 1. Hermes inlineert constante expressies
const TAX_RATE = 0.07;
const price = 100;
// Hermes berekent vooraf: TAX_RATE * price tijdens compilatie
const totalWithTax = price * (1 + TAX_RATE);

// 2. Hermes optimaliseert eigenschapstoegangsketens
const config = { api: { timeout: 5000 } };
// Hermes cached config.api-toegang intern
const timeout = config.api.timeout;
fetch(url, { timeout });

Het is belangrijk op te merken dat Hermes debuggen via Chrome DevTools ondersteunt (vanaf Hermes versie 0.12). De ontwikkelaar kan vertrouwde tools gebruiken: breakpoints, geheugenprofilering, variabele inspectie. Dit elimineert een van de belangrijkste bezwaren tegen Hermes in vroege versies, toen debuggen beperkt was.

Hermes configureren in een React Native project

De configuratie van Hermes hangt af van de React Native-versie. Sinds React Native 0.70 is Hermes standaard ingeschakeld voor nieuwe projecten. Voor eerder gemaakte projecten of bij het schakelen tussen engines, wordt de configuratie uitgevoerd via de build-instellingen.

Configuratie voor Android

Voor Android wordt Hermes ingeschakeld in het bestand android/app/build.gradle via de vlag hermesEnabled. Voor iOS wordt de configuratie uitgevoerd in de Podfile via de variabele :hermes_enabled. Na het wijzigen van de configuratie moeten de pods opnieuw worden geïnstalleerd en het project opnieuw worden gebouwd.

groovy
// android/app/build.gradle — Hermes inschakelen
project.ext.react = [
    enableHermes: true
]

// iOS Podfile — Hermes inschakelen
hermes_enabled = true
pod 'hermes-engine'

Om te controleren of Hermes in de applicatie wordt gebruikt, voert u adb logcat | grep Hermes uit op Android of controleert u de Xcode-console op iOS. Bij het starten van de applicatie toont Hermes het bericht „Hermes VM initialized” of een vergelijkbaar bericht. U kunt ook globalThis.HermesInternal uitvoeren in JavaScript-code — als Hermes actief is, is deze eigenschap beschikbaar.

js
// Controleer of Hermes actief is
if (typeof globalThis.HermesInternal !== 'undefined') {
  console.log('✅ Hermes-engine actief');
  console.log(
    'Versie:',
    globalThis.HermesInternal.getEngineProperties()
  );
} else {
  console.log('❌ Hermes niet actief (terugval naar JSC)');
}

Veelgestelde vragen

Werkt Hermes met de nieuwe architectuur van React Native?

Ja, Hermes is volledig compatibel met de nieuwe architectuur van React Native (Fabric + Turbo Module). Bovendien zijn Hermes en JSI samen ontwikkeld en bieden ze de beste prestaties in combinatie.

Kan Hermes op iOS worden gebruikt?

Ja, Hermes ondersteunt beide platforms — iOS en Android. Op iOS vervangt Hermes de standaard JavaScriptCore en biedt dezelfde voordelen: snelle start en lager geheugengebruik.

Ondersteunt Hermes alle ES6+ functionaliteiten?

Hermes ondersteunt de meeste ES6+ functionaliteiten, maar met beperkingen: eval, generatoren en Proxy ontbreken. Het wordt aanbevolen om Babel-transpilatie te gebruiken voor compatibiliteit, zoals in gewoon React Native.

Hoe beïnvloedt Hermes de grootte van de applicatie?

Hermes verkleint de grootte van de applicatie dankzij compacte bytecode en de kleinere grootte van de engine zelf. Bytecode is meestal 20–30% compacter dan de bijbehorende JS-code, en de engine zelf weegt ~250 KB versus ~2 MB bij JSC.

Wat te doen als een bibliotheek niet werkt met Hermes?

De meeste bibliotheken zijn compatibel met Hermes. Als een bibliotheek eval, Proxy of niet-standaard functies gebruikt — controleer of er een Hermes-compatibele versie is. U kunt ook Babel-plugins gebruiken om niet-ondersteunde constructies te vervangen.

Samenvatting

  • Hermes — JavaScript-engine van Meta, geoptimaliseerd voor snelle start van React Native-applicaties.
  • AOT-compilatie — JS-code wordt in de buildfase naar bytecode gecompileerd, waardoor JIT-overhead op het apparaat wordt geëlimineerd.
  • Prestaties — starttijd wordt met 50% verkort, geheugengebruik met 30–40% verminderd in vergelijking met JSC.
  • Grootte — Hermes neemt ~250 KB (gecomprimeerd) in beslag, 8–10 keer minder dan JSC.
  • Compatibiliteit — Hermes ondersteunt JSI en de nieuwe architectuur van React Native, inclusief Fabric en Turbo Module.
  • Debuggen — beschikbaar via Chrome DevTools, inclusief breakpoints en profilering.
  • Aanbeveling — gebruik Hermes voor alle React Native-projecten vanaf versie 0.70+ voor maximale prestaties op mobiele apparaten.

We ontwikkelen een mobiele applicatie turnkey

IT Sectr creëert sinds 2017 iOS- en Android-applicaties voor startups en bedrijven. We adviseren u en stellen de beste oplossing voor.

Bespreek het project

Lees ook