Documentation
Guides, API references, and troubleshooting for the Pyvorin platform.
"Frequently Asked Questions"
Concise answers to the most common questions about installing, configuring, tuning, and securing Pyvorin Edge.
15 min read
"Health Monitoring and Prometheus Export"
Deep dive into the /health and /metrics endpoints, Prometheus export, Grafana dashboards, and Alertmanager rules for the Pyvorin Edge Agent.
20 min read
"Structured Log Management and Shipping"
Integrate structlog with Pyvorin Edge, configure log rotation, and ship logs to Loki, Splunk, and CloudWatch with correlation IDs.
18 min read
"Tutorial: Cold Chain Monitoring for Pharmaceuticals"
Build a GDP-compliant cold chain monitor with privacy redaction, signed audit reports, and offline-capable cloud sync.
25 min read
"Tutorial: Precision Agriculture and Smart Irrigation"
Build a solar-powered precision agriculture station with soil moisture, temperature, and light sensors, weather API integration, and fleet-wide deployment.
25 min read
"Tutorial: Predictive Maintenance with Vibration Analysis"
Build a vibration-based predictive maintenance pipeline on the edge using accelerometers, compiled anomaly detection hot-paths, and cost modelling.
25 min read
"Tutorial: Smart Building Energy Monitor"
Complete end-to-end tutorial for building a smart building energy monitor with Raspberry Pi 4, temperature/humidity sensors, and an energy meter using Pyvorin Edge.
30 min read
"Tutorial: Telecom Tower Monitoring and Safety"
Advanced multi-sensor edge pipeline for telecom towers featuring SNMP adapters, tower-climb safety rules, and MQTT integration to the NOC.
35 min read
Actions and Events — Responding to the Edge
Writing action functions, the Event dataclass, logging, webhooks, local file output, and robust action error handling.
13 min read
Advanced Pipeline Patterns in Pyvorin Edge
Design multi-stage pipelines, implement fan-out/fan-in, build custom window functions like EWMA and percentile, and tune backpressure for production edge workloads.
22 min read
Alerting and Webhooks
Configure alerts for compilation failures, quota exhaustion, and performance regressions.
Apache Airflow Integration
Compile Airflow operator logic for faster DAG execution.
API Development
Build high-performance REST and GraphQL APIs with compiled Python.
API Rate Limits and Quotas
Understand compile credit limits, rate limiting, and quota management.
API Reference
HTTP endpoints for compile, license, usage, and artifact APIs.
ARM64 NEON Vectorization in Pyvorin Edge
A primer on ARM64 NEON SIMD, how Pyvorin uses it for vector math, automatic vs manual kernel dispatch, and benchmarking on Raspberry Pi 5.
14 min read
Artifact Caching Explained
How compiled artifacts are cached, keyed, and reused across runs.
AST Analysis Phase
How Pyvorin analyses your Python abstract syntax tree.
Audio Signal Processing
FFT, waveform analysis, and filter chains in pure Python.
Audit Chain and Signed Reports
The Ed25519-signed audit chain, how every outbound batch gets signed, signature verification, the prove-benchmark.sh attestation system, hardware fingerprinting, and generating compliance reports.
18 min read
Avoiding Common Pitfalls
Mistakes that cause deoptimisation, fallback, or poor speedup.
AWS and Azure Integration
Bridging Pyvorin Edge to AWS IoT Greengrass and Azure IoT Hub, MQTT bridge setup, cost comparison of raw versus filtered egress, and savings calculation examples in GBP.
16 min read
Batch Job Cost Optimisation
Shrink nightly ETL windows and reduce spot instance spend.
Batch Processing and ETL
Accelerate data pipelines, ETL jobs, and batch computation workloads.
Benchmarking Correctly
How to measure speedups honestly and avoid common benchmarking traps.
Benchmarking with the Pyvorin Edge SDK
Complete guide to the built-in benchmark suite, run-pi-benchmarks.sh, the 8 verticals, attested reports, prove-benchmark.sh, and creating custom benchmarks.
13 min read
Benchmarks
Learn how to run and interpret Pyvorin benchmarks to measure compiler performance improvements across your workloads.
3 min read
Building a Pyvorin Centre of Excellence
Establish an internal team to drive adoption and standards.
Bundle System Internals
How multi-file projects are bundled, hashed, and sent for compilation.
Calculating Pyvorin ROI
A framework for measuring return on investment from Pyvorin adoption.
Capacity Planning
Estimate infrastructure needs after Pyvorin acceleration.
Case Study: API Gateway
Request validation and transformation at scale.
Case Study: ETL Data Pipeline
Batch data transformation speedup in a data warehouse.
Case Study: Financial Risk Engine
A bank accelerates Monte Carlo risk simulations with Pyvorin.
Case Study: Game Physics Engine
Indie game developer compiles physics loops for 60fps.
Case Study: Genomics Sequence Analysis
DNA sequence matching and alignment acceleration.
Case Study: IoT Sensor Processing
Edge device processes 10,000 sensor readings per second.
Case Study: Log Analytics Pipeline
How a SaaS company reduced log processing time by 4x.
Case Study: ML Feature Engineering
Accelerating feature extraction for a recommendation system.
Chaos Engineering
Test resilience by forcing fallback and measuring impact.
CI/CD Integration
Add Pyvorin compilation to GitHub Actions, GitLab CI, Jenkins, and other pipelines.
Circuit Breakers and Retry Logic
Resilience patterns for distributed systems.
Class Design for Compilation
Design classes and methods that compile efficiently.
CLI Reference
Complete reference for all pyvorin commands and flags.
Closures and Scopes
Understand how Pyvorin compiles closures and free variables.
CloudSyncQueue API Reference
Complete reference for CloudSyncQueue, including enqueue, dequeue, peek, ack, nack, maybe_flush, SQLite schema, locking, and configuration.
13 min read
Compiler Pipeline Overview
From AST to LLVM IR to native machine code.
Compliance and Data Privacy
GDPR, SOC 2, and HIPAA considerations when using Pyvorin.
Compression Algorithms
Run-length encoding, Huffman coding, and LZ77 in Python.
Concurrency and Multiprocessing
Combine Pyvorin with threading, multiprocessing, and async fallback.
Conditional Branch Optimisation
Write if/else chains that compile to efficient branch logic.
Config File Format
Complete reference for thin_config.json structure and values.
Configuration Management
YAML, TOML, INI, and environment-based configuration patterns.
Contact & Support
How to get help, report issues, and reach the Pyvorin team.
Context Managers Deep Dive
Custom context managers and resource handling under Pyvorin.
Converting Existing Scripts
Practical steps to refactor scripts for maximum Pyvorin compatibility.
Correctness Guarantees
How Pyvorin ensures compiled output matches CPython exactly.
Correctness Validation
How Pyvorin verifies that native output matches CPython exactly.
Cost Optimisation
Reduce cloud bills by compiling CPU-intensive workloads.
Cost Per Request Analysis
How compilation lowers the marginal cost of every API call.
Cross-Compiling Pyvorin Edge Kernels for ARM64
Build ARM64-native shared objects from an x86 machine using Docker buildx, verify artifacts with the file command, and automate everything in GitHub Actions.
18 min read
Custom Adapters — Extending the Ingest Layer
Implement the adapter plugin interface, build a custom Modbus adapter, register it with the runtime, and write unit tests.
15 min read
Custom Benchmark Suites
Build reproducible benchmark suites for continuous performance monitoring.
Custom Cloud Endpoints
Building custom cloud receivers for Pyvorin Edge: expected JSON payload format, Bearer token authentication, batch schema, and webhook handler examples in Flask and FastAPI.
15 min read
Dagster Integration
Compile Dagster solids and assets for data pipelines.
Dash Integration
Compile Dash callback logic for responsive dashboards.
Dask Integration
Accelerate Dask task graphs with compiled functions.
Data Structure Selection
Which Python data structures compile best and which to avoid.
Database Workloads
Optimise database-heavy Python scripts with Pyvorin compilation.
Dataclasses and NamedTuples
Optimise data structures for compilation performance.
Date and Time Processing
Fast date arithmetic, parsing, and timezone handling.
dbt Integration
Compile dbt model transformation logic.
Debugging Compiled Code
Strategies for debugging when compilation fails or produces wrong results.
Decorators and Metaprogramming
How Pyvorin handles decorators, descriptors, and dynamic code.
Dictionary Performance Tips
Maximise dict lookup and insertion performance in compiled code.
Disaster Recovery and Data Integrity
SQLite WAL recovery, queue corruption repair, factory reset procedures, automated backup and restore scripts, and recovery testing for Pyvorin Edge gateways.
18 min read
Distributed Tracing
OpenTelemetry, Jaeger, and Zipkin integration with Pyvorin.
Docker and Containers
Run Pyvorin inside Docker, Kubernetes, and containerised environments.
Docker Deployment Guide
Deploy the Pyvorin Edge Agent with Docker and Docker Compose, including multi-stage builds, health checks, secrets management, and ARM64 cross-compilation.
24 min read
Dynamic Programming Patterns
Compile classic DP solutions for Fibonacci, knapsack, LCS, and pathfinding.
Ed25519 Trust Anchors
How trust_on_first_use() and load_trust_anchor() establish device identity, public key storage formats, migrating legacy anchors, key rotation, and the trust model for Pyvorin Edge bundles.
14 min read
Edge and IoT Deployment
Deploy compiled Python to edge devices and IoT hardware.
Edge CLI Tools Reference
Complete reference for pyv-edge-benchmark, pyv-edge-generate, pyv-edge-inspect, and pyv-edge-sign with every subcommand, flag, and example output.
15 min read
Edge Configuration Reference
A complete reference for every section and key in config.toml, with annotated examples.
22 min read
Edge Dashboard Overview
How to access the dashboard, what each view shows, and how to configure the Pi endpoint and settings.
12 min read
Edge Project Structure
A tour of the directory layout after installation and what each file and folder does.
10 min read
Edge Quick Start
A complete "Hello World" walkthrough from installation to live sensor output in under ten minutes.
14 min read
Edge System Requirements
Hardware, software, and network requirements for running Pyvorin Edge on ARM64 gateways.
12 min read
EdgeAgent API Reference
Complete reference for the EdgeAgent class, including constructor, lifecycle methods, health checks, threading model, and all public properties.
14 min read
Embedded Python with Pyvorin
Run compiled Python on constrained devices.
Energy Savings from Faster Compute
Less CPU time means lower carbon footprint and electricity bills.
Enterprise License vs Build In-House
Why buying Pyvorin beats building a compiler team.
Enums and Constants
Using Enum, IntEnum, and module-level constants efficiently.
Environment Variables
All PYVORIN_THIN_* environment variables and their effects.
Error Handling and Diagnostics
Interpret compiler errors, failure codes, and diagnostic messages.
Error Tracking with Sentry
Capture and diagnose errors in native-compiled Python.
Exception Handling Performance
How try/except affects compilation and when to use it.
Fallback Behaviour Deep Dive
Exactly when and why Pyvorin falls back to CPython execution.
FAQ
Frequently asked questions about licensing, privacy, and performance.
Feature Flags and A/B Testing
Implement feature toggles and experiment logic with compiled code.
Field Redaction Patterns
How to redact specific metadata fields before cloud sync using sensor pattern matching, regex-style wildcards, and both TOML configuration and programmatic APIs.
16 min read
FileReplayAdapter — Time-Travel for Sensor Data
Replay CSV and JSONL log files with timestamp parsing, real-time pacing, speed control, and loop mode for testing and regression.
12 min read
Financial Computation Workloads
Optimise risk calculations, pricing models, and portfolio analytics.
Five-Minute Tour
A narrative walkthrough from installation to live data, rules, and events in five minutes.
14 min read
Fleet Management at Scale
Manage hundreds of Pyvorin Edge devices with device provisioning, configuration drift detection, bulk config push, fleet-wide rollback, and health aggregation.
26 min read
Function Design for Compilation
How to structure functions for optimal native compilation.
Game Development
Pygame and Arcade physics, collision, and game loop optimisation.
GDPR and NIS2 Compliance
Implement GDPR Article 30 records of processing, data retention policies, right to erasure, breach notification, and NIS2 technical measures using Pyvorin Edge privacy and audit APIs.
16 min read
Getting Started
Detailed guide to installation, configuration, and first compile.
Getting the Most from Pyvorin
Top 10 practices for maximising speedup and minimising fallback.
GitHub Actions Advanced
Matrix builds, caching, and benchmark reporting in GitHub Actions.
Gradio Integration
Speed up Gradio prediction functions.
Graph Algorithms
Accelerate BFS, DFS, Dijkstra, and graph traversal workloads.
Great Expectations Integration
Speed up data validation rules with Pyvorin.
Green Computing
Reduce energy consumption and carbon footprint with faster Python.
gRPC Services
Build high-performance gRPC services with compiled Python handlers.
Guard and Deoptimisation
How type guards work and when deoptimisation happens.
Hashing and Checksums
Fast hash computation and integrity verification patterns.
Hashing Strategies for Correlation
One-way hashing with SHA-256 and HMAC, salting strategies, deterministic pseudonymisation for device fingerprinting, and full code examples for the Pyvorin Edge Runtime.
15 min read
Health Checks and Graceful Shutdown
Implement liveness, readiness, and graceful termination.
High-Frequency Data Feeds
Parse and normalise market data at microsecond latency.
How Classes Compile
Class definitions, method calls, and inheritance.
How Dicts Compile
Dictionary creation, lookup, insertion, and deletion.
How For Loops Compile
What machine code Pyvorin generates for Python for loops.
How Functions Compile
Function calls, arguments, and return values in machine code.
How If Statements Compile
Conditional branches and short-circuit evaluation.
How Lambdas Compile
Anonymous functions and closures in native code.
How Lists Compile
List creation, indexing, append, and iteration.
How Match Statements Compile
Pattern matching and case analysis.
How Remote Compilation Works
The journey from Python source code to native machine code via the Pyvorin API.
How Strings Compile
String operations, slicing, and formatting.
How to Benchmark a Function
Measure speedup correctly from start to finish.
How to Bundle a Project
Include local imports in your compile request.
How to Cache Artifacts in CI
Persist compiled artifacts between CI runs.
How to Compile Your First Function
A step-by-step walkthrough of compiling a single Python function.
How to Debug a Correctness Mismatch
Step-by-step diagnosis when native output differs from CPython.
How to Export Usage Data
Download and analyse your usage JSON files.
How to Force CPython Fallback
Temporarily disable compilation for testing or safety.
How to Handle Compilation Failure
What to do when compile fails and how to fix it.
How to Integrate with Makefile
Add Pyvorin compilation targets to your Makefile.
How to Monitor Usage
Track compile credits, fallback rates, and speedups.
How to Pre-compile Before Deployment
Warm the cache before your app goes live.
How to Profile with cProfile
Find hot functions worth compiling.
How to Read a Compile Job Report
Interpret job status, failure codes, and diagnostics.
How to Report a Bug
Collect diagnostics and submit a useful bug report.
How to Run a Speed Proof
Complete walkthrough of pyvorin proof command.
How to Set Up a Team License
Configure shared licenses for enterprise teams.
How to Share Compiled Artifacts
Share native binaries across team members and environments.
How to Use Local Native Mode
Compile locally without the remote API.
How to Use with pre-commit
Compile and benchmark before every commit.
How to Write a Custom Benchmark
Create reproducible benchmarks for your specific workload.
How Try Except Compiles
Exception handling and stack unwinding.
How While Loops Compile
While loops, break, and continue in native code.
How With Statements Compile
Context manager enter and exit in compiled code.
HTTPAdapter — REST, Webhooks, and Polling Ingest
Receive POST webhooks, poll REST endpoints, handle auth headers, rate limiting, and JSON/CSV parsing with FastAPI/Flask examples.
14 min read
HTTPCloudUploader Configuration
Complete guide to the HTTPCloudUploader class: endpoint configuration, API key management, timeouts, retries, exponential backoff, and the post_batch() method with production-ready code examples.
13 min read
IDE Integration
Integrate Pyvorin into VS Code, PyCharm, Vim, and other editors for one-click compilation.
Image Processing with Pillow
Accelerate pixel manipulation and filter pipelines.
Implementing Pyvorin at the Edge
Raspberry Pi, IoT gateways, and CDN edge workers.
Implementing Pyvorin for AIOps
Anomaly detection, log clustering, and root cause analysis.
Implementing Pyvorin for APIs
FastAPI, Flask, and Django REST framework acceleration.
Implementing Pyvorin for Batch Processing
Airflow, Prefect, and cron-based batch pipelines.
Implementing Pyvorin for Celery Workers
Compile task bodies for faster queue processing.
Implementing Pyvorin for CQRS
Speed up command handlers and read model projections.
Implementing Pyvorin for Data Lakes
Parquet reading, partitioning, and transformation.
Implementing Pyvorin for Data Warehouses
BigQuery, Snowflake, and Redshift ETL acceleration.
Implementing Pyvorin for DevOps Automation
Infrastructure as code validation and deployment scripts.
Implementing Pyvorin for Event-Driven Architecture
Compile event handlers in event-sourced systems.
Implementing Pyvorin for Feature Stores
Online and offline feature computation at scale.
Implementing Pyvorin for GraphQL Resolvers
Accelerate resolver functions in Strawberry and Graphene.
Implementing Pyvorin for gRPC Services
Compile protobuf message handlers and business logic.
Implementing Pyvorin for MLOps
Model serving, preprocessing, and monitoring pipelines.
Implementing Pyvorin for Streaming
Kafka, Kinesis, and Pub/Sub stream processors.
Implementing Pyvorin for WebSockets
Real-time message processing with compiled handlers.
Implementing Pyvorin in Microservices
Compile hot paths in containerised services without changing architecture.
Implementing Pyvorin in Monoliths
Gradual compilation inside large Django or Flask apps.
Implementing Pyvorin in Serverless
AWS Lambda, Google Cloud Functions, and Azure Functions.
Implementing Pyvorin on Kubernetes
Sidecar cache, init containers, and Helm charts.
Import Strategy
How imports affect compilation and startup time.
Incident Response
Playbook for debugging production compilation failures.
Installing Pyvorin Edge
Step-by-step installation using the curl script, manual pip install, verification, and post-install checks.
15 min read
JSON and CSV Processing
Parse and transform structured data formats efficiently.
Jupyter Notebook Integration
Use Pyvorin with Jupyter, Google Colab, and IPython notebooks.
LangChain Integration
Compile LangChain tool functions and parsers.
Language Reference
Supported statements, data types, builtins, and operators.
License Key Hashing
How your license key is protected during network transmission.
License Management and Billing
Understand license tiers, usage caps, billing events, and invoice reconciliation.
LicenseValidator API Reference
Complete reference for LicenseValidator, LicenseInfo, LicenseStatus, DevModeValidator, environment variables, local vs remote validation, and trust anchor integration.
12 min read
List vs Tuple vs Set
When to use each collection type for compilation performance.
LLVM IR Generation
How Python constructs are lowered to LLVM intermediate representation.
Local Imports and Project Bundles
How to compile multi-file Python projects with local module imports.
Logging Best Practices
Structured logging, log levels, and observability with compiled code.
Logging in Compiled Code
Log efficiently without destroying compilation gains.
Loop Optimisation Guide
How to write loops that compile to the fastest machine code.
Matrix and Vector Operations
Pure Python matrix math without NumPy dependency.
Measuring Pyvorin Adoption
KPIs and dashboards to track compilation coverage.
Memory Management
Understanding how Pyvorin manages memory for native-compiled Python.
Microservices Patterns
Service discovery, load balancing, and inter-service communication.
Migrating from C++ Extensions
Replace hand-written C++ with compiled Python.
Migrating from Codon to Pyvorin
Return to full Python with compiled hot paths.
Migrating from Cython to Pyvorin
Convert .pyx files back to .py and compile with Pyvorin.
Migrating from Nuitka to Pyvorin
Move from whole-program compilation to function-level.
Migrating from Numba to Pyvorin
Step-by-step migration for Numba JIT users.
Migrating from PyPy to Pyvorin
Keep CPython compatibility while gaining speed.
Migration from Cython
Replace Cython extensions with Pyvorin native compilation.
Migration from Numba
Switch from Numba JIT to Pyvorin with minimal code changes.
Migration Guide from CPython
Step-by-step guide to migrating existing Python projects to Pyvorin.
ML Inference Optimization
Speed up Python ML preprocessing, postprocessing, and inference code.
Mobile Development
Kivy, BeeWare, and mobile deployment strategies.
Mock Mode for Development
Develop and test without a network connection or valid license.
Monitoring and Observability
Track compilation health, execution metrics, and fallback rates.
MQTTAdapter — Broker Subscriptions and Resilient Ingest
Connect to MQTT brokers, manage QoS, TLS, authentication, topic wildcards, and automatic reconnection with full working examples.
14 min read
mTLS and Certificate Pinning
Generate a private CA with OpenSSL, create per-device client certificates, configure MQTTAdapter and HTTPAdapter for mutual TLS, and implement certificate rotation and revocation on Pyvorin Edge gateways.
20 min read
Multi-Environment Setup
Configure Pyvorin across development, staging, and production environments.
Native Code Generation
From LLVM IR to optimised machine code for your CPU.
Network Requirements
Firewall rules, ports, and endpoints the thin client needs access to.
Offline Event Queue
How events are stored and replayed when connectivity is restored.
Offline Mode and Queue Management
How Pyvorin queues events when offline and syncs when connectivity returns.
Offline-First Operation
Designing Pyvorin Edge pipelines for intermittent connectivity using SQLite WAL buffering, retry with exponential backoff, graceful degradation, connectivity detection, and queue persistence across reboots.
16 min read
Optimization Levels Explained
What each optimization level (0-3) does and when to use them.
Over-the-Air Update System
Design and implement secure OTA updates for Pyvorin Edge using Ed25519 bundle signing, atomic symlink swaps, automatic rollback, and channel-based release management.
28 min read
Package Managers
Integrate Pyvorin into poetry, pdm, pip-tools, and conda workflows.
Pagination and Filtering
Efficient in-memory pagination, sorting, and filter logic.
Pipeline API Reference
Complete reference for the Pipeline class, WindowConfig, RuleConfig, PipelineResult, and all public methods with parameters, return types, exceptions, and usage examples.
16 min read
Prefect Integration
Accelerate Prefect flow tasks with native compilation.
Privacy Filtering Overview
Why the Pyvorin Edge Runtime filters sensitive data at the edge before it ever reaches the cloud, and how the PrivacyPolicy class enforces mask, drop, hash, and allow rules.
14 min read
Production Deployment Checklist
A complete go-live checklist for Pyvorin Edge deployments covering hardware validation, security hardening, systemd setup, log rotation, SQLite backups, and monitoring alerts.
22 min read
Profiling and Performance Tuning
Identify bottlenecks and tune your code for maximum native speedup.
Profiling Edge Pipelines and System Metrics
How to profile edge pipelines with cProfile, interpret memory usage, identify bottlenecks, and use the SystemMetrics class and HTTP health endpoints.
12 min read
Programmatic API Usage
Use the Pyvorin Python API directly in your applications and scripts.
Property Descriptors
@property, @cached_property, and custom descriptors.
Pub/Sub and Message Brokers
RabbitMQ, Kafka, and Redis Pub/Sub message processing.
Pydantic and Data Validation
Validate and transform data with Pydantic models under Pyvorin.
PyTorch DataLoader
Speed up PyTorch dataset processing with Pyvorin.
Pyvorin and BuildKit Cache
Mount Pyvorin cache into Docker builds.
Pyvorin Champions Program
Identify and empower internal advocates.
Pyvorin Code Review Checklist
What to look for when reviewing compile-ready Python.
Pyvorin Docker Best Practices
Multi-stage builds, cache layers, and image size.
Pyvorin Docker Compose Setup
Local development with compiled services.
Pyvorin Dockerfile Template
Copy-paste ready Dockerfile for Pyvorin apps.
Pyvorin Edge Plugin Architecture
Build discoverable plugins with lifecycle hooks, register custom adapters, window functions, and action handlers, and configure everything from config.toml.
20 min read
Pyvorin Edge Runtime Library Internals
Deep dive into the runtime shared objects, typed object model, inline caches, ABIContract ctypes binding, ModuleLoader.verify_signature, and ExplicitFallback.run_with_guard.
28 min read
Pyvorin for 5G Orchestration
RAN slicing, resource allocation, and latency optimisation.
Pyvorin for A/B Testing
Experiment analysis, variance reduction, and early stopping.
Pyvorin for Agent-Based Modelling
Simulate millions of agents with compiled step functions.
Pyvorin for Air-Gapped Environments
Offline compilation with the full Pyvorin package.
Pyvorin for Algorithmic Execution
TWAP, VWAP, and implementation shortfall algorithms.
Pyvorin for Anti-Cheat Systems
Behavioural analysis and heuristic scoring.
Pyvorin for Astrophysics
N-body simulation and signal processing for radio astronomy.
Pyvorin for Attribution Modelling
Multi-touch attribution and incrementality testing.
Pyvorin for Audio Processing
Spectrogram generation, pitch detection, and filtering.
Pyvorin for CDR Analysis
Call detail record parsing, aggregation, and billing.
Pyvorin for Certificate Monitoring
SSL/TLS expiry tracking and chain validation.
Pyvorin for CFD
Computational fluid dynamics solvers in Python.
Pyvorin for Climate Modelling
Grid-based simulations and historical data assimilation.
Pyvorin for Clinical Trials
Patient stratification, adverse event detection, and statistical analysis.
Pyvorin for Computational Biology
Protein folding heuristics and phylogenetic trees.
Pyvorin for Computer Vision
Image preprocessing, filtering, and contour detection.
Pyvorin for Customer Segmentation
RFM analysis, cohort building, and clustering.
Pyvorin for Drug Discovery
Molecular docking scoring and compound screening.
Pyvorin for Fleet Management
Telemetry processing, fuel optimisation, and scheduling.
Pyvorin for Fraud Detection
Real-time transaction scoring and anomaly detection.
Pyvorin for Fraud in E-commerce
Chargeback prediction, bot detection, and order risk scoring.
Pyvorin for Game Server Logic
Tick simulation, physics, and collision detection.
Pyvorin for Genomics
Sequence alignment, variant calling, and pathway analysis.
Pyvorin for Health Data Interoperability
FHIR resource transformation and HL7 parsing.
Pyvorin for Insurance Pricing
Actuarial models and premium calculation engines.
Pyvorin for Inventory Optimisation
Demand forecasting, reorder points, and safety stock.
Pyvorin for Matchmaking
ELO, Glicko, and skill-based matching algorithms.
Pyvorin for Medical Imaging
DICOM processing, feature extraction, and segmentation.
Pyvorin for Monte Carlo Methods
Random sampling, integration, and option pricing.
Pyvorin for Network Optimisation
Traffic routing, load balancing, and QoS algorithms.
Pyvorin for NLP Preprocessing
Tokenisation, normalisation, and feature extraction.
Pyvorin for Predictive Maintenance
Sensor anomaly detection and remaining useful life estimation.
Pyvorin for Pricing Engines
Dynamic pricing, competitor scraping, and elasticity models.
Pyvorin for Procedural Content
Terrain generation, dungeon algorithms, and noise functions.
Pyvorin for Quality Control
Statistical process control and defect detection.
Pyvorin for Quantitative Trading
Accelerate backtesting, signal generation, and execution algorithms.
Pyvorin for Real-Time Bidding
Bid calculation, user scoring, and budget pacing.
Pyvorin for Recommendation Engines
Collaborative filtering and content-based scoring.
Pyvorin for Regulatory Reporting
MiFID II, Basel III, and Dodd-Frank report generation.
Pyvorin for Reinforcement Learning
Environment simulation and policy evaluation loops.
Pyvorin for Risk Management
VaR, CVaR, stress testing, and portfolio optimisation at speed.
Pyvorin for Route Optimisation
VRP, TSP, and last-mile delivery algorithms.
Pyvorin for Scientific Computing
ODE solvers, matrix operations, and simulation loops.
Pyvorin for SIEM Pipelines
Log normalisation, correlation, and alert generation.
Pyvorin for Signal Processing
FFT, filter banks, and modulation analysis.
Pyvorin for Smart Grid
Load forecasting, demand response, and grid stability.
Pyvorin for Startups on a Budget
Stretch your cloud credits further with native compilation.
Pyvorin for Supply Chain
Route optimisation, warehouse slotting, and demand sensing.
Pyvorin for Threat Detection
IOC matching, behavioural heuristics, and entropy analysis.
Pyvorin for Time Series Analysis
Rolling statistics, seasonal decomposition, and forecasting.
Pyvorin for Vulnerability Scanning
CVE matching, version parsing, and exploit scoring.
Pyvorin GDPR Considerations
Data handling, right to erasure, and telemetry control.
Pyvorin Governance Model
Who approves compilation, fallback policies, and licensing.
Pyvorin HIPAA Compliance
Using Pyvorin in healthcare environments.
Pyvorin in distroless Images
Minimal attack surface with compiled Python.
Pyvorin Incident Response
What to do when compiled code behaves unexpectedly in production.
Pyvorin on AWS
EC2, Lambda, ECS, EKS, and Sagemaker integration.
Pyvorin on Azure
VMs, Functions, AKS, and Azure ML.
Pyvorin on Cloudflare Workers
Edge-native Python with compiled performance.
Pyvorin on DigitalOcean
Droplets, App Platform, and Kubernetes.
Pyvorin on Google Cloud
Compute Engine, Cloud Run, GKE, and Vertex AI.
Pyvorin on Hetzner
Cost-effective bare-metal compilation.
Pyvorin on Vercel
Serverless Python functions at the edge.
Pyvorin Rollout Playbook
Phase-by-phase guide to deploying Pyvorin across engineering.
Pyvorin Secret Management
Protecting license keys and API credentials.
Pyvorin SOC 2 Compliance
How Pyvorin supports SOC 2 Type II requirements.
Pyvorin Supply Chain Security
SBOM, signed artifacts, and reproducible builds.
Pyvorin vs Codon
How Pyvorin compares to the Codon Python compiler.
Pyvorin vs CPython
What changes and what stays the same when you compile with Pyvorin.
Pyvorin vs Cython
When to choose Pyvorin over Cython and vice versa.
Pyvorin vs Mojo
Python-native compilation vs a new systems language.
Pyvorin vs Nuitka
Comparing Pyvorin native compilation to Nuitka whole-program compilation.
Pyvorin vs Numba
Key differences between Pyvorin and Numba JIT compilation.
Pyvorin vs PyPy
Ahead-of-time compilation vs JIT interpreter.
Queue Management and Backpressure
Deep dive into CloudSyncQueue: SQLite-backed persistence, enqueue and dequeue semantics, maybe_flush with optional uploader, queue depth monitoring, batch sizing, and ack/nack handling.
17 min read
Quick Start
Install, activate, and run your first compiled Python script in under 5 minutes.
Random Numbers and Simulation
Monte Carlo methods, random sampling, and stochastic modelling.
Rate Limiting Implementations
Token bucket, sliding window, and leaky bucket algorithms.
Ray Integration
Compile Ray remote functions and actors.
Real-Time Anomaly Detection
Sub-millisecond scoring for IoT and finance streams.
Recursion and Memoization
Optimise recursive algorithms with Pyvorin compilation and memoisation patterns.
Redis and Caching
Cache compiled artifacts and results with Redis and Memcached.
Reducing Cloud Compute Bills
How 3x speedup translates to 67% fewer compute hours.
Reducing Latency SLAs Penalties
Avoid breach penalties by hitting latency targets with compilation.
Regular Expressions Optimisation
When to use re module vs pure Python string parsing.
ROI and Savings Reports
Calculate return on investment and time saved with Pyvorin acceleration.
Rollback Strategies
How to revert to CPython or previous compiled artifacts when issues arise.
Rules and Conditions — Logic at the Edge
Write lambda conditions, composite AND/OR rules, stateful evaluations, and priority ordering with ten complete production examples.
16 min read
Running EdgeAgent Under Systemd
A complete guide to systemd unit configuration for the Pyvorin Edge Agent, including restart policies, resource limits, graceful shutdown, and optional socket activation.
18 min read
Runtime Libraries
The dict, list, and object runtimes that support compiled code.
Scheduled Compilation
Set up cron jobs and scheduled tasks to pre-compile workloads.
Scientific Computing Workflows
Physics simulation, ODE solving, and numerical methods.
Search Implementations
Binary search, trie, and inverted index patterns.
Secure Boot and Runtime Integrity
Raspberry Pi secure boot chain deep dive, signing kernel modules with pyv-edge-sign, runtime bundle verification, hardware attestation, and tamper detection for Pyvorin Edge deployments.
22 min read
Security & Privacy
How Pyvorin handles your source code, data, and credentials.
Security Best Practices
Harden your Pyvorin deployment: secrets management, access control, and audit logging.
SensorReading API Reference
Complete reference for SensorReading, including fields, serialization, batch operations, timestamp handling, and unit conversion helpers.
10 min read
SensorReadings — The Data Currency of the Edge
Deep dive into the SensorReading dataclass, batch operations, unit conversion, and serialization patterns.
12 min read
Serialization Deep Dive
pickle, json, msgpack, and custom serialisation strategies.
Server Consolidation with Pyvorin
Run the same workload on fewer instances.
Serverless Deployment
AWS Lambda, Google Cloud Functions, and Azure Functions with Pyvorin.
SimulatorAdapter — Synthetic Data for Real Testing
Configure the SimulatorAdapter, model noise and drift, inject anomalies, and run scenario-based simulations before touching hardware.
14 min read
SLIs and SLOs
Define service level indicators for compiled Python services.
Sorting and Searching
When Pyvorin helps with custom sorting, binary search, and lookup tables.
Spark UDFs
Use Pyvorin with PySpark user-defined functions.
State Machines
Implement and compile finite state machines in Python.
Streamlit Integration
Accelerate Streamlit data processing callbacks.
String Handling Best Practices
Efficient string concatenation, parsing, and manipulation.
String Processing and Regex
Text parsing, pattern matching, and string manipulation at native speed.
Supported Workloads
What runs fastest, what falls back, and how to optimize your code.
Task Queues
Celery, RQ, Huey, and dramatiq integration patterns.
TCO: Pyvorin vs CPython Infrastructure
Total cost of ownership comparison over three years.
Team Collaboration
Share configurations, cache artifacts, and manage team licences.
Telemetry and Privacy
What data is collected, what is not, and how to control it.
TensorFlow Data Pipeline
Compile tf.data map functions for faster preprocessing.
Testing Pyvorin Edge Pipelines
Unit testing with pytest, mocking adapters with SimulatorAdapter, property-based testing with Hypothesis, end-to-end integration tests, and CI/CD pipeline configuration for Pyvorin Edge.
18 min read
Testing with Pyvorin
Run pytest and unittest suites against compiled code with correctness checks.
Text Analytics and NLP
Tokenisation, n-grams, TF-IDF, and simple NLP pipelines.
The @edge Decorator — Under the Hood
Deep dive into the @edge decorator, AST parsing, type inference, compilation routing, limitations, and best practices.
15 min read
The GIL and Threading in Pyvorin Edge
Understand how the GIL interacts with compiled kernels, keep Pipeline.run() single-threaded, and safely use ThreadPoolExecutor and ProcessPoolExecutor for I/O and CPU parallelism.
20 min read
The Pipeline Class — Ingest, Window, Evaluate, Act
Complete guide to the Pipeline class, its execution loop, latency tracking, and the PipelineResult API.
15 min read
Thin Client vs Full Compiler
When to use pyvorin-thin and when to install the full pyvorin package.
Training Your Team on Pyvorin
Workshops, coding standards, and mentorship programs.
Troubleshooting
Common issues and how to resolve them.
Troubleshooting Installation
Common installation problems, their root causes, and step-by-step solutions with commands.
16 min read
Type Hints and Static Typing
How type annotations improve compilation quality and performance.
Type Inference System
How Pyvorin deduces types without explicit annotations.
Type Stability Best Practices
Keep variable types consistent for maximum optimisation.
Understanding Compiler Output
Read job details, compiler stderr, and artifact manifests.
Understanding Job Lifecycle
Queued, compiling, complete, failed — what each job status means.
Understanding the EdgeAgent
A deep dive into the EdgeAgent class, its lifecycle, threads, health endpoint, ingest adapters, buffers, and cloud queue.
20 min read
Understanding Usage Reports
Read and interpret local and dashboard usage, benchmark, and failure reports.
Unsupported & Fallback
How Pyvorin handles code it cannot compile.
Updating the Thin Client
How to upgrade pyvorin-thin without breaking existing caches.
Version Pinning and Reproducible Builds
Lock compiler versions and ensure deterministic compilation output.
Virtual Environments
Use Pyvorin with venv, conda, poetry, and pipenv.
Warm-up and Caching Strategies
How artifact caching works and how to minimise cold-start overhead.
WASM and Pyodide
Run compiled Python in the browser with WebAssembly.
Weak Symbol Resolution
How runtime libraries resolve symbols with RTLD_GLOBAL.
Web Frameworks
Using Pyvorin with Flask, FastAPI, Django, and other Python web frameworks.
Web Scraping Acceleration
Speed up HTML parsing, extraction, and transformation logic.
WebSocket and Real-time
Compile message handlers and transformation logic for real-time apps.
What Is Pyvorin Edge?
An introduction to Pyvorin Edge, the problems it solves, and the core concepts every beginner needs to understand.
18 min read
What Is the Thin Client
Understanding how the Pyvorin thin client works and what it does for you.
Window Aggregation — Rolling, Tumbling, and Custom Functions
Configure sliding, tumbling, and session windows. Compute mean, max, min, sum, count, and stddev with real code examples.
14 min read
Working with C Extensions
How Pyvorin interoperates with Cython, C, and Rust extensions.
Working with NumPy and Pandas
Best practices for compiling code that uses NumPy, Pandas, and SciPy.
Writing Compile-Friendly Python
Code patterns that compile well and patterns to avoid.
Writing Compiler-Friendly Python for Pyvorin Edge
Best practices for writing Python that compiles well with the Pyvorin Edge compiler, including supported types, control flow, and anti-patterns to avoid.
12 min read
Writing Custom C Kernels for Pyvorin Edge
Learn the C ABI contract, write a hand-optimized NEON kernel, build a shared object, and register it with CompilerBridge for edge-native execution.
25 min read