Run independent tasks in parallel, call across languages on one thread, and reuse compiled code through a shared engine.
Each execution context owns its guest language state. Multiple contexts run on a shared Truffle engine.[1][2]
Contexts support multiple languages
JavaScript and Python can exchange values within one context. Host access and guest thread permissions are configured at the context level.[1][2]
A context running JavaScript admits one executing thread at a time. Python-only contexts support multiple threads, with a per-context GIL serializing Python execution and normally releasing around foreign calls.[2][3]
A bounded pool of reusable contexts
Elide schedules one active task per pooled context, with a configurable bound that defaults to processor count. Reused contexts retain application state. Tasks that require a particular context return to it.[2][4]
Callbacks return to their context
I/O and worker completions post work to the context’s event loop. Callbacks run on the thread holding that context and can call another language without a thread handoff.[2][5]
For example, a server can distribute requests across pooled contexts. Within a request, a Python handler can call a JavaScript renderer and use its result directly.[1][2][4]
Dedicated workers for CPU-bound tasks
Each worker owns a dedicated host thread and a fresh context on the shared engine. Workers exchange messages through structured clone.[6]
Shared engine with JIT caching
The shared engine reuses eligible parsed and compiled code across contexts. GraalVM’s Auxiliary Engine Cache can persist this code across program starts.[2][7]
Sources
- Elide runtime — shared engines, context configuration and guest capabilities.
- Polyglot Context and Engine — context access, language interoperation and code reuse.
- GraalJS multithreading and GraalPy multithreading — language-specific threading behavior.
- Elide context-aware executor — pooling, task scheduling and context ownership.
- Elide event loop — callback execution and external completions.
- Elide workers — worker contexts, host threads and parent notifications.
- Auxiliary Engine Caching — persisting code for reuse across runs of the same native executable.