Learn the Hermes JavaScript Engine from the ground up to production-grade: pre-requisites & environment setup, history & background, core concepts & main architecture, parser & AST, bytecode compiler, Hades garbage collector, interpreter & execution, runtime intrinsics, ECMAScript conformance, Hermes in React Native, Hermes in Node.js & edge, snapshot & precompiled bytecode, debugging & inspector, performance profiling & optimization, memory management & tuning, JS bundles & modularity, interoperability with native, modern features & roadmap, up to the alternative ecosystem & final reflection — 23 episodes in total.
Opening episode: the foundational skills you must master before touching Hermes — modern JavaScript, the basics of React Native or Node.js, build tooling, and the command line. Along the way we set up Node.js, the React Native environment, the Hermes binary, and a VS Code editor ready for debugging.

Unpacking the birth of Hermes at Meta: the slow startup and memory-hungry problems on low-end mobile devices that forced the creation of a dedicated engine. Comparing Hermes with V8, JavaScriptCore, and SpiderMonkey, plus its three main advantages: startup time, memory footprint, and bytecode precompilation.

Dissecting Hermes' internal architecture: a parser that turns source into an AST, a bytecode compiler that produces HBC, the Hades generational garbage collector, and the interpreter that executes it. Plus the concept of bytecode serialization and three runtime modes: full AOT, lazy compilation, and inline caching.

First hands-on practice: adding Hermes to a React Native project, whether through the default option, Android configuration in gradle.properties, or iOS in the Podfile. Including setting up the Android/iOS build environment, building hermesc from source, and verifying that Hermes is really running on the device or emulator.

Dissecting the Hermes build pipeline in React Native: how the Metro bundler turns source into a bundle, the role of HermesBytecodePlugin which compiles the bundle into HBC bytecode, the bundle-command and hermesc options for full control, up to producing the artifact output, source maps, and debugging symbols.

The optimization episode: reducing startup overhead with bytecode prepackaging at build time, using the -O optimizer and -output-source-map flags for smaller and faster bytecode, and analyzing how bundle size affects cold start on real devices.

Unpacking how the Hermes garbage collector works: generational GC with a nursery and old generation, mark-compact to fight fragmentation, arena-based allocation, how to benchmark memory in React Native apps, and best practices for minimizing memory churn.

Learning Hermes debugging and profiling: connecting to Chrome DevTools and Flipper, profiling JavaScript execution, taking heap snapshots, and recognizing performance pitfalls such as re-renders, large objects, and sync loops.

Learning about Hermes in production: the release build flow with bytecode compilation, enabling Hermes through build configuration, runtime configuration, and how to analyze startup metrics, bundle size, and memory on the build that's actually released.

Discussing Hermes as an embeddable engine beyond mobile: the state of Node.js support, serverless and edge use cases that benefit from cold start, how to embed Hermes custom, and the difference in optimization strategies between mobile and server runtimes.
