Stellaris Debugtooltip and IDs Guide

Every Stellaris console guide eventually tells you to "enter the empire ID" or "pass the species ID" and moves on, as if you were supposed to know it. You are not. The game never shows these numbers in the normal interface — they exist only in the debug layer, and debugtooltip is the door into that layer. Once you understand that, the console stops being a list of cheats to memorize and becomes a lookup table: hover anything, read what it is, act on exactly that thing.

This page teaches the lookup table first and the commands second. If you finish it with the mental model — which IDs are stable, which are unique to your save, and how to find any ID or command the game has — you will never need another cheat sheet. If you only want the commands, the full catalog lives in the Stellaris console commands list; this guide is about the skill that makes all of them usable.

Why IDs Are the Whole Game

Console commands are technically cheats, but that framing undersells them. Their real job is testing: building scenarios that a normal game would take hours to arrange. Want to know whether twenty battleships beat a hundred corvettes? In a real campaign you would need two empires, the right tech, the right economy, and a war — days of setup for a two-minute answer. With console commands the same test takes about two minutes, because you build both fleets under one empire and make them fight each other.

Here is the catch that makes debugtooltip essential: the commands that do interesting things to specific objects do not accept names. They accept IDs. play does not take "the Aquarians" — it takes 21. add_intel does not take "my rival" — it takes an empire index and a number. The galaxy on your screen is made of named, visible, clickable things; the console speaks only in internal numbers. Debugtooltip is the translator between the two. Turn it on, hover an empire, and its index appears. Hover a species, and its species ID appears. The ID is the bridge between looking at a thing and acting on a thing.

That is also why this skill outlives any patch. Command names occasionally change, balance numbers constantly do, but the architecture — objects have internal IDs, commands consume IDs, a debug toggle reveals them — has been the shape of every Paradox game for twenty years. Learn the loop once and you can re-derive everything else in any version of the game.

The legitimate uses, in rough order of how people actually use them:

• Testing and sandbox experiments. Fleet balance checks, crisis rehearsals, "what if I played as them" afternoons. The console exists for this.
• Mod debugging. With dozens of mods loaded, hover-IDs are how you confirm which mod's empire, species, or event is actually firing.
• Fixing a broken game state. A corrupted save, a stuck event chain, a bad random start — targeted commands can repair what restarting would lose.
• Cinematics and screenshots. Observer mode plus a free camera turns the galaxy into a film set.

Turning Debugtooltip On

Start with the hard gate, because it explains half the "it doesn't work" posts on the internet: the console does not exist in Ironman mode or multiplayer. It is disabled there by design, and no key combination brings it back. Everything on this page assumes a normal, non-Ironman single-player save. If your console will not open at all, that is almost always the cause — the fix is in the console commands not working guide.

Open the console with the tilde key (~), top-left of the keyboard above Tab. On some keyboard layouts the binding is Shift+Alt+C instead; press the same key again to close it. A text field appears at the top of the screen — that is the entire interface. Type debugtooltip and press Enter. Nothing visible happens yet, which trips people up: it is a toggle command, and it arms silently. Now hover anything on the galaxy map. Empires show their internal index, systems and planets show their object IDs, species and leaders show theirs. Type debugtooltip a second time and the extra information disappears. Every toggle on this page — instant_build, invincible, debugtooltip itself — works the same way: enter once to flip on, enter again to flip off.

Two conveniences make console life much easier than typing everything. First, the console has a built-in menu that exposes many common commands as clickable toggles and sliders — disable-AI, instant build, max resources, survey, communications. You never need to remember those spellings. Second, two meta-commands answer almost any question you could have: help prints every console command the game exposes, and Tab autocompletes whatever you are typing, including technology and tradition IDs. If a command or ID exists, those two features will find it — which matters, because it means you never have to trust a guide (including this one) over the game itself.

The Two ID Systems

This is the single most useful fact in the guide, and most players never learn it: Stellaris runs two completely separate ID systems, and confusing them is the source of most failed commands.

