Can someone help me understand why JSON is handled differently in 4.4?

christineh · May 12, 2025, 8:32pm

In Godot 4.3 an array filled with integers in JSON will return looking like an array of integers.
I know that JSON does not distinguish between integers and floats. In Godot 4.4 my array of integers is converted into an array of floats.
Example:
{
“five”: [
7,
2,
3,
1,
6
]
}
loads into Godot as:
five: [7.0, 2.0, 3.0, 1.0, 6.0]

This means if I want to upgrade my game to 4.4 I have to find a way to convert a bunch of
values that had been working perfectly well. I tried to understand by reading a couple of git issues, but I still don’t really understand why this is better than leaving it the way it was

Here are the links:

github.com/godotengine/godot

JSON files are exported with floats having trailing .0 when they should not

opened 08:56AM - 08 Jan 25 UTC

closed 07:32PM - 10 Jan 25 UTC

aaronfranke

bug archived topic:core regression

### Tested versions Current master as of writing (d2ada64a03d2abdb97cafe8f10623…db8a2ce1d4c) ### System information macOS 14.6.1 ### Issue description As of PR #47502, floats are always printed with a trailing `.0`. This is great for most situations, but should not happen with JSON files. JSON does not distinguish floats and ints, so the `.0` is possibly informative of the number's original type in Godot, but is not necessary for the JSON data, and may be misleading users into thinking that JSON supports floats and ints. When exporting a glTF from Godot, part of it may look like this: <img width="300" alt="Image" src="https://github.com/user-attachments/assets/a6787ea9-7892-4afc-80f0-fce00ef47d39" /> ### Steps to reproduce 1. Have a Dictionary with float and int values, both whole numbers, like the MRP. 2. Export this Dictionary to a JSON file using Godot's JSON stringify function (or export a glTF file which uses JSON too), either printing to the terminal or writing a file to disk. 3. Notice that in master the float prints with `.0` while the int does not. 4. Notice that in Godot 4.3 the float prints without the `.0`. Note: It is expected that when printing the Dictionary it has the `.0`, but not when using `JSON.stringify`. ### Minimal reproduction project (MRP) [json-float-printing.zip](https://github.com/user-attachments/files/18344653/json-float-printing.zip) ```gdscript func _ready() -> void: var dict: Dictionary = { "myfloat": 1.0, "myint": 1, } var text = JSON.stringify(dict, "\t") print(text) ```

github.com/godotengine/godot

Fix JSON Parsing to Differentiate Integers and Floats

master ← Ebbo:master

opened 10:48PM - 15 Dec 24 UTC

Ebbo

+22 -4

This change enhances JSON compatibility by correctly parsing numeric types, alig…ning the behavior with expectations for strict JSON type handling. Data: ``` { "key1": 42, "key2": 3.14, "key3": 100, "key4": 541., "key5": 0.0, "key6": 0102 } ``` Example GDScript: ``` func _ready() -> void: var data = FileAccess.get_file_as_string("res://data.json") var json_data = JSON.parse_string(data) print(json_data["key1"]) print(json_data["key2"]) print(json_data["key3"]) print(json_data["key4"]) print(json_data["key5"]) print(json_data["key6"]) ``` ``` Current: 42.0 3.14 100.0 541.0 0.0 102.0 ``` ``` Patch: 42 3.14 100 541.0 0.0 102 ```

Calinou · May 12, 2025, 8:35pm

4.4 always prints floats with a decimal, even if the decimal portion is exactly 0. 4.3 didn’t do that, which is why some floats looked like integers when printed. This could hide bugs due to unexpected types that were not obvious.

If you are sure the number is meant to be an integer, cast using to int() before printing it.

hexgrid · May 12, 2025, 8:39pm

There’s a bit of a footgun there if you’re using integers as bit fields, though Godot’s handling of 64bit integers is kind of rough in that regard anyways.

christineh · May 12, 2025, 8:47pm

It just means I have to go through the entire code base and find every place where I use it, or else do some sort of conversions when I fill my data store, which complicates the process. I didn’t see it listed as a major breaking change in the upgrade notes but it should be there.

I don’t really understand why turning all numbers into floats helps prevent bugs. Maybe an example would help me understand.

hexgrid · May 12, 2025, 9:06pm

I think the problem is actually that JSON is actually kind of weak in the guarantees it offers for numbers. The JSON spec doesn’t differentiate between numbers that have fractional components and those which don’t. It also doesn’t differentiate between signed and unsigned values.

Unfortunately, with real hardware and fixed bitwidth representations of values, that means JSON has some sharp edges. A double and an int64_t have the same number of bits, but they spend them in different ways, and each has values that cannot be represented by the other. The floating point representation covers a wider set of magnitudes, but does so by throwing away precision at the low end. The integer values sacrifice range for precision at the high end, and (obviously) can’t represent non-integral values at all.

Since JSON has no in-spec method of tagging numeric values as anything other than “number”, it’s difficult to fix this for all cases. You could make everything strings ("uint32:0xDEADBEEF") and parse yourself, which actually wouldn’t be that much more expensive than the automatic stuff since it’s all parsed text anyways, but that’s obviously a pain in the ass too. I don’t think there are great answers here.

More recently, I’ve been seeing a move to things like CBOR, which have more precise ways of defining numeric types, don’t require as much runtime parsing, and are generally more compact. I’m not sure if Godot supports CBOR in any capacity, though.

The TL;DR here is: JSON kind of sucks for stuff like this and can’t be fixed. It’s convenient despite its weaknesses, but it’s always going to have tradeoffs. I do agree, however, that it sounds like the changes that were made were unnecessary and should have been listed as breaking; they will have improved things for some people and worsened things for others, because there’s no way of fixing the fundamental problems with JSON and have it still be JSON.

christineh · May 12, 2025, 9:20pm

I think I’ve figured out how to switch to using typed arrays and dictionaries to force the conversion back to integer. I was worried it was going to require some really messy work around. It’s still definitely a breaking change, but I guess I can see how it’s hard to make choices about the best way to handle these issues. Thank you all for taking the time to help me.