Game world size limits

Hi all,

For my next project i’m looking to create a very prestigious gameworld with approximately 3,930,520 sq miles (10,180,000 km²) in one level.

Would Blender be able to handle this ?


It depends on your definition of “prestigious”.

The complexity of your geometry is more impacting than the overall world scale.

Search the forums for “LOD” or “Level of Detail”.

I have a level that is infinite size (in space). Can blender handle it? Yes, because 99.99999% of it is empty.

Your world will be just about infinite in size by default, it’s just how much you populate it, what LOD you use, and what else you have going on at the same time.

Oh, and torkusansama is building a game consisting of a single level that contains, well, about a million planets (I think), each of which you can walk on… But then he coded his own system on top of blender’s to handle this.

Anything is possible, it’s just how you do it that’s the hard part.

Just to let you know: As far away from origin you operate as less precision you get. This means if you can transform with fractions of mm near (0,0,0) you can’t work with mm at large distances (maybe not even meters).

Beside that the main problem is to fill such area.

Essentially what monster says is correct as there is a limit to float precision (which is what a vector consists of). If you want to maintain accuracy, you could use delta vectors between one point and another.

this should really give you some perspective, i am not experienced enough to know how much this guy is full of it as compared to how much this guy really knows, but it seems there is some valid information to your question. reset button blog

also this has something to say that should be taken into account. unity docs you may say, i am using blender, not unity… no duh, bare with me.

if blender and python are good enough to run wind simulations and air-current simulations for nuclear reactor research (and is a language used by NASA and Google)… it can probably run your dream game of a million square miles. but do you have a super computer? do you want your game to run on a smart phone? do you want it to be a console product, or a testing playground for yourself and your top of the line alienware pc octo-core water cooled CPU, that you just upgraded to 144 terabytes of ram sticks super MegaGeforce 100 watts gighertz graphics card… because my, now modest, 2009 i mac, wont hold up to your state of the art gaming PC, or whoever’s.

so maybe define and outline what your project is, and start with characters and items… or write a procedural generator for environments… which seems to be all the rage/catch phrase and a seemingly quite logical idea.

this broad net your casting, might pull in some bad fish. better to refine… fish for something more specific at this point, maybe even with just a fishing pole and put the nets away, for now.

Just to let you know: As far away from origin you operate as less precision you get. This means if you can transform with fractions of mm near (0,0,0) you can’t work with mm at large distances (maybe not even meters).

Beside that the main problem is to fill such area.

I am curious about this…so if I set an object at [1000,500,0]. It will not be accurate?


But … this does not mean it prevents you from creating a large world.

What can happen is this (attention: this is just an example to make clear what I mean, this is not an example of the real world!)

You create a plan of a (very simple) house:
10m x 10m x 6m = 1,000cm x 1,000cm x 600cm

At the front of the house you cut a hole for a door:
1m x 2.30m = 100cm x 230cm

and place a door inside the hole:
1m x 2.30m = 100cm x 230cm

To make it look like a door you add a door frame. The frame has the (inner) dimensions of the door that the door fit.
The frame is a bit outside of the house lets say 1 cm.

You placed all this measures into a plan. The plan is based on cm. You have 5 digits for each value no decimals.

According to this plan you build this house. You can look around. The frame is protruding 1cm from the front wall (I hope that is the right word). Everything is as you expect.

Now you build the exact same House 1000m away. In other words all your measurements are based on a point 1,000m away (origin).

Unfortunately your plan can only handle measurements with 5 digits => max number: 99999cm = 999.99m.

If you use cm you can’t build the house the maximum distance is 100,000cm+500cm+1cm away which clearly exceeds your 5 digits.

So we can build half of the house or

we use another scale. You can change the scale from cm (=0.01m) to dm (=0.1m).
Now the numbers are small enough to fit into 5 digits
The distance to the origin is 10,000dm = more than enough to build even a much bigger house.

So we can build the house. Everything goes fine until you build the frame. Why?

The front wall is at 105dm from origin
The frame has an offset of 0.01 cm from the wall.
This means it is 1050.1dm from the origin.
But we do not have decimals so we need to round it to fit into the range: 1050dm

—> this is the distance of the front wall. Which means you loose the offset of the frame. The whole front will be a flat surface.

(I hope you see why plans usually use an origin somewhere very near).

Your computer does exactly that with data type float. If a number gets larger it skips decimal places. If the number gets smaller it adds decimal places.

The background is simple: As larger a number is as more unimportant the fractions are. But in some cases it is not that unimportant as you see.


  • rounding effects (by skipping decimals) are binary not decimal as in the above example
  • the data type float has a very large data range.
  • with [1000.0, 500.0, 0.0] is not that problematic if you move a standard cube. [1000000.0, 500000.0, 0.0] maybe

If you want an exact (technical) answer, this article should be useful (link).

A float type uses 32 bits to represent real numbers. 23 out of 32 bits are used for the actual value. 8 bits are used for the exponent, and one bit is used for the sign (+/-).

If you need higher precision, use “doubles” instead of floats. With doubles, you can get 64 bit precision.

Using doubles will not really help as you can’t change the internal data types of the BGE.

The whole thing is more a … “keep in mind” situation ;).