nlohmann/json: The Most Pythonic JSON Library in C++

As a Java veteran who's been through the wringer with the Spring ecosystem for years, I'm genuinely excited to share this C++ gem that caught my eye: nlohmann/json. Honestly, when I first saw this project, it immediately reminded me of Java's Jackson and Gson—but this C++ JSON library really stands out!

What Kind of Magic Is This?

nlohmann/json bills itself as "JSON for Modern C++," and with over 48k stars, its reputation in the C++ community speaks volumes. What blew me away? The entire library is just one header file: json.hpp! That's right—no complex compilation, no linking libraries, just #include and you're good to go. It’s the ultimate "zero-config" dream for C++ developers.

Coming from Java, where I’m used to Maven/Gradle dependency management, discovering such a refreshingly simple library in the C++ world nearly brought tears to my eyes.

Core Design Philosophy: JSON as a Native Type

The real brilliance lies in its design philosophy—making JSON operations feel as intuitive as Python. Check out this code:

// Create a JSON object as naturally as writing a JSON literal
json j = {
  {"pi", 3.141},
  {"happy", true},
  {"name", "Niels"},
  {"nothing", nullptr},
  {"answer", {{"everything", 42}}},
  {"list", {1, 0, 2}},
  {"object", {{"currency", "USD"}, {"value", 42.99}}}
};

Reading this feels just like reading raw JSON! Plus, it seamlessly converts STL containers—std::vector<int> becomes a JSON array, and std::map<std::string, int> becomes a JSON object. Now that’s modern C++ thinking.

Installation & Usage: Simplicity Redefined

Getting started couldn’t be easier:

#include <nlohmann/json.hpp>
using json = nlohmann::json;

Just two lines! If you’re using CMake, integration via package managers is also straightforward:

find_package(nlohmann_json 3.12.0 REQUIRED)
target_link_libraries(foo PRIVATE nlohmann_json::nlohmann_json)

Advanced Features: Beyond Basic Parsing

This library goes far beyond basic serialization/deserialization. I was especially impressed by its flawless support for custom types:

// Define your struct
struct person {
    std::string name;
    std::string address;
    int age;
};

// Just these two functions enable automatic conversion
void to_json(json& j, const person& p) {
    j = json{{"name", p.name}, {"address", p.address}, {"age", p.age}};
}

void from_json(const json& j, person& p) {
    j.at("name").get_to(p.name);
    j.at("address").get_to(p.address);
    j.at("age").get_to(p.age);
}

// Then use it like this
person p = {"Ned Flanders", "744 Evergreen Terrace", 60};
json j = p;  // Automatic conversion
auto p2 = j.get<person>();  // Automatic reconstruction

Even better—it provides a macro to simplify this process:

NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(person, name, address, age)

One line does it all! This reminds me of Lombok’s @Data annotation—a true blessing for the lazy developer (like me).

Performance & Production Readiness

The author candidly admits this isn’t the fastest JSON library out there (faster alternatives exist), but it prioritizes developer productivity. With 100% test coverage, Valgrind memory checks, and 24/7 Google OSS-Fuzz testing, it’s clearly production-ready.

Note: By default, it doesn’t preserve insertion order of object keys (since the JSON spec defines objects as unordered). If you need ordered keys, use nlohmann::ordered_json.

How Would I Use It?

Though I’m a Java developer, if I ever write a C++ service, this would be my go-to JSON library. For config parsing or API response handling, its simplicity and intuitiveness would drastically boost development speed.

It also supports JSON Pointer (RFC 6901), JSON Patch (RFC 6902), JSON Merge Patch (RFC 7386), and even binary formats like BSON, CBOR, and MessagePack—making it incredibly feature-complete.

Is It Worth Deep Diving?

Absolutely! Even if you don’t write C++, studying this library’s design is enlightening. It showcases how modern C++ features (templates, operator overloading, ADL, etc.) can create elegant APIs. Plus, the single-header architecture is a masterclass in organizing complex functionality without chaos.

In short, nlohmann/json is like Jackson for C++—but cleaner, more modern, and delightfully simple. Any C++ developer working with JSON should absolutely give it a try.