Linux swappiness governs how aggressively the kernel moves inactive memory pages from RAM to disk, directly influencing system responsiveness and stability. This setting, exposed through the sysctl knob vm.swappiness, sits at the intersection of memory management and performance tuning, and understanding it is essential for anyone responsible for maintaining reliable Linux workloads.
What swappiness actually does
At its core, swappiness controls the balance between keeping applications in physical memory and writing idle pages to swap space. A higher value encourages the kernel to evict unused pages more readily, while a lower value keeps data in RAM as long as possible, reserving swap for true memory pressure. The value ranges from 0 to 100, with 0 telling the kernel to avoid swapping unless absolutely necessary and 100 making it swap out pages much more aggressively.
Default behavior and common misconceptions
Many distributions ship with a moderate swappiness, such as 60, which historically aimed to provide a balanced compromise for general-purpose desktops and servers. A widespread myth is that setting swappiness to 0 eliminates swapping entirely, but the kernel will still swap to prevent out-of-memory conditions, particularly for user-space allocations that cannot be reclaimed otherwise. The real benefit of lowering the value is to reduce unnecessary disk I/O and keep latency-sensitive workloads in RAM, which is especially valuable on systems with ample memory and fast storage.
How to view and modify swappiness
You can inspect the current setting by reading the relevant sysctl file, typically through the command sysctl vm.swappiness or by directly catting /proc/sys/vm/swappiness. Temporary changes can be applied with sysctl -w vm.swappiness=10, while persistent adjustments are made in /etc/sysctl.conf or a dedicated configuration file under /etc/sysctl.d/. For systems using systemd, tuning can also be managed through sysctl.d files or via kernel command line parameters on some configurations, allowing precise control at boot time.
Workloads that benefit from lower swappiness
Latency-sensitive applications, such as databases, real-time services, and high-performance computing jobs, often perform better with a reduced swappiness value because they minimize unexpected delays caused by swapping. In containerized environments, where memory pressure can arise quickly, keeping swappiness low helps ensure that critical containers remain in RAM and do not get deprioritized to disk. Desktop users with sufficient memory also frequently lower the setting to avoid stuttering when background tasks briefly inflate memory usage.
When higher swappiness makes sense
On servers hosting many independent, memory-intensive processes, a higher swappiness can help reclaim unused pages more aggressively, reducing the risk of abrupt out-of-memory kills. Systems with slow storage or limited RAM relative to workload size might also benefit from a larger value, as swapping becomes less costly than contending for scarce physical memory. In dense environments where overall throughput matters more than individual latency, allowing the kernel to swap more freely can improve resource utilization and reduce the likelihood of memory-induced thrashing.
Monitoring and tuning in practice
Effective tuning relies on observation, and tools such as vmstat, sar, and slabtop reveal memory pressure, swap activity, and reclaim behavior over time. Metrics like swap in and swap out rates, alongside page scan frequency and reclaim counts, indicate whether the current swappiness is appropriate or needs adjustment. Because every workload reacts differently, changes should be tested under realistic load, documented as part of the system configuration, and revisited when application patterns or hardware evolve.