The first system is numeric instance IDs. Every empire, species, leader, planet, and fleet that actually exists in your save gets a number assigned when that object is created. These are the IDs debugtooltip shows you on hover. They are unique to your save file — the Aquarians might be empire 21 in one campaign and empire 9 in the next — which means you can never copy someone else's numbers from a video or a forum post and expect them to hit the same target. Always read your own. One number is the exception that anchors the whole system: your player empire is always index 0. No matter which empire you hijack, no matter how long you play, play 0 takes you home.

The second system is named string IDs. Technologies, traditions, ascension perks, and events are defined in the game's script files with fixed text names: tech_titans, tr_expansion_adopt, ap_one_vision, crisis.1000. These names are the same in every save on the same game version. You do not hover to find them — you discover them with Tab autocomplete in the console, or by browsing the game's script files, where event IDs live in the /event folder as plain text. Browsing those files is the durable skill: whatever the current version of the game, the exact list of event and technology IDs is sitting in your install directory, readable in any text editor.

Property	Numeric instance IDs	Named string IDs
Used for	Empires, species, leaders, planets, fleets, pops	Technologies (tech_), traditions (tr_), ascension perks (ap_), events (namespace.number)
How you get them	Hover with debugtooltip on	Tab autocomplete, or the game's script files
Same in every save?	No — unique to your campaign	Yes — fixed per game version
Typical command shape	command <id>, e.g. play 21	command <name>, e.g. research_technology tech_titans
What goes wrong	Copying someone else's number and hitting the wrong object	Using a name that was renamed or removed in a newer version

Notice what this means for any guide you read, this one included. Any article that gives you a numeric ID — "empire 22", "species 80" — is showing you an example from the author's save, not a value you can use. Any article that gives you a string ID — tech_titans, crisis.1000 — is giving you something real, valid until a patch renames it. The right reflex when a command fails is therefore not "the guide is wrong" but "which ID system am I in, and did I source this ID correctly?"

Empire IDs: Switch, Absorb, Spy

Empire IDs are where the loop pays off fastest, because an empire index unlocks the most dramatic commands in the game. Turn debugtooltip on, hover another empire's flag or border, note the index — then choose your verb.

play <id> transfers your control to that empire, instantly and completely: their economy, their fleets, their wars become yours. It is the cheapest way to answer "what is it actually like to play as them?" without starting a new campaign. Because your original empire is hardcoded to index 0, play 0 always returns you to where you started, which makes empire-hopping a zero-risk excursion. A subtler use: switching to a rival, toggling AI off, and building fleets under their flag to set up a balanced test battle — then switching home and watching it play out.

force_integrate <id> absorbs the target empire into yours outright — their planets, pops, and fleets join your country in one step. It is less a cheat than a fast-forward for the annexation you were going to do anyway, and it is handy for testing what a huge multi-species realm actually feels like to administer before you commit to conquering one the slow way.

add_intel <id> <amount> adds intel points on that empire — for example add_intel 2 70 might take you from 10 to 80 intel, unlocking their government details, fleet compositions, and sensor data. Pair it with the galaxy-map intel actions and you can inspect any fleet in the galaxy, including opening its ship designs to learn what a rival is building.

Two empire-adjacent commands deserve a warning label. own transfers any planet in the galaxy to you — including another empire's capital, which is the fast path to testing a different species' homeworld. But ownership follows the starbase: if you own a planet without also own-ing its system's starbase, control quietly reverts to the original owner. Always take both. And damage <amount>, run with a fleet selected, deletes that many points of hull directly — it bypasses shields and armor entirely. That makes it a surgical tool for culling an annoying fleet down to size, and it means the number you type must be sized against the target's hull, not guessed. A ship with nine hundred hull takes damage 800 and is left near death; the same command against a fleet with five thousand hull per ship is a rounding error.

Species, Leaders, and Traits

