How do I convert a Fortran program to Python?

Most conversion guides describe a rewrite: translating every routine by hand into Python or C++. There is a second option — re-hosting. The original numerics keep running as compiled Fortran or C++, and the conversion work happens in the interfaces around them. nativegate generates that interface automatically: pybind11/f2py bindings, a CMake build, an installable Python package, tests, a FastAPI service, containers, and a numerical regression check that fails a rebuild if any value moves.

What is wrong with translating Fortran to Python by hand?

Accuracy and validation. A translated routine is not the same code — it is a new implementation, and every translated numeric path is a new chance for a subtle difference (half-open loops, 1-based array origins, assumed-size arguments, COMMON-block state). If a regulator or a client ever signed off on the original numbers, the artifacts they signed are gone once translated. Re-hosting keeps the bit-exact numerics and regenerates the interface on demand.

What does nativegate generate?

From an existing C++ header or Fortran deck, it generates pybind11 or f2py bindings, CMake, an installable wheel, a pytest suite, a FastAPI service exposing the same functions over HTTP, Docker/Kubernetes artifacts, and a numerical baseline (golden record) of what the compiled code returns. Everything except the native source and the golden tape is regenerable; upgrading the generator cannot silently change an answer.

Convert legacy Fortran and C++ to Python without rewriting

What "convert Fortran to Python" usually means

A rewrite. Someone reads the deck and produces a Python file: every loop, every COMMON block, every magic constant transcribed into numpy. The reason this is the expensive plan is that a validated numerical code is a record — what your organization relies on is not merely the text of the routine, but the artifact the auditors signed and the twenty years of production runs behind it. A rewrite makes every consumer rebuild that trust from zero, in a language where 1-based array origins, assumed-size arguments and COMMON-block state are each their own subtle-difference hazard. Re-hosting keeps the compiled numerics and converts the interface around them instead.

Approach	What it recovers	What it costs
Hand-rewrite into Python	none of the validated numerics	all regression work starts over; every translated loop is a new subtle-difference risk
Hand-written bindings	the numerics keep running	argument intent, array shapes and session lifecycle re-implemented per routine
Subprocess wrapper + stdout parsing	numerics and a rough call surface	no library, no schema, no tests; brittle at scale
nativegate	numerics unchanged plus generated bindings, tests, wheel, HTTP service, containers	the integration work you wanted anyway, generated once and pinned to source hashes

What nativegate does on day one

One generator handles a tree: you point ngate quickstart at a header or a Fortran deck, and in one command it produces a pip-installable wheel and its compile artifacts. The same source drives a FastAPI service (the wheel) and a Dockerfile; you edit nothing twice.

pip install "nativegate[clang,build]"
ngate quickstart legacy/sim.f --name sim_api
pip install services/sim_api/dist/*.whl

Three minutes later, the same library is also an HTTP service:

ngate serve sim_api
curl -X POST "http://localhost:8000/solve?a=1&b=2"

The case, feature by feature

1. Handles 1990s-era sources unmodified

Fixed-form columns 6 and 73, INCLUDE decks, IMPLICIT typing, COMMON blocks, netlib's CS/CD dual-dialect marking, statement labels in the marked copy — all tested against real third-party Fortran, with the dialect resolution and label handling that the netlib specfun contact produced, published as an independently wrapped library.

2. Equality you can pin a build to

Every generated service can record a numerical baseline (ngate golden record): the return values of each entry point, tolerance, and the SHA-256 of every native source byte. ngate golden verify fails a rebuild that moved a number, and CI fails when a hash moved. For the specfun showcase, all 14 pinned entry points came back unchanged when the bindings were regenerated from the pristine downloads — that is the whole argument for generation over translation, measured.

3. One workflow, two languages

The same CLI, yaml schema, test suite and golden harness cover C++ (pybind11 through libclang) and Fortran (f2py). The team learns one interface, not one per language.

4. It refuses rather than mis-types

What it cannot bind is recorded as a skip with the reason: derived types it cannot flatten, callbacks (EXTERNAL dummies), dialect files without a chosen half. The list is published (DEFECTS.md), and every defect found in the wild is regression-tested once fixed — the specfun and quadpack contacts alone produced six of them.

5. A service, not just a wheel

The generated service ships optional API-key auth, a schema, request logging, readiness/liveness probes with SIGTERM draining, Kubernetes manifests and a reproducible, hash-locked Docker build — the deployment half a "just load the .so" wrapper leaves to you.

The case against hand-rolled wrappers

It is not that hand-written bindings are impossible — many teams have one, and it works while the API stays small. The cost grows with every new endpoint: array edges, intent, error flags, session lifecycles, all redone per routine and re-verified by nobody in particular. The generated vs hand-written comparison states the trade in measured numbers rather than adjectives.

What nativegate does not do

Stated plainly, because the narrowing helps you plan:

It does not translate your Fortran to Python. The numerics compile from the original source — that is the point and also the limit.
Routines taking an external f callback are refused for now, with a reason (QUADPACK-style integrators). Scoped in the roadmap.
fparser2 refuses Hollerith-era syntax gfortran compiles with a warning; such decks use the regex reader backend.
Fortran COMMON-block state means one native call at a time per process — scale comes from more processes behind an ingress, and the generated Kubernetes manifests are shaped accordingly.

Where to look, without being asked to take our word for it

The generator: source, test suite, DEFECTS.md and ROADMAP.md published as-is.
pip install "nativegate[clang,build]" — the tool installs from PyPI today.
specfun-py: netlib specfun wrapped end to end from the unchanged Fortran, values pinned in CI.
The blog: what the tool does, what it refuses, and the defects the third-party contacts found — with the fix version listed for each.

Try it → The enterprise page

Converting legacy Fortran and C++ to Python: the case for generation over translation