DarthFader's Satisfactory Dedicated Server Optimization Guide

For When Your Factory Needs Warp Speed Without Breaking Reality

Welcome, Pioneer!
So, you’ve decided to take your Satisfactory experience to the next level with a dedicated server? Excellent choice! This guide is your
golden blueprint for optimizing both your Satisfactory Dedicated Server and your local game client to wring out every drop of
performance. Say goodbye to stutters, lag, and conveyor belts that look like they’re doing the worm, and hello to silky-smooth gameplay,
automated backups, and server updates that would make FICSIT engineers weep with pride.

Who’s This Guide For?

This guide is laser-focused on players running their own Satisfactory Dedicated Server on Linux. We assume you’ve already got your
server up and humming like a well-oiled assembler. If you’re still staring at a blank terminal wondering what to do, fear not—there are
plenty of great guides out there to help you get started.
But wait—there’s more! Beyond optimization, this guide will teach you how to automate your server’s backups and updates, ensuring your
factory’s progress is always safe and your server is always up-to-date. It's like adding Smart Splitters to your server management
workflow—simple, efficient, and hands-free.
So, whether you’re here to fine-tune performance or embrace the magic of automation, this guide has you covered. Let’s get to work,
pioneer!

Read Before You Paste!

Yes, we know it’s tempting to skip straight to the code and start copy-pasting like you’re in a speedrun. But stop right there, pioneer! This
guide isn’t just about slapping numbers into .ini files—it’s about understanding why these changes matter. Take the time to read
through, absorb the knowledge, and appreciate the delicate art of server optimization. Trust us, your factory (and your friends) will thank
you.

Your Server Hardware Specs

Before we dive into your powerhouse server setup, let’s go over the official minimum requirements for running a Satisfactory Dedicated
Server. According to the Satisfactory Wiki, your server should have the following:

Minimum Requirements
Processor: A recent x86/64 processor with good single-core performance (e.g., Intel i5-3570 or AMD Ryzen 5 3600).

Note: The server doesn’t support 32-bit or ARM architectures.

Memory: At least 12 GB of RAM. For larger saves or more than 4 players, 16 GB is recommended.

Storage: 25 GB for the game server itself (you’ll need more for save files and mods).

Operating System: A supported version of Windows or a major Linux distribution (sorry, Windows 7 isn’t invited).

Internet Connection: A broadband connection with the ability to configure port forwarding if hosting from home.

But let’s face it, you didn’t come here to run a "minimum-spec" server. You’re here to build a server worthy of hosting the most ambitious
factories and wildest multiplayer sessions. Now, let’s talk about your setup.

My Specs: A Factory Builder’s Dream

This server doesn’t just meet the requirements—it obliterates them with a high-performance setup:

Host Platform: Running on Proxmox, a powerful virtualization platform designed for reliability and performance.

Virtual Machine (VM): Your Satisfactory server is hosted on an Ubuntu Server 24.04.01 VM, ensuring stability and efficiency.

16 CPU Cores: High single-core performance and enough extra cores to laugh at anything the game throws at it.

32 GB RAM: Double the recommended amount, ensuring buttery-smooth performance even with massive saves or player counts.

Storage: 64 GB dedicated for the server, mods, and backups—plenty of room for your factory-building empire.

Ubuntu Server 24.04.01 (VM OS): A lightweight, no-frills Linux distribution, perfect for a dedicated server.

Untitled 1
 1 Gbps Up/Down Internet Speed: Forget broadband—this is the Mk. 5 belt of internet connections.

1. Server-Side Optimization
Your dedicated server is the beating heart of your Satisfactory experience. It keeps your belts flowing, your trains on track, and your
friends from rage-quitting. In this section, we’ll turn your server from a wheezing biomass burner into a nuclear-powered beast of
automation.

1.0 Paths Disclaimer SUPER IMPORTANT

Before we dive into the settings, let’s talk about the Paths section in your Engine.ini . These are super critical—they tell the game where to
find its assets, mods, and all the magic that keeps your factory functional. DO NOT overwrite this section unless you’re 100% sure what
you’re doing. Messing with it could send your game into an existential crisis.

