Callback (computer programming)

In computer programming, a callback, also known as a "call-after" function, is any executable code that is passed as an argument to other code; that other code is expected to call back the argument at a given time. This execution may be immediate as in a synchronous callback, or it might happen at a later time as in an asynchronous callback.
Programming languages support callbacks in different ways, often implementing them with subroutines, lambda expressions, blocks, or function pointers.


There are two types of callbacks, differing in how they control data flow at runtime: blocking callbacks and deferred callbacks. While blocking callbacks are invoked before a function returns, deferred callbacks may be invoked after a function returns. Deferred callbacks are often used in the context of I/O operations or event handling, and are called by interrupts or by a different thread in case of multiple threads. Due to their nature, blocking callbacks can work without interrupts or multiple threads, meaning that blocking callbacks are not commonly used for synchronization or delegating work to another thread.
Callbacks are used to program applications in windowing systems. In this case, the application supplies a specific custom callback function for the operating system to call, which then calls this application-specific function in response to events like mouse clicks or key presses. A major concern here is the management of privilege and security: whilst the function is called from the operating system, it should not run with the same privilege as the system. A solution to this problem is using rings of protection.


The form of a callback varies among programming languages:


Callbacks have a wide variety of uses, for example in error signaling: a Unix program might not want to terminate immediately when it receives SIGTERM, so to make sure that its termination is handled properly, it would register the cleanup function as a callback. Callbacks may also be used to control whether a function acts or not: Xlib allows custom predicates to be specified to determine whether a program wishes to handle an event.
The following C code demonstrates the use of callbacks to display two numbers.

  1. include
  2. include
/* The calling function takes a single callback as a parameter. */
void PrintTwoNumbers)
/* A possible callback */
int overNineThousand
/* Another possible callback. */
int meaningOfLife
/* Here we call PrintTwoNumbers with three different callbacks. */
int main

This should provide output similar to:
125185 and 89187225
9084 and 9441
42 and 42
Note how this is different from simply passing the output of the callback function to the calling function, PrintTwoNumbers - rather than printing the same value twice, the PrintTwoNumbers calls the callback as many times as it requires. This is one of the two main advantages of callbacks.
The other advantage is that the calling function can pass whatever parameters it wishes to the called functions. This allows correct information hiding: the code that passes a callback to a calling function does not need to know the parameter values that will be passed to the function. If it only passed the return value, then the parameters would need to be exposed publicly.
Another example:

* This is a simple C program to demonstrate the usage of callbacks
* The callback function is in the same file as the calling code.
* The callback function can later be put into external library like
* e.g. a shared object to increase flexibility.
  1. include
  2. include
typedef struct _MyMsg MyMsg;
void myfunc
* Prototype declaration
void ;
int main

The output after compilation:

$ gcc cbtest.c
App Id = 100
Msg = This is a test

This information hiding means that callbacks can be used when communicating between processes or threads, or through serialised communications and tabular data.


A simple callback in C#:

public class Class1
public class Class2


Callbacks are used in the implementation of languages such as JavaScript, including support of JavaScript functions as callbacks through js-ctypes and in components such as addEventListener. However, a native example of a callback can be written without any complex code:

function calculate
function calcProduct
function calcSum
// alerts 75, the product of 5 and 15
// alerts 20, the sum of 5 and 15

First a function is defined with a parameter intended for callback:. Then a function that can be used as a callback to is defined,. Other functions may be used for, like. In this example, is invoked twice, once with as a callback and once with. The functions return the product and sum, respectively, and then the alert will display them to the screen.
In this primitive example, the use of a callback is primarily a demonstration of principle. One could simply call the callbacks as regular functions,. Callbacks are generally used when the function needs to perform events before the callback is executed, or when the function does not have meaningful return values to act on, as is the case for Asynchronous JavaScript or XMLHttpRequest requests. Useful examples can be found in JavaScript libraries such as jQuery where the.each method iterates over an array-like object, the first argument being a callback that is performed on each iteration.

Red and REBOL

From the JavaScript above, here is how one would implement the same in either REBOL or Red. Notice the cleaner presentation of data as code.

calculate: func
num1 + num2
; alerts 75, the product of 5 and 15
alert form calculate 5 15 :calc-product
; alerts 20, the sum of 5 and 15
alert form calculate 5 15 :calc-sum


A color tweening example using the [Roblox engine that takes an optional.done callback:

local DT = wait
function tween_color
local step_r = finish_color.r - object.BackgroundColor3.r
local step_g = finish_color.g - object.BackgroundColor3.g
local step_b = finish_color.b - object.BackgroundColor3.b
local total_steps = 1/
local completed;
for i = 0, 1, DT* do
object.BackgroundColor3 =,
object.BackgroundColor3.g +,
object.BackgroundColor3.b +
if completed then
print "Color tweening finished!"


A classic use of callbacks in Python is to assign events to UI elements.
Here is a very trivial example of the use of a callback in Python. First define two functions, the callback and the calling code,
then pass the callback function into the calling code.

>>> def get_square:
... """The callback."""
... return val ** 2
>>> def caller:
... return func
>>> caller