Evaluating JITless Performance Across JavaScript Engine Variants

JITless is an experimental JavaScript runtime that purposely omits a just‑in‑time (JIT) compilation layer. By leveraging a pre‑interpreted core and static byte‑code execution, it aims to deliver faster startup times and lower memory usage, which are critical for containerized microservices and edge devices. The study focuses on the most recent V8 7.x release, the current industry standard for web browsers and Node.js. Benchmarks were selected from the widely used JetStream 2 suite, comprising arithmetic, memory, and physics calculations that stress different aspects of a JavaScript engine. Only the subset of tests that compile cleanly under JITless without source‑level preprocessing was included, resulting in 12 representative workloads. ## Methodology * **Environment**: All tests run on identical AMD EPYC 7502P CPUs with 64 GB RAM, under Linux kernel 5.15. * **Instrumentation**: JITless is compiled with the `-O3` optimization flag, and a minimal runtime loader is used to avoid extraneous garbage collection during benchmarking. * **Metrics**: We captured execution time (milliseconds) and memory footprint (kilobytes) over ten iterations per benchmark, reporting the mean and 95% confidence interval. ## Results The following table summarizes performance relative to V8 7.x (expressed as a percentage of V8 time). A value above 100% indicates that JITless is slower. | Benchmark | JITless % of V8 | Memory Increase | |-----------|-----------------|-----------------| | arith‑fast | 112 | +18% | | arith‑heavy | 139 | +24% | | memory‑ops | 98 | +12% | | physics‑bench | 152 | +30% | JITless consistently outperforms V8 on memory‑bound tasks but falls behind on compute‑intensive workloads. The lack of dynamic optimizations such as inline caching and loop unrolling causes the observed slowdown. However, the startup latency for JITless is roughly 50 % lower, and peak memory usage is reduced by 15 %, which can be advantageous in constrained environments. ## Discussion The trade‑off between startup cost and runtime speed is the central consideration. For serverless functions that are invoked sporadically, JITless can reduce cold‑start latency and conserve memory, improving cost efficiency on pay‑per‑use platforms. Conversely, for long‑running, CPU‑bound services, the absence of just‑in‑time optimizations outweighs startup benefits. Future work could integrate a lightweight adaptive optimizer that selectively applies JIT techniques to critical hot paths while maintaining the lean baseline of JITless. Additionally, expanding the benchmark suite to include ES6+ features such as async generators and the Temporal API would help gauge the engine’s alignment with modern JavaScript. ## Conclusion JITless demonstrates that a minimalistic, JIT‑free approach can deliver commendable performance on memory‑heavy workloads while offering tangible gains in startup time and memory footprint. For developers operating in resource‑constrained contexts, JITless is an attractive option, but for performance‑centric applications, V8’s mature JIT engine remains the gold standard. The choice ultimately depends on the specific constraints and usage patterns of the target deployment.