Here’s what some example paths look like:

Paths=../../../Engine/Content
Paths=%GAMEDIR%Content
Paths=../../../FactoryGame/Plugins/Mods/SML/Content

TL;DR: Look but don’t touch—your paths are perfectly fine as they are.

1.1 Engine.ini Settings

The Engine.ini is where you unleash your server's hidden potential. Think of it as overclocking your game’s brain—but without the risk of
smoke. These tweaks will help your server run leaner, smoother, and more responsive.

File Location:
/home/satisfactory/SatisfactoryDedicatedServer/FactoryGame/Saved/Config/LinuxServer/Engine.ini

[Core.System]
+Suppress=Scriptwarning
+Suppress=Error
+Suppress=Scriptlog
+Suppress=Warning

[Core.Log]
LogPluginManager=all off ; Disables various logging options to reduce unnecessary logging load
LogOnlineIdentity=all off
LogOnlineSession=all off
LogMemory=all off
LogPakFile=all off
LogTemp=all off
LogLinker=all off
LogOnline=all off
LogOnlineGame=all off
LogAnalytics=all off
LogConfig=all off
LogInteractiveProcess=all off
LogInput=all off
LogOnlineEntitlement=all off
LogOnlineEvents=all off
LogOnlineFriend=all off
LogOnlinePresence=all off
LogOnlineTitleFile=all off
LogOnlineUser=all off
Global=off

[SystemSettings]
t.MaxFPS=1 ; Caps FPS at 1, conserving resources on a headless server
FixedFrameRate=1.000000 ; Fixes frame rate to 1 FPS, minimizing rendering requirements

[/script/onlinesubsystemutils.ipnetdriver]

Untitled 2
 MaxInternetClientRate=20971520 ; Sets max internet client data rate to 20 Mbps
MinInternetClientRate=20971520 ; Sets min internet client data rate to 20 Mbps
MaxClientRate=20971520 ; Sets max client data rate to 20 Mbps (same for LAN)
MinClientRate=20971520 ; Sets min client data rate to 20 Mbps (same for LAN)
LanServerMaxTickRate=90 ; LAN tick rate at 90 Hz for smoother updates
NetServerMaxTickRate=90 ; Server tick rate at 90 Hz for overall game smoothness
ConnectionTimeout=20.0 ; Sets client connection timeout to 20 seconds
InitialConnectTimeout=30.0 ; Initial connection timeout for clients at 30 seconds

[NetworkSettings]
net.UseRecvMulti=1 ; Enables multi-packet receiving, improving data handling efficiency
net.IpNetDriverUseReceiveThread=1 ; Uses a separate thread for packet receiving
net.IpConnectionUseSendTasks=1 ; Offloads connection sending to async tasks
net.IpNetDriverReceiveThreadQueueMaxPackets=8192 ; Sets the max queue size for receive thread
net.MaxNetStringSize=67108864 ; Increases the max size for network strings (64 MB)
net.MaxRPCPerNetUpdate=8 ; Limits RPCs per network update to 8 for stability

[TickSettings]
tick.AllowAsyncComponentTicks=1 ; Allows async ticking for components, improving performance
tick.AllowConcurrentTickQueue=1 ; Enables concurrent ticking for queued components
tick.AllowAsyncTickDispatch=1 ; Dispatches ticks asynchronously
tick.AllowAsyncTickCleanup=1 ; Enables async cleanup of ticks, reducing processing load

[CrashReportClient]
bAgreeToCrashUpload=false ; Disables automatic crash report uploads
bImplicitSend=False

[Engine.ErrorHandling]
bPromptForRemoteDebugging=False ; Disables remote debugging prompts
bPromptForRemoteDebugOnEnsure=False ; Disables remote debug prompts on critical errors

[/script/engine.garbagecollectionsettings]
gc.MaxObjectsNotConsideredByGC=476499 ; Optimizes garbage collection settings for stability
gc.SizeOfPermanentObjectPool=100378488
gc.ActorClusteringEnabled=True
gc.BlueprintClusteringEnabled=True

