hermes

# Hermes JS Engine
[![MIT license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/facebook/hermes/blob/HEAD/LICENSE)
[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/facebook/hermes/blob/HEAD/CONTRIBUTING.md)
<img src="./doc/img/logo.svg" alt="Hermes logo - large H with wings" align="right" width="20%"/>

Hermes is a JavaScript engine built for fast start-up and low memory use.
Its whole design centers on compiling JavaScript ahead of time: apps ship
compact bytecode, or optionally native code, and the engine does as little
work as possible when they launch. Hermes was created for
[React Native](https://reactnative.dev/), where it is the default engine.
It also runs standalone or can be embedded as a library in other programs.

## Ahead-of-time first

Most engines parse and compile JavaScript on the user's device, every time the
app starts. Hermes moves that work to build time. The compiler parses,
analyzes and optimizes the entire program once, and emits bytecode that the
engine can memory-map and start executing immediately. Start-up cost, memory
and binary size all benefit, and the optimizer can see the whole program
instead of one function at a time.

In practice this means:

* **Ship bytecode.** Compile at build time and load the result. This is how
  React Native apps use Hermes, and it is the path that gets all the
  optimizations.
* **Source still runs.** The engine includes the compiler, so `.js` files can
  be run directly during development. It is not the intended production path.
* **`eval()` and `new Function()` are supported for small things.** They run
  the compiler at runtime. Code passed to `eval` sees the global scope only;
  giving it access to the enclosing function's locals would force the
  compiler to pessimize every function, so that is deliberately left out.

## Ways to run code

Hermes can execute JavaScript in four ways, and they can be mixed freely
within one runtime.

* **From source.** The engine can also be given JavaScript source, which it
  compiles to bytecode before running. By default, large sources are
  compiled lazily, one function at a time when it is first called. Good for
  development and for code generated at runtime.
* **From bytecode.** The production path. Code is compiled ahead of time,
  the bytecode file is memory-mapped, and the interpreter runs it. This is
  how React Native apps run.
* **JIT.** An optional baseline JIT compiles frequently executed functions to
  machine code while the app runs. It is deliberately simple; the heavy
  optimization already happened at build time, so the JIT stays small and
  predictable.
* **Native code.** The `shermes` tool compiles JavaScript
  ahead of time all the way to native code, with no interpreter involved.

An app can ship some code as native, some as bytecode, and generate some at
runtime, and the JIT will pick up hot functions from the latter two.

## Static typing (in development)