---
name: "endian"
section: "3"
platform: "linux"
package: "man-pages"
version: "6.19-1"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/endian"
---

# endian(3)

convert values between host and big-/little-endian byte order

## NAME

htobe16, htole16, be16toh, le16toh, htobe32, htole32, be32toh, le32toh, htobe64, htole64, be64toh, le64toh - convert values between host and big-/little-endian byte order

## LIBRARY

Standard C library (*libc*, *-lc*)

## SYNOPSIS

```
#include <endian.h>
```

**uint16\_t htobe16(uint16\_t** *host\_16bits***);** **uint16\_t htole16(uint16\_t** *host\_16bits***);** **uint16\_t be16toh(uint16\_t** *big\_endian\_16bits***);** **uint16\_t le16toh(uint16\_t** *little\_endian\_16bits***);**

**uint32\_t htobe32(uint32\_t** *host\_32bits***);** **uint32\_t htole32(uint32\_t** *host\_32bits***);** **uint32\_t be32toh(uint32\_t** *big\_endian\_32bits***);** **uint32\_t le32toh(uint32\_t** *little\_endian\_32bits***);**

**uint64\_t htobe64(uint64\_t** *host\_64bits***);** **uint64\_t htole64(uint64\_t** *host\_64bits***);** **uint64\_t be64toh(uint64\_t** *big\_endian\_64bits***);** **uint64\_t le64toh(uint64\_t** *little\_endian\_64bits***);**

Feature Test Macro Requirements for glibc (see [**feature\_test\_macros**(7)](/feature_test_macros/7.md)):

**htobe16**(), **htole16**(), **be16toh**(), **le16toh**(), **htobe32**(), **htole32**(), **be32toh**(), **le32toh**(), **htobe64**(), **htole64**(), **be64toh**(), **le64toh**():

```
    Since glibc 2.19:
        _DEFAULT_SOURCE
    In glibc up to and including 2.19:
        _BSD_SOURCE
```

## DESCRIPTION

These functions convert the byte encoding of integer values from the byte order that the current CPU (the "host") uses, to and from little-endian and big-endian byte order.

The number, *nn*, in the name of each function indicates the size of integer handled by the function, either 16, 32, or 64 bits.

The functions with names of the form "htobe*nn*" convert from host byte order to big-endian order.

The functions with names of the form "htole*nn*" convert from host byte order to little-endian order.

The functions with names of the form "be*nn*toh" convert from big-endian order to host byte order.

The functions with names of the form "le*nn*toh" convert from little-endian order to host byte order.

## VERSIONS

Similar functions are present on the BSDs, where the required header file is *\<sys/endian.h\>* instead of *\<endian.h\>*. Unfortunately, NetBSD, FreeBSD, and glibc haven't followed the original OpenBSD naming convention for these functions, whereby the *nn* component always appears at the end of the function name (thus, for example, in NetBSD, FreeBSD, and glibc, the equivalent of OpenBSDs "betoh32" is "be32toh").

## STANDARDS

None.

## HISTORY

glibc 2.9.

These functions are similar to the older [**byteorder**(3)](/byteorder/3.md) family of functions. For example, **be32toh**() is identical to **ntohl**().

The advantage of the [**byteorder**(3)](/byteorder/3.md) functions is that they are standard functions available on all UNIX systems. On the other hand, the fact that they were designed for use in the context of TCP/IP means that they lack the 64-bit and little-endian variants described in this page.

## EXAMPLES

The program below display the results of converting an integer from host byte order to both little-endian and big-endian byte order. Since host byte order is either little-endian or big-endian, only one of these conversions will have an effect. When we run this program on a little-endian system such as x86-32, we see the following:

```
$ ./a.out;
x.u32 = 0x44332211
htole32(x.u32) = 0x44332211
htobe32(x.u32) = 0x11223344
```

### Program source

```
#include <endian.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
int
main(void)
{
    union {
        uint32_t u32;
        uint8_t arr[4];
    } x;
    x.arr[0] = 0x11;	/* Lowest-address byte */
    x.arr[1] = 0x22;
    x.arr[2] = 0x33;
    x.arr[3] = 0x44;	/* Highest-address byte */
    printf("x.u32 = %#x\n", x.u32);
    printf("htole32(x.u32) = %#x\n", htole32(x.u32));
    printf("htobe32(x.u32) = %#x\n", htobe32(x.u32));
    exit(EXIT_SUCCESS);
}
```

## SEE ALSO

[**bswap**(3)](/bswap/3.md), [**byteorder**(3)](/byteorder/3.md)