[/script/engine.streamingsettings]
s.EventDrivenLoaderEnabled=True ; Enables event-driven loading to improve performance
s.AsyncLoadingThreadEnabled=True ; Enables async loading threads for faster asset loading

[/script/engine.networksettings]
net.MaxRepArraySize=65535 ; Sets max replicated array size (improves network replication)
net.MaxRepArrayMemory=65535 ; Sets max memory for replicated arrays

[/script/factorygame.fgsavesession]
mNumRotatingAutosaves=5 ; Keeps 5 rotating autosaves

1.2 Game.ini Settings

Your server’s Game.ini is all about keeping things fair and functional in the land of conveyors and chaos. This is where we fine-tune
bandwidth and networking to ensure that your multiplayer sessions run like a dream (or at least a well-planned nightmare).
File Location
/home/satisfactory/SatisfactoryDedicatedServer/FactoryGame/Saved/Config/LinuxServer/Game.ini

[/script/engine.gamenetworkmanager]
TotalNetBandwidth=1200000 ; Allocates total bandwidth for all players.
MaxDynamicBandwidth=320000 ; Sets max bandwidth per player.
MinDynamicBandwidth=300000 ; Sets min bandwidth per player.

Untitled 3
 MAXPOSITIONERRORSQUARED=32.00f ; Limits positional errors for smoother visuals.
ClientAuthorativePosition=true ; Clients manage their own position updates.
MAXCLIENTUPDATEINTERVAL=1.0f ; Reduces client update intervals for responsiveness.
MaxMoveDeltaTime=0.5f ; Improves movement accuracy by reducing delta times.
ClientNetSendMoveDeltaTime=0.0332 ; Updates movement every 33 ms.
ServerForcedUpdateHitchThreshold=1.0f ; Responds to server hitches more quickly.

2. Local Optimization
Your PC is the nerve center of your Satisfactory experience. If your client can’t keep up with the server, you’re going to see stutters, lag,
and belts that look like they’re auditioning for a glitch horror movie. Let’s get your local settings sorted.

2.1 Local Engine.ini Settings

Your client’s Engine.ini is the command center for rendering, ticking, and visual magic. With these settings, you’ll be able to admire your
factory in all its glory—without your graphics card melting in protest.

File Location:
C:\Users\YourName\AppData\Local\FactoryGame\Saved\Config\WindowsNoEditor\Engine.ini

[/script/engine.gamenetworkmanager]
TotalNetBandwidth=104857600 ; Allocates total bandwidth for smoother data handling.
MaxDynamicBandwidth=104857600 ; Sets maximum bandwidth for dynamic updates.
MinDynamicBandwidth=104857600 ; Ensures a consistent minimum bandwidth.

[/script/socketsubsystemepic.epicnetdriver]
MaxClientRate=104857600 ; Maximum data rate per client.
MaxInternetClientRate=104857600 ; Maximum internet data rate per client.

[/script/engine.engine]
NetClientTicksPerSecond=180 ; Matches server tick rate for smooth updates.

[SystemSettings]
AllowAsyncRenderThreadUpdates=1 ; Enables async rendering updates.
AllowAsyncRenderThreadUpdatesDuringGamethreadUpdates=1 ; Allows rendering updates alongside game thread
updates.
r.SupportDepthOnlyIndexBuffers=1 ; Improves rendering efficiency.
r.SupportReversedIndexBuffers=1 ; Enables optimized buffer usage.
r.DBuffer=0 ; Disables unused rendering features.
r.GPUCrashDebugging=0 ; Disables GPU crash debugging for performance.

FX.AllowAsyncTick=1 ; Enables asynchronous FX ticking.

FX.BatchAsync=1 ; Batches FX updates for better performance.
FX.BatchAsyncBatchSize=9999999 ; Maximum batch size for FX processing.
FX.MaxCPUParticlesPerEmitter=50 ; Limits CPU particle usage per emitter.
FX.MaxGPUParticlesSpawnedPerFrame=2048 ; Limits GPU particles spawned per frame.

