2026-09-26 python compiler cython code protection open source

What Is Python to Native Compilation? A Beginner’s Guide

If you ship Python software to customers, you have probably asked a version of this question: how do I hand someone a working program without also handing over readable .py files? For many teams, the answer is Python to native compilation. This guide explains what that term actually means, what happens under the hood, and where Py2Native fits.

The Short Answer: What Python to Native Compilation Means

Python to native compilation is the process of translating Python source code ahead of time into machine code that runs directly on the CPU.

Normal Python execution is interpreted. CPython first compiles your .py file into bytecode, then a Python virtual machine executes that bytecode instruction by instruction. Native compilation changes the final step: instead of shipping bytecode for a virtual machine to interpret, you ship native instructions for the operating system to run.

A simple analogy: an interpreter is like a tour guide who translates your request one sentence at a time. Ahead-of-time compilation is like receiving a translated phrasebook before you leave — the translation has already happened, so you can use it directly.

In practice, Python to native compilation can produce:

Windows .exe or .pyd files
Linux .so shared libraries
macOS .dylib or Mach-O binaries

That does not mean every Python library you import is suddenly rewritten in C. It means your Python code becomes a native binary, while third-party libraries can continue to work as normal Python dependencies.

Why Compile Python to Native Code?

Most Python developers who look into native compilation have one of three goals.

Protect proprietary source code

A .py file is plain text. Bytecode can be extracted and decompiled with widely available tools. A compiled native binary is much harder to reverse engineer because it no longer contains human-readable Python source or easily recoverable Python bytecode.

Native compilation is not a perfect security guarantee, but it raises the bar significantly.

Improve performance for specific workloads

Some CPU-heavy Python code runs faster as native machine code. The gain depends heavily on the workload. Tight loops, numeric computation, and code that avoids frequent Python object allocation tend to benefit most. I/O-bound scripts often see little change.

Simplify distribution

With native compilation, you can ship a binary to users without requiring them to install Python or recreate a virtual environment. This is especially useful for internal tools, desktop utilities, or commercial software where a simpler install process matters.

How Python to Native Compilation Works Under the Hood

The most common modern pipeline looks like this:

Python source
    │
    ▼
C code (via Cython)
    │
    ▼
Machine code (via a C compiler and linker)
    │
    ▼
Executable or shared library

Cython acts as a transpiler: it converts Python-like code into C, which a platform toolchain then compiles into native machine code. Raw Cython is powerful, but it usually requires .pyx files, C extension knowledge, and manual build configuration.

Py2Native automates that entire pipeline. You write plain Python, and the compiler handles Cython invocation, C compilation, linking, and platform-specific output. You can read more about the difference in Python Code Protection Without Cython Syntax: Py2Native vs. Raw Cython.

There are two primary output modes:

Executable mode — produces a standalone native binary
Library mode — produces an importable shared object (.pyd, .so, or .dylib)

Platform matters because each operating system uses different binary formats and linking rules. Py2Native includes platform plugins for Windows, Linux, and macOS, so the same command produces the correct output on each target.

Py2Native: Zero-Config Python to Native Compilation

Py2Native is a Python-to-native compiler built around one idea: write plain Python, get a native binary.

The core compiler is open source under the MIT license. It uses Cython internally, but you never need to write Cython syntax, create .pyx files, or drive the C compiler yourself.

For a simple executable, you run:

uv run py2native build main.py *.py

For an importable library with a wheel:

uv run py2native build main.py *.py --library --wheel dist

You can also embed a runtime environment for deployment:

uv run py2native build main.py *.py --embed dist

The command expands glob patterns, compiles your sources, links the native output, and — when requested — packages the result as a wheel or an embedded deployment directory.

Pro license verification

The open-source core handles compilation. The commercial Pro plugin adds license verification so you can control who runs your binary.

The Pro workflow starts with generating a keypair:

uv run py2native keygen private.pem public.pem

