REPO doesn’t just hide its depth in enemy AI, procedural chaos, and co-op synergy—it also ships with a full developer console quietly sitting under the hood. This is the same internal tool the devs use to test builds, validate mechanics, and brute-force edge cases, and on PC it’s fully accessible to players willing to experiment. If you’ve ever wondered how people spawn items, freeze enemies, or recover a glitched run without restarting, this is where all of that happens.
At its core, the REPO developer console is a real-time command-line interface layered on top of the game engine. It lets you issue direct instructions to the game while it’s running, bypassing normal progression rules, RNG checks, and sometimes even core survival mechanics. Used carefully, it’s one of the most powerful sandbox tools REPO offers. Used carelessly, it can absolutely break a run, a save file, or a co-op session.
What the console actually does in REPO
The console gives you direct access to gameplay variables that are normally locked behind code. That includes spawning items or enemies, toggling invulnerability, manipulating stamina and health values, forcing events, and altering player or world states on the fly. Think of it as a surgical debug scalpel rather than a traditional cheat menu.
This is especially valuable in a game like REPO, where difficulty spikes can hinge on RNG, aggro behavior, or a single bugged interaction. Instead of wiping a 40-minute run because an enemy clipped through geometry or an objective failed to trigger, the console lets you fix the problem and keep playing. For content creators, modders, and theorycrafters, it’s also the fastest way to test how systems actually behave under stress.
How players typically use it
Most PC players use the console for controlled experimentation rather than straight-up god mode. Testing how much DPS a weapon really outputs, checking enemy health scaling in later phases, or validating whether I-frames actually exist on a dodge are all common use cases. It’s also useful for learning boss mechanics without repeatedly grinding attempts.
In solo play or private lobbies, the console becomes a full sandbox. You can practice encounters, simulate worst-case scenarios, or prototype challenge runs without wasting time on setup. For co-op groups, it’s often used as a recovery tool—unsticking a soft-locked mission, respawning a disconnected teammate’s gear, or stabilizing a session that’s about to collapse.
Enabling the console and using it safely
On PC, the console is enabled through REPO’s launch parameters or in-game settings depending on your build. Once active, it’s usually bound to a tilde or function key and opens as an overlay without pausing the game. Commands execute instantly, so there’s no confirmation prompt and no undo button.
That immediacy is where players need to be careful. The console doesn’t protect you from invalid states, conflicting commands, or progression-breaking changes. Issuing commands mid-combat or during scripted events can desync AI, break objectives, or corrupt the current run. The safest approach is to use it between encounters, test one command at a time, and avoid stacking multiple state-altering commands unless you know how they interact.
Multiplayer limitations and risks
In multiplayer, the console is not a free-for-all. Most commands only work for the host, and some are outright disabled in public matchmaking to prevent abuse. Even in private lobbies, console actions can cause desyncs if clients don’t receive the same state updates, especially when spawning entities or altering world conditions.
There’s also the social side of it. Using the console without group consent can trivialize encounters, invalidate progression, or ruin the tension that makes REPO’s co-op shine. Treat it like a DM tool in a tabletop game: powerful, situational, and best used transparently. For experimentation, testing, or fixing legitimate issues, it’s invaluable. For normal play, restraint is part of using it correctly.
How to Enable the REPO Console on PC (Launch Options, Keybinds, and Common Issues)
With the risks and limitations out of the way, the next step is actually getting the console to show up. REPO doesn’t surface its developer console by default, and the exact method can vary slightly depending on your build and platform settings. On PC, though, enabling it is straightforward once you know where to look.
Enabling the console via Steam launch options
The most reliable method is through Steam’s launch options, especially if you’re running the standard PC build without mods. In your Steam library, right-click REPO, open Properties, and look for the Launch Options field at the bottom of the General tab.
Add the developer flag used by your current build, typically something along the lines of enabling a dev or debug console. Once applied, the console is initialized as soon as the game boots, meaning you don’t need to toggle anything in-game. If the console doesn’t appear after launch, fully close REPO and restart it to make sure the parameter actually registered.
In-game settings and config file toggles
Some builds expose console access directly in the settings menu, usually under Gameplay or Advanced options. If you see anything referencing developer tools, debug mode, or console access, enable it and restart the session. These toggles often don’t take effect mid-run.
For mod-friendly players, the REPO config files can also include a console flag. Editing these manually lets you force the console on, even if the UI option is missing. Always back up the config before changing anything, since a malformed entry can prevent the game from launching.
Default console keybinds and rebinding issues
Once enabled, the console is usually bound to the tilde key, the one under Escape on most keyboards. Some layouts instead use function keys like F1 or F2, depending on region and keyboard language. Pressing the correct key brings up a transparent overlay without pausing the game.
If nothing happens, check for keybind conflicts. Overlays from Steam, Discord, GPU drivers, or keyboard software can intercept the input before REPO ever sees it. Rebinding the console key in the controls menu, if available, or temporarily disabling other overlays often fixes the issue instantly.
Why the console won’t open (and how to fix it)
The most common problem is trying to open the console in a mode where it’s restricted. Public matchmaking, certain challenge runs, or locked-down scenarios can block console access entirely, even if it’s enabled at launch. In those cases, the keypress does nothing by design.
Another frequent issue is build mismatch. After patches, older launch options or config flags may stop working. If the console suddenly disappears after an update, remove all custom parameters, launch the game once clean, then reapply them. This resets the initialization order and clears out deprecated flags.
Using the console safely once it’s open
When the console does appear, remember that it’s live the moment you hit Enter. Commands execute immediately, without validation or rollback, and they don’t care what state the game is currently in. Running commands during cutscenes, scripted objectives, or active combat can create bugs that persist for the rest of the run.
The safest workflow is to pause between encounters, issue one command at a time, and observe the result before stacking anything else. In co-op, only the host should be interacting with the console unless everyone understands the risk. Treat the console like a loaded weapon: powerful, precise, and best handled deliberately.
Console Command Safety, Save Risks, and Multiplayer Limitations Explained
Once you’re comfortable opening and using the console, the next thing to understand is what it can break. REPO’s console is not a cheat menu with guardrails; it’s a direct line into the game’s runtime logic. That power comes with real risks to saves, progression, and especially multiplayer stability if you’re careless.
How console commands interact with saves and progression
Most console commands in REPO execute at the session level, not the save-file level, but the line between the two is thinner than it looks. Commands that spawn items, alter resources, skip objectives, or force state changes can permanently flag a save as “completed” or “invalid” for certain progression checks. This is how players accidentally soft-lock future content or trigger unlocks out of order.
Autosaves are the real danger zone. If the game saves after a broken state is introduced, rolling back isn’t always possible without manual backups. If you’re experimenting, disable cloud sync temporarily and keep a clean backup of your save folder before running anything that touches inventory, world state, or objectives.
Commands that are safe to test versus commands that can break a run
Diagnostic and visualization commands are generally low-risk. Things like FPS counters, hitbox overlays, AI debug views, or camera tools usually reset cleanly when you reload the session. These are ideal for learning mechanics, testing aggro ranges, or understanding how damage and RNG actually resolve under the hood.
High-risk commands are anything that modifies the simulation itself. Spawning enemies, teleporting during scripted moments, forcing phase changes, or editing player stats mid-combat can desync triggers or leave invisible flags stuck in the wrong state. If a command changes how the game thinks time, health, or objectives work, assume it can permanently alter the run.
Why console usage is restricted in many multiplayer modes
REPO’s multiplayer architecture is host-authoritative, which means the host’s game state is the source of truth. Letting unrestricted console commands run in public or matchmaking lobbies would be an instant exploit nightmare. That’s why console access is often disabled entirely outside of solo play or private sessions.
Even in private co-op, only the host’s console commands reliably propagate to other players. Client-side commands may appear to work locally but fail to sync, leading to rubberbanding enemies, invincible targets, or objectives that complete for one player and not the others. If you’ve ever seen a boss with zero HP still attacking, that’s usually a desync caused by console interference.
Best practices for using commands in co-op without breaking everything
If you’re experimenting in co-op, treat it like a controlled test environment. Only the host should run commands, and everyone should agree on what’s being tested before anything is typed. Run commands between encounters, not mid-fight, to avoid corrupting AI states, hitboxes, or damage calculations.
For modders or groups sandboxing mechanics, private lobbies with progression disabled are the safest option. Finish the test, exit to the menu, and relaunch before continuing a “real” run. This clears temporary flags and prevents experimental commands from bleeding into long-term saves.
Anti-cheat, flags, and what the console can silently mark
REPO doesn’t always warn you when a command flags your session. Some commands quietly disable achievements, progression tracking, or online eligibility until the game is restarted. Others mark the session internally as modified, which can affect matchmaking or future unlocks even if everything looks normal on the surface.
If achievements or unlocks suddenly stop triggering, the console is the first suspect. A full restart usually clears the flag, but not always. When in doubt, test commands on a throwaway profile so your main progression stays clean.
Golden rules for safe console experimentation
Never test commands on a save you care about unless you have a backup. Use solo or private modes, issue one command at a time, and watch how the game reacts before stacking effects. If something looks wrong, stop immediately and reload instead of trying to “fix” it with more commands.
Think of REPO’s console as a developer scalpel, not a god mode toggle. Used carefully, it’s perfect for testing mechanics, fixing bugs, or understanding how the game really works. Used recklessly, it can ruin a run faster than any boss ever could.
Core Utility Commands (Debugging, Information, and Quality-of-Life Tools)
Now that the safety rules are clear, it’s time to talk about the commands you’ll actually use the most. Core utility commands don’t rewrite progression or spawn chaos—they expose information, stabilize broken states, or remove friction while testing. If you’re diagnosing a bug, verifying a mechanic, or just trying to understand why something feels off, this is where you start.
Think of these as visibility and control tools rather than cheats. Most of them are safe in solo and private lobbies, but several can still flag a session if abused in co-op. Use them deliberately, watch the game state after each command, and never stack them blindly.
Console access and command execution basics
Before any utility command works, the developer console has to be enabled. In REPO’s PC build, this is done by adding the launch parameter -console or -devconsole through Steam’s launch options, then opening it in-game with the tilde (~) key. If nothing opens, check your keyboard layout—non-US layouts often bind the console to a different key.
Commands are case-insensitive and execute immediately on Enter. There’s no undo, no confirmation prompt, and no safety net. If you mistype a value or target the wrong system, the game will happily comply and break itself in the process.
Game state and session information commands
These commands are all about seeing what REPO is actually tracking under the hood. They’re invaluable when something feels wrong but you can’t pinpoint why through normal gameplay.
The most commonly used is showdebug, which overlays real-time system data on screen. This includes FPS, tick rate, player state flags, AI update cycles, and sometimes network sync indicators in co-op. If enemies are rubberbanding or damage feels delayed, this command usually explains why.
getgamestate prints the current session state to the console. It tells you whether the game considers you in combat, exploration, scripted sequence, or a transition state. This is especially useful when doors won’t unlock or objectives refuse to update, since many triggers are state-locked.
listplayers outputs every connected player, their internal ID, and host status. In co-op testing, this helps confirm who the game actually sees as host versus who the lobby UI claims is host. Mismatches here are a common cause of command desyncs.
Player and camera quality-of-life commands
These commands don’t directly affect progression, but they make testing and exploration dramatically smoother. They’re also the least risky when used sparingly.
noclip toggles free camera movement, letting your character pass through geometry. This is perfect for checking collision issues, stuck objectives, or enemy spawn locations. Always disable it before re-entering combat, since fighting with noclip active can corrupt hit detection.
freecam detaches the camera entirely from your character. Unlike noclip, your player stays put while the camera moves. This is ideal for observing AI behavior, aggro ranges, and animation timing without interfering with the encounter itself.
fov [value] adjusts the field of view dynamically. While often used for comfort, it’s also helpful for testing peripheral visibility, enemy telegraph readability, and UI scaling at extreme values. Keep changes moderate, as extreme FOVs can cause visual bugs.
HUD, UI, and feedback debugging commands
When REPO’s interface lies to you, these commands tell the truth. They’re essential for diagnosing missing prompts, broken markers, or inconsistent damage feedback.
togglehud enables or disables the entire HUD layer. If objective markers or damage numbers stop appearing, toggling the HUD can force a refresh without reloading the session. This fixes more UI bugs than it has any right to.
showhitboxes overlays active collision and damage zones. This command is gold for understanding why attacks miss, why enemies feel unfair, or why headshots aren’t registering. Use it in solo only—co-op hitbox visualization can desync clients.
showdamage reveals raw damage numbers before mitigation. This lets you verify DPS, crit multipliers, and damage falloff without relying on enemy health bars, which can lag or lie during heavy combat.
AI, pathing, and encounter stabilization tools
When enemies break, these are the commands that get things moving again. They don’t fix underlying bugs, but they can stabilize a run long enough to continue testing.
resetai forces all active AI entities to reload their behavior trees. If an enemy freezes, loops an animation, or refuses to aggro, this command often snaps them back to life. Use it between encounters whenever possible.
killallai instantly removes all non-player AI from the current area. This is a blunt instrument, but it’s useful when an encounter soft-locks progression. Be aware that this can skip triggers tied to enemy deaths, so only use it when the run is already broken.
showpathing displays navigation meshes and AI movement routes. This is primarily for modders and advanced testers, but it also explains why enemies get stuck on certain terrain or take bizarre routes during combat.
Performance and stability monitoring commands
If REPO starts chugging, stuttering, or behaving inconsistently, performance commands help isolate the cause. These don’t improve performance directly, but they explain what’s happening.
stat fps and stat unit display frame timing, CPU usage, and GPU load. Spikes here often correlate with physics-heavy encounters, particle spam, or network sync in co-op.
netstats reveals latency, packet loss, and sync delays in multiplayer sessions. If damage feels delayed or enemies teleport, this command usually confirms whether the issue is network-side or AI-side.
flushcache clears temporary asset and shader caches mid-session. This can reduce hitching after long play sessions, but it may cause a brief stutter when assets reload. Never use it during combat.
Reset and recovery commands
These commands exist for when something has already gone wrong. They’re not elegant, but they can save a test session from a full restart.
reloadlevel reloads the current area while preserving session settings. This often fixes broken triggers, missing enemies, or unloaded assets. Progress within the level is usually lost, so treat this as a last resort.
resetplayerstate clears temporary status flags on the player, including stuck animations, invulnerability glitches, or incorrect movement states. If your character can’t sprint, dodge, or interact, this is the first thing to try.
restartsession fully resets the current run without exiting the game. This clears most console flags, but not all achievement locks. If progression matters, a full game restart is still safer.
Used correctly, these core utility commands turn REPO into a transparent, testable system instead of a black box. They’re the foundation for every deeper experiment, whether you’re chasing a bug, tuning a mod, or just trying to understand why the game behaves the way it does.
Gameplay & Sandbox Commands (Spawning, Movement, Physics, and Experimentation)
Once performance is stable and systems are behaving, REPO’s console really opens up. Gameplay and sandbox commands are where the game stops being just a run-based experience and starts functioning like a full-on test environment. These are the commands players use to spawn entities, bend movement rules, stress physics, and break encounters apart piece by piece.
Before diving in, a quick safety reminder: only use these in solo play or private co-op lobbies with full consent. Many of these commands desync clients, invalidate progression, or outright crash public sessions. If you’re testing mechanics, set up a clean environment first and document what you change.
Spawning enemies, NPCs, and objects
Spawning commands are the backbone of sandbox testing. They let you isolate enemy behavior, measure DPS, and stress-test crowd control without relying on RNG encounters.
spawnenemy [enemy_id] creates a single instance of the specified enemy at your crosshair location. This is ideal for learning attack patterns, hitboxes, and I-frame timings without distractions. Some bosses require sufficient arena space or they’ll immediately break pathing.
spawnenemywave [enemy_id] [count] drops multiple enemies at once. This command is notorious for exposing AI bottlenecks and physics instability, especially in co-op. Use it sparingly unless you’re intentionally testing worst-case scenarios.
spawnnpc [npc_id] works similarly but is reserved for non-hostile or scripted characters. This is useful when testing dialogue triggers, escort behavior, or mission flags that sometimes fail to fire naturally.
spawnitem [item_id] spawns weapons, consumables, or key objects. Players commonly use this to test damage scaling, ammo economy, or how certain modifiers interact with different builds. Be aware that spawned items can bypass progression checks.
Player movement and positioning controls
Movement commands are invaluable for debugging traversal, animation locks, and collision issues. They also let you explore maps in ways the game normally restricts.
fly toggles free-flight movement, ignoring gravity and collision. This is perfect for scouting arenas, checking invisible walls, or verifying whether geometry issues are causing enemies to get stuck. Always turn it off before resuming combat, as it can corrupt movement states.
ghost disables collision while keeping gravity active. This allows you to pass through walls, floors, and props without breaking vertical physics. It’s safer than fly for interior testing, but it still invalidates most encounters.
teleport [x] [y] [z] instantly moves your character to specific coordinates. Advanced users pair this with map debugging tools to reproduce bugs in exact locations. Teleporting during animations can cause temporary desync, so resetplayerstate afterward if something feels off.
Physics manipulation and environmental testing
REPO’s physics system is reactive, layered, and surprisingly fragile under stress. These commands let you see where it bends and where it breaks.
setgravity [value] changes global gravity strength. Lower values exaggerate knockback and airtime, while higher values can reveal animation snapping and landing bugs. Physics calculations scale in real time, so extreme values may destabilize ragdolls.
timescale [value] speeds up or slows down the entire game simulation. This is one of the best tools for studying enemy windups, dodge windows, and hit registration. Anything below 0.5 or above 2.0 can cause audio and animation desync.
freezephysics pauses all physics-driven motion in the scene. This is commonly used to inspect mid-action states, projectile trajectories, or overlapping hitboxes. Unfreezing during heavy action can cause sudden spikes, so watch your frame timing.
Combat and experimentation tools
These commands are where theorycrafting turns into hard data. They let players push combat systems beyond what normal runs allow.
godmode grants full invulnerability and infinite stamina. This is essential for learning boss patterns or testing aggro behavior without worrying about survival. Damage immunity does not always protect against scripted instant-fail mechanics.
infiniteammo removes reloads and resource constraints. DPS testing becomes dramatically more consistent with this enabled, especially when comparing weapons with different reload profiles.
killallenemies does exactly what it says. It’s a blunt tool, but useful when encounters bug out or you need to reset an arena without reloading the level. Using it can skip progression triggers tied to combat completion.
Multiplayer limitations and co-op risks
Sandbox commands behave very differently in co-op. The host’s console has authority, but not all changes propagate cleanly to clients.
Spawning enemies or items may only sync partially, leading to invisible threats or duplicated objects for other players. Movement and physics commands like fly or timescale almost always desync non-host clients.
For co-op experimentation, keep sessions private, limit command usage to the host, and avoid saving progress afterward. Treat these tools as a lab environment, not a normal run.
Player, Enemy, and World Manipulation Commands (Stats, AI, Time, and Environment)
Once you’re comfortable breaking combat rules, the next step is bending the entire simulation. These commands let you rewrite player stats, enemy behavior, and the world itself in real time. Used correctly, they’re invaluable for testing edge cases, reproducing bugs, or building custom sandbox scenarios.
Player stat manipulation
Direct stat control is where REPO starts feeling like a dev kit instead of a game. Most player-facing commands update instantly, meaning you can tweak values mid-fight and see the results without reloading.
sethealth [value] overrides your current HP to a specific number. This is useful for testing damage thresholds, bleed-out states, or how certain enemies scale their finishing moves. Setting values far above normal caps can bypass UI updates, so don’t rely on the health bar alone.
setstamina [value] controls sprinting, dodging, and any stamina-gated abilities. Zero stamina is great for confirming animation locks and recovery timing, while extreme values let you stress-test movement exploits.
setplayerspeed [value] modifies base movement speed before buffs and debuffs are applied. Small increments are best here; doubling speed can already break hitbox alignment and camera smoothing. Pair this with timescale for slow-motion movement analysis without losing precision.
fly toggles free 3D movement with no collision. This is primarily a debugging tool for navigation meshes, spawn placement, or unreachable geometry. In co-op, non-host clients often rubber-band or fall through the map when this is active.
noclip disables collision entirely, including walls and floors. Unlike fly, gravity still applies unless combined with other movement commands. Falling out of bounds can soft-lock the session, so always know how to toggle it off.
Enemy AI and behavior control
AI commands are essential for understanding how enemies perceive, target, and react to players. They’re also the fastest way to diagnose broken encounters.
ai_disable completely shuts down enemy logic while keeping models active. Enemies won’t move, attack, or react, making this perfect for inspecting hitboxes, weak points, and animation states. Reactivating AI mid-frame can cause enemies to snap or instantly aggro.
ai_ignoreplayer forces enemies to drop aggro regardless of proximity or damage taken. This is ideal for testing stealth detection cones or scripted triggers without combat interference. Some bosses ignore this flag once their fight state is locked in.
setenemyhealth [value] applies to targeted or all active enemies, depending on context. Lowering health to 1 HP is a clean way to confirm damage sources and DOT behavior. Raising it too high can overflow damage numbers and break death triggers.
killallenemies, while crude, is still part of AI control workflows. It’s often used after disabling AI to reset broken encounters or clear stuck spawns without restarting the level.
Time, simulation, and pacing control
Beyond raw timescale adjustments, REPO exposes deeper control over how the simulation advances. These tools are especially useful for animation, physics, and network testing.
pausegame halts the simulation while keeping the console active. Unlike menus, this freezes AI, physics, and timers simultaneously. It’s ideal for inspecting exact frame states during bug reproduction.
stepframe advances the game by a single simulation tick. This is a power-user command for analyzing hit registration, I-frames, and animation blending. Audio does not step cleanly, so expect desync during use.
timescale remains the cornerstone for pacing experiments, but pairing it with pausegame or stepframe gives you near frame-by-frame control. This is how players map true dodge windows instead of relying on feel.
World and environment manipulation
World-level commands affect everything in the scene, from gravity to lighting. They’re powerful, but also the easiest way to destabilize a run.
gravity [value] changes global gravity strength. Lower values are great for testing fall damage thresholds and aerial enemies, while higher values stress ragdolls and landing recovery. Extreme settings can permanently break physics until a reload.
settime [value] or settimeofday [value] forces the world clock to a specific point. This is mainly cosmetic, but some enemy spawns and events are time-gated. Skipping time can accidentally bypass progression logic.
weather_clear, weather_rain, or similar environment toggles control visual and atmospheric effects depending on the build. These don’t usually affect gameplay, but heavy weather can impact visibility and performance during testing.
freezephysics, when combined with environment changes, lets you reposition or inspect the world in impossible states. Always unfreeze during calm moments, as sudden reactivation under load can spike CPU usage or crash clients.
Safety tips for solo and co-op use
Most manipulation commands are safest in solo play or private lobbies. Even when the host has authority, world and AI changes don’t always replicate cleanly to other players.
If you’re testing with friends, agree on a reset plan before using stat or world commands. Avoid saving progress after heavy manipulation, and never assume a co-op session reflects “real” balance once the console has been involved.
Progression, Economy, and Unlock Commands (Testing Builds and Skipping Grinds)
Once you move past world manipulation, the next logical step is progression control. These commands let you bypass grind walls, test late-game builds early, or recover a save that soft-locked due to a bug or bad RNG. They’re invaluable for theorycrafting, but they’re also the fastest way to ruin a co-op run if used carelessly.
Progression and economy commands directly touch save data, unlock flags, and account-wide variables. That means they’re more persistent than physics or AI tweaks, and mistakes here tend to stick unless you reload an older save.
Currency and resource manipulation
addmoney [amount] instantly grants the specified currency to the active profile. This is the go-to command for testing shop rotations, upgrade paths, or high-cost unlocks without replaying early missions. Negative values usually work as well, which is useful for verifying economy checks or edge cases.
setmoney [amount] hard-sets your current currency total. Unlike addmoney, this overwrites rather than increments, so use it carefully if you’re mid-session. In co-op, only the host’s value is authoritative, and clients may visually desync until the next transaction.
addresource [type] [amount] injects crafting or upgrade materials directly into your inventory. Resource names must match internal IDs exactly, and invalid entries are ignored silently. This is ideal for stress-testing late-tier upgrades or confirming drop-rate balance without running dozens of missions.
Experience, levels, and progression skips
addxp [amount] grants raw experience to the current character or profile. This respects normal leveling rules, so multiple level-ups can trigger back-to-back unlocks. If you’re testing talent interactions, expect UI pop-ins or delayed notifications when large values are used.
setlevel [value] forces your character to a specific level, bypassing XP entirely. This is cleaner for build testing because it avoids partial progression states. Be aware that some passive unlocks only initialize on natural level-up events, which can lead to missing perks until a reload.
unlocktier [tier] or unlockprogression [stage] jumps the account to a defined progression breakpoint. These commands are commonly used by testers to validate mid- and late-game content. Skipping too far ahead can leave earlier tutorial flags incomplete, which may break UI prompts or soft-lock menus.
Item, gear, and ability unlocks
unlockall enables every item, weapon, ability, or character currently defined in the build. This is the nuclear option for sandbox testing and should never be used on a save you care about. In co-op, clients may see locked icons despite functional access, which is purely a UI replication issue.
unlockitem [itemID] grants access to a specific piece of gear. This is safer than unlockall and preferred for controlled testing. If the item doesn’t appear immediately, refresh the vendor or reload the hub to force inventory regeneration.
unlockability [abilityID] or unlockskill [skillID] flags a specific ability as learned. These commands don’t always auto-equip, so check your loadout manually. Using them mid-mission can cause animation or cooldown bugs, especially if the ability modifies movement or I-frames.
Resetting and fixing broken progression
resetprogression clears major progression flags while typically preserving core profile data. This is useful if a patch changes unlock logic or if a save becomes inconsistent after heavy console use. Always back up your save before running this, as results vary by build.
resettalents or resetskills refunds spent points and returns the tree to a clean state. This is safe for build experimentation and far less destructive than a full reset. In multiplayer, only the local player’s tree is affected.
fixprogression or validateprogress runs an internal check against expected unlock states. When it works, it can resolve missing unlocks or duplicated rewards caused by crashes. When it doesn’t, it usually does nothing, but it’s still worth trying before wiping a save.
Multiplayer risks and best practices
Progression commands should almost always be used in solo or private sessions. Even if the host has authority, unlocks and currencies don’t always replicate cleanly to clients, leading to phantom items or desynced shops.
If you’re testing builds with friends, establish a rule that no one saves after progression manipulation. Treat the session as disposable, gather your data, then return to a clean save. Console commands are incredible tools, but once progression is involved, discipline matters more than curiosity.
Using Console Commands in Co-op and Private Lobbies (What Works, What Breaks, What Gets Desynced)
Once you move from solo testing into co-op, REPO’s console stops being a pure sandbox and starts behaving like a half-synced developer tool. The game uses host authority for most systems, but not all values replicate cleanly to clients. That gap is where most bugs, visual glitches, and outright session-breaking behavior comes from.
Think of co-op console usage less like cheat codes and more like live database edits while multiple players are connected. Some commands are safe and predictable, others only affect the host, and a few will quietly poison the session until someone crashes or reloads.
Host authority: who should be running commands
In co-op, the host should always be the one using console commands. Client-side commands often execute locally but never replicate, creating situations where one player sees changes that don’t exist for anyone else. This is how you get invisible gear, missing abilities, or enemies that only one player can damage.
If a client absolutely needs to test something, have them host a private lobby instead. REPO does not currently provide a safe way for clients to push authoritative state changes through the console.
Commands that generally work in co-op
Spawn commands are the most reliable in multiplayer. Spawning enemies, items, or props from the host usually replicates correctly, including AI behavior, hitboxes, and loot drops. This makes them ideal for DPS testing, aggro behavior, or stress-testing encounter density with friends.
Stat inspection commands, debug overlays, and read-only queries are also safe. Anything that displays values without mutating progression or inventory state tends to stay client-local and won’t break synchronization.
Temporary world modifiers, like time scaling or AI pause commands, usually work as long as the host triggers them. Clients may see slight delays or animation stutter, but the underlying simulation stays intact.
Commands that partially work but desync clients
Inventory manipulation is the biggest offender here. Commands like giveitem, unlockitem, or addcurrency may succeed on the host but fail to fully replicate to clients. Teammates might see the item equipped but unusable, or see nothing at all while the server thinks it exists.
Ability and skill unlock commands are even riskier mid-session. Clients can end up with abilities that visually trigger but have no collision, no damage, or broken cooldowns. Movement skills are especially dangerous, often leading to rubberbanding or invalid positions that snap players back.
UI-based systems like vendors, shops, and loadout screens are prone to phantom states. One player might see an item as purchased while another sees it locked, even though both are technically interacting with the same backend data.
Commands that commonly break co-op sessions
Progression resets in multiplayer are a hard no. Commands like resetprogression, wipeprofile, or global unlock toggles can invalidate save data for clients in real time. Best case, nothing happens. Worst case, clients are forced into a broken progression state that persists after the session ends.
Mid-mission talent resets or respec commands frequently desync combat logic. Damage numbers, passive bonuses, and cooldown reductions may calculate differently per client, leading to wildly inconsistent DPS or enemies that feel invincible to one player and paper-thin to another.
Save-affecting commands should never be used while other players are connected. Even if the game doesn’t crash, the session state is often unrecoverable without everyone restarting.
Best practices for co-op testing with console commands
Always decide the goal of the session before anyone loads in. If you’re testing balance, enemy behavior, or mechanics, avoid progression and inventory edits entirely. If you’re testing builds, keep it private and treat the save as temporary.
Have all players reconnect after major command usage. A full lobby reload forces state re-synchronization and clears many soft desync issues that don’t resolve on their own.
Finally, never trust visual feedback alone in co-op. If something feels off, like inconsistent damage, missing effects, or delayed abilities, it probably is. REPO’s console is powerful, but in multiplayer, discipline and restraint matter just as much as knowing the commands.
Troubleshooting, Hidden Commands, and Best Practices for Power Users
At this point, you already know that REPO’s console is less a cheat menu and more a live wire into the game’s systems. Used correctly, it can save broken runs, isolate bugs, and let you test mechanics faster than any in-game menu. Used carelessly, it can corrupt saves, desync co-op, or leave you chasing phantom issues that aren’t actually gameplay-related.
This section is about control. Think of it as the difference between button-mashing and frame-perfect inputs.
Diagnosing bugs with console-first troubleshooting
When something breaks in REPO, your first instinct should be observation, not intervention. Enable the console and use read-only or toggle-style commands first, such as debug overlays, AI state displays, or collision visualization. These don’t change game state and are the safest way to confirm whether an issue is visual, systemic, or network-driven.
If enemies aren’t taking damage, check whether hitboxes are active and whether damage events are firing before touching health or godmode commands. A lot of “invincible enemy” bugs are actually aggro or phase-state problems, not HP values. Fixing the wrong layer can mask the real issue and make it harder to reproduce later.
For physics glitches or stuck players, position and velocity readouts are more reliable than teleport spam. Teleporting repeatedly often stacks invalid movement states, especially after knockbacks or grapples. One clean position reset is safer than five panic commands in a row.
Hidden and undocumented commands worth knowing
REPO includes several commands that don’t appear in standard help lists or only show up through autocomplete. These are typically internal debug tools left accessible for testing. They’re powerful, but also the easiest way to break things permanently.
AI-related toggles that freeze behavior, force idle states, or lock perception cones are invaluable for testing stealth, aggro ranges, and encounter scripting. Just remember that frozen AI often stops updating internal timers, which can break encounters when unfrozen mid-fight.
Environment and world-state commands, like forcing time-of-day, resetting encounter zones, or reloading map chunks, are excellent for troubleshooting softlocks. They’re also notorious for causing co-op mismatches if even one client doesn’t re-sync properly afterward.
There are also profile and flag inspection commands that let you view progression states without modifying them. These are safer than unlock-all or skip commands and should always be your first stop when diagnosing progression bugs.
Using the console to fix softlocks and corrupted states
Softlocks are where the console shines. If a door won’t open, an objective won’t advance, or an NPC refuses to update, look for commands that re-trigger objectives or refresh mission states rather than skipping them entirely. Skips often leave invisible dependencies unresolved.
Respawning entities or resetting interactables is usually safer than reloading the entire level. Level reloads can reset enemy spawns, loot tables, and RNG seeds in ways that permanently alter a run. If you care about preserving the experience, surgical fixes beat nuclear options.
If a save feels corrupted, stop experimenting. Back up the save file first, then test fixes incrementally. Many players accidentally destroy recoverable saves by stacking commands too quickly and losing track of what actually caused the failure.
Power user best practices for solo and co-op
Treat every console session like a test environment. Decide upfront whether you’re experimenting, fixing, or playing normally, and stick to that role. Mixing “just one tweak” into a serious run is how most long-term issues start.
In solo play, restart the game after heavy console usage. Memory states, cached values, and lingering flags don’t always clear on reloads alone. A full restart ensures you’re seeing real behavior, not leftovers from earlier tests.
In co-op, the host should be the only one issuing commands unless everyone explicitly agrees otherwise. Even harmless-looking commands can propagate differently to clients, especially anything tied to AI, loot, or progression. When in doubt, end the session, reset, and rejoin clean.
Final tip for mastering REPO’s console
The console isn’t about breaking the game; it’s about understanding it. The more deliberately you use commands, the better you’ll get at reading REPO’s systems, predicting edge cases, and fixing problems before they spiral. Respect the tool, document what you test, and you’ll get far more out of REPO than players who treat the console like a shortcut machine.
REPO rewards curiosity, but it punishes recklessness. Play smart, test clean, and the console becomes one of the most powerful features the game has to offer.