How to Install, Update, and Restore Factorio Mods【Space Age Compatible】

If you want to work with mods in Factorio 2.0 and Space Age environments, it's safer to separate the convenience of the in-game Mod Portal from the flexibility of manual management via the mods folder. This guide is written for anyone from those installing their first QoL mods to those managing public add-ons like quality and Elevated Rails without breaking the workflow.

The core principle is: know where your user data lives, back it up, verify dependencies and startup logs, then update, disable, or restore with confidence. Early on, I was disciplined about adding just one QoL mod at a time and checking logs before expanding. That habit meant zero save-file disasters and a smooth transition to larger mods later.

Prerequisites Before Installing Factorio Mods

Target Version and Scope of This Guide

This guide assumes Factorio 2.0 and later. I focus on the Mod Portal accessed through the in-game "MOD" menu and via the browser at factorio.com. The community commonly uses the Mod Portal, though Steam Workshop practices vary—I'd recommend checking first-hand sources for the current recommendation, as the official guidance typically lists Mod Portal as the primary route.

I separate this upfront because Factorio mod management doesn't stop at the game installation directory. Saves, settings, MODs, and script-output are all in the user data area, and their location depends on the write-data setting documented in Application directory - Factorio Wiki. On the same PC, if you're looking at the wrong folder, mods you think you've installed won't appear in-game—a basic but frustrating mismatch.

After 2.0, the boundary between vanilla, DLC, and community mods became clearer. At the same time, if you're not used to "official additions being managed as mods," the MOD list can be a bit disorienting at first glance. When I first added Space Age, I rechecked whether DLC-sourced add-on mods were active on the MOD screen, then toggled quality alone to understand the changes. Approaching it this way lets you grasp the official structure before layering community mods, reducing confusion significantly.

Note: adding or removing mods breaks replay data. Before updating to a new version, backing up the directory with saves and settings is strongly recommended. The "back up first, then tinker" approach remains valid in 2.0.

Application directory

wiki.factorio.com

Official Installation Routes

The most natural way to install Factorio mods is to search and install through the in-game Mod Portal. For ease of installation, handling dependencies, and keeping up with updates, this is the most stable entry point. Community practice confirms that auto-selecting essential dependencies during in-game browser installation is widely adopted.

The browser-based Mod Portal at factorio.com is better for searching and checking dependencies. Especially when you want to calmly see "what does this mod depend on?" and "what version series is it updated in?," the browser list is clearer than the in-game view. From a technical angle, the Mod portal API - Factorio Wiki endpoint api/mods/{name}/full also retrieves dependency arrays. For people managing large mod sets, running servers, or pinning modpacks, just knowing this API exists changes your outlook.

The strength of this approach is that version pinning and validation are straightforward. If you want to keep a large mod on an older version, avoid build breakage from updates, or preserve a reproducible environment, manual installation is more convenient than in-game adoption. In exchange, you manage dependencies and conflicts yourself. Missing prerequisite mods will simply fail on startup, and DLC-required mods will be rejected immediately. Note that UI labels and setting defaults may vary by version—always check the in-game settings screen for actual text and defaults.

When you want to keep a record of your setup, script-output/mods.txt writes all active mods and versions, handy for reproducing a configuration later. Factorio mod management relies on the official Mod Portal, user data placement, logs, and output files working together rather than a fancy dedicated launcher—understanding this design makes the whole thing clearer.

Mod portal API

wiki.factorio.com

Space Age and quality/Elevated Rails Clarified

Space Age is a paid expansion released on 21 October 2024, structured as three add-on MODs. From Japanese and English sources combined, the scope is huge: 4 new planets, 5 new science packs, 22 buildings, 30 intermediate products, 5 weapons, 2 enemy types, and 29 achievements. Even starting as a vanilla extension, you'll feel like you've crossed into an entirely separate phase. This DLC is honestly almost like a second Factorio.

What matters here is that Space Age additions aren't hardcoded into the game itself—they're visible on the MOD screen as managed items. That's why when you first see the MOD list after installing, it's unclear "where vanilla ends and community mods begin," but structurally you grasp it all on the same management screen.

Quality is a bit special: it's Quality - Factorio Wiki–described as an independent MOD you can toggle, but using it requires Space Age ownership. This is genuinely important—having Space Age doesn't mean you always play with quality enabled. I tested with quality off first, then toggled it on to feel the difference. Doing that lets you sense where recipes, equipment feel, and production chains change, making it much easier to understand.

