WOLFRAM

Wolfram Language & System Documentation Center

BinarySerialize[expr]

gives a binary representation of any expression expr as a ByteArray object.

Details and Options
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Options  
Method  
PerformanceGoal  
Applications  
Properties & Relations  
Possible Issues  
See Also
Tech Notes
Related Guides
History
Cite this Page

BinarySerialize

BinarySerialize[expr]

gives a binary representation of any expression expr as a ByteArray object.

Details and Options

Examples

open all close all

Basic Examples  (2)

Serialize an expression:

Wolfram Language code: BinarySerialize[{1, 2, 3}]

Serialize a graphic:

Wolfram Language code: BinarySerialize[Plot[Sin[x], {x, 0, Pi}]]

Convert the serialized form back to an expression:

Wolfram Language code: BinaryDeserialize[%]

Scope  (7)

Apply BinarySerialize to symbolic expressions:

Wolfram Language code: BinarySerialize[f[Sin[g[x]]]]

Serialize an image:

Wolfram Language code: BinarySerialize[[image]]

Note that the size of the serialized form roughly equals the byte count of the expression:

Wolfram Language code: ByteCount[[image]]

BinarySerialize efficiently stores machine integers:

Wolfram Language code: BinarySerialize[2 ^ 7 - 1]
Wolfram Language code: BinarySerialize[2 ^ 15 - 1]
Wolfram Language code: BinarySerialize[2 ^ 31 - 1]

BinarySerialize efficiently stores machine reals:

Wolfram Language code: BinarySerialize[N[1234 / 5678]]

Compare with an arbitrary-precision real:

Wolfram Language code: BinarySerialize[N[1234 / 5678, 16]]

BinarySerialize efficiently stores strings:

Wolfram Language code: str = FromCharacterCode[RandomInteger[{0, 2 ^ 15}, 1000]];
Wolfram Language code: ByteCount[str]
Wolfram Language code: BinarySerialize[str]

BinarySerialize supports ByteArray:

Wolfram Language code: BinarySerialize[ByteArray[RandomInteger[255, 1000]]]

BinarySerialize supports packed arrays:

Wolfram Language code: ints = RandomInteger[2 ^ ($SystemWordLength - 2), 1000]; reals = RandomReal[1, 1000]; complexes = RandomComplex[{0, 1 + I}, 1000];
Wolfram Language code: ByteCount /@ {ints, reals, complexes}
Wolfram Language code: BinarySerialize /@ {ints, reals, complexes}

Options  (4)

Method  (3)

Create a packed array of integer values:

Wolfram Language code: integers = ConstantArray[2 ^ 14, 3];

By default, BinarySerialize uses the smallest integer type that fits the data:

Wolfram Language code: BinarySerialize[integers]

Serialize the packed array using a bigger integer type:

Wolfram Language code: BinarySerialize[integers, Method -> "PackedArrayIntegerType" -> "Integer32"]

Create a packed array of real values:

Wolfram Language code: reals = RandomReal[1, 3]

Serialize the array:

Wolfram Language code: real64 = BinarySerialize[reals]

Serialize the array using machine floats, trading precision for a smaller output:

Wolfram Language code: real32 = BinarySerialize[reals, Method -> "PackedArrayRealType" -> "Real32"]

Create a packed array of complex values:

Wolfram Language code: complexes = RandomComplex[1 + I, 3]

Serialize the array:

Wolfram Language code: BinarySerialize[complexes]

Serialize the array using lower precision:

Wolfram Language code: BinarySerialize[complexes, Method -> {"PackedArrayComplexType" -> "Complex64"}]

PerformanceGoal  (1)

Serialize a Dataset:

Wolfram Language code: data = ExampleData[{"NetworkGraph", "AstrophysicsCollaborations"}];
Wolfram Language code: uncompressed = BinarySerialize[data]

Serialize the same Dataset with PerformanceGoal set to "Size":

Wolfram Language code: compressed = BinarySerialize[data, PerformanceGoal -> "Size"]

Both forms represent the same expression:

Wolfram Language code: BinaryDeserialize[uncompressed] == BinaryDeserialize[compressed]

Applications  (1)

Serialize a trained neural network:

