An application binary interface (ABI) is the contract between two pieces of compiled code: it fixes how functions are called, how arguments and return values are passed, and how data is laid out in memory. An API says which functions exist in source code; the ABI says how already-compiled programs call them. On Ethereum the Contract ABI plays the same role: it is the standard way wallets, apps and other contracts encode calls to a smart contract.
How it works
Where you see it today
Microsoft’s Arm64EC is an ABI for Windows 11 on Arm devices. Code built as Arm64EC runs natively and interoperates with x64 code running under emulation in the same process, so developers can move an app to Arm piece by piece; Microsoft cites accelerated AI and ML workloads among the benefits.
NVIDIA’s CUDA Compatibility rules define when applications built with a newer CUDA toolkit can run on an existing driver, such as Minor Version Compatibility within a major release family. Data centres rely on this because driver updates follow different schedules from application updates.
Much of the Python AI stack ships compiled extension modules. PEP 384 defined a stable ABI for Python 3 so an extension that restricts itself to that subset can work across feature releases without being rebuilt.
Every wallet, block explorer or automated agent that calls an Ethereum contract needs its ABI to encode the call and decode the result. The encoding is not self-describing, so without the schema the bytes cannot be read.
ABI vs related ideas
How to use it
- Treat the ABI of any library you ship as a public promise: changing a structure's layout can break users who never recompile.
- When you build Python extensions, target the stable ABI if you can, so one build works across more Python versions.
- Before moving software to Arm devices, list which binaries and plugins need recompiling and which can run under emulation.
- Pin and test the GPU driver and CUDA toolkit combination that your AI workloads depend on, using the vendor's documented compatibility rules.
- Publish and verify the ABI of every smart contract you deploy, so wallets and other contracts can call it correctly.
Binary compatibility decides how cheaply a platform can change underneath its users: a stable ABI lets an ecosystem upgrade hardware, drivers or runtimes without forcing every developer to rebuild. In the AI build-out that makes compatibility layers, from GPU drivers to Arm transitions, part of the moat as much as raw performance.
Read: The Agent-Native API →Explore the platform →Related: Smart contracts · Blockchain protocol · ERC-20 token · Hard fork · Web3
Frequently asked questions
What is an application binary interface?
It is the set of rules that lets separately compiled code work together: how functions are called, how arguments are passed and how data is laid out in memory.
What is the difference between an API and an ABI?
An API defines what you can call in source code; an ABI defines how compiled code actually makes that call at the machine level.
What is an ABI in Ethereum?
The Contract ABI is the standard way to encode calls to a smart contract, from outside the chain or from another contract, and to decode what it returns.
Why does ABI stability matter?
If the ABI stays the same, existing compiled programs keep working when a library, runtime or operating system is updated, without being rebuilt.
Sources
- Solidity documentation, Contract ABI Specification
- Microsoft Learn, Arm64EC: Build and port apps for native performance on Arm
- NVIDIA, CUDA Compatibility guide
- von Löwis (2009), PEP 384: Defining a Stable ABI, Python Enhancement Proposals
The full guide
The complete explainer, cleaned up and reformatted for mobile.

An ABI is a contract between pieces of binary code defining the mechanisms by which functions are invoked and how parameters are passed between the caller and callee.
An Application Binary Interface (ABI) is a set of rules and conventions that dictate how binary code or machine code communicates and interacts with other binary code, particularly in the context of software libraries, operating systems, or hardware.
While the API lists the functions that may be called, the ABI dictates how each function may be called.
Embedded ABIs (EABIs) specify conventions for register usage, data types, stack frame organization, and file formats for use in an embedded operating system.
Layout refreshed 6 October 2026. The article text below is unchanged.
ABIs have become critical in the development of applications leveraging smart contracts, on Blockchain protocols like Ethereum.
ABIs are crucial for binary compatibility and the proper functioning of software systems.
ABIs are essential in a wide range of software and hardware systems, including operating systems, software libraries, device drivers, and firmware.
Visual overview and quick answers (tap to expand)
An Application Binary Interface (ABI) is the interface between two binary program modules that work together. An ABI is a contract between pieces of binary code defining the mechanisms by which functions are invoked and how parameters are passed between the caller and callee. ABIs have become critical in the development of applications leveraging smart contracts, on Blockchain protocols like Ethereum.
Understanding an Application Binary Interface
In understanding an Application Binary Interface, it can be helpful to first define the Application Programming Interface (API).
Think of an API as a contract between pieces of source code. This contract defines the return value and parameters of a function and dictates whether inheritance is allowed. An API is enforced by a compiler, or a program converting instructions into a format that can be read and executed by a compute — as explored in the economics of AI compute infrastructure — r. In other words, the API contains instructions on what the source code can and cannot do as part of a platform operating system.
An ABI, on the other hand, is a contract between pieces of binary code. An Application Binary Interface defines the mechanisms by which functions are invoked and how parameters are passed between the caller and callee. The ABI also governs how programs are loaded into memory and how libraries are implemented. Indeed, the ABI is enforced by the linker – defined as a program used with a compiler to provide links to libraries needed for an executable program.
This means the ABI contains rules on how unrelated code must work together and how processes should coexist on the same system. While the API lists the functions that may be called, the ABI dictates how each function may be called. ABIs are commonly established between user programs and libraries but also in OS services and programming languages.
Application Binary Interface functions
ABIs cover a variety of functions, including
- Processor instruction sets that denote details such as memory access types and register file structure.
- How an application makes system calls to the OS and whether direct systems calls or procedure calls are used to system call stubs.
- Basic data type layout, size, and alignment.
Calling convention, which dictates how arguments of functions are passed and return values retrieved. Calling convention controls which parameters are passed on the stack and which are passed in registers. It also assigns registers to function parameters and determines whether the first function parameter passed on the stack is pushed first or last.
Complete and embedded ABIs
Complete ABIs
A complete ABI enables a program from the OS supporting it to run without modifications on any similar system. This is on the proviso that shared libraries exist and similar prerequisites are satisfied.
For example, the Intel Binary Compatibility Standard (iBCS) is the standardized ABI for Unix operating systems on Intel-compatible computers.
Embedded ABIs
Embedded ABIs (EABIs) specify conventions for register usage, data types, stack frame organization, and file formats for use in an embedded operating system.
Object code created by compilers to support the EABI is compatible with the code generated by other compilers. This enables developers to link the library generated with one compiler with the library generated by another using object code.
Ultimately, embedded ABIs are designed for performance optimization. Operating within the limits of an embedded system, the ABI removes the majority of abstractions made between kernel and user code in complex operating systems.
Key takeaways
An Application Binary Interface is the interface between two binary program module programs allowing them to work together.
While an Application Programming Interface (API) is a contract between two pieces of source code, an ABI is a contract between two sources of binary code. The ABI also dictates how functions may be called from the API.
Application Binary Interfaces are present in several scenarios. They influence processor instruction sets and determine how an application makes system calls to the OS. An ABI also dictates the layout, size, and alignment of basic data types.
Connected · ABI Application Binary Interface
Where to go next from ABI Application Binary Interface
Picked for this page by topic. Every link checked live.
The Business Engineer readThe Agent-Native APIRead on businessengineer.ai →More on ABI Application Binary Interface: Blockchain Flywheel
















