Deep Insight Think Deeper. See Clearer
an interesting library the other day that I hadn’t heard of before.
PythoC is a Domain-Specific Language (DSL) compiler that allows developers to write C programs using standard Python syntax. It takes a statically-typed subset of Python code and compiles it directly down to native machine code via LLVM IR (Low Level Virtual Machine Intermediate Representation).
LLVM IR is a platform-independent code format used internally by the LLVM compiler framework. Compilers translate source code into LLVM IR first, and then LLVM turns that IR into optimised machine code for specific CPUs (x86, ARM, etc.).
A core design philosophy of PythoC is: C-equivalent runtime + Python-powered compile-time, and it has the following almost unique selling points.
1. Creates Standalone Native Executables
Unlike tools such as Cython, which are primarily used to create C-extensions to speed up existing Python scripts, PythoC can generate completely independent, standalone C-style executables. Once compiled, the resulting binary doesn’t require the Python interpreter or a garbage collector to run.
2. Has Low-Level Control with Python Syntax
PythoC mirrors C’s capabilities but wraps them in Python’s cleaner syntax. To achieve this, it uses machine-native type hints instead of Python’s standard dynamic types.
- Primitives: i32, i8, f64, etc.
- Memory structures: Pointers (ptr[T]), arrays (array[T, N]), and structs (created by decorating standard Python classes).
- Manual Memory Management: Because it does not use a garbage collector by default, memory management is explicit, just like in C. However, it offers modern, optional safety checks, such as linear types (which ensure that every allocation is explicitly deallocated to prevent leaks) and refinement types (to enforce compile-time validation checks).
Python as a Metaprogramming Engine
One of PythoC’s most powerful features is its handling of the compilation step. Because the compile-time environment is just Python, you can use standard Python logic to generate, manipulate, and specialise your PythoC code before it gets compiled down to LLVM. This gives you highly flexible compile-time code-generation capabilities (similar to C++ templates but driven by pure Python).
It sounds promising, but does the reality live up to the hype? Ok, let’s see this library in action. Installing it is easy, like most Python libraries its just a pip install like this:
pip install pythocBut it’s probably better to set up a proper development environment where you can silo your different projects. In my example, I’m using the UV utility, but use whichever method you are most comfortable with. Type in the following commands into your command line terminal.
C:\Users\thoma\projects> cd projects
C:\Users\thoma\projects> uv init pythoc_test
C:\Users\thoma\projects> cd pythoc_test
C:\Users\thoma\projects\pythoc_test> uv venv --python 3.12
C:\Users\thoma\projects\pythoc_test> .venv\Scripts\activate
(pythoc_test) C:\Users\thoma\projects\pythoc_test> uv pip install pythocA Simple Example
To use PythoC, you define functions using specific machine types and mark them with PythoC’s compile decorator. There are two main ways to run your PythoC code. You can call the compiled library directly from Python like this,
from pythoc import compile, i32
@compile
def add(x: i32, y: i32) -> i32:
return x + y
# Can compile to native code
@compile
def main() -> i32:
return add(10, 20)
# Call the compiled dynamic library from Python directly
result = main()
print(result)Then run it like this.
(pythoc_test) C:\Users\thoma\projects\pythoc_test>python test1.py
30Or you can create a standalone executable that you can run independently from Python. To do that, use code like this.
from pythoc import compile, i32
@compile
def add(x: i32, y: i32) -> i32:
print(x + y)
return x + y
# Can compile to native code
@compile
def main() -> i32:
return add(10, 20)
if __name__ == "__main__":
from pythoc import compile_to_executable
compile_to_executable()We run it the same way.
(pythoc_test) C:\Users\thoma\projects\pythoc_test>python test4.py
Successfully compiled to executable: build\test4.exe
Linked 1 object file(s)This time, we don’t see any output. Instead, PythoC creates a build directory underneath your current directory, then creates an executable file there that you can run.
(pythoc_test) C:\Users\thoma\projects\pythoc_test>dir build\test4*
Volume in drive C is Windows
Volume Serial Number is EEB4-E9CA
Directory of C:\Users\thoma\projects\pythoc_test\build
26/02/2026 14:32 297 test4.deps
26/02/2026 14:32 168,448 test4.exe
26/02/2026 14:32 633 test4.ll
26/02/2026 14:32 412 test4.o
26/02/2026 14:32 0 test4.o.lock
26/02/2026 14:32 1,105,920 test4.pdbWe can run the test4.exe file just as we would any other executable.
(pythoc_test) C:\Users\thoma\projects\pythoc_test>build\test4.exe
(pythoc_test) C:\Users\thoma\projects\pythoc_test>But wait a second. In our Python code, we explicitly asked to print the addition result, but we don’t see any output. What’s going on?
The answer is that the built-in Python print() function relies on the Python interpreter running in the background to figure out how to display objects. Because PythoC strips all of that away to build a tiny, blazing-fast native executable, the print statement gets stripped out.
To print to the screen in a native binary, you have to use the standard C library function: printf.
How to use printf in PythoC
In C (and therefore in PythoC), printing variables requires format specifiers. You write a string with a placeholder (like %d for a decimal integer), and then pass the variable you want to insert into that placeholder.
Here is how you update our code to import the C printf function and use it correctly:
from pythoc import compile, i32, ptr, i8, extern
# 1. Tell PythoC to link to the standard C printf function
@extern
def printf(fmt: ptr[i8], *args) -> i32:
pass
@compile
def add(x: i32, y: i32) -> i32:
printf("Adding 10 and 20 = %d\n", x+y)
return x + y
@compile
def main() -> i32:
result = add(10, 20)
# 2. Use printf with a C-style format string.
# %d is the placeholder for our integer (result).
# \n adds a new line at the end.
return 0
if __name__ == "__main__":
from pythoc import compile_to_executable
compile_to_executable()Now, if we re-run the above code and run the resulting executable, our output becomes what we expected.
(pythoc_test) C:\Users\thoma\projects\pythoc_test>python test5.py
Successfully compiled to executable: build\test5.exe
Linked 1 object file(s)
(pythoc_test) C:\Users\thoma\projects\pythoc_test>build\test5.exe
Adding 10 and 20 = 30Is it really worth the bother, though?
All the things we’ve talked about will only be worth it if we see real speed improvements in our code. So, for our final example, let’s see how fast our compiled programs can be compared to the equivalent in Python, and that should answer our question definitively.
First, the regular Python code. We’ll use a recursive Fibonacci calculation to simulate a long-running process. Let’s calculate the fortieth Fibonacci number.
import time
def fib(n):
# This calculates the sequence recursively
if n <= 1:
return n
return fib(n - 1) + fib(n - 2)
if __name__ == "__main__":
print("Starting Standard Python speed test...")
start_time = time.time()
# fib(38) usually takes around 10 seconds in Python,
# depending on your computer's CPU.
result = fib(40)
end_time = time.time()
print(f"Result: {result}")
print(f"Time taken: {end_time - start_time:.4f} seconds")I got this result when running the above code.
(pythoc_test) C:\Users\thoma\projects\pythoc_test>python test6.py
Starting Standard Python speed test...
Result: 102334155
Time taken: 15.1611 secondsNow for the PythoC-based code. Again, as with the print statement in our earlier example, we can’t just use the regular import timing directive from Python for our timings. Instead, we have to borrow the standard timing function directly from the C programming language: clock(). We define this in the same way as the printf statement we used earlier.
Here is the updated PythoC script with the C timer built in.
from pythoc import compile, i32, ptr, i8, extern
# 1. Import C's printf
@extern
def printf(fmt: ptr[i8], *args) -> i32:
pass
# 2. Import C's clock function
@extern
def clock() -> i32:
pass
@compile
def fib(n: i32) -> i32:
if n <= 1:
return n
return fib(n - 1) + fib(n - 2)
@compile
def main() -> i32:
printf("Starting PythoC speed test...\n")
# Get the start time (this counts in "ticks")
start_time = clock()
# Run the heavy calculation
result = fib(40)
# Get the end time
end_time = clock()
# Calculate the difference.
# Note: On Windows, 1 clock tick = 1 millisecond.
elapsed_ms = end_time - start_time
printf("Result: %d\n", result)
printf("Time taken: %d milliseconds\n", elapsed_ms)
return 0
if __name__ == "__main__":
from pythoc import compile_to_executable
compile_to_executable()My output this time was,
(pythoc_test) C:\Users\thoma\projects\pythoc_test>python test7.py
Successfully compiled to executable: build\test7.exe
Linked 1 object file(s)
(pythoc_test) C:\Users\thoma\projects\pythoc_test>build\test7.exe
Starting PythoC speed test...
Result: 102334155
Time taken: 308 millisecondsAnd in this small example, although the code is slightly more complex, we see the real advantage of using compiled languages like C. Our executable was a whopping 40x faster than the equivalent Python code. Not too shabby.
Who is PythoC for?
I see three main types of users for PythoC.
1/ As we saw in our Fibonacci speed test, standard Python can be slow when doing heavy mathematical lifting. PythoC could be useful for any Python developer building physics simulations, complex algorithms, or custom data-processing pipelines who has hit a performance wall.
2/ Programmers who work closely with computer hardware (like building game engines, writing drivers, or programming small IoT devices) usually write in C because they need to manage computer memory manually.
PythoC could appeal to these developers because it offers the same manual memory control (using pointers and native types), but it lets them use Python as a “metaprogramming” engine to write cleaner, more flexible code before it gets compiled down to the hardware level.
3/ If you write a helpful Python script and want to share it with a coworker, that coworker usually needs to install Python, set up a virtual environment, and download your dependencies. It can be a hassle, particularly if the target user is not very IT-literate. With PythoC, though, once you have your compiled C executable, anyone can run it just by double-clicking on the file.
And who it’s not for
The flip side of the above is that PythoC is probably not the best tool for a web developer, as performance bottlenecks there are usually network or database speeds, not CPU calculation speeds.
Likewise, if you are already a user of optimised libraries such as NumPy, you won’t see many benefits either.
Summary
This article introduced to you the relatively new and unknown PythoC library. With it, you can use Python to create super-fast stand-alone C executable code.
I gave several examples of using Python and the PythoC library to produce C executable programs, including one that showed an incredible speedup when running the executable produced by the PythoC library compared to a standard Python program.
One issue you’ll run into is that Python imports aren’t supported in PythoC programs, but I also showed how to work around this by replacing them with equivalent C built-ins.
Finally, I discussed who I thought were the kinds of Python programmers who might see a benefit in using PythonC in their workloads, and those who wouldn’t.
I hope this has whetted your appetite for seeing what kinds of use cases you can leverage PythoC for. You can learn much more about this useful library by checking out the GitHub repo at the following link.
