DEV Community: PixLab | Symisc Systems

Making C++ and Python Work Together a Little Better with NumPy Files

Vincent — Fri, 03 Apr 2026 00:00:32 +0000

A lot of modern systems are split between two worlds:

Python for experimentation, model training, data science workflows, and notebooks
C++ for performance-sensitive code, native applications, embedded systems, or production pipelines

That split is completely normal. It is also where a lot of unnecessary friction shows up.

You prototype an ML workflow in Python, generate arrays with NumPy, and then at some point you need those same arrays inside a C++ application. Suddenly the clean notebook pipeline turns into format conversion, custom parsers, awkward glue code, or an extra serialization layer you did not really want.

That is the kind of problem syNumpy tries to solve.

The Interoperability Problem

Python and C++ are often used in the same stack, but they do not naturally speak the same data format conventions out of the box.

When the Python side already uses NumPy, the simplest answer is often to keep using NumPy’s own file format rather than introducing something heavier. The .npy format is compact, well understood, and practical for moving numeric arrays between environments.

That becomes useful in cases like:

exporting embeddings from Python and consuming them in C++
moving preprocessed tensors into native inference code
exchanging OCR or vision-related feature vectors across services
saving intermediate numerical results from one environment and loading them in another

The goal is not to replace every other interchange format. The goal is to make one common workflow much less painful.

Where syNumpy Fits

syNumpy is a standalone C++17 library for reading and writing NumPy .npy files.

It gives native C++ code a direct way to consume or produce NumPy arrays without adding a large dependency stack or building a custom bridge around Python.

A few things I like about this approach:

it stays close to an already common Python workflow
it keeps the integration path simple
it is easy to vendor into an existing C++ project
it avoids inventing a new format just to move arrays around

If your Python code already emits NumPy arrays, letting your C++ side read the same .npy files directly is often the lowest-friction option.

A Small Example

Here is a simple C++ example using syNumpy:

#include "synumpy.hpp"
#include <vector>

int main() {
    // Save a small array to disk
    std::vector<float> values = {1.0f, 2.0f, 3.0f};
    syNumpy::saveNpy("floats.npy", values);

    // Load it back
    syNumpy::NpyArray arr = syNumpy::loadNpy("floats.npy");
    std::vector<float> roundtrip = arr.asVector<float>();

    return roundtrip.size() == 3 ? 0 : 1;
}

That may look small, but it is exactly the kind of thing that helps when your Python tooling and native C++ code need to cooperate without ceremony.

Why This Matters in Practice

This kind of interoperability is not theoretical.

syNumpy is used internally by FACEIO for facial feature extraction workflows, and also inside PixLab production systems tied to vision, document processing, and related internal workflows.

That matters because it suggests the library was shaped by actual production needs, not just by a synthetic “hello world” use case.

In practice, when a library is used in real pipelines, the important details tend to be the boring ones:

predictable behavior
explicit failures on malformed input
small API surface
easy integration into existing build systems

That is usually what makes interoperability tools worth keeping around.

Why `.npy` Is a Good Middle Ground

There are many ways to move structured data between systems, but arrays are a special case. When the core unit of exchange is already a NumPy array, using .npy directly is often more natural than wrapping it in something more generic.

It is a nice middle ground between:

staying inside Python-only tooling
building a custom binary format
introducing a bigger serialization framework than the problem requires

For teams working across both ecosystems, simple things like this compound over time. Less conversion code means less maintenance, fewer failure points, and fewer hidden assumptions about layout or dtype handling.

If You Want to Explore It

You can find syNumpy here:

Project page: https://pixlab.io/numpy-cpp-library
Source code: https://github.com/symisc/sy-numpy-cpp

And if you want to see where this kind of tooling shows up in real products:

FACEIO: https://faceio.net/
PixLab: https://pixlab.io/

Closing

C++ and Python are going to keep living side by side for a long time. That is not a problem by itself. The real problem is when moving data between them becomes harder than it should be.

A small library that reads and writes NumPy .npy files will not solve every interoperability problem. But for a very common one, it can remove a surprising amount of friction.

Replace Your Authentication System with Face Recognition using FACEIO's fio.js, & Tailwind.css

Vincent — Mon, 27 Nov 2023 00:40:04 +0000

In the realm of web development, user authentication has traditionally been dominated by username and password combinations. However, with advancements in biometric technologies, face recognition is emerging as a more secure and user-friendly alternative. This article delves into the integration of FACEIO, a cutting-edge face recognition platform, into web applications, offering a step-by-step guide to replace traditional login methods with facial authentication.

Why Choose Face Recognition Authentication?

Face recognition authentication offers several advantages over traditional methods:

Enhanced Security: Unlike passwords, which can be guessed or stolen, facial features are unique to each individual, making it much harder to impersonate a user.
Improved User Experience: Users can access their accounts quickly and effortlessly without the need to remember passwords.
Reduced Fraud Risk: Face recognition reduces the risk of phishing and other social engineering attacks.