Trait commands are the first place you meet the two-argument pattern: one ID says who, the second says what. Hover a species with debugtooltip on and you get its species ID — say 80. The trait itself also has a numeric ID; trait 0 is Intelligent. So add_trait_species 80 0 makes that entire species Intelligent, and remove_trait_species 80 0 takes it back. Leaders work the same way through add_trait_leader <leader_id> <trait_id>: hover the leader to read their ID, then pair it with the trait you want.

The principle underneath: any command shaped like command <target_id> <modifier_id> is asking two questions, and debugtooltip only answers the first one. Your cursor can find the species; it cannot find the trait number, because traits are not objects on the map. For the second argument you lean on the string-and-list side of the world — the Stellaris IDs list collects the trait, technology, and event numbers worth knowing, and Tab autocomplete plus the game files cover the rest.

This is genuinely useful beyond sandbox fun. Modders use it constantly to verify that a custom species or leader trait is attaching to the right target. Players use it to prototype: before spending a genetic modification campaign on a trait combination, slap the traits onto a test species with the console and watch the economy for fifty years. It is the difference between guessing that a build works and measuring that it does.

One related command, grow_pops <number>, selects a planet and adds pops for testing buildings and district layouts. Know its quirk before you trust it: the number is a scaled input, not a literal pop count — since the pop rework, grow_pops 1000 produces far more than a thousand pops — and large values still take real in-game time to finish growing. Treat it as "add a lot of pops to this world" rather than "add exactly N."

Event IDs: Crises on Demand

Events are the half of the game that runs on pure string IDs, and the event command is how you fire them by hand: event <namespace.number>. No hovering involved — there is nothing on the map to point at. You are invoking a script by name, and the names live in the game's /event script files, one text file per namespace. That is worth internalizing, because it makes every published "event ID list" — including the one below — a convenience rather than a dependency. When a list is incomplete or stale, the authoritative source is a folder on your disk.

The classic use is summoning end-game crises for a rehearsal, a time-lapse, or a challenge run. The crisis namespace is crisis, and the three galactic crises each have an entry point:

Crisis	Command	What happens
Prethoryn Scourge	event crisis.10	Starts the full warning chain; they arrive within a couple of years. For near-instant arrival, fire event crisis.12 then event crisis.14.
The Unbidden	event crisis.1000	Spawns them directly — no warning chain.
The Contingency	event crisis.2005	Fires the natural "go signal" chain. event crisis.2000 is the immediate-spawn alternative.

There is exactly one trap here, and it is a good one: do not fire both Contingency commands. crisis.2000 and crisis.2005 are two separate spawn paths, and running both gives you two separate Contingencies. If you want the natural version, crisis.2005 alone is the whole recipe.

The payoff most people never try: spawn all three crises, enter observe mode, and watch. Observer mode detaches you from any empire — you can spectate freely across the galaxy or view the war from any nation's seat — which turns a three-crisis free-for-all into the best cinema Stellaris can produce. The same mode is how you study what the AI actually does with a new mechanic, which is worth more than any amount of theorycrafting.

Ship Designs and Script Files

Ships break the ID pattern, and knowing how saves a lot of confusion. add ship <name> spawns a ship at your cursor — but it takes the design name, a string you chose in the ship designer, not a numeric ID. And it only sees designs you created yourself: auto-generated designs are filtered out of the spawn pool entirely. So the setup is deliberate. Open the ship designer (F9), switch off the auto-generated designs toggle, create a design, and give it a memorable name. Only then does add ship hello have something to find. The full design side of this — what is worth building in the first place — is in the ship design guide.

Spawning one ship at a time gets old fast, which is where script files come in. The run <filename> command executes a text file line by line, each line parsed as a console command. A file containing three lines of add ship hello spawns three ships. Two rules keep it working: leave no empty line at the end of the file (the parser will try to execute the blank line and throw a "command not found" error), and place the file in the Stellaris root folder — the one Steam opens via right-click → Properties → Local Files → Browse — because run resolves names relative to that directory.

