Google Gravity Tornado -

Alternatively, you can directly visit a mirror site (e.g., gravitytornado.com) that has embedded the effect.

What makes the Tornado more than just a visual gag is the interactivity. This isn't a video playing on a loop; it is a physics simulation.

If you are quick enough, you can grab the spinning elements with your mouse. You can catch the search bar as it whips by and fling it off-screen, or try to stack the letters back together while the "wind" tries to tear them apart again. It turns the user from a passive observer into a god of the storm, capable of disrupting the digital weather.

There is a specific, distinct pleasure in dragging the "Gmail" link across the screen and watching it knock over the "Images" button like a bowling pin. It reminds the user that the web page is not a static document, but a collection of objects that can be manipulated.

| Aspect | Detail | |--------|--------| | Core technology | JavaScript + HTML5 Canvas + Box2D (physics engine) | | DOM manipulation | Original Google elements are re-positioned as draggable, physical bodies | | Force simulation | Radial force (toward center) + angular force (rotation) = tornado | | Collision detection | Elements bounce off each other and page edges | | Rendering | Real-time via requestAnimationFrame | google gravity tornado

The tornado effect is achieved by applying:

If you grew up in the golden age of internet easter eggs (roughly 2005–2015), you probably remember the thrill of typing strange phrases into Google and watching the search results fall apart. Among the most legendary of these hidden tricks is Google Gravity, the JavaScript prank that makes the entire homepage collapse like a Jenga tower. But over the years, a more intense, chaotic cousin emerged: the Google Gravity Tornado.

For those who haven’t seen it, "Google Gravity Tornado" sounds like a disaster movie about a weather event that sucks up your search history. In reality, it’s one of the most creative user-generated hacks built on top of Google’s original gravity experiment. This article dives deep into what Google Gravity Tornado is, how it works, who created it, and—most importantly—how you can trigger it yourself.

Google Gravity Tornado is a fan-made or user-triggered variation of the original Google Gravity experiment (created by developer Mr. Doob). While standard Google Gravity makes all page elements fall down due to simulated gravity, the Tornado version adds a swirling vortex that pulls letters, buttons, and the search bar into a spiraling, rotating mess. Alternatively, you can directly visit a mirror site (e

Think of it as:
Normal Google → Gravity pulls down → Tornado spins everything out

For the curious developers out there, here’s a very simplified conceptual example of how you might apply a tornado effect to any webpage using JavaScript and a physics library. (This is not a full working hack but demonstrates the logic.)

// Pseudo-code for a tornado force
function applyTornadoForce(element, centerX, centerY, strength) 
  let dx = element.x - centerX;
  let dy = element.y - centerY;
  let distance = Math.sqrt(dx*dx + dy*dy);
// Radial force (pulls inward)
let radialForceX = -dx / distance * strength;
let radialForceY = -dy / distance * strength;
// Tangential force (creates spin)
let tangentialForceX = -dy / distance * strength * 0.5;
let tangentialForceY = dx / distance * strength * 0.5; What makes the Tornado more than just a
// Apply to element's velocity
element.vx += radialForceX + tangentialForceX;
element.vy += radialForceY + tangentialForceY;

In the real Google Gravity Tornado, this function runs on every UI element 60 times per second, creating the swirling illusion.

const dt = 1/60;
function step() 
  for (body of bodies) 
    const r = body.pos.subtract(center);
    const radial = r.normalize().scale(-k_r * (r.length() - r0));
    const tangential = new Vector(-r.y, r.x).normalize().scale(k_t / Math.max(r.length(), 1));
    body.force = radial.add(tangential).subtract(body.velocity.scale(damping));
    integrate(body, dt);
resolveCollisions();
  render();
  requestAnimationFrame(step);

If you want, I can: