How to Customize Chrome Dino (Browser Tricks)

The Chrome Dino game is open source under a BSD-style license, and on pages running the original runner code, the live JavaScript object that runs it sits in the global scope. That means a single DevTools console line can change how high the dino jumps, how fast cacti come at you, or whether you can die at all. Here is exactly how to customize Chrome Dino without installing anything.

Play it here: No extensions needed for a new look: Dino Game Night Mode gives you a permanent dark mode, and Dino Game 3D puts the runner in 3D.

How to open the console

The console is where every tweak below happens. On Chrome, Edge, Brave, or any Chromium browser, press F12 or Ctrl + Shift + I (Cmd + Option + I on Mac). Click the “Console” tab. You should see a blinking prompt. Firefox uses the same shortcuts. Safari requires turning on its developer features in Settings first.

Load the T-Rex Runner before opening the console. The simplest way is to play it right here on this site — the game instance is already running and the Runner object is reachable. You can also open DevTools on chrome://dino in Chrome itself, though Chrome’s current built-in version has been reworked since the original code, so some names below may differ there.

The Runner.config object

Almost every tunable number lives in Runner.config. Paste this in the console and you will see the full object:

Runner.config

You will get back an object with fields like GRAVITY, MAX_SPEED, INITIAL_JUMP_VELOCITY, SPEED, ACCELERATION, INVERT_DISTANCE, BG_CLOUD_SPEED, and several others. Some of these, such as MAX_SPEED, are read on every frame, so editing them directly works immediately. Others are copied to the dinosaur when the game starts, so the reliable way to change them is the game’s own debugging helper:

Runner.instance_.updateConfigSetting('GRAVITY', 0.2)

That method updates the config and pushes the new value to the parts of the game that need it.

Gravity

GRAVITY controls how quickly the dino falls after a jump. The default is 0.6. Lower it for a slower fall and longer hang time:

Runner.instance_.updateConfigSetting('GRAVITY', 0.2)

Setting Runner.config.GRAVITY by hand changes the number in the list but not the dinosaur’s own copy, which is why that version of the trick often seems to do nothing.

Try 0.05 for a floaty moon-jump feel, or push it to 1.5 for a slammed-down brick of a dino. Combined with jump velocity below, this is the single most fun tweak.

Maximum speed

The game starts at a speed of 6 and adds 0.001 every frame until it reaches MAX_SPEED. Default is 13. Push it up for a ridiculous late-game pace, or keep it low for a never-stressful run:

Runner.config.MAX_SPEED = 30

The cap only stops acceleration; it never slows the game down. Lowering MAX_SPEED below the current speed mid-run just freezes the pace where it is. At very high values, obstacles move many pixels per frame, so collisions start to feel random rather than skill-based.

Jump velocity

Jump velocity sets how hard the dino launches upward. The dinosaur’s default is 10 (stored internally as -10, because the y-axis is inverted in canvas coordinates), plus a small bonus that grows with speed. Pass a bigger positive number for a bigger leap:

Runner.instance_.updateConfigSetting('INITIAL_JUMP_VELOCITY', 25)

Combined with low gravity, this puts the dino in orbit. Pair them carefully and you can clear every pterodactyl in a single bound.

Starting speed

Runner.config.SPEED is the starting speed, used each time a run begins or restarts. The current speed lives in Runner.instance_.currentSpeed. To change both at once:

Runner.instance_.updateConfigSetting('SPEED', 20)

Because 20 is above the default MAX_SPEED of 13, the game simply stops accelerating and holds that pace. On narrow phone screens the game scales speed down to fit the smaller canvas.

Disabling game over

The single most-shared T-Rex Runner trick is the immortality one-liner. The game’s gameOver method lives on the Runner prototype, and assigning a new function to the running instance overrides it:

Runner.instance_.gameOver = function(){}

After running that, hitting a cactus does nothing. The dino phases through. This is a well-known quirk of the open-source codebase, not a hack of the site. The code comes from the Chromium project, and the widely used wayou t-rex-runner extraction on GitHub is a common reference copy.

