Swap, ZRAM, and Memory Tuning on Low-RAM Machines

A Linux machine with limited memory can feel perfectly usable until a browser opens several tabs, an update starts in the background or a larger application begins working.

Then everything changes.

The system may slow to a crawl, applications may freeze, the desktop may become unresponsive and the Linux kernel may eventually terminate a process to recover memory. On machines with 2 GB, 4 GB or even 8 GB of RAM, the difference between a frustrating system and a dependable one often comes down to how memory pressure is handled.

Three tools matter most:

• Swap, which uses storage as overflow memory
• ZRAM, which creates compressed swap inside RAM
• Memory tuning, which changes how Linux balances RAM, cache and swap

None of these creates real memory out of nothing. They help Linux use limited RAM more effectively, survive short bursts of demand and fail more gracefully when memory runs low.

What Happens When Linux Runs Out of RAM?

Linux uses RAM for more than open applications.

Memory may be occupied by:

• Programs and background services
• Filesystem cache
• Shared libraries
• Graphics memory
• Containers
• Browser tabs
• Temporary data
• Kernel structures

The filesystem cache is not usually wasted memory. Linux uses spare RAM to cache recently accessed files because cached data can be discarded quickly when applications need more space.

Commands such as free therefore need to be interpreted carefully.

Run:

free -h

Example:

               total        used        free      shared  buff/cache   available

Mem:           3.8Gi       2.1Gi       210Mi       180Mi       1.5Gi       1.3Gi

Swap:          2.0Gi       320Mi       1.7Gi

The most useful figure is often:

available

This estimates how much memory can be given to applications without immediately swapping.

A very low free figure does not automatically mean the system is in trouble. A low available figure is more important.

What Is Swap?

Swap is disk space Linux can use when physical RAM is under pressure.

It can be provided as:

• A dedicated swap partition
• A swap file
• A compressed RAM device such as ZRAM

When memory is needed, Linux may move less-active memory pages out of RAM and into swap. This frees physical memory for applications that are currently active.

Swap is much slower than RAM, particularly on hard drives. However, slow memory can still be better than an application crash or a completely frozen system.

What Swap Is Good For

Swap helps with:

• Short spikes in memory usage
• Background applications that remain open but inactive
• Preventing immediate out-of-memory failures
• Hibernation, when configured appropriately
• Giving the kernel more flexibility under pressure
• Keeping desktop sessions alive during temporary overload

Swap is not a substitute for enough physical RAM.

A system that continuously moves large amounts of data between RAM and disk may become extremely slow. This is known as thrashing.

Check the Current Swap Configuration

Use:

swapon --show

Example:

NAME      TYPE SIZE USED PRIO

/swapfile file   2G 320M   -2

You can also use:

free -h

or:

cat /proc/swaps

To see all memory-related devices:

lsblk

Check Whether the System Is Actually Swapping

Run:

vmstat 1

Important columns include:

si

so

These mean:

• si — swap in
• so — swap out

Occasional activity is normal.

Continuous high values while the system is slow suggest serious memory pressure or thrashing.

You can also monitor swap usage with:

watch -n 2 free -h

For a more detailed view:

sar -W 1

The sar command is usually provided by the sysstat package.

Creating a Swap File

A swap file is often easier to resize than a dedicated partition.

The following example creates a 2 GB swap file.

First, check whether one already exists:

swapon --show

Create the file:

sudo fallocate -l 2G /swapfile

If fallocate is unsupported on the filesystem, use:

sudo dd if=/dev/zero of=/swapfile bs=1M count=2048 status=progress

Protect the file:

sudo chmod 600 /swapfile

Turn it into swap:

sudo mkswap /swapfile

Enable it:

sudo swapon /swapfile

Confirm:

swapon --show

free -h

Make the Swap File Permanent

Add this line to /etc/fstab:

/swapfile none swap sw 0 0

Back up the file first:

sudo cp /etc/fstab /etc/fstab.backup

Then edit it:

sudo nano /etc/fstab

Test the configuration:

sudo findmnt --verify

A swap entry does not mount like a normal filesystem, but the validation still helps identify formatting problems.

Safely Disabling a Swap File

Turn it off:

sudo swapoff /swapfile

Remove or comment out its entry in /etc/fstab.

Then delete it:

sudo rm /swapfile

