Hello everyone, I am Cai Jun Programmer, a crawler practicing in the market for a year and a half.
In the past three years, I have used PyExecJS, PyMiniRacer, js2py, dukpy… none of them have completely satisfied me:
– PyExecJS is as slow as a turtle, requiring a process to start every time, taking 70 seconds for 1000 signatures;
– PyMiniRacer is fast, but Promise is always “pending”, and modern JS libraries crash as soon as they run;
– js2py and dukpy are pure interpreters, and their performance is directly discouraging.
Until 3 AM on November 11, 2025, I saw this project while browsing GitHub—**never-jscore**, which instantly gained over a thousand stars, and the changelog blew my mind!
> “A V8 engine library encapsulated based on Rust + Deno Core, designed for high-performance JS execution in Python, aiming to completely surpass PyExecJS and become the new benchmark!”
I immediately ran `pip install never-jscore`, and 10 seconds later, I was over the moon.
### Performance? A Dimension Reduction Strike!
Official testing (same hardware, 1000 times complex signature algorithm):
| Solution | Time | Speedup |
|—————-|————|—————-|
| PyExecJS | 69.4735 s | 1× |
| PyMiniRacer | 0.0383 s | 1815× |
| **never-jscore** | **0.0111 s** | **6264×** 🏆 |
0.01 seconds! This is not just fast; it’s instantaneous!
### Features? Fully Equipped Top Environment!
v2.2.1 takes the concept of “environment supplementation” to the extreme, **zero polyfill, ready to use out of the box**:
“`python
ctx = never_jscore.Context() # All extensions enabled by default
“`
Everything you want is here:
– ✅ **Complete support for Promise/async/await** (the only high-performance implementation!)
– ✅ **require() + fs + path**: directly `require(‘./utils.js’)`, node_modules resolved automatically
– ✅ **fetch() true network requests**: supports timeout, JSON, Headers, POST file streams
– ✅ **localStorage/sessionStorage**: persistent storage, perfectly passes storage detection
– ✅ **Complete browser family**: navigator, location, document, window, screen all available at once
– ✅ **URL/URLSearchParams/FormData**: no more manual parameter sorting signatures
– ✅ **EventTarget + XMLHttpRequest**: even XHR asynchronous callbacks can be perfectly restored
– ✅ **Performance API (new in v2.2.1)**: `performance.mark()` to pinpoint JS performance bottlenecks in one line of code
– ✅ **Full Crypto suite**: md5, sha256, hmac, btoa, randomUUID… all built-in
– ✅ **Worker simulation**: `typeof Worker === ‘function’` can be detected directly
In short: **All risk control checks you can think of, it can pass!**
### Real Case: Parameters for Certain Apps Obtained in One Go
“`python
import never_jscore
ctx = never_jscore.Context()
with open(“x-s.js”, encoding=”utf-8″) as f:
ctx.compile(f.read())
# Directly call the encryption function, automatically await Promise
token = ctx.call(“get_sign”, [{“page”: 1, “size”: 20}])
print(token)
# Output: t=1731291900&sign=8f9d3c2a1e5b7f6d4…
# Then fetch the interface
headers = ctx.evaluate(“JSON.parse(localStorage.getItem(‘headers’))”)
print(headers)
“`
The whole process took **0.03 seconds**, CPU usage was almost 0, and memory was stable as a rock.
### Why is it so powerful?
Because it is based on **Rust + Deno Core + native V8 engine**:
– No inter-process communication overhead (PyExecJS kneels)
– True V8 Isolate context isolation
– Tokio single-threaded asynchronous runtime, fetch is truly asynchronous
– Rust zero-cost abstraction, performance pushed to the extreme
– Automatic garbage collection + manual `ctx.gc()`, memory never leaks
### Usage Limitations? Actually not as troublesome as you think
The official documentation states clearly: **Multiple Contexts must be deleted in LIFO order**.
But in 99% of scenarios, you don’t need multiple Contexts at all!
“`python
# Recommended approach: global singleton, never destroyed
GLOBAL_CTX = never_jscore.Context()
def get_sign(params):
return GLOBAL_CTX.call(“get_sign”, [params])
“`
One line of code, globally reusable, speed will always take off!
### Installation & Star
“`bash
pip install never-jscore -U
“`
GitHub link (hit the star! Over 1k+):
https://github.com/neverl805/never-jscore
### In Conclusion
In 2025, are crawlers still worrying about JS execution environments?
**never-jscore directly announces: the environment problem of JS reverse engineering is completely solved!**
From today on:
– Say goodbye to the 70 seconds wait of PyExecJS
– Say goodbye to the Promise red cross of PyMiniRacer
– Say goodbye to 300 lines of garbage code for manual polyfills
**One line of code, instant takeoff!**
“`python
pip install never-jscore && python -c “import never_jscore, time; ctx=never_jscore.Context(); t=time.time(); [ctx.evaluate(‘Promise.resolve(1)’) for _ in range(10000)]; print(‘10,000 Promises:’, time.time()-t, ‘seconds’)”
“`
I tested: **0.89 seconds**, averaging **89 microseconds** each!
Brothers, just go for it!
Hit like + share, let more crawlers see this gospel!
**never-jscore — The strongest Python JS execution engine of 2025, no exceptions!**
> Project link: https://github.com/neverl805/never-jscore
> Author: neverl805 (has open-sourced all source code, MIT license, commercial use allowed)
> Current version: v2.2.1 (released on 2025-11-11)
**Crawlers never die, reverse engineering never fades! See you next time!** 🚀