AudioThread.BatchAsyncBatchSize=9999999 ; Improves audio batching for performance.

AudioThread.UseBackgroundThreadPool=1 ; Enables background threading for audio.
AudioThread.EnableBatchProcessing=1 ; Improves audio thread performance.

r.ShadowQuality=3 ; Reduces shadow quality for better performance.

r.ViewDistanceScale=1.5 ; Adjusts view distance scaling.
r.ViewDistanceQuality=4 ; Improves view distance quality.
foliage.MinimumScreenSize=0.009 ; Adjusts foliage rendering settings.
foliage.LODDistanceScale=1.4 ; Increases foliage level-of-detail distances.
foliage.DensityScale=1.5 ; Adjusts foliage density.
grass.DensityScale=2 ; Increases grass density.

Untitled 4
 grass.MaxUpdateFrequency=40 ; Sets grass update frequency.

r.MaterialQualityLevel=2 ; Adjusts material quality to medium.

r.DefaultFeature.AntiAliasing=2 ; Enables anti-aliasing for smoother visuals.
r.FinishCurrentFrame=0 ; Disables forced frame finishing for better performance.
r.Streaming.UseFixedPoolSize=0 ; Disables fixed texture pool size.
r.Streaming.PoolSize=0 ; Allows dynamic pool size adjustment.
r.Streaming.FullyLoadUsedTextures=1 ; Forces textures to fully load for better quality.
r.Streaming.LimitPoolSizeToVRAM=0 ; Disables VRAM pool size limitations.
r.Streaming.AmortizeCPUToGPUCopy=1 ; Improves streaming by amortizing CPU to GPU transfers.
r.Streaming.MaxTempMemoryAllowed=10 ; Allocates temporary memory for streaming.

r.MaxAnisotropy=16 ; Sets maximum anisotropic filtering for textures.

r.TemporalAACurrentFrameWeight=0.02 ; Adjusts temporal anti-aliasing weight.
r.TemporalAAFilterSize=0.2 ; Adjusts temporal anti-aliasing filter size.
r.TemporalAASamples=16 ; Sets temporal anti-aliasing samples.

r.Shadow.MaxResolution=1024 ; Adjusts shadow resolution for performance.

r.Shadow.DistanceScale=2 ; Adjusts shadow distance scaling.
r.Shadow.PreShadowResolutionFactor=0.5 ; Adjusts pre-shadow resolution.

r.Upscale.Quality=6 ; Enables high-quality upscaling.

r.PostProcessAAQuality=6 ; Improves post-processing anti-aliasing quality.
r.MipMapLODBias=0 ; Sets mipmap level-of-detail bias.
r.Color.Mid=0.47 ; Adjusts color settings.
r.TemporalAA.Upsampling=1 ; Enables temporal anti-aliasing upsampling.
r.TemporalAASharpness=1 ; Adjusts sharpness of temporal anti-aliasing.
r.Tonemapper.Sharpen=1.6 ; Adjusts tonemapper sharpening.
r.TonemapperFilm=1 ; Enables filmic tonemapper settings.
r.Tonemapper.Quality=5 ; Sets tonemapper quality.

r.TemporalAACatmullRom=1 ; Enables Catmull-Rom anti-aliasing.

r.OneFrameThreadLag=1 ; Allows one-frame thread lag.
r.HZBOcclusion=0 ; Disables occlusion for performance.
r.RenderTargetPoolMin=1000 ; Sets render target pool size.
r.AllowOcclusionQueries=1 ; Enables occlusion queries.
r.SceneColorFormat=3 ; Adjusts scene color format.
r.D3D11.Depth24Bit=0 ; Uses optimized depth buffer.
r.DefaultFeature.MotionBlur=0 ; Disables motion blur.
r.MotionBlurQuality=0 ; Disables motion blur quality.

[/script/engine.garbagecollectionsettings]
gc.MaxObjectsNotConsideredByGC=476499 ; Optimizes garbage collection thresholds.
gc.SizeOfPermanentObjectPool=100378488 ; Allocates memory for permanent objects.
gc.ActorClusteringEnabled=True ; Groups actors for efficient garbage collection.
gc.BlueprintClusteringEnabled=True ; Groups blueprints for optimized cleanup.