Do not disable swap while the system is already under heavy memory pressure. Linux must move the swapped pages back into RAM, which may fail if insufficient memory is available.

Check first:

free -h

How Large Should Swap Be?

There is no single correct ratio for every system.

The old rule that swap should always be twice the size of RAM is too simplistic for modern systems.

A practical starting point is:

Low-RAM desktops often benefit from more swap than large-memory servers because they encounter memory pressure more frequently.

Workloads involving large applications, compilation, image processing, virtual machines or containers may need more.

Swap and Hibernation

Hibernation writes the system’s memory state to storage and powers the machine off.

For reliable hibernation, the swap area normally needs enough capacity to hold the memory image. The exact requirement depends on compression, used memory and distribution configuration.

A swap file also requires additional resume configuration on many systems because the kernel must know both:

• Which filesystem contains the file
• The file’s physical offset on disk

Do not assume that creating a swap file automatically enables hibernation.

Test hibernation carefully before depending on it.

What Is ZRAM?

ZRAM creates one or more compressed block devices in physical memory.

Linux can then use those devices as swap.

This sounds strange at first: why use RAM as swap when RAM is already limited?

The answer is compression.

Suppose 1 GB of inactive memory compresses to 400 MB. Moving those pages into ZRAM can free roughly 600 MB of usable physical memory, minus compression overhead.

Instead of writing the data to a slow disk, Linux compresses it and keeps it in RAM.

Why ZRAM Is Useful on Low-RAM Systems

ZRAM can improve responsiveness on:

• Older laptops
• Small single-board computers
• Lightweight desktops
• Chromebooks running Linux
• Virtual machines
• Thin clients
• Systems using slow eMMC storage
• Systems with mechanical hard drives

It is particularly useful for workloads containing compressible memory, such as:

• Browser tabs
• Application code
• Text data
• Idle desktop programs
• Repeated library pages

Already compressed data may gain much less.

ZRAM Is Not Extra Physical Memory

If a system has 4 GB of RAM and creates a 4 GB ZRAM device, it does not suddenly have 8 GB of real memory.

The ZRAM device consumes physical RAM as compressed pages are stored inside it.

The apparent capacity assumes that the data will compress effectively.

If the contents compress poorly, ZRAM fills sooner and may consume more CPU for limited benefit.

Check Whether ZRAM Is Already Enabled

Many distributions enable ZRAM by default.

Check:

swapon --show

You may see:

NAME       TYPE      SIZE USED PRIO

/dev/zram0 partition   2G 640M  100

/swapfile  file        2G 120M   -2

Check ZRAM devices:

zramctl

Example:

NAME       ALGORITHM DISKSIZE DATA COMPR TOTAL STREAMS MOUNTPOINT

/dev/zram0 zstd            2G 900M  310M  330M       4 [SWAP]

Useful fields include:

• DISKSIZE — the virtual capacity
• DATA — the original uncompressed amount
• COMPR — compressed data size
• TOTAL — total memory consumed including overhead
• ALGORITHM — compression algorithm

Understanding ZRAM Compression Results

Suppose zramctl shows:

DATA   1.2G

COMPR  420M

TOTAL  460M

This means approximately 1.2 GB of logical memory is being held using around 460 MB of physical RAM.

That is a substantial saving.

If DATA and TOTAL are very similar, the workload is not compressing efficiently.

Installing ZRAM on Ubuntu or Debian

A common package is:

sudo apt update

sudo apt install zram-tools

Depending on the distribution release, the configuration may be stored in:

/etc/default/zramswap

A typical configuration might include:

ALGO=zstd

PERCENT=50

PRIORITY=100

This creates ZRAM with a virtual size equal to 50% of physical RAM.

Restart the service:

sudo systemctl restart zramswap

Confirm:

zramctl

swapon --show

Package names and configuration methods can vary, so inspect the installed package documentation on the system.

ZRAM on Fedora

Fedora commonly uses zram-generator.

Check:

systemctl status systemd-zram-setup@zram0.service

Inspect the device:

zramctl

swapon --show

Configuration can be placed in:

/etc/systemd/zram-generator.conf

A simple example:

[zram0]

zram-size = ram / 2

compression-algorithm = zstd

swap-priority = 100

After changing the configuration, reboot or restart the associated ZRAM service.

