Last numbers of IntValue doesn't changing

I need to make IntValue change on the server. So i wrote script but last 2-3 numbers of IntValue not changing, it’s always 000.

I searched for an answer but no one got this error, there’s a few screenshots of the error, and code. I need to know what reason of this problem.


Also parameters:
[Player], "908779319084589067"

(My first topic, sorry if i did something wrong :grimacing:)

There’s lines of code:

Also tonumber() doesn’t do anything.

im pretty sure that this"part", smthn)-- decapitated

try this

local part ="Part") 
part.parent = smthn

you get what im trying to do with the examples

I’m not sure why you destroy it in the first branch? If it exists re-use it and simply change the value.
I would do this:

local DsID = player:FindFirstChild("DsID");
if not DsID then
  DsID ="IntValue",player);
  DsID.Name = "DsID";

DsID.Value = int;

And what is the difference between player and Player, you should name these to distinguish them from one another.

Thanks, already did that. Anyways i found another example of this bug.

local OwnId = 908779319084589067


Yeah odd, this doesn’t work either. Maybe string manip has some limitations on it.

local OwnId = 908779319084589067;

I checked for an IntValue documentation and there’s no limits like this :frowning:

IntValues (or at least standard ones do) definitely have limitations on the range ( -2,147,483,648 to 2,147,483,647) but Lua’s clever interpreter can expand values when they fall outside the standard range. I added a .0 to the end of OwnId so it would be interpreted as double precision and that number is well within the range of
( -1.797693134862315E+308 to -2.225073858507201E-308) but and it still doesn’t work. Odd…

This doesn’t work either, and we are definitely telling the compiler that we are requesting a 64bit number.

local OwnId ="NumberValue")
OwnId.Value = 908779319084589067;

This prints 908779319084589000.

It must be down to some sort of limitation/error in tostring() or the methods employed in string concatenation (""…OwnId);

This is bugging me…

This fails too:


I’m going to try this in C++, it could be a universal bug that you have found, or a systematic bug in Roblox’s core scripts.

My range was wrong before, Roblox uses signed 64bit integers. This is down to integer overflow!
Oddly though the max value returns the same as min value and the overflow value.

local INT_MAX = (2 ^ 63)-1;
local INT_MIN = -(2 ^ 63)

local minInteger ="IntValue");
local maxInteger ="IntValue");
local overInteger ="IntValue");

minInteger.Value = INT_MIN;
maxInteger.Value = INT_MAX;
overInteger.Value = INT_MAX + 1;


Outputs the same value each time, so Roblox’s implementation of Int64 is truncating before it should do. It’s overflowing to negative before the apparent data range.

This doesn’t explain why the number you posted is incorrect because it is below the threshold, but the same test in C++ on double and __int64 returns two different values for your number.

__int64 is correct at = 908779319084589067
double is incorrect at = 908779319084589056.000000 (but close).

cc. @dduck5tar

There’s no int64_t data type in the Luau VM. The only numeric data type there are in Luau are IEEE binary64 (double) and vector, and because IEEE binary64 has a precision of the 53 most significant binary bits so integers up to 253 can be safely represented (and integers after that can only be safely represented in every 2s until 254 which integers after that can only be represented in every 4s, etc).
IntValue.Value actually returns an int64_t casted to a double which is printed in its shortest decimal representation so this…

…is not a bug.

However, IntValues internally stores the value as int64_t (from a double casted to int64_t), and because some integers after 253 cannot be exactly represented as a double, using IntValue is pointless.

This works just fine for doubles on both Luau and JavaScript, I also tested this in a programming language without any integer data type on a VM-level like JavaScript.

On V8 JavaScript which also doesn’t have any integer data type returns as expected
as it’s rounded to its shortest decimal representation of a double.

In your Luau example script, both the INT_MAX and the INT_MIN local variable is actually a double and not an integer so it is rounded to the nearest representable value for the INT_MAX local variable.

1 Like

Yeah I figured they must be using a double to represent 64bit int because of the overflow. But the IntValue info on the website clearly says they can hold the full range:

“An IntValue is an object that stores a single signed 64-bit integer. Integers do not include decimal points. The highest value that can be stored is 2^63-1, or around 9.2 quintillion. Attempting to store numbers larger than this may cause integer overflow. The lowest value that can be stored is -2^63, or about negative 9.2 quintillion”

