an interesting library the other day that I had never heard of before.
PythoC includes a Domain Specific Language (DSL) that allows developers to write C programs using standard Python syntax. It takes a mathematically 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 an organization platform-independent code format used internally by the LLVM compiler framework. Compilers translate the source code into the LLVM IR first, and then LLVM converts that IR into machine code optimized for specific CPUs (x86, ARM, etc.).
The main design philosophy of PythonC is: A C-equivalent runtime + Python-enabled compile-time, and has the following almost unique selling points.
1. Creates a Standalone Native Executable
Unlike tools like Cython, which are primarily used to create C extensions to accelerate existing Python scripts, PythoC can generate completely independent, C-style scripts. Once compiled, the resulting binary does not require a Python interpreter or garbage collector to run.
2. Has Low Level Control with Python Syntax
PythoC showcases the capabilities of C but wraps them in the clean syntax of Python. To achieve this, it uses native type hinting instead of standard Python variable types.
- Primitives: i32, i8, f64, etc.
- Memory structures: Pointers (ptr[T]), arrays (list[T, N]), and properties (created by decorating standard Python classes).
- Manual Memory Management: Because it does not use the garbage collector automatically, memory management is transparent, just like in C. However, it provides modern, optional security checks, such as line types (ensuring that all allocated funds are clearly identified to prevent leakage) and types of refining (forcing to include time validation tests).
Python as a Metaprogramming Engine
One of the most powerful features of PythonC is its handling of the compile step. Because it's just a Python compile-time environment, you can use standard Python logic to generate, manage, and customize your Python code. before it is compiled down to LLVM. This gives you a very flexible ability to generate compile-time code (similar to C++ templates but run in 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 just install the pipe like this:
pip install pythocBut it's probably better to set up a proper development environment where you can store your different projects. In my example, I'm using the UV utility, but use whatever method you're comfortable with. Type the following commands in your command line terminal.
C:Usersthomaprojects> cd projects
C:Usersthomaprojects> uv init pythoc_test
C:Usersthomaprojects> cd pythoc_test
C:Usersthomaprojectspythoc_test> uv venv --python 3.12
C:Usersthomaprojectspythoc_test> .venvScriptsactivate
(pythoc_test) C:Usersthomaprojectspythoc_test> uv pip install pythocSimple Example
To use PythoC, you define functions using specific types of machines and mark them with a PythoC collection. the decorator. There are two main ways to run your Python 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:Usersthomaprojectspythoc_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:Usersthomaprojectspythoc_test>python test4.py
Successfully compiled to executable: buildtest4.exe
Linked 1 object file(s)In this case, we don't see any output. Instead, PythoC creates a build directory under your current directory, and creates an executable file there for you to use.
(pythoc_test) C:Usersthomaprojectspythoc_test>dir buildtest4*
Volume in drive C is Windows
Volume Serial Number is EEB4-E9CA
Directory of C:Usersthomaprojectspythoc_testbuild
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 use the test4.exe file just like we would any other executable.
(pythoc_test) C:Usersthomaprojectspythoc_test>buildtest4.exe
(pythoc_test) C:Usersthomaprojectspythoc_test>But wait a minute. In our Python code, we explicitly asked to print the result of addition, but we don't see any output. What's going on?
The answer is that the built-in Python print() function depends on the Python interpreter running in the background to figure out how to display things. Because PythoC removes all of that to create a smaller, more usable native, the print statement is omitted.
To print to the screen in native binary, you must use a standard C library function: printf.
How to use printf in PythonC
In C (and therefore in PythonC), print variables require format specifiers. You write a string with a placeholder (like %d for a decimal number), and pass the variable you want to put into that placeholder.
Here's 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 = %dn", 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 run the above code again and use the executable result, the output is what we expected.
(pythoc_test) C:Usersthomaprojectspythoc_test>python test5.py
Successfully compiled to executable: buildtest5.exe
Linked 1 object file(s)
(pythoc_test) C:Usersthomaprojectspythoc_test>buildtest5.exe
Adding 10 and 20 = 30Is it really worth the worry, though?
All the things we talked about will only be worth it if we see real speed improvements in our code. So, for our last example, let's see how fast our compiled programs can be compared to the Python equivalent, and that should answer our question for sure.
First, regular Python code. We will use the recursive Fibonacci calculation to simulate the long-term process. Let's calculate the Fibonacci number of forty.
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 while running the above code.
(pythoc_test) C:Usersthomaprojectspythoc_test>python test6.py
Starting Standard Python speed test...
Result: 102334155
Time taken: 15.1611 secondsNow for the Python-based code. Also, as with the print statement in our previous example, we can't just use the normal import-time directive from Python for our sessions. Instead, we have to borrow the standard timer function directly from the C programming language: clock(). We define this in the same way as the printf statement we used earlier.
Here is an updated Python script with a built-in C timer.
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: %dn", result)
printf("Time taken: %d millisecondsn", elapsed_ms)
return 0
if __name__ == "__main__":
from pythoc import compile_to_executable
compile_to_executable()My result this time was,
(pythoc_test) C:Usersthomaprojectspythoc_test>python test7.py
Successfully compiled to executable: buildtest7.exe
Linked 1 object file(s)
(pythoc_test) C:Usersthomaprojectspythoc_test>buildtest7.exe
Starting PythoC speed test...
Result: 102334155
Time taken: 308 millisecondsAnd in this small example, although the code is more complex, we see the real advantage of using compiled languages like C. Our implementation was 40x faster than the equivalent Python code. Not too shabby.
Who is PythoC?
I see three main types of Python users.
1/ As we saw in our Fibonacci speed test, regular Python can be slow when doing complex calculations. PythoC can be useful for any physics-based Python simulation, complex algorithms, or custom data processing pipelines that hit a performance wall.
2/ Programmers who work closely with computer hardware (such as building game engines, writing drivers, or programming small IoT devices) often write in C because they need to manage computer memory manually.
PythoC can appeal to these developers because it provides the same memory management (using pointers and native types), but allows them to use Python as a “metaprogramming” engine to write clean, flexible code before it is compiled down at the hardware level.
3/ If you write a useful Python script and want to share it with a colleague, the colleague usually needs to install Python, set up a virtual environment, and download your dependencies. It can be a hassle, especially if the target user is not very IT literate. With PythonC, however, once you've compiled a C executable, anyone can run it by double-clicking on the file.
And not for people
The flip side of the above is that PythoC is probably not the best tool for a web developer, as performance bottlenecks are often network or database speed, not CPU computing speed.
Likewise, if you're already a user of advanced libraries like NumPy, you won't see many benefits.
Summary
This article introduced you to the relatively new and unknown Python library. With it, you can use Python to create very fast standalone C executable code.
I have provided several examples of using Python and the PythoC library to generate executable C programs, including one that showed a dramatic speedup when using an executable generated by the PythoC library compared to a standard Python program.
One issue you'll run into is that Python imports aren't supported in Python programs, but I've also shown how to work around this by replacing the C built-in.
Finally, I discussed who I thought were the types of Python programmers who might see a benefit in using PythonC in their workloads, and who didn't.
I hope this has whetted your appetite to see what kinds of cases you can use Python for. You can learn more about this useful library by checking out the GitHub repo at the following link.