Elevated Rails works similarly: the official feature is Space Age's contribution, but the Mod Portal has several community mods related to it. So seeing "Elevated Rails–related names" in your MOD list doesn't mean they're all the same thing. You must distinguish between official DLC add-on MODs and community mods that expand, enable early, or adjust that feature.

Mastering this distinction makes Space Age mod expansion much easier. Start by understanding the three official add-ons and quality together, then layer on QoL or big mods. After 2.0, approaching mods in this order alone drops your accident rate significantly.

Two Ways to Install Mods: In-Game Mod Portal and Manual Installation

Installing via In-Game Mod Portal

The least confusing route is to use the Mod Portal directly from the in-game "MOD" menu. Factorio's flow is straightforward—search, install, and update all happen in one screen—making it powerful, especially for a few QoL mods where chasing dependencies by hand is much harder.

The process is simple: open "MOD" from the main menu, search for your desired mod in the install tab, select it, and proceed. As the community knows well, essential dependencies get auto-selected more often, making the benefit huge for beginners. Even library mods that won't run alone sometimes get picked up automatically by the in-game browser.

After installation, mods appear in your list and often activate immediately. What matters isn't just "did it install" but did it load error-free at startup. Dependency auto-handling is convenient but doesn't guarantee compatibility. Large mods or DLC-dependent setups can install fine yet fail at load. Technically, Mod portal API - Factorio Wiki documents retrieval specs; api/mods/{name}/full retrieves dependency arrays too. You needn't touch the API directly during normal play, but knowing the in-game browser has this background makes it clear why this method is beginner-friendly.

Account Creation and Steam Linking Notes

One slightly rough point about the in-game Mod Portal is needing a factorio.com account for some downloads. Even Factorio via Steam doesn't bypass this directly to Steam's systems—the Mod Portal side has its own authentication.

So even for Steam purchasers, creating a factorio.com account and linking your Steam account keeps things tidy. This setup stabilizes the in-game search–and–install flow. Without this link, you risk "the game runs but mods won't download"—a confusing early blocker.

In Space Age environments, this matters especially. Official additions show up on the MOD screen alongside community mods, so muddled authentication makes it unclear whether you've hit an install failure, an ownership issue, or a dependency error. I now check my in-game login state before touching MODs in any new setup. This one step makes root-cause analysis much faster.

Manual Installation (mods Folder Placement) and ZIP Handling

Manual installation means placing downloaded ZIPs directly in your mods folder. You might think you should extract them, but usually leaving them as ZIP files is fine. Factorio's user-data mods folder works as described above; if you've changed write-data, that location becomes your mods placement.

This approach shines when pinning versions and validating setups. Large mods you want to keep on an older version, avoiding updates that break your build, preserving test environments—all easier manually than in-game. The trade-off is managing dependencies and conflicts yourself. Missing prerequisite mods cause startup failure; DLC-required ones are rejected on the spot.

An easy oversight: don't keep multiple versions of the same mod together. The community knows that stacking old and new ZIPs for the same mod in the mods folder stops it from starting. I always check that mods directly below don't have duplicate names or versions before booting with a large setup. It sounds tedious but is the single most effective check I do. Operationally unglamorous, but it works.

If you're tuning things manually, load order and failure points are clearer in the log, and writing all active mods and versions to script-output/mods.txt lets you compare configs later. During conflict triage, that list is surprisingly useful.

Choosing Between Installation Methods

It's not really about superiority—pick based on your goal. For first-time QoL additions or everyday play, the in-game Mod Portal is clearly easier. Search, install, dependencies mostly follow—the pace of adding mods is very light.

For version pinning, validation reproduction, and configuration preservation, manual installation suits you better. The ZIP-on-disk approach is unglamorous but resists updates and keeps the same state longer. Play large setups like Krastorio 2 or Space Exploration long enough and that stability value becomes very visible.

In brief: the in-game Mod Portal offers installation ease, manual installation offers configuration pinning. But manual management assumes you catch dependency and conflict issues yourself, so jumping straight to bulk installs without experience gets messy. Starting small in-game, then shifting manual when needed, feels natural.

Detailed thinking through compatibility: separating "dependencies," "engine support," and "load order" makes understanding clearer.

The mods Folder and User Data Directory

OS-Specific User Data and mods Folders

In Factorio, MODs, saves, and settings live in the user data directory. The mods folder you use for manual installation sits here too, best thought of as part of Factorio's user-data system, not standalone. Paths vary by OS; exact structures are in Application directory - Factorio Wiki.

