LEB128 (Little Endian Base 128) is a variable-length encoding for integers. Each byte holds 7 bits of the number plus one continuation flag, so small values take fewer bytes. WebAssembly binaries and the DWARF debug format both use it heavily.

What is the difference between unsigned and signed LEB128?

Unsigned LEB128 encodes non-negative integers by emitting 7-bit groups until the value is exhausted. Signed LEB128, or SLEB128, uses an arithmetic right shift and stops based on the sign bit of the final group, so it can round-trip negative numbers correctly.

How is the continuation bit used?

The high bit (0x80) of each byte is the continuation flag. It is set on every byte except the last, telling the decoder that more 7-bit groups follow. The decoder keeps reading until it sees a byte with that bit cleared.

Why are the low bits emitted first?

LEB128 is little-endian: the least significant 7 bits are written in the first byte and higher groups follow. When decoding, each group is shifted left by an increasing multiple of 7 before being combined.

Does it handle very large integers?

Yes. Both encoding and decoding use JavaScript BigInt, so 64-bit and larger values are exact. The signed decoder also sign-extends correctly so negatives reconstruct without overflow.

What is the LEB128 Encoder/Decoder?

Encode and decode integers using LEB128, the variable-length integer format used by WebAssembly and DWARF. Supports both unsigned LEB128 and signed SLEB128, with BigInt precision and hex byte output. Runs in your browser. It runs free in your browser on Gera Tools, with nothing uploaded.

LEB128 Encoder/Decoder

Name: LEB128 Encoder/Decoder
Creator: Gera Tools
License: https://creativecommons.org/licenses/by/4.0/

Get one useful tool a week

Like this tool? Enter your email and we'll send you one genuinely useful Gera tool a week — plus a link to come back to this one. No spam, one-click unsubscribe any time.

LEB128, short for Little Endian Base 128, is the variable-length integer encoding used inside WebAssembly modules and the DWARF debugging format. This tool converts an integer to its LEB128 byte sequence and back, in both the unsigned and the signed (SLEB128) variants.

How it works

Each output byte carries 7 bits of the number in its low bits and a continuation flag in its high bit (0x80). For unsigned encoding the value is shifted right 7 bits at a time; the continuation bit is set on every byte except the last:

624485 -> E5 8E 26
  byte0 = 0xE5 (continuation set)
  byte1 = 0x8E (continuation set)
  byte2 = 0x26 (last byte)

Signed encoding (SLEB128) uses an arithmetic right shift so the sign propagates, and it stops once the remaining value is 0 (for non-negatives) or -1 (for negatives) and the sign bit of the final 7-bit group already matches. Decoding reverses the process: combine each group with a left shift of 7 times its index, and for signed values sign-extend if the final group’s bit 0x40 is set.

Where LEB128 appears in practice

WebAssembly binary format uses unsigned LEB128 for every integer constant, function index, local index, type index, and section length in the .wasm binary. This is why hand-disassembling a .wasm file requires knowing how to strip continuation bits. DWARF — the debug information format embedded in ELF and Mach-O binaries — uses both unsigned and signed LEB128 heavily in its abbreviation tables, attribute values, and line-number program instructions.

Signed vs unsigned: a concrete difference

The integer -123456 encoded as SLEB128 and as unsigned LEB128 gives different byte sequences, because the sign bit determines when the encoding can stop:

Unsigned: cannot represent -123456 (negatives are undefined in unsigned LEB128).
Signed (SLEB128): encodes as C0 BB 78 (3 bytes), using arithmetic right shift and sign-bit checking to terminate correctly.

If you paste SLEB128 bytes into the unsigned decoder, you will get a completely wrong (and usually very large) integer, since the sign extension bits are treated as data. Always match the mode to your data source.

Tips and edge cases

When decoding, separate bytes with spaces or commas; tokens like E5, 0xE5, or 229 are all accepted. Mixed formats work fine.
The last byte you supply must have its continuation bit cleared (high bit = 0). If all your bytes have the high bit set, the decoder reports the input as incomplete — a common mistake when copying a truncated byte sequence.
Encoding 0 produces exactly one zero byte. This is the canonical minimal form used in WebAssembly for zero-valued immediates.
For signed data, always select SLEB128. Decoding negative numbers with the unsigned decoder will produce an astronomically large positive integer.
This tool uses JavaScript BigInt internally, so values beyond 64-bit integers encode and decode correctly without overflow.