What are the limits of Geometry Dash?
Over the years, people have pushed this simple mobile game to new heights.
From making a level that uses over a million objects, to one that is over a billion years
long.
Today, we’ll be taking a deep dive into the mechanics of Geometry Dash to find an
answer to this rather interesting question.
How far can we truly push this game before it breaks?
Where do we start, though?
This is the game’s supposed health.
Our goal is to bring it down to 0 and what better way to do that than finding the highest
possible object count.
So, what is it?
Let’s begin with 80 thousand objects and work our way up.
Since placing so many objects one by one will take forever, I’ll just copy-paste them
into the same grid space.
But when I do that, something weird happens.
As you can see, the level cannot open.
And while there is no known reason why this occurs, some Geometry Dash modders have theorised
why.
It’s interesting; to say the least, so let me explain.
Back in 2.0, Absolute had just released a version of his “Image to Editor Converter”,
a program that allows you to import images into the Geometry Dash editor.
However, while this could be used to make some pretty sick art, a lot of people made,
well, inappropriate art with it.
Of course, this made RobTop quite unhappy.
And so later in 2.1, it is said that he added a system to prevent it by not allowing levels
to open that have more than 2k objects in one grid space.
Of course, this is just a theory but it honestly makes sense considering the circumstances.
Other theories also include an anti-lag feature using a blocks divided by seconds method.
Anyhow, now that we know we can’t place a lot of objects in one grid space, let’s
just put them separately.
The highest object count a level can normally have is 80 thousand because exceeding it could
cause instability on lower-end devices.
However, since we are only trying to find the highest possible object count, we do not
really care about that (add joke about phone exploding).
Sorry, mobile players.
How can we exceed that limit, though?
Well, since some creators feel sort of constrained with the object restriction, people have developed
modifications that allow you to bypass it.
So, let’s try going from 80k to 100k objects.
As you can see, the level opens just fine.
*music stop* But what happens if we just jump to, let’s say, 700 thousand objects (make
them triggers in the editing)?
Are you ready; 3, 2, 1 (show crash or something).
The game crashed, but why?
While you may think it has to do with my PC not being good enough, this is actually because
Geometry Dash can only use up to 2GBs of ram at once.
If a level has too many objects, it will exceed that limit and you will not be able to open
it.
And that’s exactly what happened here, the game needed more ram that it didn’t have
and it crashed.
So now that we know that, what actually is the highest object count possible?
I went and asked Adaf, a skilled GD modder, to see what he had to say.
He told me that without a patch that doubles GD’s ram usage, it’s 300k-400k (show tinxia
and have text under say uses 400k objects) objects.
If you download a patch, though, the number becomes around double that.
But this is not 100% accurate.
You see, the types of objects used in a level also play a role in if it can open.
So if you compare a level with 800k 1.9 objects with one that has 800k 2.1 objects, the level
with the 1.9 objects will open up more easily.
Taking this into account, we can make a rough estimate that the maximum amount of playable
objects is around 600 to 900 thousand; while the maximum combinable is around 1 million,
since playing and saving have some differences.
However, even if this is already pretty insane for Geometry Dash’s standards, when we take
a look at how long a level can get, things get even crazier.
The longest level you can normally build in Geometry Dash is 12 minutes and 51 seconds.
This is because the editor just ends there, not allowing you to build any further.
But what if I told you we could?
With the use of an external program called cheat engine, we can modify the level’s
length directly.
A level that used this software is Timeless.
Timeless by Cyrillic is thought to be one of the longest levels ever made in Geometry
Dash.
When you enter it in the editor, you will see that the level is about minus 2.147 billion
seconds in length.
This led to a lot of people believing that the level is either negative in length, or
that it is 68 years long, by converting the 2.147 and so billion seconds into years.
The thing is none of these are actually true.
Let me explain.
The level displays that big number, which is the maximum 32-bit integer value, in the
editor because of overflow.
Basically, if the level’s length surpasses the maximum integer value, a.k.a that big
number, it will overflow and show it as a negative value.
Think of it as an error message.
Now that we know that, though, how long is it actually?
Well, around 2.5 billion years To comprehend how absurdly long this is, humans
have existed for around 2 million years.
That’s more than a thousand times less than this level’s length!
And the crazy part is that we can go even longer.
In fact, we already have.
Emptiness is a level by EulerNum that’s way, way longer.
By how much you ask?
Around 35 octillion times.
But what if I told you that both levels are impossible to complete?
Not humanly impossible (cause well that’s pretty obvious), but literally impossible.
You can never, ever, ever, reach the end, no matter how long you wait.
The icon will abruptly stop moving.
So, what is the true longest possible level in Geometry Dash and why does this happen?
Well, the answer happens to lie in the FPS you use.
Yes, you heard that right; Frames per second are the reason why you can’t complete Timeless.
Not because RobTop is bad at coding but due to how float accuracy works.
So let’s look into it and maybe we can find answer to our question.
To understand this, we need to first take a look at how GD calculates where you’ll
move next.
In short, it takes your current X position and adds the distance you’ll go to, depending
on your FPS.
The higher your FPS, the smaller the movement is and vice versa.
Keep this in mind for later as it will be important.
Anyhow, let’s look at an example.
Your cube is at X position 900, that’s around 3 seconds into the level.
To move to the next frame, GD will take your current X position, being 900, and add 10
steps to it.
(Put text at the bottom of the video saying these numbers aren’t 100% accurate and are
dependent on the speed and FPS you use).
This means that your new position is now 910.
This is then repeated for every single frame onwards and your X position keeps increasing,
until it doesn’t.
So, why does this happen?
Due to how computers calculate equations between float variables, gosh that sounded way more
complicated than it actually is, the result is a bit inaccurate.
Let’s look back at our example.
If you remember, we added 10 steps to our X position of 900 to make it 910.
The thing I didn’t mention, however, is that the result won’t be exactly 910 but
something like 910.000, some 0s later, 1.
Now the reason this happens and the science behind it is admittedly very complex and while
researching for this my brain restarted multiple times.
And since this is a GD video, I won’t go too in-depth on how it works but what you
need to know is that the bigger the numbers get, the less accurate equations become.
Now, this is a huge issue when talking about massive lengths and it makes sense.
The way GD calculates your next move is by adding a number to your current X position.
If we go too far, way too far, that X position number will be so big that the inaccuracy
of the result will go off by so much to the point it can’t calculate your next move,
rendering your icon still.
But while we’ve figured out why it stops, how does FPS affect this?
Well, accuracy pretty much determines how many decimal points the program can calculate.
Remember what I said before?
Well, the more FPS, the less you move.
So the equation on a very high frame rate would probably be like 900 + 0.002 steps,
which requires more accuracy than something like 900 + 10 steps.
Hopefully, I didn’t lose you too much in the explanation but now that we understand
this, what is the longest possible level in Geometry Dash?
After talking to Adaf for a while, he told me that the estimated time before your icon
stops, is around 32 hours, making that the longest possible level in Geometry Dash.
While we’ve discussed a lot so far about the object limit and length, we’ve only
touched on how we can break levels in the game.
Of course, that can only mean that there is one last thing we need to figure out.
How can we break Geometry Dash?
The fact is, is that there are lots, and I mean lots of game-breaking things.
Either it’d the countless bugs littered inside the game or the use of external programs
to make it do unintended things.
So, where do we start?
Let me explain to you how a crash trigger works.
First, you place a move trigger.
Second, you set the values of it to something the game can’t handle.
Then you place it in one of the most anticipated extreme demons, forget to remove it, get it
unrated, remove it, and then get it rerated; that no joke happened.
Basically, what a crash trigger does is well, crash your game.
It’s nothing too crazy but due to how popular it has become after that whole Sonic Wave
Infinity shebang I thought it’d be best to mention it.
Things get way more interesting from here, though.
What if I told you about the “Geometry Dash far lands”?
I know that sounds confusing, how can the “far lands” exist in GD?
Remember when we talked about the longest possible level in Geometry Dash?
Well, one thing I didn’t mention is that the farther you are in a level, the weirder
things get.
Let me show you a clip.
Notice something odd?
The cube seems to be jumping normally but the distance it covers is way more than usual.
Why?
Well, the farther you are in a level the faster your icon moves.
The reason this happens is the same as we explained before but wait, there’s something
else.
The icon and textures are also funnily messed up.
Like look at this, it looks drunk.
Editor’s note: Apparently if your wave gets stuck far in a level, taking a screenshot
makes it move by just a bit, making your trail messy.
It’s really funny to say the least and I thought it’d be nice to mention it, but
ye let’s continue.
Guess long lengths mess up any game.
But what if I told you there’s something that’s even messier?
Frames per second; the more of them you have, the buggier this madness becomes.
So, of course, let’s use 19 thousand FPS.
As you can see, the wave moves at a strange angle, making things that shouldn’t be doable
possible.
The reason this happens is once again because of float inaccuracies.
I swear every problem we’ve found has something to do with them.
Anyhow, frame rate also messes with physics in general, the maximum level length as we
said before, and the ship’s rotation.
*brush sound effect or something lol* But so far we’ve been looking at things only
possible with the use of modifications.
What if we take a peek at some bugs; game-breaking ones.
Game file corruption is something no one wants to deal with.
However, there is a small chance that when you save a level it corrupts.
This makes you unable to open Geometry Dash from steam, forcing you to verify the game’s
files.
As far as I know, the exact cause for this is unknown but after doing some research,
one explanation I found was that it has to do with how GD decrypts save data.
Now I won’t go into detail on how this happens, but it is quite scary that you can lose access
to the game for a bit just because you saved your level.
*sigh* Even so, the next bug we are going to discuss gets even more interesting.
Ocular Miracle is a level released back in June of 2020.
Upon its release, it got rated extreme demon and people were already trying to complete
it.
However, the level had an insane amount of objects.
This led to GD using more ram than it could and caused some weird texture glitches on
some devices, yeah.
However, graphical glitches like these have happened before, more often on AMD hardware.
GD modders have theorised that the glitches happen because of high memory usage, which
causes the textures that are stored in the same memory to be corrupted.
They have even tried debugging this issue and found it to be in some of AMD’s libraries,
but the exact reason is unknown.
It’s pretty funny that a single level can mess up your textures, though.
While these seem to be the limits of the game for now, with new exploits and modifications
being in development daily, there’s one thing for sure.
These limits will be broken.
The older video on this topic is located here and massive thanks to Adaf for helping me
out immensely with this video and make sure to check out the other people in the description
for also helping me.
Goodbyeeeeeeeeeeeeeeeeeeeee.