Quick reference: Windows uses %APPDATA%\Factorio\mods, Linux uses ~/.factorio/mods, macOS uses ~/Library/Application Support/factorio/mods. The saves and config files sit alongside these, so thinking of MODs separately from the rest causes confusion. Treating everything as "your Factorio user data collection" works better in practice.

I've played across Windows and Linux environments; tracking mods separately is much harder than treating mods, saves, and config as one parent-directory unit. Backup and sync units align, preventing "saves are fresh here but settings are old there"—a problem that compounds with large mod switching.

How write-data Affects Storage

Easy to miss: your actual storage location isn't hardcoded. Factorio's config/config.ini has a write-data setting letting you move the user data directory. If you've changed this, mods storage and folder position move with it.

So searching %APPDATA%\Factorio\mods on Windows fails if you're using write-data elsewhere. Mods, saves, settings, and script-output all move together, making this essential context for installation, backup, and restore. The ZIP placement I mentioned works in the directory write-data points to.

Understanding this makes multi-environment setup much cleaner. I've used write-data to deliberately align user data across dual environments. From there, backup and sync became straightforward. Thinking "pin the parent directory" rather than "chase the mods folder" raises reproducibility a lot.

Saves, Settings, and player-data.json Relationship

The user-data directory holds more than mods and saves—settings and account info too. Worth understanding is player-data.json. It's not just appearance settings; it's where your Mod Portal token lives. Knowing its role helps avoid confusion around mod fetching and API usage.

To sort it out: mods is the mod packages, saves is your factory data, settings files are your keyboard and display setup, and player-data.json is player info and Mod Portal auth help. All live in the same user-data directory, so backing up and migrating work best when you treat related parts together instead of picking pieces.

This structure makes it clear why "mods came back but login status didn't" or "saves returned but settings didn't"—you've missed part of the related set. Factorio file work is a bit rough, but knowing saves, settings, and auth sit on the same foundation makes it obvious what changes what.

Safe Practices for Updating, Disabling, and Backing Up

Pre-Update Checklist and Backup

How you back up before updating matters more than the update itself for avoiding accidents. Factorio bundles mods, saves, and settings in one user data folder, so backing up that parent directory as a ZIP beats tracking pieces separately. The restore-on-demand speed difference is huge. Before any big update, especially one like Space Age with large public additions, this one step pays off a lot.

In practice, zipping mods and saves separately is slower than zipping the whole user-data directory before restore. I do this before major updates, and any incompatibilities roll back quickly. Especially with Space Age, where public additions arrive in volume, that buffer is valuable.

Keep pre-update checks to three points:

1. Back up your entire user data directory
2. Duplicate your active save with a new name
3. Recognize whether this update breaks your current mod setup

Save duplication is crucial. MOD additions or removals break replay compatibility—not just load feasibility. Replay System - Factorio Wiki explains it clearly: changing mod configs breaks replays. Day-to-day play obscures this, but wanting to revisit or test later makes pre-update save duplication insurance-level important, really routine upkeep.

Disabling and Restoring (Rollback) Basics

If trouble appears after an update, resetting to your last known-good state beats chasing one broken file. Factorio's mod troubles usually stem from combinations of engine, mods, and saves, not one corrupted file, so rollback means restoring that combo.

First, isolate which added or updated mod caused it. But flipping a checkbox doesn't always restore the state. A save might load but change content, or the save might expect that mod. Production-chain or entity-adding mods especially have broad impact—disabling them warps your factory instantly.

So recovery works better if you restore both the pre-update save and the pre-update mods state together, rather than "remove the bad mod." This sidesteps "save is old but mods are new" limbo. That parent-directory bundling idea pays off again.

Easy to overlook: settings that auto-activate new mods. If you manually put a ZIP in mods, the next boot might enable it by default. Even if you've "restored," leftovers still trigger the problem, so rollback means aligning "which files exist" and "which mods activate" at once.

Avoiding Multiple-Version Conflicts

Wanting to keep old versions is common. Test builds, extending old saves, waiting for mod updates—many reasons exist. The trap is mixing versions of the same mod.

If you must keep old versions, manually stick to one active setup per play session. Sharing one mods folder between current and test configs tempts fate; instead, "place only the mods this save uses" cuts mix-ups and update surprises. Manual handling is strong on version pinning but soft on cleanup, so stacking without clearing grows into accident kindling.

Space Age blurs public and community mods, making similar names hide different meanings. Test setups benefit from minimal mods configs. Putting everything in one folder feels efficient until something breaks; shrinking to "one factory's recipe" across your whole environment is slower setup but way faster fixes. This habit alone has meant nearly zero maintenance pain for me.