2.2 Local Game.ini Settings

The Game.ini ensures that your local networking is up to snuff. Smooth movement, seamless updates, and perfect synchronization with
the server—it’s like giving your client a jetpack for performance.

File Location:
C:\Users\YourName\AppData\Local\FactoryGame\Saved\Config\Windows\Game.ini

[/script/engine.gamenetworkmanager]
TotalNetBandwidth=1200000 ; Allocates total bandwidth for client networking.
MaxDynamicBandwidth=320000 ; Sets maximum bandwidth per client for dynamic updates.
MinDynamicBandwidth=300000 ; Sets minimum bandwidth per client for consistent updates.

Untitled 5
 2.3 Understanding Tick Rate Differences
Ah, the infamous tick rate! You might notice in-game that your local tick rate (what your client processes) doesn’t always match the
server’s tick rate. For example, if your server is set to 90 ticks per second (TPS), your client might average between 13 and 16 TPS. Don’t
panic—this isn’t a bug or a sign that something’s gone horribly wrong.

Why It Happens
Your client doesn’t need to process all the same information as the server. The server handles the heavy lifting—updating all the belts,
machines, and trains in the game world—while your client only processes what’s necessary to keep your visuals and interactions smooth.
Think of it as the server being the “factory manager” and your client being the “visual inspector.” The manager works constantly, while
the inspector just checks what’s visible.

Is It Bad?
Short answer: Nope! Even if your local tick rate is much lower, as long as the server is maintaining its set tick rate (e.g., 90 TPS),
everything in the factory will still be processed accurately. Your belts might occasionally stutter visually, but the throughput (items per
minute) will remain correct because the server is keeping everything in sync behind the scenes.

The Important Part

What matters is that the server maintains a stable tick rate close to its set value. If the server tick rate drops significantly (e.g., below 50
when set to 90), then you might see issues like laggy belts, trains with a mind of their own, or desynchronization in multiplayer. As long as
the server is steady, your factory is running just fine!

Takeaway
Don’t sweat a lower local tick rate. It’s normal for clients to process fewer updates compared to the server. What you should focus on is
server tick rate stability, which is the real key to keeping your factory running smoothly. And hey, those minor stutters? Just pretend the
Pioneer is blinking really fast—it’s all part of the immersive experience!

2.4 Make Your Configuration Files Read-Only

Once you’ve finished modifying your Engine.ini and Game.ini files on both your server and local machine, it’s crucial to set them to read-
only. Why? Because Satisfactory loves to reset configuration files to their default values whenever the game or server updates. Making
these files read-only ensures your carefully crafted optimizations stay intact.

Why It’s Important

Without setting your files to read-only:

Your optimized settings might get overwritten during game or server updates.

Any custom tweaks you’ve made will be lost, and you’ll have to redo them.

By locking the files, you’re effectively saying, “Hands off, Satisfactory! My settings are perfect as they are.”

How to Set Your Files to Read-Only

For the Server (Linux):

1. Open a Terminal on your server.

2. Navigate to the directory where the configuration files are stored. For example:

cd /path/to/your/server/FactoryGame/Saved/Config/LinuxServer

3. Use the chmod command to make the files read-only:

chmod 444 /home/satisfactory/SatisfactoryDedicatedServer/FactoryGame/Saved/Config/LinuxServer/Engine.

ini
chmod 444 /home/satisfactory/SatisfactoryDedicatedServer/FactoryGame/Saved/Config/LinuxServer/Game.in
i

4. Verify the Permissions:

Run:

Untitled 6
 ls -l /home/satisfactory/SatisfactoryDedicatedServer/FactoryGame/Saved/Config/LinuxServer/Engine.i
ni /home/satisfactory/SatisfactoryDedicatedServer/FactoryGame/Saved/Config/LinuxServer/Game.ini

You should see something like:

-r--r--r-- 1 satisfactory satisfactory 1234 Nov 15 14:32 Engine.ini