ZRAM on Arch Linux

Arch users can use zram-generator.

Install it:

sudo pacman -S zram-generator

Create:

sudo nano /etc/systemd/zram-generator.conf

Example:

[zram0]

zram-size = ram / 2

compression-algorithm = zstd

swap-priority = 100

Reload and start the generated unit, or reboot:

sudo systemctl daemon-reload

sudo systemctl start systemd-zram-setup@zram0.service

Confirm:

zramctl

swapon --show

Choosing a ZRAM Size

Common starting points include:

25% of RAM

50% of RAM

100% of RAM

A 4 GB machine might start with:

2 GB ZRAM

A 2 GB machine might use:

1–2 GB ZRAM

Setting a ZRAM device larger than RAM is not automatically wrong because it represents compressed capacity, but oversized settings can create unrealistic expectations and worsen performance under heavy pressure.

A sensible starting point is 50% of physical RAM, followed by monitoring.

Compression Algorithm Choices

Common ZRAM compression algorithms include:

• lz4
• lzo
• zstd

Their availability depends on the kernel.

Check supported algorithms:

cat /sys/block/zram0/comp_algorithm

The active algorithm appears inside square brackets.

Example:

lzo-rle lzo lz4 [zstd]

General tendencies:

• lz4 prioritises speed
• zstd often provides stronger compression
• lzo offers a middle ground

On weak processors, lz4 may feel more responsive.

On modern processors, zstd can provide useful compression without excessive overhead.

Test with the actual workload rather than relying only on theoretical comparisons.

Using ZRAM and Disk Swap Together

ZRAM and disk-based swap do not have to be mutually exclusive.

A practical low-RAM configuration may use:

• High-priority ZRAM for fast compressed swapping
• Lower-priority disk swap as an emergency overflow area

Example:

/dev/zram0   priority 100

/swapfile    priority -2

Linux fills the higher-priority swap area first.

Check priorities:

swapon --show

To assign a priority in /etc/fstab:

/swapfile none swap sw,pri=10 0 0

For ZRAM, the priority is usually configured through its service or generator.

This layered approach can provide good responsiveness while still offering protection against unusually large memory spikes.

What Is Zswap?

Zswap and ZRAM are related but different.

ZRAM

ZRAM creates a compressed in-memory block device and uses it directly as swap.

Zswap

Zswap acts as a compressed cache in front of an existing disk-backed swap device.

With Zswap:

1. A page is selected for swapping.
2. Linux compresses it in RAM first.
3. If the compressed cache fills or cannot store the page, it is written to the real swap device.

Zswap therefore requires a normal swap backend.

Check whether it is enabled:

cat /sys/module/zswap/parameters/enabled

A result of:

Y

means enabled.

ZRAM is often easier to understand on small systems. Zswap can make sense where disk swap is already in place and you want a compressed cache before disk writes.

Running ZRAM and Zswap together is rarely necessary for a simple low-RAM machine and can make behaviour harder to predict.

What Is Swappiness?

Swappiness controls how willing Linux is to move anonymous memory into swap compared with reclaiming filesystem cache.

Check the current value:

sysctl vm.swappiness

Example:

vm.swappiness = 60

The value usually ranges from 0 to 200 on modern kernels, although many discussions still describe the older 0–100 interpretation.

A lower value generally makes Linux less eager to swap.

A higher value generally allows it to use swap more readily.

Common Swappiness Misunderstandings

A value of 0 does not always mean swap is completely disabled.

A high value does not mean Linux will immediately fill swap while RAM is still empty.

Swappiness influences the kernel’s balancing decisions. It is not a direct percentage or a simple threshold.

Choosing a Swappiness Value

Common starting points include:

Desktop with slow disk swap

vm.swappiness = 10

This may reduce unnecessary disk swapping.

General-purpose system

vm.swappiness = 60

This is a common default.

ZRAM-focused low-memory system

vm.swappiness = 100

or sometimes higher, depending on the kernel and distribution.

Because ZRAM is much faster than disk swap, allowing Linux to use it earlier can improve overall memory availability.

Do not copy a value from a forum without monitoring the result.

Change Swappiness Temporarily

Use:

sudo sysctl vm.swappiness=20

This lasts until reboot.

Confirm:

sysctl vm.swappiness

