Connecting Fortran and Python: Why It's Needed and How to Do It

In scientific computing, you'll often see the phrase "easy connection between Fortran and Python." This refers to tools and techniques that let Python and Fortran call each other seamlessly—so you can keep performance-critical code in Fortran while using Python for scripting, data analysis, and user interfaces.

Why Connect Fortran and Python?

1. Performance vs. Productivity

By connecting them, you get Fortran's speed where it matters and Python's convenience everywhere else. If you need help implementing these solutions and need IT services contact Granite IT.

2. Legacy Code Preservation

Many organizations have decades-old Fortran codebases for physics simulations, climate models, and engineering software. Rewriting them in Python would be risky and expensive. Instead, you wrap the Fortran code and call it from Python, preserving the investment while modernizing the workflow.

3. Modern Scientific Workflows

Python is now the default language for scientific computing, data visualization, and machine learning. Many Python libraries (like NumPy, SciPy, and portions of scikit-learn) actually use Fortran under the hood. Connecting your own Fortran code to Python lets you plug into this ecosystem.

Tools for Connecting Fortran and Python

1. F2PY (Fortran to Python Interface Generator)

The most popular and easiest option.

• What it does: Automatically generates Python extension modules from Fortran code
• Part of: NumPy (comes installed with NumPy)
• Supports: Fortran 77, 90, 95, and modern Fortran modules
• Key features:
  • Calls Fortran functions/subroutines from Python
  • Accesses Fortran COMMON blocks and module data
  • Supports callbacks (Python functions called from Fortran)
  • Automatically handles array ordering differences between Fortran and NumPy

Basic usage:

f2py3 -c add.f90 -m fortran_module

Then in Python:

from fortran_module import add
import numpy as np
x = np.arange(10.)
result = add(x, y)

2. ISO C Binding + ctypes / Cython

More control, slightly more work.

• Use Fortran's iso_c_binding module to create a C-compatible interface
• Compile Fortran to a shared library (.so on Linux, .dll on Windows)
• Call from Python using:
  • ctypes (built into Python)
  • Cython (can interface directly with Fortran using iso_c_binding)

Example compilation:

gfortran -shared -fPIC -o mult.so mult.f90

Then use ctypes in Python to load and call the function.

Some developers find this more reliable than F2PY for complex code.

3. gfort2py

A Python package specifically designed to make Fortran easy to call from Python.

• Less common than F2PY but well-regarded by users who've tried it
• Provides a simpler interface for some use cases

4. System Calls / File-Based Communication

Simplest but least elegant.

• Fortran calls Python script using execute_command_line()
• Python writes results to a file; Fortran reads the file
• Or vice versa: Python launches Fortran executable

This avoids complex linking but is slower and less flexible.

5. C Wrapper + pybind11 / Cython

For advanced use cases.

• Write a C wrapper around Fortran code using bind(C)
• Use pybind11 (C++/Python binding) or Cython to connect to Python
• Useful when you need complex data structures or C++ interoperability

6. MPI for Runtime Communication

For parallel/distributed computing.

• Run Fortran and Python programs with the same MPI communicator
• Exchange data via MPI messages
• Avoids Python startup overhead and allows direct library calls

Which Tool Should You Use?

Bottom Line

Connecting Fortran and Python gives you the best of both worlds: the raw speed and maturity of Fortran for heavy computation, plus Python's modern ecosystem for everything else. F2PY is the go-to tool for most people because it's built into NumPy, well-documented, and handles most of the complexity automatically.

For new projects, many scientists now use Python as the main language and call Fortran only where performance is critical—a strategy that leverages decades of optimized Fortran code while embracing modern workflow tools.