-r--r--r-- 1 satisfactory satisfactory 5678 Nov 15 14:32 Game.ini

For Your Local Machine (Windows):

1. Locate the Files:

Navigate to:

C:\Users\YourName\AppData\Local\FactoryGame\Saved\Config\Windows

2. Right-Click the File (e.g., Engine.ini ) and select Properties.

3. In the Properties Window, look for the Attributes section at the bottom.

4. Check the box for Read-only and click Apply.

5. Repeat this process for Game.ini .

How to Make Files Writable Again

If you need to make changes later:

Linux:

chmod 644 /home/satisfactory/SatisfactoryDedicatedServer/FactoryGame/Saved/Config/LinuxServer/Engine.

ini
chmod 644 /home/satisfactory/SatisfactoryDedicatedServer/FactoryGame/Saved/Config/LinuxServer/Game.in
i

Windows:Uncheck the Read-only box in the file’s Properties window.

The Bottom Line

Set your configuration files to read-only to lock in your optimizations and save yourself the hassle of reconfiguring them after every
update. Think of it as putting a “Do Not Touch” sign on your factory settings—Satisfactory will get the message loud and clear!

3. Applying the Changes

Now that you’ve got the secret sauce, it’s time to sprinkle it on your server and client. This section shows you how to edit your
configuration files, save the changes, and lock them in so they don’t get overwritten by the game. It’s like putting your factory in a vault—
but better.

3.1 Editing Files

Server Settings: Edit the files located in the server's Config folder.
/home/satisfactory/SatisfactoryDedicatedServer/FactoryGame/Saved/Config/LinuxServer/Game.ini

/home/satisfactory/SatisfactoryDedicatedServer/FactoryGame/Saved/Config/LinuxServer/Engine.ini

Local Settings:Navigate to:

C:\Users\YourName\AppData\Local\FactoryGame\Saved\Config\Windows\Game.ini

C:\Users\YourName\AppData\Local\FactoryGame\Saved\Config\Windows\Engine.ini

Open the files with Notepad, VS Code, or any text editor, and paste the configurations.

3.2 Setting Files to Read-Only

Linux (Server):

Untitled 7
 chmod 444 /path/to/Engine.ini
chmod 444 /path/to/Game.ini

Windows (Local):

1. Right-click the file (e.g., Engine.ini ).

2. Select Properties.

3. Check Read-only under the "Attributes" section.

4. Click OK.

4. Automating Your Server: Backups, Updates, and Restarts

Alright, pioneer, now that your server and local settings are optimized to perfection, let’s take it to the next level. Automation! Why spend
your valuable time manually updating, restarting, or backing up your server when you can make the machines do it for you? After all, isn’t
that what Satisfactory is all about?

This section walks you through automating your server setup with tools like cron, systemd, and SteamCMD. Trust me, once you set this
up, you’ll feel like you just built the ultimate automated factory.

Create a Systemd Service

Make your server self-managing by setting up a systemd service:

sudo nano /etc/systemd/system/satisfactory.service

Add this content:

[Unit]
Description=Satisfactory Dedicated Server
After=network.target

[Service]
Type=simple
User=satisfactory
WorkingDirectory=/home/satisfactory/SatisfactoryDedicatedServer
ExecStart=/home/satisfactory/SatisfactoryDedicatedServer/FactoryServer.sh start
ExecStop=/home/satisfactory/SatisfactoryDedicatedServer/FactoryServer.sh stop
Restart=on-failure

[Install]
WantedBy=multi-user.target

This block of code might look a little intimidating, but it’s really just a fancy to-do list for your server, telling your operating system how to
start, stop, and manage it. Let’s break it down:

[Unit] Section
Description=Satisfactory Dedicated Server

This is just a friendly name for your service, so you know what it’s doing.

After=network.target

This ensures your server waits for the network to be ready before it starts. Because what good is a multiplayer server without the
internet?

[Service] Section
Type=simple

This tells systemd that the service runs a single process, which is great for simplicity.

User=satisfactory

Untitled 8
 Specifies which user account will run the server. In this case, it’s the satisfactory user.