Then you sign a license payload:

uv run py2native sign --private private.pem payload.json license.dat

You can inspect the resulting JWT:

uv run py2native show --public public.pem license.dat

When you build with Pro, the plugin bakes the signature verification code and public key into the executable:

uv run py2native build main.py *.py --license license.dat --public public.pem

Inside your application, you call the runtime verifier. The signature is:

_runtime_verify_es256_jwt(token, expected_iss="RSJ Software GmbH", expected_aud="TimestampGIT")

Add a small .pxd declaration to expose the baked-in verifier:

# py2native_license.pxd
from _p2n_bootstrap cimport _runtime_verify_es256_jwt

cdef _runtime_verify_es256_jwt(token, expected_iss=*, expected_aud=*)

Then call it from your Python module:

# license_gate.py
from _p2n_bootstrap import _runtime_verify_es256_jwt


def enforce_license(licenseString: str) -> None:
    # The Pro plugin embeds the signature verification code and public key
    # into the compiled binary.
    license = _runtime_verify_es256_jwt(
        licenseString,
        expected_iss="RSJ Software GmbH",
        expected_aud="TimestampGIT"
    )
    if not license:
        raise SystemExit("Invalid or expired license")

Only the public key is stored in the executable. The elliptic key verification is handled with compiled code in Py2Native Pro, not a third-party library.

Common Misconceptions About Python to Native Compilation

Misconception: Native compilation makes code impossible to reverse engineer

Reality: it makes reverse engineering much harder, but a determined specialist with enough time can still analyze a binary. The goal is to raise the cost and effort high enough that casual copying or source theft is no longer practical.

Misconception: You need to rewrite Python code in C or Cython

Reality: with Py2Native, you keep writing standard Python. Raw Cython and hand-written C extensions are the hard way. Py2Native automates the transpilation and compilation for you.

Misconception: All Python libraries must be compiled too

Reality: third-party libraries remain as Python source and continue to work normally. Py2Native compiles your code while leaving dependencies unmodified.

Misconception: Native compilation always improves performance

Reality: performance gains depend on the code. The primary benefit for many commercial Python projects is code protection, not raw speed.

FAQ

Q: What is the difference between Python to native compilation and freezing, e.g. PyInstaller?

Freezing packages the Python interpreter and bytecode into an executable, but the bytecode can often be extracted and decompiled. Native compilation translates your Python code into machine code, which is much harder to reverse engineer. Py2Native produces true native binaries, not just bundled bytecode. For a deeper comparison, see Py2Native vs PyInstaller: Which Python to EXE Compiler Protects Your Code?.

Q: Can I compile Python to native code on Windows, Linux, and macOS?

Yes. Py2Native supports Windows, Linux, and macOS, producing platform-specific native binaries such as .pyd, .so, and .dylib. You build on each target operating system with the same uv run py2native build workflow.

Q: Does native compilation protect my code from being decompiled?

Native compilation significantly raises the bar compared to shipping .py files or bytecode. However, no protection is absolute. Advanced reverse engineers can still analyze binaries. Py2Native Pro adds JWT license verification so you can control where and how your compiled code runs.

Q: Do I need to learn C or Cython to use Py2Native?

No. Py2Native works with plain Python. You write standard Python code, and Py2Native handles the Cython transpilation and C compilation automatically. No Cython syntax or manual build configuration is required.

Conclusion

Python to native compilation is a practical way to ship Python software as compiled native binaries instead of readable source code. It protects proprietary logic, simplifies distribution, and can improve performance for some workloads.

Py2Native makes the process zero-config: one uv run py2native build command turns plain Python into a native executable or library. The open-source core covers compilation, and the Pro plugin adds JWT license verification baked into the binary. If you are ready to protect your Python code without rewriting it, start with the best Python code protection tools comparison or jump straight into How to Compile Python to Native Code with Py2Native.

What Is Python to Native Compilation? A Beginner's Guide