ByteJSON

JSON to Zig Struct Generator

Generate Zig struct definitions from JSON data with std.json and serde.zig support. Supports optional types (?T), nested structs, and inline type definitions.

What is JSON to Zig Struct Generator?

Zig is a systems programming language designed to be a better alternative to C, with compile-time code execution, no hidden control flow, and strict safety guarantees. Its struct system is the primary way to define structured data, and the standard library includes std.json for JSON parsing and serialization. This generator converts your JSON data into Zig struct definitions with automatic type inference, mapping JSON strings to []const u8 (slice of constant bytes), integers to i64, decimals to f64, and booleans to bool. Nullable fields are handled with Zig optional types (?T), and nested objects become separate struct definitions. The tool supports two output modes: std.json for basic serialization with the standard library, and serde.zig for advanced features like automatic field renaming.

How to Use

  1. Enter a root struct name in the input field — this becomes the name of the top-level Zig struct
  2. Select output mode: std.json for basic standard library support, or serde.zig for advanced serialization features
  3. Toggle "Optional fields (?T)" to wrap nullable JSON values in Zig optional types
  4. Toggle "Inline types" to embed nested structs directly instead of creating separate declarations
  5. Paste your JSON data into the input area and click "Generate Zig Structs"
  6. Copy the output into a .zig file in your project and add any custom logic needed

Why Use This Tool?

Automatic type inference from JSON values produces correct Zig types without manual annotation
Nested struct generation with proper dependency ordering — children are defined before parents
Optional types (?T) for nullable fields make your Zig code safer by explicitly representing missing data
Slice types ([]const T) for arrays follow Zig conventions for read-only data references
serde.zig mode generates rename_all blocks for automatic JSON key mapping to camelCase field names
Inline struct types produce flat, self-contained definitions when you prefer fewer separate declarations

Tips & Best Practices

  • Provide JSON with representative values — type inference depends on actual data, so null fields default to ?[]const u8
  • Enable serde.zig mode for seamless JSON serialization and deserialization with automatic field renaming
  • Optional types (?T) wrap nullable values for safer Zig code — access them with orelse for default values or try for error handling
  • Inline types embed nested structs directly within the parent, reducing the number of separate type declarations
  • The generated code includes the std import automatically; serde.zig mode also adds the serde import

Frequently Asked Questions

How are JSON types mapped to Zig types?

JSON strings become []const u8 (slice of constant bytes), integers become i64, floats become f64, booleans become bool, null becomes ?T (optional type), arrays become []const T, and nested objects become separate Zig struct definitions. When inline types is enabled, nested objects become anonymous struct types inline.

When should I NOT use this generator?

Skip this tool if you need Zig tagged unions (e.g., a field that can be one of several struct types) — those cannot be inferred from a single JSON sample. Also, if you need custom allocators, error unions, or comptime logic in your structs, those must be added manually after generation.

What does the ?T optional type mean in Zig?

In Zig, ?T is an optional type that can hold either a value of type T or null. When "Optional fields" is enabled, JSON null values are mapped to ?T types, making your Zig structs safer by explicitly representing the possibility of missing data. Access optional values with orelse for defaults or if (value) |v| for conditional handling.

What is serde.zig?

serde.zig is a serialization and deserialization library for Zig, inspired by Rust's serde. It provides derive-style attributes like rename_all for mapping JSON keys to Zig field names, making it easy to work with JSON APIs that use camelCase or snake_case conventions while keeping your Zig code idiomatic.

What is the rename_all serde block?

In serde.zig mode, pub const serde = .{ .rename_all = .camel_case } tells the serialization library to automatically convert Zig field names (camelCase) to match JSON keys. This allows idiomatic Zig naming while working with any JSON naming convention.

Is my data sent to any external server?

No. All processing happens entirely inside your browser. Your JSON data never leaves your device, and no network requests are made during the conversion.

Real-world Examples

Defining a configuration struct with optional fields

Generate Zig structs from a JSON configuration object where some fields may be null.

Input
{
  "host": "localhost",
  "port": 8080,
  "debug": true,
  "maxConnections": null,
  "tls": {
    "certPath": "/etc/ssl/cert.pem",
    "keyPath": "/etc/ssl/key.pem"
  }
}
Output
// Generated by ByteJSON - JSON to Zig Struct Generator
const std = @import("std");

pub const Tls = struct {
    certPath: []const u8,
    keyPath: []const u8,
};

pub const Root = struct {
    host: []const u8,
    port: i64,
    debug: bool,
    maxConnections: ?i64,
    tls: Tls,
};

Using serde.zig mode for camelCase JSON keys

A JSON object with camelCase keys generates a serde block that handles the mapping automatically.

Input
{
  "userName": "alice",
  "isActive": true,
  "lastLogin": null
}
Output
// Generated by ByteJSON - JSON to Zig Struct Generator
const std = @import("std");
const serde = @import("serde.zig");

pub const serde = .{
    .rename_all = .camel_case,
};

pub const Root = struct {
    userName: []const u8,
    isActive: bool,
    lastLogin: ?[]const u8,
};

Related Tools

JSON to Rust SerdeJSON to TypeScriptJSON to PythonJSON to Go StructJSON to V Struct