WorkingDirectory=/home/satisfactory/SatisfactoryDedicatedServer

This tells systemd where your server files are located. It’s like saying, “Start working from this folder.”

ExecStart=/home/satisfactory/SatisfactoryDedicatedServer/FactoryServer.sh start

This is the command to start your server. It runs the FactoryServer.sh script with the start argument.

ExecStop=/home/satisfactory/SatisfactoryDedicatedServer/FactoryServer.sh stop

This is the command to stop your server. Simple and clean.

Restart=on-failure

This is your safety net! If your server crashes for any reason, systemd will automatically try to restart it.

[Install] Section
WantedBy=multi-user.target

This tells systemd to start the service automatically in multi-user mode (a fancy way of saying "when the server is fully booted
and ready for multiple users").

The Bottom Line

This configuration ensures your server:

1. Starts automatically when your system boots up.

2. Waits for the network to be ready before starting.

3. Restarts automatically if something goes wrong.

It’s like putting your server on autopilot while keeping a crash recovery plan in place! Simple, effective, and reliable—just like a good
factory design.

Enable and start the service:

sudo systemctl daemon-reload

sudo systemctl enable satisfactory
sudo systemctl start satisfactory

Now your server will automatically restart if it crashes. It's like putting a Smart Splitter on your downtime.

3.3 Automating Backups

We all know the pain of losing hours of factory progress. Let’s set up a backup script that saves your progress hourly and cleans up old
backups.

Create the Backup Script

nano /home/satisfactory/backup_satisfactory.sh

Add this script:

#!/bin/bash
SAVE_DIR="/home/satisfactory/.config/Epic/FactoryGame/Saved/SaveGames/server"
BACKUP_DIR="/home/satisfactory/backup"
TIMESTAMP=$(date +"%Y%m%d-%H%M%S")
mkdir -p "$BACKUP_DIR"
tar -czvf "$BACKUP_DIR/satisfactory-backup-$TIMESTAMP.tar.gz" "$SAVE_DIR"
find "$BACKUP_DIR" -type f -name "*.tar.gz" -mtime +1 -exec rm {} \;

This code might look intimidating, but don’t worry—let’s break it down step by step. It’s like assembling a factory, one conveyor belt at a
time:

1. #!/bin/bash

Untitled 9
 This line tells the system, "Hey, I’m a bash script! Use the bash shell to run me."

2. SAVE_DIR="/home/satisfactory/.config/Epic/FactoryGame/Saved/SaveGames/server"

This is the location where your game saves live. Think of it as the storage container for all your factory blueprints.

3. BACKUP_DIR="/home/satisfactory/backup"

This is where your backups will be stored—like a smart splitter sending saves to safety.

4. TIMESTAMP=$(date +"%Y%m%d-%H%M%S")

This creates a timestamp for your backup files, so you can easily identify when each backup was made.

5. mkdir -p "$BACKUP_DIR"

This makes sure the backup directory exists. If it doesn’t, it creates it—because no factory should run without a storage container.

6. tar -czvf "$BACKUP_DIR/satisfactory-backup-$TIMESTAMP.tar.gz" "$SAVE_DIR"

This compresses your save files into a neat .tar.gz archive with the timestamped name, saving space and keeping things
organized.

7. find "$BACKUP_DIR" -type f -name "*.tar.gz" -mtime +1 -exec rm {} \;

This cleans up old backups. Any backup older than 1 day gets deleted to keep the storage from overflowing. It’s like automating
storage cleanup in your factory.

By the end, all this script does is ensure your precious saves are backed up in a timestamped file and clears out old backups to save
space. It's your factory's safety net!

Make it executable:

chmod +x /home/satisfactory/backup_satisfactory.sh

Test it:

/home/satisfactory/backup_satisfactory.sh

3.4 Setting Up Cron Jobs

Think of a cron job as your very own factory automation for Linux. It’s a scheduling tool that runs commands or scripts at specific times
or intervals—like an assembler that produces results on a set schedule. Instead of manually running backups, updates, or other server
tasks, you can set up a cron job to handle them for you. It's hands-off, stress-free, and wonderfully efficient.

How It Works
Cron jobs use a special configuration file called a crontab (short for "cron table"). This file tells your server:

1. What to run: A script, command, or program.

2. When to run it: Down to the exact minute, hour, day, or week.

Why You Need It

Cron jobs are perfect for tasks that need to happen regularly. For example:

Hourly Backups: Save your factory’s progress without lifting a finger.

Daily Updates: Keep your server software fresh and ready for action.

Scheduled Restarts: Avoid server lag by giving it a daily reboot, even while you sleep.

The Coolest Part

You don’t even have to babysit it! Once set up, cron jobs run silently in the background, working tirelessly like a perfectly overclocked
machine. It’s the ultimate set-it-and-forget-it tool for a Satisfactory server.

Cron jobs: Turning your server into a self-maintaining automation wonder!

Let’s automate both backups and server updates with cron.

Edit Cron Jobs

Untitled 10
 crontab -e

Add these entries:

Hourly Backup:

0 * * * * /home/satisfactory/backup_satisfactory.sh >> /home/satisfactory/backup/backup.log 2>&1

Daily Update and Restart (at 5 AM):

0 5 * * * /home/satisfactory/backup_satisfactory.sh && steamcmd +force_install_dir /home/satisfactory/Sa

tisfactoryDedicatedServer +login anonymous +app_update 1690800 validate +quit && sudo systemctl restart
satisfactory >> /home/satisfactory/backup/backup.log 2>

Your server will now keep itself updated and your saves backed up without you lifting a finger. You’re basically an IT genius now.

3.5 Restoring Backups

Accidentally overloaded your power grid and want to go back in time? Here’s how to restore a backup:

ls /home/satisfactory/backup
mv /home/satisfactory/.config/Epic/FactoryGame/Saved/SaveGames/server /home/satisfactory/.config/Epic/Fa
ctoryGame/Saved/SaveGames/server_backup
tar -xzvf /home/satisfactory/backup/satisfactory-backup-YYYYMMDD-HHMMSS.tar.gz -C /home/satisfactory/.co
nfig/Epic/FactoryGame/Saved/SaveGames/server
sudo systemctl restart satisfactory

And just like that, your factory is back on track.

3.6 Command Cheat Sheet

Here are the commands you’ll use most often:

Start the server:

sudo systemctl start satisfactory

Stop the server:

sudo systemctl stop satisfactory

Restart the server:

sudo systemctl restart satisfactory

Update the server manually:

steamcmd +force_install_dir /home/satisfactory/SatisfactoryDedicatedServer +login anonymous +app_upda

te 1690800 validate +quit

Run the backup script manually:

/home/satisfactory/backup_satisfactory.sh

View cron jobs:

crontab -l

Conclusion

Untitled 11
 Congratulations, pioneer! You’ve taken your Satisfactory Dedicated Server and local client to new heights of performance and
efficiency. By optimizing your settings, automating backups, scheduling updates, and understanding the inner workings of your server,
you’ve built a system as reliable as a perfectly balanced factory.

Here’s what you’ve accomplished:

Smoothed out gameplay with optimized tick rates and network settings.

Locked in your changes with read-only configurations (because Satisfactory will try to mess with your genius).

Automated backups to ensure your factory progress is always safe, no matter what chaos happens.

Set up daily updates and restarts to keep your server running like a champ.

This guide has transformed your server into a lean, mean, factory-running machine. Sure, the process involved some “scary” code, but
now you know it’s not so bad when you break it down step by step. Remember, your server is now smarter and more efficient than ever—
just like the pioneer running it.
And if something ever feels off, don’t hesitate to revisit the guide, tweak a setting, or add another automation. After all, Satisfactory isn’t
just about building factories—it’s about constantly improving them.

Now go forth and conquer, knowing your server is a shining beacon of optimization in the chaotic world of FICSIT pioneers. May your
belts never stutter, your trains always run on time, and your factories thrive! And remember: automation isn’t just a feature—it’s a lifestyle.
Happy building! 🎉

Untitled 12