from v8cffi import shortcuts

ctx = shortcuts.get_context()
ctx.run_script('foo.render("hola mundo");')
# "hola mundo"

This is the most simple and limited form of usage. A platform, VM and global context are created when calling set_up, then the global context can be retrieve by calling get_context from anywhere within the application, even from other threads.

The normal usage is to set_up and load_libs at the start of the application, then call run_script in many other places.

One thing to have in mind is the context is global, this means any modification to the global scope will persist.


The API section contains useful information about: platform, vm and context.

Multiple VMs & contexts

from v8cffi.platform import platform

with platform as p:
    with p.create_vm() as vm:
        with vm.create_context() as ctx:
            res = ctx.run_script('foo.render("hola mundo");')

        with vm.create_context() as ctx_b:
            ctx_b.load_libs(['./bar.js', './baz.js'])
            res_b = ctx_b.run_script('baz.render("hello world");')

    with p.create_vm() as vm_b:
        # ...

Or alternatively, without with statement:

from v8cffi.platform import platform

p = platform
vm = p.create_vm()
ctx = vm.create_context()

    # ...

This allows much greater flexibility than the previous shortcuts example.

As you may have read in the API section, the first thing is to create a V8 platform, there must be one and only one per process (python instance).

Creating many VMs allows to run JS code in parallel. Every VM takes about ~1MB of RAM. It should be possible to spawn a fixed pool of them with loaded libs to reuse and obtain N times the number of opts/s (where N is the number of VMs).

Every VM should run in a different python thread, so when calling run_script, the thread blocks (the GIL is released) and another python thread can run code in a different VM.

In case two python threads are using the same VM, the VM will prevent them from running at the same time. But both will block and release the GIL, allowing other python threads to run.

At last, creating many Context allows JS code run without sharing the same global scope.