It is well known, that the collision between to game objects can fail if one of them is moving at a high speed. I was wondering, which properties affect this behaviour and when does one need to start to worry about countermeasures. Thus I've run some tests and I want to share the results with you. The setup: The test unit is essentially a script (CollisionTest.cs) which instantiates fast moving projectiles and a target which reports a successful collision. It has properties for: projectile speed as float projectile size as float target scale as Vector3 CollisionDetectionMethod number of repeats as int The projectile is a simple sphere collider with a rigidbody component attatched. It has gravity and isKinematic turned off and is on a layer which ignores collision among itself. The start position is randomized a bit. This is neccessary since the success of the collision basically depends on the position of the two colliders during each frame. For reference: The projectiles fly only in z-direction. The target is simple cube collider. It has a script (Target.cs) attatched which increases a counter on the corresponding CollisionTest.cs. After the set amount of shots have been fired, CollisionTest calculates the ratio of hits and total projectiles. During the test the frame rate was between 10 and 20 fps. Results: What does not affect the behaviour (no plot here since horizontal lines are boring): 1.The global scale. Scaling up the speed of the projectile and the scale of both the projectile and the target does not make a difference. 2.xy-scale of the target. The chance for a successful collision only depends on the size of the target in movement direction. 3.CollisionDetectionMode This one is quite disappointing. However in this case the target is a simple cube collider. It could still make a difference for mesh colliders. What does affect the behaviour: 1.The speed. Thats the point of this thread, isn't it? In these plots the projectile size is 1 the target size is (1,1,1).The test is repeated 1500 times: In the second image you can see, that the collision is save until a speed of 100. 2.The z-size of the target In this plot the projectile size is 1 and its speed is 500. The test is repeated 1500 times: 3.The size of the projectile The same game as for the target z-size (but with a better choice for the x-axis). Target z-size is 1 the speed is 500. The test is repeated 1500 times: Conclusion: When the speed of an object is large agains its size and its collision partners size, then a collision can fail. Deducing from the plots, I'd say, that as long as the sum of the sizes the collision partners in movement direction times 50 is greater than the speed of the moving partner the collision is save. (size_projectile + size_target) * 50 > speed Keep this in mind if you are dealing with high velocities. In addition: I've run the speed test again for a mesh collider. It has has bounds of (1,1,1), which means it fits tightly into the previous cube target. Due to the nature of mesh colliders, the frame rate dropped below 5FPS during the test. Projectile and Targetsize are again 1. I was pretty much surprised about this outcome. The discrete collision started to fail a lot sooner. Even less than half of the cube colliders save speed already led to failed collisions. Continuous detection on the other hand always(!) detected the collision correctly. I've rund this test for a maximum speed of 20000 and still the detection never failed.