The failure that catches everyone is not Stellaris at all; it is Windows. Explorer hides file extensions by default, so the file displayed as "spawnships" is really spawnships.txt on disk, and run spawnships fails with "could not find file." Worse: if you typed ".txt" yourself while extensions were hidden, the real name is spawnships.txt.txt, and Explorer will never show you that. The quick diagnosis is right-click → Properties → Details, which shows the resolved name. The permanent fix is Explorer → View → Options → View tab → uncheck "Hide extensions for known file types." Do the permanent fix — it costs thirty seconds and removes an entire class of mystery failures from your life.

A Clean Testing Workflow

The difference between a console session that teaches you something and one that corrupts a save is workflow, not knowledge. Three principles carry everything below: isolate (never experiment in the save you care about), freeze (an active AI turns your experiment into noise), and checkpoint (save after setup, before the test, so the test is repeatable). Every step below is one of those three.

1. Duplicate your save, or start a fresh test campaign. Commands like own and force_integrate rewrite the game state with no undo. A copied save file costs nothing and makes every mistake recoverable.
2. Prepare the empire. research_all_technologies unlocks every normal technology — everything except repeatables; adding a 1 argument also grants event-locked tech like Leviathan armor and L-gate insights. instant_build makes all construction instant and, usefully, raises your resource storage cap to around a million. max_resources then fills those stores, so you can mass-build ships without re-running the command every time you run dry.
3. Turn the AI off. This is the step people skip and then cannot explain their results. instant_build is galaxy-wide — with the AI active, every empire in the galaxy builds instantly too, and the map turns to chaos. With the AI frozen the game also runs faster, because less is happening. Toggle it from the console menu or by command.
4. Build the scenario, then save. Construct both fleets, position them, grow your test pops with grow_pops. Now save the game. This checkpoint is what lets you run the same test ten times with different variables instead of rebuilding the setup ten times.
5. Run the test. For fleet combat, use the make-hostile toggle — find its exact current name with help — which turns all fleets hostile to each other, including your own fleets against each other. That last part is the trick: you do not need two empires to test a fight. For zero-risk observation, invincible stops your ships taking damage at all.

Two quality-of-life mechanics make the loop fast. The period key (.) advances the game by exactly one day; with instant build active, everything in the queue takes one day, so a single tap completes whatever you queued — a ship, a finished research project. And the up arrow recalls your last console command, so repeating grow_pops 1000 twenty times is twenty up-arrows and twenty Enters, not twenty retypes.

Two interactions will bite you if nobody mentions them. yesman forces every AI to accept any diplomatic demand — declare war, demand surrender, they fold — but it does nothing while the AI is disabled; with the AI toggled off, your demands simply hang unanswered. Re-enable the AI for yesman to bite. And remember that instant_build and the other toggles stay armed until you enter them again; a forgotten toggle in a long session is the classic source of "the game got weird" stories.

When the testing is done and you want the cinema: observe mode for spectating any empire's war, a plugged-in controller plus the gamepad command for free camera flight (one trigger for slow pans, the other for fast travel), and Ctrl+F9 to hide the entire UI for clean screenshots. This is the same toolkit machinima makers use — the console is half of Stellaris' film studio, and debugtooltip is how you aim the camera at exactly the right object.

FAQ

Next Reads

• Stellaris Console Commands and Cheats — the full command catalog this guide plugs into.
• Stellaris Console Commands Not Working — fixes when the console will not open or commands do nothing.
• Stellaris IDs List — trait, technology, and event IDs collected in one reference.
• Stellaris Ship Design Guide — what to build before you spawn it with add ship.
• Stellaris Beginner Guide — the normal-game fundamentals the console shortcuts skip over.
• Stellaris Returning Player Guide — what changed if your last campaign was a few versions ago.
• Stellaris Economy Guide — the resource flows you will be stress-testing with max_resources off.
• Best Stellaris Traditions and Best Ascension Perks — the tr_ and ap_ string IDs worth knowing by name.