Bun Adds Shared-Memory Threads to JavaScriptCore

A recent open PR on GitHub proposes adding shared-memory threads to JavaScriptCore, a significant development for the JavaScript ecosystem. This feature would enable true parallelism in JavaScript, allowing developers to run functions on separate threads while sharing the same heap and objects. The implications of this change are substantial, as it could fundamentally alter how JavaScript applications are designed and developed.

## What happened The PR, submitted by Jarred-Sumner, introduces a new Thread function that allows running functions on separate threads, all within the same heap and with access to the same objects. This approach eliminates the need for structured cloning, message passing, or relying on SharedArrayBuffer as an escape hatch. The implementation has made significant progress, with parallel JavaScript execution through all four JIT tiers and the thread test suite now passing without a global lock. However, the PR is still in its experimental phase and requires further work, including thread-sanitizer cleanup, fuzzing, and benchmarking. ## Why it matters The addition of shared-memory threads to JavaScriptCore matters because it addresses a long-standing limitation of JavaScript: its single-threaded nature. By enabling true parallelism, developers can create more efficient and scalable applications. This feature could particularly benefit applications that rely heavily on computational tasks, such as scientific simulations, data processing, and machine learning. The change also aligns with the broader trend of increasing parallelism in software development, driven by the growing availability of multi-core processors. ## How to think about it When considering the implications of shared-memory threads in JavaScriptCore, developers should think about how this feature can be leveraged to improve the performance and efficiency of their applications. This might involve identifying computational bottlenecks that could be addressed through parallelism, as well as rethinking development practices to accommodate shared-memory concurrency. It's also crucial to weigh the potential benefits against the added complexity and risks, ensuring that the use of shared-memory threads is judicious and well-managed. ## FAQ