WrapStar

WrapStar is how we turn C and C++ into Python. Not a thin, foreign-looking shim over a native API, but a module that feels like it was written in Python, backed by code that still runs at native speed. The star is the point: we can wrap effectively any C or C++, including libraries that manage their own object and resource lifecycles, without intrusively modifying the original source.

The wildcard: any C or C++, made properly Pythonic

Most bindings get you method calls and attribute access and stop there. WrapStar goes the rest of the way, to the parts that make a library actually pleasant to use from Python: real lists and dictionaries, stable object identity that holds up across repeated access, correct object lifetimes with no slow leak of accumulated wrappers, and plain Python functions standing in for native callbacks. Objects pass cleanly in both directions, so anything created on the C++ side is usable from Python and the reverse. We have taken this all the way up to libraries as demanding as OpenSceneGraph and VulkanSceneGraph, which run their own intrusive reference counting and resource management.

Why not just have an AI do it

You can. Point a coding assistant at a large C++ library and it will generate something. What it generates is usually thousands of lines of boilerplate that cannot be safely removed once it exists, leaks objects because it never understood the library's ownership model, and does not feel like Python to the people who have to use it. A library that manages its own memory and lifecycle is full of sharp edges, and an unguided model walks straight into them. We are direct about this because it is exactly where the value is: wrapping hard C++ well is a craft, and WrapStar is that craft made systematic, each sharp edge found once and solved once.

Into the AI and data stack, without the copies

Python is the language of AI and data science, so wrapped native code has to move data with the tools that world uses. WrapStar connects C and C++ to NumPy, PyTorch, and Jupyter so arrays move in and out with little or no copying. When the data lives on the GPU it can stay there: a native library and a compute kernel can share the same memory, so model tensors or simulation state are consumed, processed, or visualized without a round trip through the CPU.

Add it to an existing codebase, without a rewrite

You do not have to rewrite anything. WrapStar adds Python to an existing C or C++ codebase incrementally, as a scripting and runtime layer on top of the code you already ship. It works both ways: exposing your C++ to a Python process, or embedding a Python interpreter inside your C++ application. For a mature codebase this is often the fastest and least risky path to modernization, because the existing code keeps running while Python grows around it.

Teaching an AI to use your code

Wrapping the library is only half the job. Once it is wrapped, we build the guidance that teaches an AI agent to use it correctly, so a model works with your code the way an experienced developer would instead of guessing at an unfamiliar API and hitting the same sharp edges from the Python side. That pairs with aipython, our tool for co-driving one live Python session with a human and an agent in the same interpreter.

What it makes possible

WrapStar is the tooling behind our own Python integration work, including a complete, Sketchfab-style physically based renderer authored and driven entirely from Python. If your native code has to show up in Python, cleanly, and be usable by both people and AI, this is how we do it.

Who works on it

AlphaPixel is a US-owned small business, founded in 2004, with senior C++ and Python developers who have bound native code to Python and shipped the tooling around it. DLA DD2345 / ITAR registered. We take closed-source work and open source alike.