Documentation

AOT vs JIT for Python: An Honest Comparison

Warm-up, peak performance, compatibility and running cost: the AOT vs JIT trade-offs for Python, the cases where each wins, and Pyvorin's position.

8 min read

Benchmarking Correctly

Cold compiles, micro-workloads and single runs: the measurement mistakes that make benchmark numbers meaningless, and the verified commands that avoid them.

Benchmarking with the Pyvorin Edge SDK

Benchmark Pyvorin Edge pipelines honestly: cost-model assumptions, warm-up discipline, a CI regression example, and micro-benchmark limits.

13 min read

Benchmarks

Every measured CPython vs Pyvorin result across 71 workloads — the wins, the losses, and how to reproduce every number yourself.

3 min read

Custom Benchmark Suites

Turn pyvorin bench --json into a repeatable suite: capture raw_times_ms, p95 and stddev per function, aggregate across a directory, and gate regressions in CI.

Example Workload: ETL Pipeline

An illustrative ETL pipeline with acceleratable stages (transforms, windowed aggregates) and non-acceleratable ones (CSV parsing, joins) separated by evidence.

Example Workload: Financial Risk Calculations

An illustrative financial-risk batch dissected stage by stage: Monte Carlo, correlations and moving averages — what a compiler accelerates, what it cannot.

Example Workload: Log Analytics

An illustrative log-analytics pipeline dissected stage by stage: where native compilation wins, where parsing-bound stages do not, and the measured anchors.

Example Workload: ML Feature Engineering

An illustrative ML feature pipeline split into what a compiler accelerates — aggregations, transforms — and what it cannot: histograms, string features, I/O.

High-Frequency Data Feeds

On high-frequency feeds, Pyvorin accelerates ingestion-side batch transforms, not the wire path. Measured anchors and where to draw the boundary.

How to Run a Speed Proof

The measurement a sceptical CFO could audit: captured baseline, warmed runs, median-of-N, correctness check, compile-time amortisation, and an honest write-up.

Implementing Pyvorin in Microservices

Compile CPU-bound services at build time, ship the artefacts in the image, and skip the compiler sidecar. Which service shapes benefit, which do not, and why.

Making Python ETL Pipelines Faster, Measured

Measured per-transform ETL results: windowed aggregates to 134.62x, merge joins to 0.64x — which transforms accelerate, which do not, and where the seam sits.

8 min read

Migrating from Numba to Pyvorin

What @njit gave you, what Pyvorin compilation gives you instead, which kernels should stay on Numba, and how to verify each migrated function.

Profiling Edge Pipelines and System Metrics

Profile edge pipelines in place: cProfile on hot rules, memory measurement, system metrics, and how to read results without fooling yourself.

12 min read

Python Log Processing Performance

Parsing log lines is already fast under CPython — measured 0.86x compiled. The wins live in the aggregation layer behind the parser; here is the measured map.

8 min read

Pyvorin for Algorithmic Execution

Slicing schedules, market-impact research and pre-trade analytics are legitimate compiler targets; the hot order loop on a microsecond budget is not.

Pyvorin for Fraud Detection

Batch scoring grids, feature aggregation and anomaly loops are strong measured matches; inline authorisation-path scoring is not a compiler problem.

Pyvorin for Quantitative Trading

Backtests, signal generation and portfolio simulations accelerate well; market-data parsing and the live order path do not. A candid map of the boundary.

Pyvorin for Regulatory Reporting

Report pipelines split cleanly: enrichment, validation and aggregation loops have strong measured anchors; parsing, joins and formatting regress.

Pyvorin for Risk Management

Monte Carlo simulation, correlation matrices and stress-test grids are strong measured matches; intraday limit monitoring on a latency budget is not.

Pyvorin vs Codon

Codon compiles Python-syntax code to standalone native binaries; Pyvorin compiles the Python you already run, in-process, beside CPython. Where each fits.

Pyvorin vs CPython

Pyvorin runs your existing Python as native machine code beside CPython. Where that helps, where it does not, and the measured results from 71 workloads.

Pyvorin vs Cython

Cython asks you to maintain a second language for speed. Pyvorin compiles the Python you already have. The right choice depends on who owns the code.

Pyvorin vs Mojo

Mojo and Pyvorin both promise Python-like ergonomics with native performance, but they answer different questions. Goals, fit, and honest trade-offs.

Pyvorin vs Nuitka

Nuitka's deliverable is a binary you can hand to a customer. Pyvorin's deliverable is speed inside the Python environment you already run. Choose accordingly.

Pyvorin vs Numba

Both tools turn Python into machine code through LLVM. The deciding factor is what your slow code looks like — and this page shows how to find out.

Reducing Python CPU Usage Without Rewriting

Profile first, compile what the profile points at: a measured workflow for lower Python CPU usage, the workloads where it works, and a labelled capacity model.

8 min read

Warm-Up and Caching Strategies

Where pyvorin-native 1.0.9 caches compiled code, what a cache hit is worth in measured milliseconds, and how to key the cache in CI.