Jeroen Ooms

Google's amazing [V8 JavaScript/WASM engine](https://v8.dev/) is
probably one of the most sophisticated open-source software libraries
available today. It is used to power the computation in Google Chrome,
NodeJS, and also [CloudFlare
Workers](https://developers.cloudflare.com/workers/learning/how-workers-works),
which make it possible to run code for your website inside the CDN
edges.

The R package V8 exposes this same engine in R, and has been on CRAN
since 2014. It is used by many R packages to wrap JavaScript libraries,
such as [geojsonio](https://docs.ropensci.org/geojsonio/),
[jsonld](https://docs.ropensci.org/jsonld/),
[DiagrammeR](https://github.com/rich-iannone/DiagrammeRsvg), or
[almanac](https://davisvaughan.github.io/almanac/). Recently we have
seen an increase in usage because the latest version of
[rstan](https://mc-stan.org/rstan/) now uses V8 for their parser.

However some rstan users complained that they found V8 difficult to
install on Linux servers. This release tries to make that even easier.

## Installing V8 on Windows / MacOS

Installing V8 from CRAN on Windows and MacOS works out of the box:

::: {.highlight}
``` {.chroma tabindex="0"}
install.packages("V8")
```
:::

The V8 engine is statically linked with the R package, so there are no
external dependencies. Everything just works.

## Installing V8 on Linux, the usual way

Because R packages on Linux are always installed from source, you need
to install the V8 C++ engine separately. This is easy to do, for example
on Ubuntu/Debian you use:

::: {.highlight}
``` {.chroma tabindex="0"}
# Debian / Ubuntusudo apt-get install libv8-dev
```
:::

And on Fedora/CentOS you would need:

::: {.highlight}
``` {.chroma tabindex="0"}
# Fedora / CentOSsudo yum install v8-devel
```
:::

Once the V8 engine is installed, you can install the R package using the
regular `install.packges("V8")` and everything will work as usual.

## Installing V8 on Linux, the alternative way

For most users, the instructions above are all you need. However some
Linux users complained that they had difficulty getting V8, for example
because they do not have sudo permissions, or because they are on a
Linux distribution that does not provide the V8 engine (e.g. Gentoo
Linux or OpenSuse).

Therefore we added an alternative installation method for Linux to
automatically download a static build of libv8 during package
installation. Simply set an env variable `DOWNLOAD_STATIC_LIBV8` when
installing the package, for example:

::: {.highlight}
``` {.chroma tabindex="0"}
# For Linux: download libv8 during installationSys.setenv(DOWNLOAD_STATIC_LIBV8=1)install.packages("V8")
```
:::

This way, you can install the V8 package on any x64 Linux system,
without separate system requirements.

Another benefit over the other method, is that this gives you a more
recent version of the V8 engine than what ships with some Linux
distributions. We found that it works so well that we decided to enable
this by default on Travis and Github-Actions. But for local
installations, you need to opt-in via the environment variable above.

I hope that this takes away the last bit of friction, to take advantage
of the amazing features of V8 in R, and that it is safe to depend on
this package. At least it has made some rstan users [very
happy](https://github.com/stan-dev/rstan/issues/831#issuecomment-717614929).


Google’s amazing V8 JavaScript/WASM engine is probably one of the most sophisticated open-source software libraries available today. It is used to power the computation in Google Chrome, NodeJS, and also CloudFlare Workers, which make it possible to run code for your website inside the CDN edges. The R package V8 exposes this same engine in R, and has been on CRAN since 2014.

Installing V8 is now even easier

This week [version 2.0 of the V8
package](https://cran.r-project.org/package=V8) has been released to
CRAN. Go get it now!

::: {.highlight}
``` {.chroma tabindex="0"}
install.packages("V8")
```
:::

The V8 package provides an embedded JavaScript engine that can be used
inside of R. You can use it interactively as a JavaScript console, but
it is mostly useful for wrapping JavaScript libraries in R packages.
Some cool examples include
[jsonld](https://cran.r-project.org/web/packages/jsonld/index.html),
[jsonvalidate](https://cran.r-project.org/web/packages/jsonvalidate/index.html),
and [daff](https://cran.r-project.org/web/packages/daff/index.html).

This major and much anticipated upgrade brings a new version of the
JavaScript engine, effectively upgrading the JavaScript language. This
opens up a lot of new possibilities, but it can also introduce some
subtle behavioral changes, so read on carefully.

### A Brief History of V8

The V8 R package provides R bindings to Google's [V8 JavaScript
engine](https://v8.dev/): the core of both Google Chrome and NodeJS
JavaScript interpreter. The amount of engineering that Google has
invested in V8 to make Chrome faster and more reliable with every
release is absolutely incredible. Their recent [10 year anniversary blog
post](https://v8.dev/blog/10-years) highlights some of the major
improvements from the last decade. Also below is a useless but cool
visualization of the evolving codebase.

::: {style="position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden;"}
::: {.iframe}
::: {#player}
:::

::: {.player-unavailable}
# Ein Fehler ist aufgetreten. {#ein-fehler-ist-aufgetreten. .message}

::: {.submessage}
[Sieh dir dieses Video auf www.youtube.com
an](https://www.youtube.com/watch?v=G0vnrPTuxZA){target="_blank"} oder
aktiviere JavaScript, falls es in deinem Browser deaktiviert sein
sollte.
:::
:::
:::
:::

Ever since the initial 2014 release of the V8 package on CRAN, we used
version 3.14 of Google's V8 engine. This V8 version implemented
ECMAscript version 5 (ES5), which is the official JavaScript language
spec from 2009 (now sometimes referred to as "traditional JavaScript").

Back in 2009, JavaScript was an odd but relatively simple scripting
language. However over the past 10 years, both the V8 engine as well as
the JavaScript language definition have completely evolved. In 2015, ES6
added significant new syntax for writing complex applications,
introducing promises, array buffers, classes, modules, and much more.
Since then, the ECMA standard is now revised annually, with more
functionality continuously added to support modern internet. With the
new latest release of the CRAN package this functionality now becomes
available in R.

### Upgrading the R bindings

Porting the R package to support recent V8 engines was not easy. The V8
maintainers have the bad habit of changing the API all the time, so the
Linux distributions don't like to ship and upgrade libv8. CRAN requires
that R packages will work on Windows, MacOS, Fedora, Debian, and
Solaris, and for a long time it seemed impossible to upgrade the R
package while keeping it working on all systems.

Things changed a few weeks ago when Debian announced [libv8 would be
removed](https://packages.qa.debian.org/libv/libv8-3.14.html) in the
upcoming Debian Buster, and instead a new package
[libnode-dev](https://packages.debian.org/buster/libnode-dev) would be
added which contains the V8 build that is included with NodeJS 10.15.
This will allow to us to install the R package on Debian 10 (Buster) and
Ubuntu 19.04 (Disco) and take advantage of Node's embedded V8 engine.

To complete the migration I also had to build new libv8 binaries for
MacOS and Windows to ship with the CRAN binary packages. The V8 CRAN
binary package will now ship with [libv8
7.2](https://github.com/jeroen/bottles) on MacOS and [libv8
6.2](https://github.com/rwinlib/libv8) on Windows. The latter is a bit
behind because I couldn't get the most recent libv8 to build with the
Rtools compilers, but both versions should support modern JavaScript
features.

### A Word of Caution

Currently the main benefit of upgrading V8 is that we can load JS
libraries which require a recent JavaScript standard. Some JS libraries
may automatically switch to async behavior when supported. This is
usually a good thing, unless you were not anticipating this in your R
wrapper, and you may get unexpected behavior after upgrading V8!

I got surprised by this myself in the [jsonld
package](https://cran.r-project.org/package=jsonld). It turned out most
functions in the
[jsonld.js](https://github.com/digitalbazaar/jsonld.js/) library return
a promise instead of the actual results, but I never realized this
because the old V8 did not support promises. To make things work with
the new V8, I changed the R wrappers to store results via callback
functions.

If you write R packages with JS bindings, note that some Linux systems
will still be running the legacy 3.14 engine for now. Hence to release
the package on CRAN, you still need to use a fallback polyfill or
transpile your modern JS to traditional JS something like
[babel.js](https://babeljs.io/) to support legacy ES5 engines.

### Modern JavaScript in R

Modern JavaScript opens up a whole new set of possibilities and
challenges. The current version of the R package does not change the R
interface yet, but perhaps future versions will add special R wrappers
for resolving promises and calling async JavaScript code from R.

I'm not sure yet what this would look like. It's an interesting case
because JavaScript is primarily an async (non-blocking) language,
whereas R calls are usually blocking. Maybe we can use R
[promises](https://rstudio.github.io/promises/) to run non-blocking JS
tasks in the background, but I have not come across a good use case yet.


This week version 2.0 of the V8 package has been released to CRAN. Go get it now!install.packages("V8") The V8 package provides an embedded JavaScript engine that can be used inside of R. You can use it interactively as a JavaScript console, but it is mostly useful for wrapping JavaScript libraries in R packages. Some cool examples include jsonld, jsonvalidate, and daff.

Publicaciones de Rogue Scholar

Installing V8 is now even easier

A Major Upgrade of the V8 package