And Roblox obviously have their own implementation of Lua so that’s why it was bugging me…

Oddly enough if you run this code:

local OwnId ="IntValue"); -- should be a full range 64bit int
OwnId.Value = 908779319084589067; -- this is below the threshold quoted on the website

for i=0, 10000 do

The output hints at boundary issues in the storage of signed character because of when the changes occur in the printed value, i.e. the print only skips to the next line when the value actually changes, the amount of times it prints shows the bits that had to change before it did change. The first few changes are shown below and you can see the value changes firstly on a half signed char step (+1), and then either one below or one above the signed character limit. This could indicate that the representation of signed char is incorrect in the Roblox’s Lua implementation (i.e. bits are overflowing/underflowing). Not sure, it’s odd and requires more testing.

19:23:42.572 908779319084589000 (x65) - Client - LocalScript:6
19:23:42.576 908779319084588900 (x127) - Client - LocalScript:6
19:23:42.583 908779319084588800 (x129) - Client - LocalScript:6
19:23:42.590 908779319084588700 (x127) - Client - LocalScript:6
19:23:42.597 908779319084588500 (x129) - Client - LocalScript:6
19:23:42.604 908779319084588400 (x127) - Client - LocalScript:6
19:23:42.612 908779319084588300 (x129) - Client - LocalScript:6
19:23:42.619 908779319084588200 (x127) - Client - LocalScript:6
19:23:42.626 908779319084588000 (x129) - Client - LocalScript:6
19:23:42.634 908779319084587900 (x127) - Client - LocalScript:6
19:23:42.641 908779319084587800 (x129) - Client - LocalScript:6
19:23:42.649 908779319084587600 (x127) - Client - LocalScript:6
19:23:42.656 908779319084587500 (x129) - Client - LocalScript:6
19:23:42.664 908779319084587400 (x127) - Client - LocalScript:6
19:23:42.671 908779319084587300 (x129) - Client - LocalScript:6
19:23:42.677 908779319084587100 (x127) - Client - LocalScript:6
19:23:42.684 908779319084587000 (x129) - Client - LocalScript:6
19:23:42.691 908779319084586900 (x127) - Client - LocalScript:6
19:23:42.698 908779319084586800 (x129) - Client - LocalScript:6
19:23:42.705 908779319084586600 (x127) - Client - LocalScript:6

If you run this from max value (i.e. INT64_MAX = 2 ^ 63-1) the issue is always represented along bit boundaries. Again a half step (+1) first and then full steps (+/-1) usually finishing with a quarter step (not shown):


19:47:34.405 -9223372036854776000 (x1025) - Client - LocalScript:6
19:47:34.463 -9223372036854778000 (x2047) - Client - LocalScript:6
19:47:34.579 -9223372036854780000 (x2049) - Client - LocalScript:6
19:47:34.715 -9223372036854782000 (x2047) - Client - LocalScript:6
19:47:34.838 -9223372036854784000 (x2049) - Client - LocalScript:6
19:47:34.959 -9223372036854786000 (x2047) - Client - LocalScript:6
19:47:35.082 -9223372036854788000 (x2049) - Client - LocalScript:6
19:47:35.204 -9223372036854790000 (x2047) - Client - LocalScript:6
19:47:35.329 -9223372036854792000 (x2049) - Client - LocalScript:6
19:47:35.450 -9223372036854794000 (x2047) - Client - LocalScript:6
19:47:35.571 -9223372036854796000 (x2049) - Client - LocalScript:6
19:47:35.693 -9223372036854798000 (x2047) - Client - LocalScript:6
19:47:35.813 -9223372036854800000 (x2049) - Client - LocalScript:6
19:47:35.934 -9223372036854802000 (x2047) - Client - LocalScript:6

So actually i can’t fix the problem with MAX_INT and MIN_INT but i got an idea to just do not use IntValues, so ill contain info in StringValue, and it’s working good:


If someone will get the same error with overflow i can’t help there :pensive:
(Also roblox now has the issue with Unknown+DN to players so this is why my nickname is “unknown”)

But surely you would have to type this number manually into the string, which really isn’t a solution it’s a workaround which renders your original function redundant. You should be able to assign this to a string based off the number fitting into an IntValue and it successfully being cast to the correct string representation. The issue still exists, you just found a non-unique solution for the single case of that number.

I know but my bug with an id fixed, and my issue wasn’t really about INT i just wanted to contain number information in variable.