msgpack-d 1.0.0-beta.6

MessagePack for D.

To use this package, put the following dependency into your project's dependencies section:


Build Status

MessagePack for D

MessagePack is a binary-based JSON-like serialization library.

MessagePack for D is a pure D implementation of MessagePack.


  • Small size and High performance
  • Zero copy serialization / deserialization
  • Streaming deserializer for non-contiguous IO situation
  • Supports D features (Ranges, Tuples, real type)

Note: The real type is only supported in D. Don't use the real type when communicating with other programming languages. Note that Unpacker will raise an exception if a loss of precision occurs.

Current Limitations

  • No circular references support
  • If you want to use the LDC compiler, you need at least version 0.15.2 beta2


Use dub to add it as a dependency:

% dub install msgpack-d


Example code can be found in the example directory.

The documentation can be found here

pack / unpack

msgpack-d is very simple to use. Use pack for serialization, and unpack for deserialization:

import std.file;
import msgpack;

struct S { int x; float y; string z; }

void main()
    S input = S(10, 25.5, "message");

    // serialize data
    ubyte[] inData = pack(input);

    // write data to a file
    write("file.dat", inData);

    // read data from a file
    ubyte[] outData = cast(ubyte[])read("file.dat");

    // unserialize the data
    S target = outData.unpack!S();

    // verify data is the same
    assert(target.x == input.x);
    assert(target.y == input.y);
    assert(target.z == input.z);

Feature: Skip serialization/deserialization of a specific field.

Use the @nonPacked attribute:

struct User
    string name;
    @nonPacked int level;  // pack / unpack will ignore the 'level' field

Feature: Use your own serialization/deserialization routines for custom class and struct types.

msgpack-d provides the functions registerPackHandler / registerUnpackHandler to allow you to use custom routines during the serialization or deserialization of user-defined class and struct types. This feature is especially useful when serializing a derived class object when that object is statically typed as a base class object.

For example:

class Document { }
class XmlDocument : Document
    this() { }
    this(string name) { = name; }
    string name;

void xmlPackHandler(ref Packer p, ref XmlDocument xml)

void xmlUnpackHandler(ref Unpacker u, ref XmlDocument xml)

void main()
    /// Register the 'xmlPackHandler' and 'xmlUnpackHandler' routines for
    /// XmlDocument object instances.
    registerPackHandler!(XmlDocument, xmlPackHandler);
    registerUnpackHandler!(XmlDocument, xmlUnpackHandler);

    /// Now we can serialize/deserialize XmlDocument object instances via a
    /// base class reference.
    Document doc = new XmlDocument("test.xml");
    auto data = pack(doc);
    XmlDocument xml = unpack!XmlDocument(data);
    assert( == "test.xml");  // is "test.xml"

The PackerImpl / Unpacker / StreamingUnpacker types

These types are used by the pack and unpack functions.

See the documentation of PackerImpl, Unpacker and StreamingUnpacker for more details.

The official MessagePack protocol website.

Use this issue tracker to review and file bugs in msgpack-d.

Other language bindings and implementations of the msgpack protocol can be found here.

Copyright (c) 2010- Masahiro Nakagawa


Distributed under the Boost Software License, Version 1.0.

  • Masahiro Nakagawa
1.0.0-beta.6 2017-Jan-19
1.0.0-beta.5 2016-Nov-04
1.0.0-beta.4 2016-Sep-14
1.0.0-beta.3 2016-Mar-14
1.0.0-beta.2 2015-May-26
Show all 18 versions
Download Stats:
  • 21 downloads today

  • 199 downloads this week

  • 1236 downloads this month

  • 33965 downloads total

Short URL: