2026.08.12.4¶
Speed up large JSON documents rendered as Rust
serde_json::Valuewhile preserving runtime type checking and generated output.Preserve standalone YAML comments between top-level sequence items.
Stop TypeScript call-result variable bindings from deriving type annotations from the input argument row.
Render Dhall multi-argument calls as curried function application.
Escape non-ASCII characters in Perl double-quoted string literals as
\x{HHHH}, so the output no longer requiresuse utf8;in the surrounding source file.Under the Rust
RECORDheterogeneous strategy, dicts with the same key set but conflicting field types (for example a nested record with different fields, or a differing scalar type under one key) no longer share one generated struct, which silently emitted field types that failed to compile. Such dicts now resolve to distinct record shapes: conflicting groups that never share a list each render as a separate struct that compiles, while sibling lists spanning them raiseHeterogeneousSiblingListsError. Arecord_shape_namesentry whose key set splits this way raisesUnrepresentableInputError, since one custom name cannot identify one generated struct.Under the Go
RECORDheterogeneous strategy, dicts with the same key set but conflicting field types (for example a nested record with different fields, or a differing scalar type under one key) no longer share one generated struct, which silently emitted field types that failed to compile. Such dicts now resolve to distinct record shapes: conflicting groups that never share a list each render as a separate struct that compiles, while sibling lists spanning them raiseHeterogeneousSiblingListsError. Arecord_shape_namesentry whose key set splits this way raisesUnrepresentableInputError, since one custom name cannot identify one generated struct. This ports the Rust field-type split to the shared record strategy behind an opt-in flag; the remainingRECORDlanguages follow in later increments.Under the Java
RECORDheterogeneous strategy, dicts with the same key set but conflicting field types (for example a nested record with different fields, or a differing scalar type under one key) no longer share one generatedrecord, which silently emitted field types that failed to compile (incompatible types: String cannot be converted to int). Such dicts now resolve to distinct record shapes: conflicting groups that never share a list each render as a separaterecordthat compiles, while sibling lists spanning them raiseHeterogeneousSiblingListsError. Arecord_shape_namesentry whose key set splits this way raisesUnrepresentableInputError, since one custom name cannot identify one generated declaration. This ports the shared field-type split (issue #2888) to Java.Under the Swift
RECORDheterogeneous strategy, dicts with the same key set but conflicting field types (for example a nested record with different fields, or a differing scalar type under one key) no longer share one generatedstruct, which silently emitted field types that failed to compile. Such dicts now resolve to distinct record shapes: conflicting groups that never share a list each render as a separatestructthat compiles, while sibling lists spanning them raiseHeterogeneousSiblingListsError. This ports the shared field-type split (issue #2888) to Swift as part of issue #2961.Under the Zig
RECORDheterogeneous strategy, dict keys that collide with a Zig keyword (for exampleerrororswitch) now render as quoted identifiers (@"error") in both the generatedstructdeclaration and its literals, so the output compiles instead of failing witherror: expected '.', found ':'. A key that is not identifier-shaped text is escaped the same way.Under the Zig
RECORDheterogeneous strategy, dicts with the same key set but conflicting field types (for example a nested record with different fields, or a differing scalar type under one key) no longer share one generatedstruct, which silently emitted field types that failed to compile. Such dicts now resolve to distinct record shapes: conflicting groups that never share a list each render as a separatestructthat compiles, while sibling lists spanning them raiseHeterogeneousSiblingListsError. A record field key that is a Zig keyword (such aserror) is now quoted as@"error"so the generatedstructcompiles. This ports the shared field-type split (issue #2888) to Zig as part of issue #2961.Add explicit C++ language-version targets:
Cpp.version_formats.CPP14,CPP17, andCPP20.CPP20remains the default; callers can select an older target withCpp(language_version=Cpp.version_formats.CPP17).Under the Kotlin
RECORDheterogeneous strategy, dicts with the same key set but conflicting field types (for example a nested record with different fields, or a differing scalar type under one key) no longer share one generateddata class, which silently emitted field types that failed to compile. Such dicts now resolve to distinct record shapes: conflicting groups that never share a list each render as a separatedata classthat compiles, while sibling lists spanning them raiseHeterogeneousSiblingListsError. Arecord_shape_namesentry whose key set splits this way raisesUnrepresentableInputError, since one custom name cannot identify one generated declaration. This ports the shared field-type split (issue #2888) to Kotlin as part of issue #2961.Under the Scala
RECORDheterogeneous strategy, dicts with the same key set but conflicting field types (for example a nested record with different fields, or a differing scalar type under one key) no longer share one generatedcase class, which silently emitted field types that failed to compile. Such dicts now resolve to distinct record shapes: conflicting groups that never share a list each render as a separatecase classthat compiles, while sibling lists spanning them raiseHeterogeneousSiblingListsError. Arecord_shape_namesentry whose key set splits this way raisesUnrepresentableInputError, since one custom name cannot identify one generated declaration. This ports the shared field-type split (issue #2888) to Scala as part of issue #2961.The shared
RECORDrenderer now rejects a dict key whose backend field-name mapping is not a lexical identifier before returning target source. This prevents invalid declarations and literals for keys such asa-b; Zig continues to use its quoted@"a-b"identifier form consistently.Under the C
RECORDheterogeneous strategy, dicts with the same key set but conflicting field types (for example a nested record with different fields, or a differing scalar type under one key) no longer share one generatedstruct, which silently emitted field types that failed to compile. Such dicts now resolve to distinct record shapes: conflicting groups that never share a list each render as a separatestructthat compiles, while sibling lists spanning them raiseHeterogeneousSiblingListsError. This ports the shared field-type split (issue #2888) to C as part of issue #2961.Under the C++
RECORDheterogeneous strategy, dicts with the same key set but conflicting field types (for example a nested record with different fields, or a differing scalar type under one key) no longer share one generatedstruct, which silently emitted field types that failed to compile. Such dicts now resolve to distinct record shapes: conflicting groups that never share a list each render as a separatestructthat compiles, while sibling lists spanning them raiseHeterogeneousSiblingListsError. This ports the shared field-type split (issue #2888) to C++ as part of issue #2961.Under the Crystal
RECORDheterogeneous strategy, dicts with the same key set but conflicting field types (for example a nested record with different fields, or a differing scalar type under one key) no longer share one generatedrecord, which silently emitted field types that failed to compile. Such dicts now resolve to distinct record shapes: conflicting groups that never share a list each render as a separaterecordthat compiles, while sibling lists spanning them raiseHeterogeneousSiblingListsError. This ports the shared field-type split (issue #2888) to Crystal as part of issue #2961.Under the D
RECORDheterogeneous strategy, dicts with the same key set but conflicting field types (for example a nested record with different fields, or a differing scalar type under one key) no longer share one generatedstruct, which silently emitted field types that failed to compile. Such dicts now resolve to distinct record shapes: conflicting groups that never share a list each render as a separatestructthat compiles, while sibling lists spanning them raiseHeterogeneousSiblingListsError. This ports the shared field-type split (issue #2888) to D as part of issue #2961.Under the Nim
RECORDheterogeneous strategy, dicts with the same key set but conflicting field types (for example a nested record with different fields, or a differing scalar type under one key) no longer share one generatedobject, which silently emitted field types that failed to compile. Such dicts now resolve to distinct record shapes: conflicting groups that never share a list each render as a separateobjectthat compiles, while sibling lists spanning them raiseHeterogeneousSiblingListsError. This ports the shared field-type split (issue #2888) to Nim as part of issue #2961.Under the Odin
RECORDheterogeneous strategy, dicts with the same key set but conflicting field types (for example a nested record with different fields, or a differing scalar type under one key) no longer share one generatedstruct, which silently emitted field types that failed to compile. Such dicts now resolve to distinct record shapes: conflicting groups that never share a list each render as a separatestructthat compiles, while sibling lists spanning them raiseHeterogeneousSiblingListsError. This ports the shared field-type split (issue #2888) to Odin as part of issue #2961.Under the V
RECORDheterogeneous strategy, dicts with the same key set but conflicting field types (for example a nested record with different fields, or a differing scalar type under one key) no longer share one generatedstruct, which silently emitted field types that failed to compile. Such dicts now resolve to distinct record shapes: conflicting groups that never share a list each render as a separatestructthat compiles, while sibling lists spanning them raiseHeterogeneousSiblingListsError. This ports the shared field-type split (issue #2888) to V as part of issue #2961.Handle embedded null bytes without emitting invalid target-language string literals.
Type an empty Rust map from its non-empty sibling so a list mixing empty and non-empty maps compiles.
Under V’s default strategy, an empty map beside a non-empty map sibling was emitted at the
map[string]IVal{}interface fallback type, which the V compiler rejected because the sibling’s concrete value could not coerce toIVal. The empty map now borrows the sibling’s value type (for examplemap[string]int{}) so the list compiles.V and Zig now reject positive integers above
u64::MAXwithUnrepresentableIntegerErrorinstead of emitting overflowing fixed-width literals or union payloads.V’s default strategy now raises
NullInCollectionErrorfor a non-empty list whose members are all null instead of emitting avoidptrelement list that the V/C back end rejected; select theINTERFACEorRECORDheterogeneous strategy to materialize such data.V’s default strategy now raises
NullInCollectionErrorfor a non-empty map whose values are all null instead of emitting avoidptrmap that the V/C back end rejected; select theINTERFACEorRECORDheterogeneous strategy to materialize such data.Wrap an empty list or map that sits beside a scalar in a Rust
TAGGED_ENUMsequence, emitting aList/Mapvalue-enum variant so the generated source compiles.Reject reserved Standard ML
NewVariablenames with a clear error.Reject reserved Swift
NewVariablenames with a clear error.Reject reserved JavaScript and TypeScript
NewVariablenames with a clear error.Reject reserved V
NewVariablenames with a clear error.Reject reserved Zig
NewVariablenames with a clear error.Reject language-specific reserved words when they are used as new variable names.
A Go homogeneous integer collection whose values exceed the signed 64-bit range now opens as
[]uint64/map[...]uint64with every element formatted for the unsigned element type, so an in-range negative sibling raisesUnrepresentableIntegerErrorinstead of rendering as a signed literal that Go rejects at compile time.Emit the Rust TAGGED_ENUM declaration when per-element calls need to widen homogeneous maps in the same argument position.
Make C++14 explicit heterogeneous literals native-only: fixed scalar sequences use
std::tupleunderTUPLEand object-shaped data uses generated structs.Make C++14’s default heterogeneous rendering native-only: use tuples and records where possible, retain standard maps for non-identifier keys, and reject shapes that would require
LiteralizerVariant.Add C++14 heterogeneous
Valuecarriers with configurable names, usableis<T>()/get<T>()accessors, and self-contained generated preambles.C++14 heterogeneous value carriers now store rendered string literals as owning
std::stringvalues, sois<std::string>()andget<std::string>()match the source data model instead of exposing a decayedconst char*.C++14 sequences now use a matching external
record_shape_namestype under theERRORheterogeneous strategy while retaining nativestd::mapelement literals.Include constructors used only by emitted ref declarations in composed Gleam
GValpreambles.Import
Unionwhen explicit Python type hints use thetypingunion format.Prevent source comments from terminating suffix-delimited target comments.
Reject unpaired UTF-16 surrogates in parsed strings before rendering target source.
Add a shared
StringFormats.MULTILINEoption for Python, Java, C++, C#, Go, JavaScript, TypeScript, Dart, Kotlin, Ruby, Scala, Rust, and Lua, preserving exact string values with native multiline syntax and safe escaped fallbacks.Expand multiline-string coverage across root, nested, variable, and indented contexts, fixing invalid nested keys, Crystal JSON escapes, and Perl UTF-8 handling uncovered by executable round trips.
Add a native multiline string format for Swift using collision-free extended delimiters and safe escaped fallbacks.
Add a native multiline string format for Groovy using non-interpolating triple-single-quoted strings.
Add native multiline string formats for D and Nim using raw source literals with safe escaped fallbacks.
Add a native multiline string format for Crystal using non-interpolating percent strings.
Add a conventional multiline string format for PHP using non-interpolating single-quoted strings and safe fixed-width escaped fallbacks.
Add a non-interpolating multiline string format for Perl.
C++ multiline strings now use an empty raw-string delimiter when safe and short neutral delimiters for collisions, removing
LITERALIZERbranding from generated code.Allow callers to configure the fallback delimiter base for C++ multiline raw-string literals.
Golden input coverage now lives in validated, versioned
case.tomlmanifests beside each fixture. The migration also removes the redundantsimple_sequencesequence-variable-name golden cases.Fortran and V byte strings now pass hexadecimal and base64 payloads through each language’s normal string formatter, keeping quoting and escaping consistent with ordinary strings.
F# native dates and datetimes now use their generated
DateandDatetimeunion constructors instead of culture-dependent string conversions, and those cases are declared only when the selected format uses them.Lua’s native date and datetime formats now emit Unix epoch seconds directly instead of calling timezone-dependent
os.timewith an unzoned field table.Perl, Tcl, and SystemVerilog booleans now use representations distinct from integer
1and0:JSON::PPsingletons, Tcl boolean words, and a dedicated SystemVerilog value tag respectively.COBOL booleans now use distinct numeric
1and0values instead of the strings"TRUE"and"FALSE", preserving their type distinction from string input.Julia hexadecimal, octal, and binary integer formats now wrap literals in
Intand apply a leading sign outside that conversion, preventing unsigned-width inference and negative wraparound.Gleam now honors hexadecimal, octal, and binary integer formats for negative values instead of silently falling back to decimal.
Fixed-point float formatting now increases precision when six decimal places would change the value, preventing small nonzero values such as
1e-9from being emitted as zero.MATLAB now rejects dictionary keys that are not valid struct field names instead of emitting code that fails at runtime.
Raise
UnrepresentableSpecialFloatErrorconsistently when Odin JSON values contain NaN or infinity.Add
LiteralizerErroras the common base for every public exception so callers can handle all Literalizer failures without maintaining an allowlist.Exercise Bash’s default string format in its round-trip check.
Cpp(json_type=NLOHMANN_JSON)now honorscollection_layout=CollectionLayout.MULTILINEunder a variable form: the structuralnlohmann::jsonfactory expressions flow through the shared collection layout machinery instead of always rendering on one line.