Question

What things can I do in chromes developer console that will let me edit variables in a Unity WebGL game?

Answer 1

Short answer: a lot — but exactly what you can do depends on how the WebGL build was made (Mono vs IL2CPP, asm.js vs wasm, whether the page keeps a global unityInstance/Module, etc.). Below are practical techniques and concrete console commands you can try. Always do this only on code you own or have permission to inspect.

Steps and techniques

1) Open DevTools
- Ctrl/Cmd+Shift+I → Console / Sources.

2) Find the Unity instance / Module
- Common globals: window.unityInstance, window.gameInstance, window.Module.
- In the console try:
- Object.keys(window).filter(k => /unity|gameInstance|module/i.test(k))
- window.unityInstance || window.gameInstance || window.Module
- If the page used UnityLoader.instantiate it often returns a variable you can inspect.

3) Use SendMessage to call C# methods
- If a GameObject and method exist you can call them from JS:
- unityInstance.SendMessage('GameObjectName', 'MethodName', 'stringOrNumber')
- Example: unityInstance.SendMessage('Player', 'SetHealth', '999')
- This is the simplest way to change game state if the game exposes methods.

4) Inspect and edit JS scope variables / closures
- In Sources, open the generated JS file(s). Use Pretty print ({}) if minified.
- Set breakpoints on initialization or game loops. When paused you can inspect/modify local variables in the Console.
- While paused, type variable names or assign new values (e.g., player.health = 100).

5) Edit runtime JS code / override functions
- In Sources you can edit JS (or use Local Overrides) and change functions, then resume execution.
- You can also redefine functions at runtime in Console, e.g.:
- const old = Module.doSomething; Module.doSomething = function(){ return 42; }

6) Use Emscripten exports (Module.ccall / Module.cwrap / Module._foo)
- Many builds expose Module.ccall / Module.cwrap (Emscripten). If a C function is exported, call it:
- Module.ccall('my_exported_function', 'number', ['number','string'], [1,'a'])
- Or wrap: const fn = Module.cwrap('my_exported', 'number', ['number']); fn(123);
- You can also access raw exported symbols as Module._symbolName.

7) Read/write memory via HEAP buffers (advanced)
- Emscripten exposes typed array views of wasm/asm heap:
- Module.HEAP8, Module.HEAPU8, Module.HEAP32, etc.
- You can read and write raw memory:
- Module.HEAP32[addr >> 2] = 42
- This requires knowing addresses/structures (not trivial for managed C# objects).

8) WebAssembly -> exported functions and memory
- For wasm builds you may find WebAssembly exports. Look on Module or unityInstance.Module for 'wasmExports' or similar.
- DevTools (Sources) can show wasm files and let you set breakpoints in wasm functions (experimental). You can view/modify linear memory via the Memory tab.

9) Use the debugger to modify variables when paused
- Set breakpoints in the JS/wasm code. When execution is paused you can inspect scopes and change variable values directly in the Console (or via right-click → Add expression).

10) DOM/UI hacks
- If the value is just shown in DOM elements, change the DOM directly:
- document.querySelector('#score').textContent = '9999'
- Or overlay your own HTML/CSS to change the player display.

11) Create small snippets to run repeatedly
- In Sources → Snippets create a helper snippet to locate the instance and call SendMessage or patch Module.

Useful quick console commands (try these)
- Find probable instance:
- Object.values(window).find(x => x && typeof x.SendMessage === 'function')
- Call SendMessage:
- (window.unityInstance || window.gameInstance).SendMessage('Player','SetHealth','999')
- List Module keys:
- Object.keys(window.Module || {})
- Try ccall existence:
- typeof Module.ccall === 'function' && console.log('ccall ready')

Caveats and limitations
- IL2CPP/managed C# objects are not trivially editable by poking wasm memory unless you deeply understand the runtime and memory layout.
- Many builds don’t expose game internals to JS, so SendMessage or exported bindings might be the only safe path.
- Modifying code client-side is temporary (reload will restore original) unless you use DevTools Local Overrides.
- Be careful: modifying runtime objects can break the game or cause crashes.
- Don’t use these techniques on multiplayer games where changing values could be cheating — legal/ethical issues.

If you tell me which Unity/WebGL build you’re looking at (see window.Module, unityInstance, whether you see wasm files in Network tab, or paste a snippet of the global variables), I can give specific commands tailored to that build.