Hand-drawn Business Engineer cover: ABI contract between two binary program modules. ABI Application Binary Interface: Blockchain Guide 2026

ABI Application Binary Interface: Blockchain Guide 2026

Updated October 2026 · reviewed for today
In short

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.

ABI Application Binary Interface: hand-drawn explainer by The Business Engineer
Drawing by The Business Engineer.

How it works

01
Calling convention
Which arguments go in registers and which on the stack, who cleans up, and where the return value lands.
02
Data layout
The size, alignment and byte order of basic types and structures, so both sides read memory the same way.
03
System and file conventions
How a program asks the operating system for services and how object files and libraries are formatted and linked.
04
The Ethereum version
The Solidity Contract ABI encodes each call as a function selector, the first four bytes of the call data, followed by the arguments encoded by type.

Where you see it today

AI PCs on Arm

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.

GPU software stacks

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.

Python for machine learning

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.

Smart contracts and agents

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

API
What it fixesFunction names, parameters and types in source code
Who must agreeProgrammers and the compiler
ABI
What it fixesCalling convention, data layout and binary formats of compiled code
Who must agreeCompilers, linkers, the OS and libraries
Embedded ABI (EABI)
What it fixesRegister use, data types, stack frames and file formats for embedded systems
Who must agreeToolchains for one processor family
Stable ABI
What it fixesA subset promised not to change across releases
Who must agreeA platform and its extension authors (e.g. Python's PEP 384)
Ethereum Contract ABI
What it fixesHow calls to a contract and its results are encoded
Who must agreeContracts, wallets and apps

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.
The Business Engineer lens

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

The full guide

The complete explainer, cleaned up and reformatted for mobile.

Hand-drawn Business Engineer cover: ABI contract between two binary program modules. ABI Application Binary Interface: Blockchain Guide 2026
FourWeekMBABusiness EngineerAt a glance

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.

Why it mattersFrom the article

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)
BUSINESS CONCEPT

Application Binary Interface And Why It Matters To Understand Blockchain Business Models

An Application Binary Interface — as explored in the interface layer wars reshaping consumer tech — (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. In understanding an Application Binary Interface, it can be helpful to first define the Application Programming Interface (API).

Key Components
Understanding an Application Binary Interface
In understanding an Application Binary Interface, it can be helpful to first define the Application Programming Interface (API).
Application Binary Interface functions
ABIs cover a variety of functions, including:
Real-World Examples
Apple Facebook Google Ibm Intel Twitter
Quick Answers
What is an Application Binary Interface?
In understanding an Application Binary Interface, it can be helpful to first define the Application Programming Interface (API).
What are the application binary interface functions?
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.
Key Insight
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.
Exec Package + Claude OS Master Skill | Business Engineer Founding Plan
FourWeekMBA x Business Engineer | Updated 2026

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.

Definition
ExplanationAn 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. The ABI defines data structures, calling conventions, register usage, and other low-level details that ensure compatibility and interoperability between different software components. It acts as an interface between high-level programming languages and the machine code, allowing programs written in various languages to work together seamlessly. ABIs are crucial for binary compatibility and the proper functioning of software systems.
Key Concepts
Explanation– Binary Compatibility: ABIs ensure that compiled binary code can interact with other binary code without conflicts or errors. – Calling Conventions: ABIs specify how functions or procedures are called and how parameters are passed between functions. – Data Layout: They define how data structures are represented in memory, including alignment, padding, and byte order. – Register Usage: ABIs dictate how registers are used for function arguments and return values. – Exception Handling: Some ABIs define how exceptions and errors are handled.
Characteristics
Explanation– Standardization: ABIs are standardized to ensure compatibility across different platforms and compilers. – Low-Level: ABIs deal with low-level details of binary code, making them essential for interoperability. – Compiler Specific: While ABIs follow standards, they can still be compiler-specific, leading to variations between different compilers. – Binary Interoperability: ABIs enable different binary modules to work together regardless of the high-level programming language used to create them.
Implications
Explanation– Interoperability: ABIs enable software components written in different languages to communicate and function together. – Compatibility: A stable ABI lets existing compiled code keep working when a library or runtime is updated, as long as the binary rules do not change. – Portability: Applications compiled for one platform can be used on another platform if the ABIs match. – Maintenance: Maintaining a stable ABI is crucial for backward compatibility and the success of software libraries.
Advantages
Explanation– Interoperability: ABIs allow software written in different languages to work together seamlessly. – Portability: Software compiled with a particular ABI can be run on different platforms with compatible ABIs. – Efficiency: ABIs are designed to optimize the interaction between software components at the binary level. – Compatibility: Changes to source code or compilers do not necessarily break binary compatibility if the ABI remains stable.
Drawbacks
Explanation– Complexity: ABIs can be complex, particularly in heterogeneous environments with multiple programming languages. – Compiler Dependencies: ABIs can be influenced by the choice of compiler, leading to variations. – Maintenance: Ensuring backward compatibility with previous ABIs can be challenging when making updates or changes. – Inflexibility: Changes to the ABI can be limited due to compatibility concerns.
Applications
ExplanationABIs are essential in a wide range of software and hardware systems, including operating systems, software libraries, device drivers, and firmware. They are particularly crucial in the development of application programming interfaces (APIs), system-level programming, and cross-language development.
Use Cases
Explanation– Operating Systems: ABIs define how user-level applications interact with the operating system kernel. – Software Libraries: ABIs ensure that software libraries can be used by applications written in various programming languages. – Device Drivers: ABIs are vital for device drivers that communicate with hardware components. – Cross-Language Development: ABIs enable the development of software that combines multiple programming languages, such as using a C library from a Python program. – Embedded Systems: ABIs play a role in embedded system development, where efficient communication with hardware is crucial.

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 Agent-Native APIThe Business Engineer readThe Agent-Native APIRead on businessengineer.ai →

More on ABI Application Binary Interface: Blockchain Flywheel

Scroll to Top
FourWeekMBA