If parallel versions are unavoidable, keep engine, saves, and mods together as a unit. Mixing just parts loses reproducibility and causes later confusion. Factorio's strength is knowing what runs now vs. what broke. Clarity here is your biggest safety tool.

Reading Dependencies, Compatibility, and Conflicts

Reading Dependencies

Most non-starting mods fail on misread dependencies. Mod Portal pages list them; distributed files carry dependency info in info.json. In-game Mod Portal auto-grabs essential ones sometimes, but hand installation and version pinning soon land you reading this yourself.

The trick: don't ask "does this mod work alone?" but rather "what does this mod assume?" Library, translation helper, or overhauled-based expansions hide their weight from names alone. Descriptions help, but the dependency field directly affects startup. Misreading it is a common early stumble.

For mechanical checking, Mod portal API 's api/mods/{name}/full pulls the dependencies array. When in-game text is hard to chase, API info is closer to real internals and clarifies fast. Shared modsets and dependency sorting benefit a lot.

I check the dependency field before reading descriptions when adding large mods. Spotting there saves me from "I'm just adding one convenience thing" implying a whole framework requirement.

Checking Engine Version Support

Aligned dependencies aren't enough—engine version match is make-or-break. What engine version does this mod target? is critical. Right after major releases, popular mods often sit non-updated, and that's your main jam-up.

Space Age dropped 21 October 2024; migration to 2.0 and DLC support happened overnight. Big moments like that see stable setups turn unsupported instantly. Space Age, though, shows as add-ons even while being official, so "the name's visible, it must work" easily misfires.

Mod Portal pages show supported engine versions; distribution metadata tracks them too. Does your Factorio's generation match the MOD's advertised generation? If keeping an old-save alive, lock to contemporary engine and contemporary mods rather than mix. Parent-directory bundling works again.

Clash Resolution Through Error Messages and Logs

When clashes occur, following error messages and log order beats guessing. Factorio's startup is pleasantly transparent—focus on which load stage failed, not just "it broke."

Error screens show the failing mod's internal name. Display names are friendly but errors use internal names; mix that up and you hunt the wrong Mod Portal entry. Details come from Log file's load order and failure spots. Logs preserve "how far we got," revealing "A looks guilty but B was missing" mismatches fast.

Log reading: skip flashy English error walls and peek at the lines before. Missing dependencies, version mismatches, and other-mod definition collisions announce themselves before the headline. Heavy mod setups reward tracing the load flow over reading the final error. Systematic conflict checking via "dependencies," "engine fit," and "load order" separates cases neatly.

Log file

wiki.factorio.com

Internal Name (name) vs. Display Name (title)

Factorio mod management benefits quietly from internal name (name) and display name (title) being separate. Display name is human-friendly (Mod Portal, in-game), while internal name sits in info.json and serves as identifier. Logs, dependencies, APIs, and save data use internal name as standard. Trouble-shooting without reading internal names leaves you stranded.

Display names might be decorated, and similar titles might spawn variants; internally they're total strangers. Conversely, display names might refresh while internal names stay old. That gap means searching Mod Portal by error-text names fails if you only look at pretty titles.

API work uses api/mods/{name}/full where {name} is internal name. Dependencies, logs, APIs all speak internal name; lists speak display names. Split that mentally and confusion drops. Early, I tracked only titles, but mods with mismatched visible and logged names broke my hunts. Learning internal names was the pivot.

Common Errors and Fixes

Login and Account Mishaps

Mod Portal in-game surprisingly often trips on assuming your Steam account equals your factorio.com account. Steam Factorio ownership ≠ auto MOD auth—factorio.com side has separate gates.

A typical snag: mixing Steam email with factorio.com username/password. In-game login prompts one; getting them mixed means valid credentials that still fail—a vague frustration. Early on, I figured "Steam owns it, login must work" and failed.

Clean thinking: Steam is purchase and launch; factorio.com is MOD distribution auth. Checking login status in-game with "am I entering factorio.com info?" eliminates mix-ups. Login stuck? Check the account pair first, not just retry the password.

Multiple Versions and Missing Dependencies

Manual installs often hit leaving old-version ZIPs alongside new ones. Updating before removing old files, stashing test ZIPs "safely" nearby—these keep both versions active, breaking startup despite installing latest. Old backup files and test folders create clashes easily, and "keeping everything is safe" backfires into conflicts.