Now, the Details:

FACEIO is a cross-browser, Cloud & On-Premise deployable, facial authentication framework, with a client-side JavaScript library (fio.js) that integrates seamlessly with any website or web application desiring to offer secure facial recognition experience to their users.

Put it simply, FACEIO is the easiest way to add passwordless authentication to web sites or applications. Simply implement fio.js on your website, and you will be able to instantly authenticate your existing users, and enroll new ones via Face Recognition using their computer Webcam or smartphone frontal camera on their favorite browser.

Some Nice FACEIO Features

Highest security standards. Privacy by design with maximum user convenience.
No requirements for biometric sensor.
Authenticates and confirms identity of users instantly without FIDO keys, OTP codes, or security questions. Refer to the
Full cross-browser compatibility (Chrome, Firefox, Safari, Edge & Chromium derivatives).
Zero external dependency. Only standard technology implemented in plain JavaScript & CSS.
Defense grade accuracy with less than 100 milliseconds recognition speed powered by state-of-the-art facial recognition engines.

FACEIO works with regular Webcams or smartphones frontal camera on all modern browsers, does not require biometric sensors to be available on the client side, and works seemingly with all websites and web-based applications regardless of the underlying front-end JavaScript framework or server-side language or technology.

Implementing FACEIO on your web application

Integrating FACEIO on your website or web application is straightforward regardless of the underlying JavaScript framework whether it is React., Vue.js, Next.js or even Vanilla JS.
Before so, you need to create a new application first on the FACEIO Console, and link this resource to your website or web application. The checklist below highlights the steps to follow for a smooth integration of
fio.js on your website or app:

Create a new FACEIO application first: Follow the Application Wizard on the FACEIO Console to create your first application and link it to your website or web application.
The Application Wizard should automate the creation process for you. Usually, this involve inputting an application name, selecting a facial recognition engine, cloud storage region, reviewing security options, customizing the Widget layout, and so forth...
Once your first FACEIO application created, simply implement fio.js, our facial recognition JavaScript library on your website, and initialize the library with your application Public ID.
Congratulations 👏. You have FACEIO up & running! Now, it's time to enroll() and authenticate() your first user via face recognition as we will see on the HTML boilerplate..

The HTML Integration Boilerplate

Understand the fundamentals

To enroll (register) a new user, simply call the enroll() method from the recently instantiated faceIO object. The enroll() method let you transactionally enroll new users on your application. A process better known as on-boarding. It is the equivalent implementation of a standard register/sign-up function in a traditional password managed, authentication system. This is done on line 31 of the gist above.
Effective call to enroll(), will trigger the FACEIO Widget, ask for user’s consent (if not yet authorized), request access (if not yet granted) to the browser’s Webcam/Frontal camera stream, and finally extract & index the facial features of the enrolled user for future authentication purposes.
enroll() takes a number of Optional Parameters including locale for the interaction language, permissionTimeout which correspond to the number of seconds to wait for the user to grant camera access permission, but more importantly, enroll() accept a payload which simply put, an arbitrary set of data you can link to this particular user such as an Email Address, Name, ID, etc. This payload will be forwarded back to you upon successful future authentication of this particular user.

👉 The enroll() method, its expected parameters, Promise fulfillment, error handling, etc. are officially documented here.

To Authenticate & Recognize a previously enrolled user, simply call the authenticate() method from the recently instantiated faceIO object. The authenticate() method let you transactionally authenticate (recognize) previously enrolled users on your application. It is the equivalent implementation of a standard login/sign-in function in a traditional password managed, authentication system.
authenticate() returns a Promise whose fulfillment handler receives a userData object when the user has successfully been identified. The most important fields of this object are: payload, which is the arbitrary data you have already linked (if any) to this particular user during his enrollment via the payload parameter, the enroll() method takes, and Facial ID, which is an Universally Unique Identifier assigned to this particular user during his enrollment. This Facial ID alongside the payload data could serve as a lookup key on your backend to fetch data linked to this particular user on each future successful authentication for example.

👉 The authenticate() method, its expected parameters, Promise fulfillment, error handling, etc. are officially documented here.

Best Practices and Considerations

Integrating FACEIO for face recognition authentication offers a blend of enhanced security and user convenience. As web technologies evolve, embracing such innovative authentication methods can significantly improve user experience while maintaining high security standards.

Security Best Practices: This guideline presents several best practices that have a significant, positive impact on your FACEIO application's security.
Privacy Best Practices: This guideline presents several best practices that have a significant, positive impact on your FACEIO application's privacy practices.

Community Contributed Tutorials

The following, high-content, community contributed guides & tutorials should help you implement fio.js on your web or mobile application using your favorite JavaScript framework whether it is React, Vue, Angular, Next, React or Vanilla JavaScript: