Compile Python to .pyd / .so with Cython (Tested): Faster & Harder to Reverse

Cython takes Python source and transpiles it to C, then a normal C compiler builds that into a platform-specific extension module: yourmodule.cp311-win_amd64.pyd on Windows, yourmodule.cpython-311-x86_64-linux-gnu.so on Linux. You import it exactly like a .py module — the difference is what ships. A .py is source; a .pyc is decompilable bytecode; a .pyd/.so is native machine code with no bytecode to recover.

Here's the module I compiled — a fake license check plus a compute loop, the classic "protect this" case:

SECRET_KEY = "PYOB-2026-PRO-9f83kd"

def check_license(key):
    return key == SECRET_KEY

def compute(long long n):
    cdef long long total = 0, i
    for i in range(n):
        total += (i * i) % 97
    return total

The cdef long long type declarations are the Cython part — they tell the compiler to use raw C integers instead of Python objects, which is where the speed comes from. (Plain .py files compile too, but untyped code stays object-based and gains far less.)

You need Cython (pip install cython) and a C compiler — MSVC Build Tools on Windows, gcc/clang on Linux/macOS. A three-line setup.py drives the build:

from setuptools import setup
from Cython.Build import cythonize

setup(ext_modules=cythonize("liccore.pyx", language_level=3))

[1/1] Cythonizing liccore.pyx
building 'liccore' extension
cl.exe /c /O2 ... /Tcliccore.c /Fo...\liccore.obj
link.exe /DLL ... /OUT:...\liccore.cp311-win_amd64.pyd
Finished generating code

Import and call it exactly like Python:

>>> import liccore
>>> liccore.check_license("wrong")
False
>>> liccore.check_license("PYOB-2026-PRO-9f83kd")
True
>>> liccore.compute(10_000_000)
480000219

For the speed test I ran the identical loop in pure Python and in the compiled module — same input, same output (480000219), so it's a fair comparison:

This is the payoff. The tools that make .pyc "not protection" — decompilers that rebuild near-original source — need bytecode. A .pyd/.so has none; it's compiled machine code. Point uncompyle6 or pycdc at it and there's simply nothing to decompile. Recovering logic from a native binary means reading disassembled x86/ARM — orders of magnitude harder than reading recovered Python.

$ grep -a -o "PYOB-2026-PRO-9f83kd" liccore.cp311-win_amd64.pyd
PYOB-2026-PRO-9f83kd

So compilation hides logic (the algorithm, the control flow) but not data (hard-coded keys, license strings, URLs). Same rule as every other technique: keep real secrets off the client — load them from the environment or a server. See how to protect API keys in Python.

• You need a C toolchain — MSVC on Windows, gcc/clang on Linux/macOS. This is the main friction; it's why you can't truly "compile Python to .pyd online" in a browser.
• The binary is platform- and version-specific — my file is cp311-win_amd64: CPython 3.11, 64-bit Windows only. You must build one per OS × Python version you support (CI matrix builds handle this).
• C-type gotchas — the overflow above is real; untyped .py compiles but barely speeds up, and aggressive typing changes semantics. Type the hot paths, test the output.
• Not a licensing system — it stops casual source theft, not a determined reverse-engineer with a disassembler, and it enforces no license on its own.

Where it fits vs the alternatives: Nuitka compiles your *whole app* to a binary (see Nuitka vs PyArmor); PyInstaller only *bundles* bytecode and is extractable (PyInstaller vs Nuitka); Cython is the sweet spot for compiling the *sensitive modules* of an otherwise-normal Python project.

Compilation and obfuscation aren't rivals — they defend different things, so stack them. Obfuscate the source first (rename identifiers, encrypt string literals so even a byte search yields nothing), *then* Cython-compile the result to a .pyd/.so. Now an attacker faces native machine code and, even if they extract strings, finds only encrypted blobs. That combination — obfuscated logic with no bytecode to decompile and no plaintext strings — is about as far as client-side Python protection goes.