The mods folder, once checked for same-name duplicates consolidated to one, often resolves instantly. Want old versions? Move them to a separate folder, leaving only current versions where the game reads. Keeping test and current setups in one place invites mismatches, version slips, and missed updates.

Another classic: missing dependency MODs. In-game fills essential deps somewhat, but hand install means you fill gaps. Look up that broken internal name on Mod Portal's dependencies—often you'll find "the body is fine, but I forgot the foundation MOD."

Fixing Load Order and Startup Failures

Startup fails: isolate what you added recently and check logs for load sequence. What's the last MOD that loaded before the crash? Start there.

Cutting works: toggle suspect mods off and boot; if it works, re-enable one by one to pinpoint the clash. Bulk environments make this seem tedious, but narrow first from your latest additions and log endpoint narrows fast.

Key items to check, in order:

1. Note the internal name from the error screen
2. See what loaded last in the log
3. Switch off recent additions momentarily
4. Boot, then flip them back one at a time to nail the spot
5. Separate whether it's missing deps, duplication, or combo clash

Recording and Restoring via mods.txt

A simple trick with big payoff: keep a text record of active mods. Using Console (mods.txt output) via script-output/mods.txt writes all active mods and versions. Whether you use in-game or manual, this list cuts "what did I install?" puzzles dramatically.

Even if mods folders list files, actual active mods differ. mods.txt captures what really ran, your safety edge. When I've crashed and needed recovery, having saved script-output/mods.txt let me hand-rebuild the exact config later and restore fast.

The value is "before crash" vs. "after crash" configs compared side-by-side: forgotten prerequisite, update drift, activation state flip—all spot-checked easily. Record-keeping on mods.txt beats instinct-based recovery.

Console

wiki.factorio.com

Advanced: Mod Portal API and Profile-Style Workflows

API Basics

For normal play, using the in-game MOD browser (Mod Portal) feels most native. Steam owners also use in-game browser primarily, though Steam Workshop practices vary community-to-community—check official guidance or test your setup before deciding operational policy.

What's neat: not just "auto-download" but recording setups themselves. Pinning which mods, which versions, which dependencies to config or script gradually turns hand-remembered modsets into "reproducible builds." A few large mods in and this shift feels huge. Testing environments I rebuild often taught me that recorded configs recover much faster than memory.

Organizing related mods helps: Space Age–compatible mods, QoL, translation tools. Clumping by compatibility makes adoption calls and check prioritization clearer.

Token and player-data.json

API and auth-secured downloads hinge on player-data.json's token. Factorio auth uses username + token together; pair them and you unlock authenticated API calls and downloads. In-game browser hides this backstage, but external tools or custom scripts using Mod Portal need this pair as the practical entry.

Underlying that: factorio.com account. Factorio on Steam still wires MOD downloads through factorio.com. Steam Factorio users often stumble on login when factorio.com and Steam aren't linked. "Steam has it, so everything flows" is the mental trap.

Token demands careful handling: sharing full configs, posting screenshots with it visible—sharing memo becomes credential leak. API use tempts putting token inline; public repos or shared files really shouldn't hold raw tokens. For personal use, "my-machine-only auth" is realistic practice.

Profile-Style Workflows (Environment Separation)

Manual install's edge is mods folder ZIPs—your setup's explicit**. Instead of in-game convenience, lay ZIPs flat: %APPDATA%\Factorio\mods (Windows), ~/.factorio/mods (Linux), ~/Library/Application Support/factorio/mods (macOS). Version pinning and test swaps click here versus in-game.

Critically, leave ZIPs zipped; Factorio reads them packed. Hand extraction confuses things—manage as-is. And never mix versions of the same MOD in one mods folder. Backup habit of old ZIPs "nearby" becomes startup dynamite inadvertently.

This leads to pseudo–profile management. Factorio lacks built-in profiles, but separating mods by purpose, or using write-data or --mod-directory to swap folders creates "test," "live," "legacy-save" setups. Once I used this for large-mod testing, retry became painless—break test without touching live.

In-game browser vs. manual/API routes aren't rivals—task division. Daily play: browser. Version lock and reproduce: hand manage. Code-as-config: API. Each layer builds naturally; forcing all onto one approach breaks.

Wrapping Up

The start is simple: go small, test, keep recoverable. Once I moved to "small → record → expand," mod trouble nearly vanished. Backup your current saves and user-data directory now, drop one QoL mod in via in-game browser, check the startup log. No issues? Make logs and mods.txt part of routine before big mods. With Space Age live, preview quality solo first—later expansion is way easier with that feel.

Related articles (candidates)