Make Swappiness Permanent

Create:

sudo nano /etc/sysctl.d/99-memory-tuning.conf

Add:

vm.swappiness = 20

Apply it:

sudo sysctl --system

What Is

vm.vfs_cache_pressure

?

Linux caches directory and inode information to make file access faster.

The setting:

vm.vfs_cache_pressure

controls how aggressively the kernel reclaims that metadata cache.

Check it:

sysctl vm.vfs_cache_pressure

A common default is:

100

Lower values keep filesystem metadata cached for longer.

Higher values reclaim it more aggressively.

On a low-RAM system, increasing this value may free memory sooner, but it can also make filesystem navigation and application startup slower.

A modest experimental value might be:

150

Set temporarily:

sudo sysctl vm.vfs_cache_pressure=150

Use this only after measuring the actual workload.

Dirty Memory Settings

Linux often buffers disk writes in memory before flushing them to storage.

Important settings include:

vm.dirty_background_ratio

vm.dirty_ratio

or their byte-based alternatives:

vm.dirty_background_bytes

vm.dirty_bytes

Check current values:

sysctl vm.dirty_background_ratio

sysctl vm.dirty_ratio

High dirty-page limits can create large bursts of disk activity and noticeable pauses, particularly on machines with slow storage.

A conservative low-RAM configuration might use:

vm.dirty_background_ratio = 5

vm.dirty_ratio = 10

This causes writeback to begin earlier and limits how much unwritten data can accumulate.

Add to:

/etc/sysctl.d/99-memory-tuning.conf

Then apply:

sudo sysctl --system

Test carefully. Workloads involving large file writes may behave differently.

Overcommit Settings

Linux may allow applications to reserve more virtual memory than the machine physically has available.

This behaviour is controlled by:

vm.overcommit_memory

Check it:

sysctl vm.overcommit_memory

Common modes are:

• 0 — kernel uses a heuristic
• 1 — always allow overcommit
• 2 — strict accounting

For most desktops and general-purpose systems, the default heuristic is appropriate.

Strict overcommit can make some applications fail allocations earlier.

Always allowing overcommit can delay failure until the system is under severe pressure.

Do not change this casually on a low-RAM machine.

The Out-of-Memory Killer

When Linux cannot satisfy memory demands, it may invoke the Out-of-Memory killer.

The OOM killer selects one or more processes to terminate so the system can recover.

Check the logs:

sudo journalctl -k | grep -iE "out of memory|oom|killed process"

You may see:

Out of memory: Killed process 4128 (firefox)

This does not necessarily mean the kernel malfunctioned. It means the machine reached a point where something had to be terminated.

Check Which Processes Use the Most Memory

Use:

ps aux --sort=-%mem | head -20

Or:

top

Inside top, press:

M

to sort by memory usage.

A more readable tool is:

htop

Install it on Ubuntu or Debian:

sudo apt install htop

On Fedora:

sudo dnf install htop

Also consider:

smem

smem can provide a more realistic view of shared memory usage than simple RSS figures.

Use

systemd-oomd

Some systemd-based distributions use systemd-oomd to react to memory pressure before the kernel reaches a complete OOM crisis.

Check its status:

systemctl status systemd-oomd

It can monitor cgroups and terminate workloads that exceed configured pressure limits.

This may improve system responsiveness, but users may notice applications closing sooner.

Review logs:

journalctl -u systemd-oomd

Do not disable it automatically because an application was terminated. Confirm whether the system was genuinely under sustained memory pressure.

Use EarlyOOM

earlyoom is another userspace service that can terminate a process before the system becomes completely unresponsive.

On Ubuntu or Debian:

sudo apt install earlyoom

Enable it:

sudo systemctl enable --now earlyoom

Check:

systemctl status earlyoom

This is particularly useful on desktop systems where remaining responsive is more important than keeping every application alive.

Reduce Background Memory Use

Swap tuning helps, but removing unnecessary memory demand often produces a larger improvement.

List enabled services:

systemctl list-unit-files --state=enabled

List running services:

systemctl --type=service --state=running

Do not disable services at random.

Investigate whether you actually need:

• Printing services
• Bluetooth
• File indexing
• Cloud synchronisation
• Database servers
• Container platforms
• Development services
• Remote-access agents
• Desktop search tools

Disable an unnecessary service:

