Aforeign function interface (FFI) is a mechanism by which a program written in oneprogramming language can call routines or make use of services written or compiled in another one. An FFI is often used in contexts where calls are made into a binarydynamic-link library.
The primary function of a foreign function interface is to mate the semantics andcalling conventions of one programming language (thehost language, or the language which defines the FFI), with the semantics and conventions of another (theguest language). This process must also take into consideration theruntime environments andapplication binary interfaces of both. This can be done in several ways:
Requiring that guest-language functions which are to be host-language callable be specified or implemented in a particular way, often using a compatibilitylibrary of some sort.
Use of a tool to automaticallywrap guest-language functions with appropriateglue code, which performs any necessary translation.
Restricting the set of host language abilities which can be used cross-language. For example, C++ functions called from C may not (in general) include reference parameters or throw exceptions.
FFIs may be complicated by the following considerations:
If one language supportsgarbage collection (GC) and the other does not; care must be taken that the non-GC language code does nothing to cause GC in the other to fail. In JNI, for example, C code which "holds on to" object references that it receives from Java must communicate this information successfully to theJava virtual machine orJava Runtime Environment (JRE), otherwise, Java may delete objects before C finishes with them. (The C code must also explicitly release its link to any such object once C has no further need of that object.)
Complicated or non-trivial objects or datatypes may be difficult to map from one environment to another.
It may not be possible for both languages to maintain references to the same instance of a mutable object, due to the mapping issue above.
One or both languages may be running on avirtual machine (VM); moreover, if both are, these are often different VMs.
Ada language bindings, allowing not only to call foreign functions but also to export its functions and methods to be called from non-Ada code.[7]
C++ has a trivial FFI withC, as the languages share a significant common subset. The primary effect of theextern "C" declaration in C++ is to disable C++name mangling. With other languages, separate utils or middleware are used, examples include:
Factor has FFIs for C,Fortran,Objective-C, andWindows COM; all of these enable importing and calling arbitrary shared libraries dynamically.
Fortran 2003 has a module ISO_C_BINDING which provides interoperable data types (both intrinsic types and POD structs), interoperable pointers, interoperable global data stores, and mechanisms for calling C from Fortran and for calling Fortran from C.[11] It has been improved in the Fortran 2018 standard.
Go can call C code directly via the"C" pseudo-package.[12]
Google Web Toolkit (GWT), in which Java is compiled to JavaScript, has an FFI named JSNI which allows Javasource code to call arbitrary JavaScript functions, and for JavaScript to call back into Java.
Java Native Interface (JNI), which provides an interface betweenJava and C/C++, the preferred systems languages on most systems where Java is deployed.Java Native Access (JNA) provides an interface with native libraries without having to writeglue code. Another example isJNR
LuaJIT, ajust-in-time implementation ofLua, has an FFI that allows "calling external C functions and using C data structures from pure Lua code".[4][5]: 35
Nim has an FFI which enables it to use source fromC,C++, andObjective-C. It can also interface with JavaScript.
JavaScript usually runs insideweb browser runtimes that don't provide direct access to system libraries or commands to run, but there are few exceptions:
Node.js provides functions to open precompiled.node modules that in turn may provide access to non-builtin resources.
Deno, provides kind of FFI interface viadlopen(...) functions.[13]
Bun provides a built-in module,bun:ffi, to efficiently call native libraries directly from JavaScript.[14]
Julia hasccall keyword to call C (and other languages, e.g., Fortran);[15] while packages, providing similar no-boilerplate support, are available for some languages e.g., for Python[16] (to e.g. provide OO support and GC support), Java (and supports other JDK-languages, such as Scala) and R. Interactive use with C++ is also possible with Cxx.jl package.
PhoneGap (was named Apache Callback, but is nowApache Cordova) is a platform for building native mobile applications using HTML, CSS and JavaScript. Also, it has FFIs via JavaScript callback functions for access to methods and properties of mobile phone's native features including accelerometer, camera (also PhotoLibrary and SavedPhotoAlbum), compass, storage (SQL database and localStorage), notification, media and capture (playing and recording or audio and video), file, contacts (address book), events, device, and connection information.[1],[2].
Python provides thectypes andcffi modules. For example, the ctypes module can load C functions from ashared library, ordynamic-link library (DLL) on-the-fly and translate simple data types automatically between Python and C semantics as follows:
importctypeslibc=ctypes.CDLL('/lib/libc.so.6')# Under Linux/Unixt=libc.time(None)# Equivalent C code: t = time(NULL)print(t)
Ruby provides FFI either through theffi gem, or through the standard libraryfiddle.
require'fiddle'libm=Fiddle.dlopen('/lib/libm.so.6')# Equivalent to: double floor(double x);floor=Fiddle::Function.new(libm.sym('floor'),# ptr is a referenced function(, or symbol), of a Fiddle::Handle.[Fiddle::TYPE_DOUBLE],# args is an Array of arguments, passed to the ptr function.Fiddle::TYPE_DOUBLE# ret_type is the return type of the function)# Equivalent to: floor(3.14159);floor.call(3.14159)#=> 3.0
V (Vlang) can include and supports the use of C source code and libraries.[24]
Visual Basic has a declarative syntax that allows it to call non-Unicode C functions.
Wolfram Language provides a technology named Wolfram Symbolic Transfer Protocol (WSTP) which enables bidirectional calling of code between other languages with bindings for C++, Java,.NET. and other languages.
Zig provides FFI to C using the builtincImport function.[25]
In addition, many FFIs can be generated automatically: for example,SWIG. However, in the case of anextension language a semantic inversion of the relationship of guest and host can occur, when a smaller body of extension language is the guest invoking services in the larger body of host language, such as writing a small plugin[26] for GIMP.[27]
Some FFIs are restricted to free standingfunctions, while others also allow calls of functions embedded in an object or class (often calledmethod calls); some even permit migration of complex datatypes or objects across the language boundary.
Many FFIs also provide the means for the called language to invoke services in the host language also.
The term foreign function interface is generally not used to describe multi-lingual runtimes such as the MicrosoftCommon Language Runtime, where a commonsubstrate is provided which enables any CLR-compliant language to use services defined in any other. (However, in this case the CLR does include an FFI,P/Invoke, to call outside the runtime.) In addition, many distributed computing architectures such as theJava remote method invocation (RMI), RPC,CORBA,SOAP andD-Bus permit different services to be written in different languages; such architectures are generally not considered FFIs.
There are some special cases, in which the languages compile into the same bytecode VM, likeClojure andJava, as well asElixir andErlang. Since there is no interface, it is not an FFI, strictly speaking, while it offers the same functions to the user.
^"FFI Introduction".HaskellWiki. Retrieved19 June 2015.Haskell's FFI is used to call functions from other languages (basically C at this point), and for C to call Haskell functions.
^"std::ffi".Rust-lang.org. Retrieved1 April 2021.This module provides utilities to handle data across non-Rust interfaces, like other programming languages and the underlying operating system. It is mainly of use for FFI (Foreign Function Interface) bindings and code that needs to exchange C-like strings with other languages.
^"PHP FFI Manual".PHP Manual. Retrieved31 August 2023.Defined C variables are made available as properties of the FFI instance.
^"CFFI documentation". Retrieved19 June 2015.C Foreign Function Interface for Python. The goal is to provide a convenient and reliable way to call compiled C code from Python using interface declarations written in C.