To restore game over without reloading:

Runner.instance_.gameOver = Runner.prototype.gameOver

The pterodactyl-free run

In the original code, pterodactyls have a minimum speed of 8.5; below that, the obstacle generator only picks cacti. That makes a pterodactyl-free run easy. Set the speed cap under the threshold before you start:

Runner.config.MAX_SPEED = 8

The game will never get fast enough to spawn a pterodactyl. At default settings on a typical 60Hz desktop screen, they first become possible at around 450 points. You can also inspect Runner.instance_.horizon.obstacles mid-game to see the obstacles currently on screen.

Changing the dino’s look

Two ways. The first is the night mode that ships with the game. Every time your score reaches a multiple of 700, a moon and stars appear and, on Chrome’s own offline page, the colors invert for about 12 seconds. You can change how often it happens:

Runner.config.INVERT_DISTANCE = 100

Note that Runner.instance_.invert(true), often shared as a “force night mode” command, does the opposite: the true argument resets the game to day. If you just want a dark look, the Night Mode version linked at the top of this page keeps it dark permanently.

The second is replacing the sprite image. The game uses a single sprite sheet loaded from the page. Replacing that asset means forking the project. A self-hosted copy of the open-source code lets you swap the sprite for any image laid out the same way. People have used this to turn the dino into a cat, a pixel ghost, or a custom mascot. It is not a console-only trick; it requires hosting your own copy.

Persistence and the reload problem

Everything above is wiped on page reload. That is by design — the page reloads, the JavaScript loads fresh, the defaults reapply. If you want your tweaks to stick across sessions, two options. Use a browser extension that runs a userscript on the page (Tampermonkey is the standard tool). The script can wait for Runner to exist and then apply your config edits automatically. Or take a copy of the open-source code, change the defaults in the source, and host it yourself. Either approach is real customization rather than runtime poking.

Why this works at all

The T-Rex Runner shipped to Chrome’s offline page in 2014 as readable, open-source code. The global object is exposed, a debugging helper for changing settings is built in, and no obfuscation hides the field names. That has let people build Python bots that read pixel data, AI agents that learn to play, and fan sites that customize the visuals. The accessibility of the internals is part of why this little game has had such a long second life. For more on the codebase itself, our source code explainer walks through the main loops.

Frequently asked questions

Will customizing Chrome Dino get me banned?

There is nothing to be banned from. The game has no accounts, no leaderboards, and no server. Console tweaks affect only your local browser session and reset on reload. You are modifying a copy of the game that is running locally.

Why do my changes disappear when I refresh?

The page reloads the original JavaScript and recreates the Runner instance with default values. To persist changes, use a userscript manager like Tampermonkey or fork the open-source codebase.

Can I customize the Chrome Dino on chrome://dino?

Mostly. Chrome’s built-in page also uses a Runner object, and the gameOver override is widely reported to work there. Chrome’s current code has been reorganized since the original release, though, so config names and helper methods may not match exactly. Test each command and check Runner.instance_ in the console to see what’s available.

What’s the highest MAX_SPEED that still feels playable?

It depends on your reflexes and screen. The default cap is 13, so even values in the high teens feel very fast. As the number climbs, obstacles jump many pixels per frame and collisions start to feel like luck rather than skill. Try raising it a few points at a time.

Is the immortality trick a bug?

Not really — it’s a consequence of how the game exposes its methods. The original Chromium developers shipped the code without obfuscation, so the gameOver method can be overridden like any JavaScript function. It is a feature of an open codebase, not a vulnerability.

The bottom line

The T-Rex Runner is one of the most modifiable games on the public web because its authors never tried to hide it. Five console lines can turn it into a slow-motion meditation, a hypersonic blur, or an unkillable side-scroller. None of it persists, none of it cheats anyone, and all of it teaches you a little bit about how the game actually works. Open the console, paste something silly, and watch the dino do something it was never quite supposed to do.

Related: The Silence of Chrome Dino: A Tribute · The Cult of Chrome Dino Explained · How to Teach Kids Chrome Dino (Beginner Guide)