sudo systemctl disable --now example.service

Only do this after confirming its purpose.

Choose Lighter Applications

On a low-RAM machine, application choice matters.

Potential improvements include:

• Fewer browser extensions
• Fewer open tabs
• Lightweight text editors
• Lightweight email clients
• Simpler desktop environments
• Reduced animation and visual effects
• One cloud-sync client instead of several
• Fewer background communication tools

Browser tabs are frequently the largest memory consumers on low-end desktops.

Use the browser’s internal task manager to identify heavy tabs and extensions.

Choose a Lightweight Desktop Environment

Full desktop environments provide useful features but can consume significant memory.

Lighter options may include:

• Xfce
• LXQt
• MATE
• Lightweight window managers

The exact memory saving depends on the distribution, enabled services and applications.

Changing desktop environment may provide more benefit than aggressively tuning obscure kernel parameters.

Container and Virtual-Machine Limits

Containers and virtual machines can quickly overwhelm a low-RAM host.

For Docker, set memory limits:

docker run --memory=512m --memory-swap=768m example-image

For a Compose configuration:

services:

  app:

    image: example-image

    mem_limit: 512m

Support for specific Compose options depends on the Compose version and deployment mode.

For systemd services, use:

[Service]

MemoryMax=512M

You can also set:

MemoryHigh=400M

MemoryHigh applies pressure before the hard limit is reached.

Reload and restart:

sudo systemctl daemon-reload

sudo systemctl restart example.service

Browser and Application Caches

Clearing a cache does not normally create permanent memory savings, because caches are often rebuilt.

However, an application with runaway cache growth or a memory leak may improve after restart.

Check process memory over time:

watch -n 5 'ps -C application-name -o pid,%mem,rss,cmd'

Restarting an application may temporarily reclaim memory, but repeated growth suggests a leak or unsuitable workload.

Monitor Memory Pressure With PSI

Linux Pressure Stall Information measures how much time tasks spend waiting for CPU, memory or I/O resources.

Check memory pressure:

cat /proc/pressure/memory

Example:

some avg10=0.25 avg60=0.10 avg300=0.05 total=123456

full avg10=0.02 avg60=0.01 avg300=0.00 total=2345

The some line means at least some tasks were stalled.

The full line means all non-idle tasks were stalled because of memory pressure.

Sustained high full pressure indicates a serious problem even if the machine has not yet invoked the OOM killer.

Monitor ZRAM Properly

Use:

watch -n 2 zramctl

Also monitor:

watch -n 2 free -h

and:

vmstat 2

Look for:

• Increasing ZRAM use
• Good compression ratios
• Acceptable CPU load
• Low disk-swap activity
• Whether the system remains responsive
• Whether applications are still being killed

ZRAM is working well when it absorbs pressure without creating excessive CPU overhead or causing heavy fallback to disk swap.

A Practical 4 GB Laptop Configuration

A reasonable starting point for a 4 GB machine might be:

• 2 GB ZRAM
• 2 GB disk swap
• ZRAM priority 100
• Disk-swap priority 10
• Swappiness between 80 and 120
• Reduced background services
• Earlier dirty-page writeback
• An early OOM service where responsiveness matters

Example sysctl file:

vm.swappiness = 100

vm.vfs_cache_pressure = 100

vm.dirty_background_ratio = 5

vm.dirty_ratio = 10

Do not treat this as a universal optimum. It is a baseline for testing.

A Practical 2 GB Machine Configuration

For a 2 GB system:

• Use a lightweight desktop or no desktop
• Configure 1–2 GB of ZRAM
• Keep 2–4 GB of disk swap as emergency capacity
• Remove unnecessary startup services
• Limit browser tabs and extensions
• Avoid running virtual machines
• Set memory limits on containers
• Consider earlyoom or systemd-oomd

On hardware this constrained, application choice is usually more important than fine-grained kernel tuning.

SSD Wear and Swap

Modern SSDs are designed to handle substantial write activity, but continuous heavy swapping still indicates an undersized or overloaded system.

ZRAM can reduce swap writes by keeping compressed pages in RAM.

Disk swap on an SSD is usually much faster than on a hard drive and can be a useful safety net.

Do not disable swap solely because the machine uses an SSD. A more sensible approach is to:

