Developing native applications and shared libraries with NeqSim

[EvenSol]

Hi,

We would like to make the community aware of the neqsim-native project:

https://github.com/equinor/neqsim-native

The purpose of this project is to make it possible to compile NeqSim-based process simulation models into native shared libraries and native applications using GraalVM. This means that selected NeqSim models can be packaged as native libraries such as .dll, .so, or .dylib, and then called directly from applications written in languages such as C, C++, MATLAB, LabVIEW, .NET, Python wrappers, or process-control environments.

One of the important benefits of this approach is performance. GraalVM native images can give very fast startup times and reduced runtime overhead compared with starting a full JVM-based application. This is especially useful for command-line tools, microservices, operator-support tools, real-time workflows, embedded calculations, and applications where many small calculations are started repeatedly.

This opens up several interesting possibilities for NeqSim users.

What this enables

With neqsim-native, you can develop lightweight native applications that use NeqSim thermodynamics and process models without running a full Java application at runtime. Typical use cases could include:

• Embedding NeqSim calculations in existing engineering tools
• Building native desktop applications for PVT, fluid properties, hydrate, dew point, or process calculations
• Integrating NeqSim models into C/C++-based simulators or control systems
• Creating fast-starting calculation services or command-line tools
• Using NeqSim models in environments where Java integration is difficult
• Deploying selected NeqSim calculations closer to real-time or operational applications
• Building vendor-neutral engineering calculation libraries based on open thermodynamic models

Speed and deployment benefits

Native GraalVM applications are particularly attractive when NeqSim calculations need to be called frequently, started quickly, or deployed in constrained environments.

Potential benefits include:

• Faster application startup
• Lower memory footprint for selected use cases
• Easier deployment as a standalone executable or shared library
• Reduced dependency on a locally configured Java runtime
• Better integration with native engineering software
• Improved suitability for cloud functions, microservices, command-line tools, and operational workflows

For long-running simulations, the performance gain will depend on the specific model, calculation type, and implementation. However, for many engineering tools and service-based workflows, the combination of fast startup, simpler deployment, and native integration can be very valuable.

Java and Python model support

Process models can be developed in Java, and optional builds also support Python models using GraalPy. This means that users can prototype models in Python, or implement them directly in Java, and expose the resulting calculation as a native function.

From the outside, the calling application does not need to know whether the model was originally written in Java or Python. It only sees a native shared library with exported functions.

Why this is useful

Many industrial and engineering applications still rely on native interfaces. Examples include legacy C/C++ tools, control-system software, dynamic simulators, optimization tools, operator advisory systems, and proprietary engineering applications.

neqsim-native makes it easier to bring open-source NeqSim models into these environments.

This can be especially useful for applications such as:

• Online process monitoring
• Digital twins
• Process-control advisory tools
• Fluid-property services
• Hydrate and water-dew-point calculations
• Gas quality and hydrocarbon dew point tools
• Compressor and separator performance tools
• Engineering calculation packages for students and researchers

Get involved

We encourage NeqSim users to test the repository, try the examples, and suggest useful native functions or process models that should be exposed.

Possible contributions include:

• New native calculation functions
• Example C/C++ applications
• MATLAB or Python wrapper examples
• Documentation improvements
• Test cases and validation examples
• Benchmarks comparing JVM and native execution
• Industrial use cases where native NeqSim integration would be valuable

This project is an important step toward making NeqSim easier to embed in industrial software, digital twins, and operational tools.

Feedback, ideas, benchmarks, and contributions are very welcome.