Show HN: Nimic – Pure Python as a systems language with...

Show HN: Nimic – Pure Python as a systems language with AOT compilation

A recent benchmark showed that a pure‑Python program compiled with Nimic ran up to 4× faster than the same code executed by CPython, rivaling small‑C utilities. If you’ve ever thought you needed to learn C, Rust, or Go to write high‑performance system tools, Nimic proves you can stay in the python ecosystem and still ship native binaries. Imagine writing a data‑processing script that pulls a massive CSV with pandas, does heavy numeric crunching with numpy, and then ships as a single executable you can run on any server—no virtualenv, no Docker, just a single file.

In This Article

• What is Nimic and How Does It Fit Into the Python Landscape?
• Installing Nimic – From pip to First‑Run
• Practical Walkthrough: Building a High‑Performance Data‑Science CLI
• Why This Matters: Real‑World Impact for Python Developers
• Actionable Takeaways & Next Steps
• Frequently Asked Questions

What is Nimic and How Does It Fit Into the Python Landscape?

Nimic is a pure‑Python to native compiler that keeps the language surface identical to CPython while emitting LLVM bitcode that turns into a 100% native binary. Unlike tools that wrap Python code in a virtual machine, Nimic rewrites your script into machine code, so you get the speed of a compiled language plus the simplicity of writing in python. No external C extensions are needed. By generating stub files for standard library modules and popular wheels like pandas and numpy, Nimic bundles everything into the final executable. In my experience, this means you can keep using the same imports you would in a notebook and end up with a single file that runs on any target machine without a separate Python interpreter. When compared to Cython, Nuitka, or PyInstaller, Nimic offers a distinct trade‑off: it avoids the two‑step build of Cython (Python → C → binary) and the runtime dependencies of PyInstaller. Instead, it takes you straight from a .py file to a fully‑self‑contained binary, which is pretty much what you want when shipping data‑science tools to production servers.

Installing Nimic – From pip to First‑Run

The first step is simply installing via pip. On most systems you can run: ```bash pip install nimic ``` If you’re on Windows or macOS, you’ll also need a working LLVM toolchain. For Linux, the package manager usually provides the required libraries. The thing is, you don’t have to fuss with clang flags or makefiles; Nimic handles the rest. Next, set up a tiny project. Create a `requirements.txt` with pandas and numpy, and add a `main.py` that just prints “Hello, Nimic!” This is the minimal scaffold that shows Nimic’s magic. ```bash echo "pandas\nnumpy" > requirements.txt echo 'print("Hello, Nimic!")' > main.py ``` Now compile with a single command: ```bash nimic build main.py -o bin/mytool ``` Run `bin/mytool` and you’ll see the greeting. Notice there’s no python interpreter lurking inside—it's a native executable. But the real power shows up when you bring in real libraries. In the next section we’ll dive into a full data‑science CLI.

Practical Walkthrough: Building a High‑Performance Data‑Science CLI

Below is a step‑by‑step recipe that turns a typical Jupyter‑style script into a portable command‑line tool. Feel free to copy the code into a file named `data_stats.py` and follow along. ```python # file: data_stats.py import sys import pandas as pd import numpy as np def summarize(csv_path: str) -> None: # 1 Load data with pandas df = pd.read_csv(csv_path) # 2 Simple NumPy heavy‑lift: compute column-wise RMS rms = np.sqrt(np.mean(np.square(df.select_dtypes('number')), axis=0)) # 3 Print a tidy report print("=== Summary Statistics ===") print(df.describe()) print("\nColumn RMS values:") for col, val in zip(df.select_dtypes('number').columns, rms): print(f"{col}: {val:.3f}") def main() -> None: if len(sys.argv) != 2: print("Usage: data_stats ") sys.exit(1) summarize(sys.argv[1]) if __name__ == "__main__": main() ``` Compile it: ```bash nimic build data_stats.py -o dist/data-stats ``` Now `dist/data-stats` runs on any supported OS. To benchmark, use a tool like `hyperfine`: ```bash hyperfine "python data_stats.py big_data.csv" "dist/data-stats big_data.csv" ``` You’ll usually see the compiled binary beating the CPython run by 2–4× on CPU‑bound workloads. Sound familiar? That's the same speed bump you get when moving from pandas loops to vectorized numpy operations—but now you get the whole package for free.

Why This Matters: Real‑World Impact for Python Developers

Performance gains without leaving python mean that data‑engineers can replace slow ETL scripts with near‑C speed. I think this is better than writing a C++ helper just for a single loop because you keep the familiar syntax and ecosystem. Simplified deployment is another win. One binary eliminates “works on my machine” headaches, which is pretty much a must‑have for CI/CD pipelines and edge devices. As of 2026, many cloud providers still charge for compute time per second, so shaving a few milliseconds per run can add up. Ecosystem synergy stays intact. You can still use pandas for data wrangling, numpy for heavy math, and even import Jupyter modules for quick experiments. The compiled binary can still open sockets, watch files, or spawn processes just like any C program. The community is already growing. Nimic is open source, and the repo includes contribution guidelines. Upcoming features such as async support and better stub generation promise an even smoother developer experience.

Actionable Takeaways & Next Steps

- **Quick checklist** - Do you process > 10 GB of data? - Is deployment to servers or edge devices a requirement? - Do you rely on pandas or numpy? If you answered yes to most, Nimic is worth a try. - **Starter template** GitHub hosts a minimal Nimic skeleton: . Fork it, replace the placeholder script, and compile. - **Learning resources** - Official docs: - Tutorial videos on the Nimic YouTube channel - Join the Discord community for quick help - **Call to action** Fork the Nimic repo, submit a pull request, or share your compiled tools on Hacker News with the “Show HN” tag. Let’s be real: the more people see the speed and simplicity, the faster the ecosystem will grow.

Frequently Asked Questions

What is the difference between Nimic and Cython for Python performance?

Cython requires you to write type‑annotated Python or C‑style code and compiles to C extensions, while Nimic compiles pure python directly to a native binary via LLVM. Nimic therefore needs no separate build step for extensions and produces a single executable, whereas Cython still depends on a Python runtime.

Can Nimic compile projects that use pandas and numpy?

Yes. Nimic generates stub files for many popular libraries, allowing you to import pandas and numpy as usual. The compiled binary bundles the necessary compiled wheels, so the end user does not need to install those packages separately.

How does Nimic handle Jupyter notebooks?

Nimic does not compile .ipynb files directly, but you can export a notebook to a .py script (jupyter nbconvert --to script) and then compile that script with Nimic. This is a common workflow for turning exploratory notebooks into production‑ready CLI tools.

Is the Nimic‑generated binary truly self‑contained?

The binary includes the Python interpreter, the standard library, and any third‑party wheels you bundled during the build. External dynamic libraries (e.g., system OpenSSL) are still required, but you won’t need a separate pip install on the target machine.

What platforms does Nimic support?

Currently Windows (x86_64), macOS (Intel & Apple Silicon), and Linux (x86_64, ARM64). Cross‑compilation is possible with the appropriate LLVM toolchain, but native builds are recommended for best performance.

---

Related reading: Original discussion

What do you think?

Have experience with this topic? Drop your thoughts in the comments - I read every single one and love hearing different perspectives!