• Use ZRAM first
• Keep moderate disk swap
• Monitor actual writes
• Avoid constant memory overcommitment
• Replace or upgrade hardware when the workload consistently exceeds capacity

Clear Swap Without Rebooting

Sometimes administrators want to move swapped pages back into RAM.

First check that sufficient memory is available:

free -h

Then:

sudo swapoff -a

sudo swapon -a

This can create a sudden memory spike and may trigger the OOM killer.

Do not do this on a heavily loaded production system simply to make the swap-used figure return to zero.

Used swap is not automatically a problem. Inactive pages may remain in swap even after memory pressure has passed because there is no benefit in immediately reading them back.

Common Memory-Tuning Mistakes

Disabling Swap Completely

This can make the system fail more abruptly under pressure.

A small amount of swap often improves resilience.

Assuming Used Swap Means Something Is Wrong

Linux may leave inactive pages in swap while using RAM for more valuable cache.

Look at current swap activity and pressure, not only the amount used.

Setting Swappiness to Zero Automatically

A very low value can force Linux to reclaim useful cache aggressively and may produce worse behaviour.

Creating Enormous Swap on a Slow Hard Drive

This may prevent an immediate crash but leave the machine thrashing for minutes.

Oversizing ZRAM

A huge virtual ZRAM device does not create unlimited memory. Poorly compressible workloads may still fail.

Using ZRAM, Zswap and Multiple Swap Files Without a Plan

Complexity makes performance harder to understand.

Start with one clear configuration and measure it.

Tuning Random Kernel Values From Forums

Settings that help a database server may harm a desktop.

Change one thing at a time and record the result.

Ignoring the Application Causing the Pressure

Kernel tuning cannot make an unsuitable workload efficient.

Identify which program is consuming the memory.

Clearing Caches Repeatedly

Commands that force Linux to drop caches may make the system slower and do not solve ongoing memory demand.

A Safe Tuning Process

Use this order.

1. Check memory and swap

free -h

swapon --show

2. Identify large processes

ps aux --sort=-%mem | head -20

3. Check active swapping

vmstat 1

4. Check memory-pressure information

cat /proc/pressure/memory

5. Confirm whether ZRAM is already active

zramctl

6. Remove unnecessary background workloads

Review services and startup applications.

7. Add or resize swap if necessary

Use a protected swap file and test it before rebooting.

8. Add ZRAM

Begin with a conservative size, such as 50% of RAM.

9. Adjust swappiness

Change it temporarily first.

10. Monitor for several normal work sessions

Check responsiveness, compression, swap activity and application failures.

11. Make successful settings permanent

Store them in documented configuration files.

12. Upgrade the hardware when possible

No tuning setting can fully replace additional physical RAM.

Useful Commands at a Glance

Show memory:

free -h

Show swap:

swapon --show

Show ZRAM:

zramctl

Show memory-heavy processes:

ps aux --sort=-%mem | head

Watch swapping:

vmstat 1

Show memory pressure:

cat /proc/pressure/memory

Check swappiness:

sysctl vm.swappiness

Change swappiness temporarily:

sudo sysctl vm.swappiness=100

Show OOM events:

sudo journalctl -k | grep -iE "oom|out of memory|killed process"

Final Thoughts

Low-RAM Linux machines work best when memory pressure is managed in layers.

ZRAM provides fast compressed memory for inactive pages. Disk swap provides slower emergency capacity. Swappiness and related kernel settings influence how those resources are used. Service limits and lighter applications reduce the demand in the first place.

A good low-memory configuration is not the one with the most aggressive tuning. It is the one that keeps the machine responsive, avoids constant disk thrashing and gives important applications enough room to complete their work.

Start by measuring. Add ZRAM conservatively. Keep some disk swap available. Remove unnecessary background services and change one tuning setting at a time.

When the system spends most of its day under heavy memory pressure, however, the honest answer may be that the workload needs more RAM or lighter software.

Need Help Optimising a Low-Memory Linux Machine?

Hamilton Group can help diagnose Linux memory pressure, configure swap and ZRAM, reduce unnecessary background usage and stabilise machines that freeze or terminate applications under load.

We can also assess whether tuning is enough or whether a hardware upgrade would provide better long-term value.

Call 0330 043 0069 or visit hgmssp.com to speak with one of our IT specialists.