Wolfram Language code: bin = BinarySerialize[NetTrain[NetGraph[{LinearLayer[1], LinearLayer[3], LinearLayer[3], LinearLayer["Real"]}, {1 -> 2 -> 3 -> 4}, "Input" -> "Real"], {.1 -> .07, .25 -> .24, .3 -> .32, .5 -> .5}, MaxTrainingRounds -> 1000]]

Create a new file:

Wolfram Language code: file = CreateFile[];

Open an output binary stream:

Wolfram Language code: ow = OpenWrite[file, BinaryFormat -> True]

Write the serialized expression to the file:

Wolfram Language code: BinaryWrite[ow, bin]
Wolfram Language code: Close[ow];

Read the data from the file:

Wolfram Language code: nettrained = BinaryDeserialize[ByteArray[BinaryReadList[file, "Byte"]]]

Plot the prediction of the net as a function of the input:

Wolfram Language code: Plot[nettrained[x], {x, 0, 5}]

Properties & Relations  (4)

Using PerformanceGoal->"Speed" is faster but produces larger outputs:

Wolfram Language code: data = Range[10 ^ 6];
Wolfram Language code: BinarySerialize[data, PerformanceGoal -> "Speed"]//AbsoluteTiming

Using PerformanceGoal->"Size" is slower but produces smaller outputs:

Wolfram Language code: BinarySerialize[data, PerformanceGoal -> "Size"]//AbsoluteTiming

BinarySerialize encodes strings as UTF-8:

Wolfram Language code: bytes = BinarySerialize["→ hello there ←"]
Wolfram Language code: ByteArrayToString[bytes, "UTF-8"]

BinaryDeserialize is the inverse of BinarySerialize:

Wolfram Language code: BinaryDeserialize[BinarySerialize[x]] === x

DumpSave stores definitions attached to a symbol in a file:

Wolfram Language code: f[x_] := x ^ 2
Wolfram Language code: mx = FileNameJoin[{$TemporaryDirectory, "f.mx"}]; DumpSave[mx, f];

Using Get will return Null but restore the value of f:

Wolfram Language code: Clear[f]; restored = Get[mx]; DeleteFile[mx]; {restored, f[x]}

BinarySerialize only stores the input expression, which can be restored by BinaryDeserialize:

Wolfram Language code: BinarySerialize[f]; Clear[f]; restored = BinaryDeserialize[%%]; {restored, f[x]}

Possible Issues  (2)

From small expressions, PerformanceGoal->"Size" may not produce smaller outputs:

Wolfram Language code: BinarySerialize[{1, 2, 3}, PerformanceGoal -> "Size"]
Wolfram Language code: BinarySerialize[{1, 2, 3}]

The Method parameter "PackedArrayIntegerType" must be chosen consistently with the data:

Wolfram Language code: BinarySerialize[ConstantArray[2 ^ 17, 3], Method -> {"PackedArrayIntegerType" -> "Integer16"}]

These values require 32-bit integers:

Wolfram Language code: BinarySerialize[ConstantArray[2 ^ 17, 3], Method -> {"PackedArrayIntegerType" -> "Integer32"}]

A setting of Automatic will always use a size that fits the data:

Wolfram Language code: BinarySerialize[ConstantArray[2 ^ 17, 3], Method -> {"PackedArrayIntegerType" -> Automatic}]
Wolfram Research (2017), BinarySerialize, Wolfram Language function, https://reference.wolfram.com/language/ref/BinarySerialize.html (updated 2018).

Text

Wolfram Research (2017), BinarySerialize, Wolfram Language function, https://reference.wolfram.com/language/ref/BinarySerialize.html (updated 2018).

CMS

Wolfram Language. 2017. "BinarySerialize." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2018. https://reference.wolfram.com/language/ref/BinarySerialize.html.

APA

Wolfram Language. (2017). BinarySerialize. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/BinarySerialize.html

BibTeX

@misc{reference.wolfram_2026_binaryserialize, author="Wolfram Research", title="{BinarySerialize}", year="2018", howpublished="\url{https://reference.wolfram.com/language/ref/BinarySerialize.html}", note=[Accessed: 13-June-2026]}

BibLaTeX

@online{reference.wolfram_2026_binaryserialize, organization={Wolfram Research}, title={BinarySerialize}, year={2018}, url={https://reference.wolfram.com/language/ref/BinarySerialize.html}, note=[Accessed: 13-June-2026]}